From dd0127cddb03b6a5ed3079cb1f0dd57bd098c579 Mon Sep 17 00:00:00 2001
From: nsz <nsz@port70.net>
Date: Thu, 21 Jul 2011 11:18:01 +0200
Subject: [PATCH] new htmlization approach

---
 ann2html.sh    |   210 +
 annot.sh       |   234 +
 n1256.html     | 45664 ++++++++++++++++++++-----------------
 n1256.pre.html | 20761 +++++++++++++++++
 n1548.html     | 58040 ++++++++++++++++++++++++++---------------------
 n1548.pre.html | 26323 +++++++++++++++++++++
 tohtml.pre.sh  |   125 +
 tohtml.sh      |   124 +-
 8 files changed, 104448 insertions(+), 47033 deletions(-)
 create mode 100755 ann2html.sh
 create mode 100755 annot.sh
 create mode 100644 n1256.pre.html
 create mode 100644 n1548.pre.html
 create mode 100755 tohtml.pre.sh

diff --git a/ann2html.sh b/ann2html.sh
new file mode 100755
index 0000000..7b3bcac
--- /dev/null
+++ b/ann2html.sh
@@ -0,0 +1,210 @@
+#!/bin/sh
+
+export LC_ALL=C
+awk '
+BEGIN {
+	noteid = 1
+	sid = 1
+	ss[sid] = "<pre>"
+}
+
+{
+	gsub(/\&/, "\\&amp;")
+	gsub(/</, "\\&lt;")
+	gsub(/>/, "\\&gt;")
+}
+
+/^@sect Contents/ {
+	ss[sid] = ss[sid] "</pre>\n"
+	seencontents = 1
+}
+
+/^@sect Foreword/ {
+	ss[sid] = ss[sid] "</pre>\n"
+	seenfore = 1
+}
+
+/^@sect Index/ {
+	seenindex = 1
+}
+
+/^@title/ {
+	if (!seencontents) {
+		ss[sid] = ss[sid] "</pre>\n"
+	}
+	sid++
+	getline
+	ss[sid] = ss[sid] "<h1>" $0 "</h1>\n"
+	title = $0
+	if (!seencontents) {
+		ss[sid] = ss[sid] "<pre>\n"
+	}
+	next
+}
+
+/^@sect/ {
+	sid++
+	slevel = split($2,a,/\./)+1
+	if (slevel > 5)
+		slevel = 5
+	sect = $2
+	getline
+	# todo hX, back to top
+	ss[sid] = sprintf("<a name=\"%s\" href=\"#%s\"><h%s>%s</h%s></a>\n", sect, sect, slevel, $0, slevel)
+	if ($0 ~ /^(Index|Contents)/)
+		ss[sid] = ss[sid] "<pre>\n"
+	next
+}
+
+/^@ul/ {
+	ss[sid] = ss[sid] "<ul>\n"
+	next
+}
+/^@end ul/ {
+	ss[sid] = ss[sid] "</ul>\n"
+	next
+}
+/^@ol/ {
+	ss[sid] = ss[sid] "<ol>\n"
+	next
+}
+/^@end ol/ {
+	ss[sid] = ss[sid] "</ol>\n"
+	next
+}
+
+/^@li/ {
+	ss[sid] = ss[sid] "<li>"
+	next
+}
+
+/^@pre/ {
+	pre = "<pre>"
+	next
+}
+
+/^@end pre/ {
+	if (!pre)
+		next
+	pre = pre "</pre>\n"
+	if (nn)
+		note[nn] = note[nn] "\n" pre
+	else
+		ss[sid] = ss[sid] pre
+	pre = ""
+	next
+}
+
+/^@note/ {
+	nn = $2+0
+	note[nn] = ""
+	next
+}
+
+/^@page/ {
+	nn = 0
+	p = $2
+	getline
+	i = $2
+	ss[sid] = ss[sid] "<!--page " p " indent " i "-->\n"
+	next
+}
+
+/^@para/ {
+	ss[sid] = ss[sid] "<p><!--para " $2 "-->\n"
+	next
+}
+
+/^ *(Syntax|Semantics|Description|Constraints|Synopsis|Returns)$/ {
+	ss[sid] = ss[sid] "<h6>" $0 "</h6>\n"
+	next
+}
+
+!seenfore {
+	ss[sid] = ss[sid] $0 "\n"
+	next
+}
+
+{
+	s = $0
+	p = ""
+	if (seenindex)
+		r = " [A-Z1-9][0-9.]*"
+	else
+		r = "[ ([][A-Z1-9]\\.[0-9.]*[0-9]"
+	# hack
+	s = " " s
+	while (match(s, r)) {
+		p = p substr(s,1,RSTART)
+		m = substr(s,RSTART+1,RLENGTH-1)
+		if (m ~ /\.0$/ || m ~ /[4-9][0-9]/ || m ~ /[0-3][0-9][0-9]/ ||
+		    substr(s,RSTART+RLENGTH,1) ~ /[a-zA-Z_\-]/)
+			p = p m
+		else
+			p = p "<a href=\"#" m "\">" m "</a>"
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+	p = ""
+	while (match(s, /[Aa]nnex [A-Z]/)) {
+		p = p substr(s,1,RSTART-1)
+		m = substr(s,RSTART,RLENGTH)
+		p = p "<a href=\"#" substr(m,RLENGTH,1) "\">" m "</a>"
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+	p = ""
+	while (match(s, /&lt;[a-zA-Z0-9_]*\.h&gt;/)) {
+		p = p substr(s,1,RSTART-1)
+		m = substr(s,RSTART,RLENGTH)
+		if (m in header)
+			p = p "<a href=\"#" header "\">" m "</a>"
+		else
+			p = p m
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+	p = ""
+	while (match(s, noteid "\\)")) {
+		if (noteid==1 && s !~ /\.1\)/)
+			break
+		p = p substr(s,1,RSTART-1)
+		p = p "<sup><a href=\"#note" noteid "\"><b>" noteid ")</b></a></sup>"
+		snote[sid] = snote[sid] " " noteid
+		noteid++
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+#	if (s ~ /^ *[1-9][0-9]*\) /) {
+#		sub(/\)/,"",s)
+#		sub(/[0-9]+/,"<sup><a name=\"note&\" href=\"#note&\"><b>&)</b></a></sup>",s)
+#	}
+
+	if (pre)
+		pre = pre "\n" s
+	else if (nn)
+		note[nn] = note[nn] s "\n"
+	else
+		ss[sid] = ss[sid] s "\n"
+}
+
+END {
+	ss[sid] = ss[sid] "</pre>"
+
+	print "<html><head><title>C</title></head><body>"
+
+	for (i = 1; i <= sid; i++) {
+		print ss[i]
+#		if (slev[i] < 4)
+		n = split(snote[i],a)
+		if (n > 0) {
+			s = "<h6>footnotes</h6>\n"
+			for (j = 1; j <= n; j++) {
+				s = s "<p><a name=\"note" a[j] "\">" a[j] ")</a>" note[a[j]+0] "\n"
+			}
+			print s
+		}
+	}
+
+	print "</body></html>"
+}'
diff --git a/annot.sh b/annot.sh
new file mode 100755
index 0000000..debb71d
--- /dev/null
+++ b/annot.sh
@@ -0,0 +1,234 @@
+#!/bin/sh
+
+export LC_ALL=C
+awk '
+function initpage() {
+	if (innote)
+		endpre()
+
+	indent = 10
+	para = 0
+	innote = 0
+	ok = 0
+	empty = ""
+	page = ""
+}
+
+function endlist() {
+	if (listindex) {
+		listindent = 0
+		listindex = 0
+		print "@end ol"
+	} else if (listlevel) {
+		listlevel--
+		print "@end ul"
+	}
+}
+
+function donote(s) {
+	if (match(s, /^[1-9][0-9]*\) +/)) {
+		# todo..
+		endpre()
+		print "@note " substr(s, 1, RLENGTH-2)
+		s = substr(s, RLENGTH+1)
+		innote = 1
+		noteindent = RLENGTH
+	} else if (innote) {
+		if (match(s, /^ +/) && RLENGTH >= noteindent)
+			s = substr(s, noteindent+1)
+		else
+			innote = 0
+	}
+	return s
+}
+
+function doul(s) {
+	if (!listlevel) {
+		if (s ~ /^--/) {
+			s = dopre(s)
+			listlevel++
+			print "@ul"
+		} else
+			return s
+	}
+	if (listlevel == 1) {
+		if (s ~ /^   *o /) {
+			listlevel++
+			print "@ul"
+		} else if (s ~ /^--/) {
+			s = dopre(s)
+			s = substr(s , 3)
+			print "@li"
+		} else if (match(s, /^ +/) && RLENGTH > 1) {
+			sub(/^  /, "", s)
+		} else if (s !~ /^$/) {
+			endpre()
+			endlist()
+		}
+	}
+	if (listlevel == 2) {
+		if (s ~ /^   *o /) {
+			sub(/ *o /, "", s)
+			s = dopre(s)
+			print "@li"
+		} else if (match(s, /^ +/) && RLENGTH > 5) {
+			sub(/^ +/, "", s)
+		} else if (s !~ /^$/) {
+			sub(/^  /, "", s)
+			endlist()
+		}
+	}
+	return s
+}
+
+function dool(s) {
+	if (listindex == 0) {
+		if (s ~ /^   *1\. /)
+			print "@ol"
+		else
+			return s
+	}
+
+	if (match(s, "^ +" (listindex+1) "\\. +")) {
+		listindex++
+		listindent = RLENGTH
+		s = substr(s, RLENGTH)
+		s = dopre(s)
+		print "@li " listindex
+	} else if (match(s, /^ +/) && RLENGTH >= listindent) {
+		s = substr(s, listindent+1)
+	} else if (s !~ /^$/) {
+		endpre()
+		endlist()
+	}
+	return s
+}
+
+function endpre() {
+	if (inpre) {
+		print "@end pre"
+		inpre = 0
+	}
+}
+
+function dopre(s) {
+	if (seenindex != 1)
+		return s
+	if (!inpre) {
+		if (s ~ /^    */) {
+			print "@pre"
+			inpre = 1
+		} else
+			return s
+	}
+	if (s !~ /^    */)
+		endpre()
+	return s
+}
+
+function dosect(s,   n,a) {
+	if (seenindex > 1)
+		return s
+	if (s ~ /^Programming languages/) {
+		print "@title " s
+		return s
+	}
+	if (s !~ /^([1-9]\.|[A-Z]\.[1-9]| *Annex |Contents|Index|Foreword|Introduction| *Bibliography)/)
+		return s
+	if (s ~ /^[0-9.]+[^0-9. ]/)
+		return s
+	n = split(s, a)
+	id = a[1]
+	if (id ~ /Annex/)
+		id = a[2]
+	if (id ~ /^([A-Z]|[1-9]\.|[1-9A-Z]\.[0-9.]*[0-9]|Contents|Index|Foreword|Introduction|Bibliography)$/ &&
+	    (n==1 || a[2] ~ /^[A-Z.v]/)) {
+		sub(/^ +/,"",s)
+		if (id ~ /\.$/)
+			id = substr(id,1,length(id)-1)
+		if (seenindex || id == "Contents") {
+			endpre()
+			endlist()
+			print "@sect " id
+		}
+		if (id == "Index")
+			seenindex++
+	}
+	return s
+}
+
+BEGIN {
+	listlevel = 0
+	listindex = 0
+	listindent = 0
+	noteindent = 0
+	inpre = 0
+	seenindex = 0
+	pn = 1
+	initpage()
+}
+
+/^\[page/ {
+	if(!para && indent && ok)
+		indent = -1
+
+	if (!ok)
+		indent = 0
+
+	n = split(page, a, /\n/)
+	print "@page " pn
+	print "@indent " indent
+	if (indent < 0)
+		indent = 0
+	for (i = 1; i < n; i++) {
+		if (a[i] ~ /^@/) {
+			if (a[i] ~ /^@para/)
+				endlist()
+			print a[i]
+		} else {
+			s = substr(a[i], indent+1)
+			s = dosect(s)
+			s = donote(s)
+			if (!innote) {
+				s = doul(s)
+				s = dool(s)
+			}
+			s = dopre(s)
+			print s
+		}
+	}
+
+	pn++
+	initpage()
+	next
+}
+
+/^$/ {
+	if (ok)
+		empty = empty "\n"
+	next
+}
+
+length(empty) > 0 {
+	page = page empty
+	empty = ""
+}
+
+{
+	ok = 1
+	if (match($0, /^[0-9]+ +/)) {
+		para = 1
+		i = RLENGTH
+		match($0, /^[0-9]+/)
+		page = page "@para " substr($0,1,RLENGTH) "\n"
+	} else if (match($0, /^ +/)) {
+		i = RLENGTH
+	} else if ($0 !~ /^[0-9]*$/) {
+		i = 0
+	} else
+		i = 10
+	if (i < indent)
+		indent = i
+	page = page $0 "\n"
+}'
+
diff --git a/n1256.html b/n1256.html
index edd1a81..b5add74 100644
--- a/n1256.html
+++ b/n1256.html
@@ -1,20761 +1,25065 @@
-<html><head><title>WG14/N1256                Committee Draft -- Septermber 7, 2007                   ISO/IEC 9899:TC3</title></head><body><pre>
+<html><head><title>C</title></head><body>
+<pre><!--page 1 indent 0-->
 WG14/N1256                Committee Draft -- Septermber 7, 2007                   ISO/IEC 9899:TC3
 
 
-<a name="Contents" href="#Contents">Contents</a>
-<a href="#Foreword">Foreword       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                   xi</a>
-<a href="#Introduction">Introduction     . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                  xiv</a>
-<a href="#1">1. Scope       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                    1</a>
-<a href="#2">2. Normative references      . . . . . . . . . . . . . . . . . . . . . . .                                  2</a>
-<a href="#3">3. Terms, definitions, and symbols     . . . . . . . . . . . . . . . . . . .                                 3</a>
-<a href="#4">4. Conformance       . . . . . . . . . . . . . . . . . . . . . . . . . .                                    7</a>
-<a href="#5">5. Environment    . . . . . . . . . . .        . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9</a>
-<a href="#5.1">   5.1 Conceptual models      . . . . . .      . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9</a>
-<a href="#5.1.1">        5.1.1  Translation environment .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9</a>
-<a href="#5.1.2">        5.1.2  Execution environments     .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .   11</a>
-<a href="#5.2">   5.2 Environmental considerations    . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   17</a>
-<a href="#5.2.1">        5.2.1 Character sets     . . . . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   17</a>
-<a href="#5.2.2">        5.2.2  Character display semantics       .   .   .   .   .   .   .   .    .   .   .   .   .   .   19</a>
-<a href="#5.2.3">        5.2.3 Signals and interrupts . .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .   20</a>
-<a href="#5.2.4">        5.2.4  Environmental limits    . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   20</a>
-<a href="#6">6. Language . . . . . . . . . . . . . . . .              .   .   .   .   .   .    .   .   .   .   .   .   29</a>
-<a href="#6.1">   6.1 Notation . . . . . . . . . . . . . .              .   .   .   .   .   .    .   .   .   .   .   .   29</a>
-<a href="#6.2">   6.2 Concepts      . . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   29</a>
-<a href="#6.2.1">        6.2.1 Scopes of identifiers      . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   29</a>
-<a href="#6.2.2">        6.2.2   Linkages of identifiers . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   30</a>
-<a href="#6.2.3">        6.2.3 Name spaces of identifiers      . . .       .   .   .   .   .   .    .   .   .   .   .   .   31</a>
-<a href="#6.2.4">        6.2.4 Storage durations of objects     . .       .   .   .   .   .   .    .   .   .   .   .   .   32</a>
-<a href="#6.2.5">        6.2.5 Types       . . . . . . . . . . .          .   .   .   .   .   .    .   .   .   .   .   .   33</a>
-<a href="#6.2.6">        6.2.6 Representations of types . . . .           .   .   .   .   .   .    .   .   .   .   .   .   37</a>
-<a href="#6.2.7">        6.2.7 Compatible type and composite type             .   .   .   .   .    .   .   .   .   .   .   40</a>
-<a href="#6.3">   6.3 Conversions     . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   42</a>
-<a href="#6.3.1">        6.3.1 Arithmetic operands       . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   42</a>
-<a href="#6.3.2">        6.3.2 Other operands        . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   46</a>
-<a href="#6.4">   6.4 Lexical elements      . . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   49</a>
-<a href="#6.4.1">        6.4.1 Keywords . . . . . . . . . .               .   .   .   .   .   .    .   .   .   .   .   .   50</a>
-<a href="#6.4.2">        6.4.2 Identifiers . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .   51</a>
-<a href="#6.4.3">        6.4.3 Universal character names      . . .       .   .   .   .   .   .    .   .   .   .   .   .   53</a>
-<a href="#6.4.4">        6.4.4   Constants . . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .   54</a>
-<a href="#6.4.5">        6.4.5 String literals     . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   62</a>
-<a href="#6.4.6">        6.4.6   Punctuators . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .   63</a>
-<a href="#6.4.7">        6.4.7 Header names        . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   64</a>
-<a href="#6.4.8">        6.4.8 Preprocessing numbers        . . . .       .   .   .   .   .   .    .   .   .   .   .   .   65</a>
-<a href="#6.4.9">        6.4.9 Comments         . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   66</a>
-<a href="#6.5">   6.5 Expressions     . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   67</a>
-
-[page iii]
-
-<a href="#6.5.1">          6.5.1   Primary expressions      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    69</a>
-<a href="#6.5.2">          6.5.2 Postfix operators . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .    69</a>
-<a href="#6.5.3">          6.5.3   Unary operators      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    78</a>
-<a href="#6.5.4">          6.5.4 Cast operators . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .    81</a>
-<a href="#6.5.5">          6.5.5   Multiplicative operators   . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    82</a>
-<a href="#6.5.6">          6.5.6 Additive operators       . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    82</a>
-<a href="#6.5.7">          6.5.7 Bitwise shift operators . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .    84</a>
-<a href="#6.5.8">          6.5.8   Relational operators . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    85</a>
-<a href="#6.5.9">          6.5.9 Equality operators       . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    86</a>
-<a href="#6.5.10">          6.5.10 Bitwise AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    87</a>
-<a href="#6.5.11">          6.5.11 Bitwise exclusive OR operator         .   .   .   .   .   .   .   .   .   .   .   .   .    88</a>
-<a href="#6.5.12">          6.5.12 Bitwise inclusive OR operator     .   .   .   .   .   .   .   .   .   .   .   .   .   .    88</a>
-<a href="#6.5.13">          6.5.13 Logical AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    89</a>
-<a href="#6.5.14">          6.5.14 Logical OR operator       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    89</a>
-<a href="#6.5.15">          6.5.15 Conditional operator      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    90</a>
-<a href="#6.5.16">          6.5.16 Assignment operators . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    91</a>
-<a href="#6.5.17">          6.5.17 Comma operator . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .    94</a>
-<a href="#6.6">     6.6 Constant expressions . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    95</a>
-<a href="#6.7">     6.7 Declarations     . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .    97</a>
-<a href="#6.7.1">          6.7.1 Storage-class specifiers      . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    98</a>
-<a href="#6.7.2">          6.7.2   Type specifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    99</a>
-<a href="#6.7.3">          6.7.3 Type qualifiers . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   108</a>
-<a href="#6.7.4">          6.7.4   Function specifiers     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112</a>
-<a href="#6.7.5">          6.7.5 Declarators        . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   114</a>
-<a href="#6.7.6">          6.7.6 Type names . . . . . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   122</a>
-<a href="#6.7.7">          6.7.7   Type definitions      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   123</a>
-<a href="#6.7.8">          6.7.8 Initialization       . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   125</a>
-<a href="#6.8">     6.8 Statements and blocks       . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   131</a>
-<a href="#6.8.1">          6.8.1   Labeled statements     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   131</a>
-<a href="#6.8.2">          6.8.2 Compound statement         . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   132</a>
-<a href="#6.8.3">          6.8.3 Expression and null statements         .   .   .   .   .   .   .   .   .   .   .   .   .   132</a>
-<a href="#6.8.4">          6.8.4 Selection statements       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   133</a>
-<a href="#6.8.5">          6.8.5 Iteration statements . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   135</a>
-<a href="#6.8.6">          6.8.6 Jump statements        . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   136</a>
-<a href="#6.9">     6.9 External definitions       . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   140</a>
-<a href="#6.9.1">          6.9.1   Function definitions . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   141</a>
-<a href="#6.9.2">          6.9.2 External object definitions     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   143</a>
-<a href="#6.10">     6.10 Preprocessing directives     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   145</a>
-<a href="#6.10.1">          6.10.1 Conditional inclusion     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147</a>
-<a href="#6.10.2">          6.10.2 Source file inclusion      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   149</a>
-<a href="#6.10.3">          6.10.3 Macro replacement . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   151</a>
-<a href="#6.10.4">          6.10.4 Line control . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   158</a>
-<a href="#6.10.5">          6.10.5 Error directive . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   159</a>
-<a href="#6.10.6">          6.10.6 Pragma directive . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   159</a>
-
-[page iv]
-
-<a href="#6.10.7">       6.10.7 Null directive      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   160</a>
-<a href="#6.10.8">       6.10.8 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   160</a>
-<a href="#6.10.9">       6.10.9 Pragma operator       . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   161</a>
-<a href="#6.11">  6.11 Future language directions     . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.1">       6.11.1 Floating types      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.2">       6.11.2 Linkages of identifiers . .      .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.3">       6.11.3 External names        . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.4">       6.11.4 Character escape sequences          .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.5">       6.11.5 Storage-class specifiers     .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.6">       6.11.6 Function declarators      . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.7">       6.11.7 Function definitions . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.8">       6.11.8 Pragma directives       . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#6.11.9">       6.11.9 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
-<a href="#7">7. Library . . . . . . . . . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   164</a>
-<a href="#7.1">   7.1 Introduction     . . . . . . . . . . . . . . .                 . .     .    .   .   .   .   .   .   164</a>
-<a href="#7.1.1">         7.1.1 Definitions of terms . . . . . . . . .                  . .     .    .   .   .   .   .   .   164</a>
-<a href="#7.1.2">         7.1.2 Standard headers . . . . . . . . . .                   . .     .    .   .   .   .   .   .   165</a>
-<a href="#7.1.3">         7.1.3 Reserved identifiers . . . . . . . . .                  . .     .    .   .   .   .   .   .   166</a>
-<a href="#7.1.4">         7.1.4 Use of library functions    . . . . . . .              . .     .    .   .   .   .   .   .   166</a>
-<a href="#7.2">   7.2 Diagnostics &lt;assert.h&gt;          . . . . . . . . .              . .     .    .   .   .   .   .   .   169</a>
-<a href="#7.2.1">         7.2.1 Program diagnostics       . . . . . . . .              . .     .    .   .   .   .   .   .   169</a>
-<a href="#7.3">   7.3 Complex arithmetic &lt;complex.h&gt;           . . . . .             . .     .    .   .   .   .   .   .   170</a>
-<a href="#7.3.1">         7.3.1 Introduction . . . . . . . . . . . .                   . .     .    .   .   .   .   .   .   170</a>
-<a href="#7.3.2">         7.3.2 Conventions . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   171</a>
-<a href="#7.3.3">         7.3.3 Branch cuts . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   171</a>
-<a href="#7.3.4">         7.3.4 The CX_LIMITED_RANGE pragma              . .           . .     .    .   .   .   .   .   .   171</a>
-<a href="#7.3.5">         7.3.5 Trigonometric functions . . . . . . .                  . .     .    .   .   .   .   .   .   172</a>
-<a href="#7.3.6">         7.3.6 Hyperbolic functions      . . . . . . . .              . .     .    .   .   .   .   .   .   174</a>
-<a href="#7.3.7">         7.3.7 Exponential and logarithmic functions      .           . .     .    .   .   .   .   .   .   176</a>
-<a href="#7.3.8">         7.3.8 Power and absolute-value functions       . .           . .     .    .   .   .   .   .   .   177</a>
-<a href="#7.3.9">         7.3.9 Manipulation functions      . . . . . . .              . .     .    .   .   .   .   .   .   178</a>
-<a href="#7.4">   7.4 Character handling &lt;ctype.h&gt; . . . . . . .                     . .     .    .   .   .   .   .   .   181</a>
-<a href="#7.4.1">         7.4.1 Character classification functions      . . .           . .     .    .   .   .   .   .   .   181</a>
-<a href="#7.4.2">         7.4.2 Character case mapping functions       . . .           . .     .    .   .   .   .   .   .   184</a>
-<a href="#7.5">   7.5 Errors &lt;errno.h&gt;         . . . . . . . . . . . .               . .     .    .   .   .   .   .   .   186</a>
-<a href="#7.6">   7.6 Floating-point environment &lt;fenv.h&gt;         . . . .            . .     .    .   .   .   .   .   .   187</a>
-<a href="#7.6.1">         7.6.1 The FENV_ACCESS pragma           . . . . .             . .     .    .   .   .   .   .   .   189</a>
-<a href="#7.6.2">         7.6.2 Floating-point exceptions      . . . . . .             . .     .    .   .   .   .   .   .   190</a>
-<a href="#7.6.3">         7.6.3 Rounding . . . . . . . . . . . . .                     . .     .    .   .   .   .   .   .   193</a>
-<a href="#7.6.4">         7.6.4 Environment        . . . . . . . . . . .               . .     .    .   .   .   .   .   .   194</a>
-<a href="#7.7">   7.7 Characteristics of floating types &lt;float.h&gt; . .                 . .     .    .   .   .   .   .   .   197</a>
-<a href="#7.8">   7.8 Format conversion of integer types &lt;inttypes.h&gt;                  .     .    .   .   .   .   .   .   198</a>
-<a href="#7.8.1">         7.8.1 Macros for format specifiers      . . . . .             . .     .    .   .   .   .   .   .   198</a>
-<a href="#7.8.2">         7.8.2 Functions for greatest-width integer types             . .     .    .   .   .   .   .   .   199</a>
-
-[page v]
-
-<a href="#7.9">     7.9 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . .         .   .   .   .   202</a>
-<a href="#7.10">     7.10 Sizes of integer types &lt;limits.h&gt;       . . . . . . . . . .   .   .   .   .   203</a>
-<a href="#7.11">     7.11 Localization &lt;locale.h&gt; . . . . . . . . . . . . . .           .   .   .   .   204</a>
-<a href="#7.11.1">          7.11.1 Locale control . . . . . . . . . . . . . . . .         .   .   .   .   205</a>
-<a href="#7.11.2">          7.11.2 Numeric formatting convention inquiry . . . . . .      .   .   .   .   206</a>
-<a href="#7.12">     7.12 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .            .   .   .   .   212</a>
-<a href="#7.12.1">          7.12.1 Treatment of error conditions . . . . . . . . . .      .   .   .   .   214</a>
-<a href="#7.12.2">          7.12.2 The FP_CONTRACT pragma           . . . . . . . . . .   .   .   .   .   215</a>
-<a href="#7.12.3">          7.12.3 Classification macros      . . . . . . . . . . . . .    .   .   .   .   216</a>
-<a href="#7.12.4">          7.12.4 Trigonometric functions . . . . . . . . . . . .        .   .   .   .   218</a>
-<a href="#7.12.5">          7.12.5 Hyperbolic functions      . . . . . . . . . . . . .    .   .   .   .   221</a>
-<a href="#7.12.6">          7.12.6 Exponential and logarithmic functions    . . . . . .   .   .   .   .   223</a>
-<a href="#7.12.7">          7.12.7 Power and absolute-value functions     . . . . . . .   .   .   .   .   228</a>
-<a href="#7.12.8">          7.12.8 Error and gamma functions . . . . . . . . . . .        .   .   .   .   230</a>
-<a href="#7.12.9">          7.12.9 Nearest integer functions . . . . . . . . . . . .      .   .   .   .   231</a>
-<a href="#7.12.10">          7.12.10 Remainder functions      . . . . . . . . . . . . .    .   .   .   .   235</a>
-<a href="#7.12.11">          7.12.11 Manipulation functions      . . . . . . . . . . . .   .   .   .   .   236</a>
-<a href="#7.12.12">          7.12.12 Maximum, minimum, and positive difference functions       .   .   .   238</a>
-<a href="#7.12.13">          7.12.13 Floating multiply-add . . . . . . . . . . . . .       .   .   .   .   239</a>
-<a href="#7.12.14">          7.12.14 Comparison macros . . . . . . . . . . . . . .         .   .   .   .   240</a>
-<a href="#7.13">     7.13 Nonlocal jumps &lt;setjmp.h&gt;           . . . . . . . . . . . .   .   .   .   .   243</a>
-<a href="#7.13.1">          7.13.1 Save calling environment       . . . . . . . . . . .   .   .   .   .   243</a>
-<a href="#7.13.2">          7.13.2 Restore calling environment      . . . . . . . . . .   .   .   .   .   244</a>
-<a href="#7.14">     7.14 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . .          .   .   .   .   246</a>
-<a href="#7.14.1">          7.14.1 Specify signal handling      . . . . . . . . . . . .   .   .   .   .   247</a>
-<a href="#7.14.2">          7.14.2 Send signal       . . . . . . . . . . . . . . . . .    .   .   .   .   248</a>
-<a href="#7.15">     7.15 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . .   .   .   .   .   249</a>
-<a href="#7.15.1">          7.15.1 Variable argument list access macros . . . . . . .     .   .   .   .   249</a>
-<a href="#7.16">     7.16 Boolean type and values &lt;stdbool.h&gt;         . . . . . . . .   .   .   .   .   253</a>
-<a href="#7.17">     7.17 Common definitions &lt;stddef.h&gt; . . . . . . . . . . .            .   .   .   .   254</a>
-<a href="#7.18">     7.18 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . .          .   .   .   .   255</a>
-<a href="#7.18.1">          7.18.1 Integer types       . . . . . . . . . . . . . . . .    .   .   .   .   255</a>
-<a href="#7.18.2">          7.18.2 Limits of specified-width integer types   . . . . . .   .   .   .   .   257</a>
-<a href="#7.18.3">          7.18.3 Limits of other integer types    . . . . . . . . . .   .   .   .   .   259</a>
-<a href="#7.18.4">          7.18.4 Macros for integer constants     . . . . . . . . . .   .   .   .   .   260</a>
-<a href="#7.19">     7.19 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . .    .   .   .   .   262</a>
-<a href="#7.19.1">          7.19.1 Introduction . . . . . . . . . . . . . . . . .         .   .   .   .   262</a>
-<a href="#7.19.2">          7.19.2 Streams         . . . . . . . . . . . . . . . . . .    .   .   .   .   264</a>
-<a href="#7.19.3">          7.19.3 Files . . . . . . . . . . . . . . . . . . . .          .   .   .   .   266</a>
-<a href="#7.19.4">          7.19.4 Operations on files      . . . . . . . . . . . . . .    .   .   .   .   268</a>
-<a href="#7.19.5">          7.19.5 File access functions     . . . . . . . . . . . . .    .   .   .   .   270</a>
-<a href="#7.19.6">          7.19.6 Formatted input/output functions     . . . . . . . .   .   .   .   .   274</a>
-<a href="#7.19.7">          7.19.7 Character input/output functions . . . . . . . . .     .   .   .   .   296</a>
-<a href="#7.19.8">          7.19.8 Direct input/output functions    . . . . . . . . . .   .   .   .   .   301</a>
-
-[page vi]
-
-<a href="#7.19.9">         7.19.9 File positioning functions      . . . . . . . . . . . .     .   .   .   302</a>
-<a href="#7.19.10">         7.19.10 Error-handling functions . . . . . . . . . . . . .         .   .   .   304</a>
-<a href="#7.20">  7.20   General utilities &lt;stdlib.h&gt;         . . . . . . . . . . . . .     .   .   .   306</a>
-<a href="#7.20.1">         7.20.1 Numeric conversion functions . . . . . . . . . . .          .   .   .   307</a>
-<a href="#7.20.2">         7.20.2 Pseudo-random sequence generation functions       . . . .   .   .   .   312</a>
-<a href="#7.20.3">         7.20.3 Memory management functions . . . . . . . . . .             .   .   .   313</a>
-<a href="#7.20.4">         7.20.4 Communication with the environment          . . . . . . .   .   .   .   315</a>
-<a href="#7.20.5">         7.20.5 Searching and sorting utilities . . . . . . . . . . .       .   .   .   318</a>
-<a href="#7.20.6">         7.20.6 Integer arithmetic functions      . . . . . . . . . . .     .   .   .   320</a>
-<a href="#7.20.7">         7.20.7 Multibyte/wide character conversion functions     . . . .   .   .   .   321</a>
-<a href="#7.20.8">         7.20.8 Multibyte/wide string conversion functions      . . . . .   .   .   .   323</a>
-<a href="#7.21">  7.21   String handling &lt;string.h&gt; . . . . . . . . . . . . . .             .   .   .   325</a>
-<a href="#7.21.1">         7.21.1 String function conventions . . . . . . . . . . . .         .   .   .   325</a>
-<a href="#7.21.2">         7.21.2 Copying functions       . . . . . . . . . . . . . . .       .   .   .   325</a>
-<a href="#7.21.3">         7.21.3 Concatenation functions . . . . . . . . . . . . .           .   .   .   327</a>
-<a href="#7.21.4">         7.21.4 Comparison functions . . . . . . . . . . . . . .            .   .   .   328</a>
-<a href="#7.21.5">         7.21.5 Search functions      . . . . . . . . . . . . . . . .       .   .   .   330</a>
-<a href="#7.21.6">         7.21.6 Miscellaneous functions . . . . . . . . . . . . .           .   .   .   333</a>
-<a href="#7.22">  7.22   Type-generic math &lt;tgmath.h&gt;           . . . . . . . . . . . .     .   .   .   335</a>
-<a href="#7.23">  7.23   Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .       .   .   .   338</a>
-<a href="#7.23.1">         7.23.1 Components of time         . . . . . . . . . . . . . .      .   .   .   338</a>
-<a href="#7.23.2">         7.23.2 Time manipulation functions       . . . . . . . . . . .     .   .   .   339</a>
-<a href="#7.23.3">         7.23.3 Time conversion functions       . . . . . . . . . . . .     .   .   .   341</a>
-<a href="#7.24">  7.24   Extended multibyte and wide character utilities &lt;wchar.h&gt; . .      .   .   .   348</a>
-<a href="#7.24.1">         7.24.1 Introduction . . . . . . . . . . . . . . . . . .            .   .   .   348</a>
-<a href="#7.24.2">         7.24.2 Formatted wide character input/output functions     . . .   .   .   .   349</a>
-<a href="#7.24.3">         7.24.3 Wide character input/output functions       . . . . . . .   .   .   .   367</a>
-<a href="#7.24.4">         7.24.4 General wide string utilities     . . . . . . . . . . .     .   .   .   371</a>
-<a href="#7.24.5">         7.24.5 Wide character time conversion functions      . . . . . .   .   .   .   385</a>
-<a href="#7.24.6">         7.24.6 Extended multibyte/wide character conversion utilities .    .   .   .   386</a>
-<a href="#7.25">  7.25   Wide character classification and mapping utilities &lt;wctype.h&gt;      .   .   .   393</a>
-<a href="#7.25.1">         7.25.1 Introduction . . . . . . . . . . . . . . . . . .            .   .   .   393</a>
-<a href="#7.25.2">         7.25.2 Wide character classification utilities . . . . . . . .      .   .   .   394</a>
-<a href="#7.25.3">         7.25.3 Wide character case mapping utilities . . . . . . . .       .   .   .   399</a>
-<a href="#7.26">  7.26   Future library directions    . . . . . . . . . . . . . . . .       .   .   .   401</a>
-<a href="#7.26.1">         7.26.1 Complex arithmetic &lt;complex.h&gt; . . . . . . . .              .   .   .   401</a>
-<a href="#7.26.2">         7.26.2 Character handling &lt;ctype.h&gt;           . . . . . . . . .    .   .   .   401</a>
-<a href="#7.26.3">         7.26.3 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .      .   .   .   401</a>
-<a href="#7.26.4">         7.26.4 Format conversion of integer types &lt;inttypes.h&gt;         .   .   .   .   401</a>
-<a href="#7.26.5">         7.26.5 Localization &lt;locale.h&gt;           . . . . . . . . . . .     .   .   .   401</a>
-<a href="#7.26.6">         7.26.6 Signal handling &lt;signal.h&gt;           . . . . . . . . . .    .   .   .   401</a>
-<a href="#7.26.7">         7.26.7 Boolean type and values &lt;stdbool.h&gt;           . . . . . .   .   .   .   401</a>
-<a href="#7.26.8">         7.26.8 Integer types &lt;stdint.h&gt;          . . . . . . . . . . .     .   .   .   401</a>
-<a href="#7.26.9">         7.26.9 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .     .   .   .   402</a>
-
-[page vii]
-
-<a href="#7.26.10">        7.26.10 General utilities &lt;stdlib.h&gt;      . . . . . . .            . . . . . . 402</a>
-<a href="#7.26.11">        7.26.11 String handling &lt;string.h&gt;        . . . . . . .            . . . . . . 402</a>
-<a href="#7.26.12">        7.26.12 Extended multibyte and wide character utilities
-                &lt;wchar.h&gt;          . . . . . . . . . . . . . .             . . . . . . 402</a>
-<a href="#7.26.13">        7.26.13 Wide character classification and mapping utilities
-                &lt;wctype.h&gt; . . . . . . . . . . . . . .                     . . . . . . 402</a>
-<a href="#A">Annex A (informative) Language syntax summary   . .       .    .   .   .   .   .   .   .   .   .   403</a>
-<a href="#A.1">  A.1 Lexical grammar       . . . . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   403</a>
-<a href="#A.2">  A.2 Phrase structure grammar . . . . . . . . .          .    .   .   .   .   .   .   .   .   .   409</a>
-<a href="#A.3">  A.3 Preprocessing directives    . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   416</a>
-<a href="#B">Annex B (informative) Library summary     . . . . . . . . . . . . .                    .   .   .   419</a>
-<a href="#B.1">  B.1 Diagnostics &lt;assert.h&gt;          . . . . . . . . . . . . . . .                    .   .   .   419</a>
-<a href="#B.2">  B.2 Complex &lt;complex.h&gt; . . . . . . . . . . . . . . . .                              .   .   .   419</a>
-<a href="#B.3">  B.3 Character handling &lt;ctype.h&gt; . . . . . . . . . . . . .                           .   .   .   421</a>
-<a href="#B.4">  B.4 Errors &lt;errno.h&gt;         . . . . . . . . . . . . . . . . . .                     .   .   .   421</a>
-<a href="#B.5">  B.5 Floating-point environment &lt;fenv.h&gt;          . . . . . . . . . .                 .   .   .   421</a>
-<a href="#B.6">  B.6 Characteristics of floating types &lt;float.h&gt; . . . . . . . .                       .   .   .   422</a>
-<a href="#B.7">  B.7 Format conversion of integer types &lt;inttypes.h&gt; . . . . .                        .   .   .   422</a>
-<a href="#B.8">  B.8 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . . .                         .   .   .   423</a>
-<a href="#B.9">  B.9 Sizes of integer types &lt;limits.h&gt;          . . . . . . . . . . .                 .   .   .   423</a>
-<a href="#B.10">  B.10 Localization &lt;locale.h&gt; . . . . . . . . . . . . . . .                           .   .   .   423</a>
-<a href="#B.11">  B.11 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . . .                            .   .   .   423</a>
-<a href="#B.12">  B.12 Nonlocal jumps &lt;setjmp.h&gt;          . . . . . . . . . . . . .                    .   .   .   428</a>
-<a href="#B.13">  B.13 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . . .                          .   .   .   428</a>
-<a href="#B.14">  B.14 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . . .                   .   .   .   428</a>
-<a href="#B.15">  B.15 Boolean type and values &lt;stdbool.h&gt;           . . . . . . . . .                 .   .   .   428</a>
-<a href="#B.16">  B.16 Common definitions &lt;stddef.h&gt; . . . . . . . . . . . .                            .   .   .   429</a>
-<a href="#B.17">  B.17 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . . .                          .   .   .   429</a>
-<a href="#B.18">  B.18 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   429</a>
-<a href="#B.19">  B.19 General utilities &lt;stdlib.h&gt;       . . . . . . . . . . . . .                    .   .   .   431</a>
-<a href="#B.20">  B.20 String handling &lt;string.h&gt; . . . . . . . . . . . . . .                          .   .   .   433</a>
-<a href="#B.21">  B.21 Type-generic math &lt;tgmath.h&gt;          . . . . . . . . . . . .                   .   .   .   434</a>
-<a href="#B.22">  B.22 Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   434</a>
-<a href="#B.23">  B.23 Extended multibyte/wide character utilities &lt;wchar.h&gt;     . . .                 .   .   .   435</a>
-<a href="#B.24">  B.24 Wide character classification and mapping utilities &lt;wctype.h&gt;                   .   .   .   437</a>
-<a href="#C">Annex C (informative) Sequence points     . . . . . . . . . . . . . . . . . 439</a>
-<a href="#D">Annex D (normative) Universal character names for identifiers           . . . . . . . 440</a>
-<a href="#E">Annex E (informative) Implementation limits        . . . . . . . . . . . . . . 442</a>
-<a href="#F">Annex F (normative) IEC 60559 floating-point arithmetic    .    .   .   .   .   .   .   .   .   .   444</a>
-<a href="#F.1">  F.1 Introduction     . . . . . . . . . . . . . .        .    .   .   .   .   .   .   .   .   .   444</a>
-<a href="#F.2">  F.2 Types . . . . . . . . . . . . . . . . .             .    .   .   .   .   .   .   .   .   .   444</a>
-<a href="#F.3">  F.3 Operators and functions     . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   445</a>
-
-[page viii]
-
-<a href="#F.4">   F.4   Floating to integer conversion       .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   447</a>
-<a href="#F.5">   F.5   Binary-decimal conversion        .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   447</a>
-<a href="#F.6">   F.6   Contracted expressions . .       .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   448</a>
-<a href="#F.7">   F.7   Floating-point environment       .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   448</a>
-<a href="#F.8">   F.8   Optimization . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   451</a>
-<a href="#F.9">   F.9   Mathematics &lt;math.h&gt; .           .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   454</a>
-<a href="#G">Annex G (informative) IEC 60559-compatible complex arithmetic                              .   .   .   .   .   .   467</a>
-<a href="#G.1">  G.1 Introduction      . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   467</a>
-<a href="#G.2">  G.2 Types . . . . . . . . . . . . . . . . . . . .                                   .    .   .   .   .   .   .   467</a>
-<a href="#G.3">  G.3 Conventions       . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   467</a>
-<a href="#G.4">  G.4 Conversions       . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   468</a>
-<a href="#G.5">  G.5 Binary operators      . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   468</a>
-<a href="#G.6">  G.6 Complex arithmetic &lt;complex.h&gt;          . . . . . . .                           .    .   .   .   .   .   .   472</a>
-<a href="#G.7">  G.7 Type-generic math &lt;tgmath.h&gt;          . . . . . . . .                           .    .   .   .   .   .   .   480</a>
-<a href="#H">Annex H (informative) Language independent arithmetic . .                         .   .    .   .   .   .   .   .   481</a>
-<a href="#H.1">  H.1 Introduction     . . . . . . . . . . . . . . . .                            .   .    .   .   .   .   .   .   481</a>
-<a href="#H.2">  H.2 Types . . . . . . . . . . . . . . . . . . .                                 .   .    .   .   .   .   .   .   481</a>
-<a href="#H.3">  H.3 Notification      . . . . . . . . . . . . . . . .                            .   .    .   .   .   .   .   .   485</a>
-<a href="#I">Annex I (informative) Common warnings             . . . . . . . . . . . . . . . . 487</a>
-<a href="#J">Annex J (informative) Portability issues      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   489</a>
-<a href="#J.1">  J.1 Unspecified behavior . . . .             . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   489</a>
-<a href="#J.2">  J.2 Undefined behavior          . . . .      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   492</a>
-<a href="#J.3">  J.3 Implementation-defined behavior            . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   505</a>
-<a href="#J.4">  J.4 Locale-specific behavior         . .     . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   512</a>
-<a href="#J.5">  J.5 Common extensions          . . . .      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   513</a>
-<a href="#Bibliography">Bibliography      . . . . . . . . . . . . . . . . . . . . . . . . . . . 516</a>
-<a href="#Index">Index     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519</a>
-
-[<a name="pix" href="#pix">page ix</a>] (<a href="#Contents">Contents</a>)
-
-
-[<a name="px" href="#px">page x</a>] (<a href="#Contents">Contents</a>)
-
-<a name="Foreword" href="#Foreword"><b>    Foreword</b></a>
-1   ISO (the International Organization for Standardization) and IEC (the International
-    Electrotechnical Commission) form the specialized system for worldwide
-    standardization. National bodies that are member of ISO or IEC participate in the
-    development of International Standards through technical committees established by the
-    respective organization to deal with particular fields of technical activity. ISO and IEC
-    technical committees collaborate in fields of mutual interest. Other international
-    organizations, governmental and non-governmental, in liaison with ISO and IEC, also
-    take part in the work.
-2   International Standards are drafted in accordance with the rules given in the ISO/IEC
-    Directives, Part 3.
-3   In the field of information technology, ISO and IEC have established a joint technical
-    committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
-    committee are circulated to national bodies for voting. Publication as an International
-    Standard requires approval by at least 75% of the national bodies casting a vote.
-4   International Standard ISO/IEC 9899 was prepared by Joint Technical Committee
-    ISO/IEC JTC 1, Information technology, Subcommittee SC 22, Programming languages,
-    their environments and system software interfaces. The Working Group responsible for
-    this standard (WG 14) maintains a site on the World Wide Web at
-    http://www.open-std.org/JTC1/SC22/WG14/                        containing      additional
-    information relevant to this standard such as a Rationale for many of the decisions made
-    during its preparation and a log of Defect Reports and Responses.
-5   This second edition cancels and replaces the first edition, ISO/IEC 9899:1990, as
-    amended and corrected by ISO/IEC 9899/COR1:1994, ISO/IEC 9899/AMD1:1995, and
-    ISO/IEC 9899/COR2:1996. Major changes from the previous edition include:
-    -- restricted character set support via digraphs and <a href="#7.9">&lt;iso646.h&gt;</a> (originally specified
-      in AMD1)
-    -- wide character library support in <a href="#7.24">&lt;wchar.h&gt;</a> and <a href="#7.25">&lt;wctype.h&gt;</a> (originally
-      specified in AMD1)
-    -- more precise aliasing rules via effective type
-    -- restricted pointers
-    -- variable length arrays
-    -- flexible array members
-    -- static and type qualifiers in parameter array declarators
-    -- complex (and imaginary) support in <a href="#7.3">&lt;complex.h&gt;</a>
-    -- type-generic math macros in <a href="#7.22">&lt;tgmath.h&gt;</a>
-    -- the long long int type and library functions
-
-[<a name="pxi" href="#pxi">page xi</a>] (<a href="#Contents">Contents</a>)
-
--- increased minimum translation limits
--- additional floating-point characteristics in <a href="#7.7">&lt;float.h&gt;</a>
--- remove implicit int
--- reliable integer division
--- universal character names (\u and \U)
--- extended identifiers
--- hexadecimal floating-point constants and %a and %A printf/scanf conversion
-  specifiers
--- compound literals
--- designated initializers
--- // comments
--- extended integer types and library functions in <a href="#7.8">&lt;inttypes.h&gt;</a> and <a href="#7.18">&lt;stdint.h&gt;</a>
--- remove implicit function declaration
--- preprocessor arithmetic done in intmax_t/uintmax_t
--- mixed declarations and code
--- new block scopes for selection and iteration statements
--- integer constant type rules
--- integer promotion rules
--- macros with a variable number of arguments
--- the vscanf family of functions in <a href="#7.19">&lt;stdio.h&gt;</a> and <a href="#7.24">&lt;wchar.h&gt;</a>
--- additional math library functions in <a href="#7.12">&lt;math.h&gt;</a>
--- treatment of error conditions by math library functions (math_errhandling)
--- floating-point environment access in <a href="#7.6">&lt;fenv.h&gt;</a>
--- IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
--- trailing comma allowed in enum declaration
--- %lf conversion specifier allowed in printf
--- inline functions
--- the snprintf family of functions in <a href="#7.19">&lt;stdio.h&gt;</a>
--- boolean type in <a href="#7.16">&lt;stdbool.h&gt;</a>
--- idempotent type qualifiers
--- empty macro arguments
-
-[<a name="pxii" href="#pxii">page xii</a>] (<a href="#Contents">Contents</a>)
-
-    -- new structure type compatibility rules (tag compatibility)
-    -- additional predefined macro names
-    -- _Pragma preprocessing operator
-    -- standard pragmas
-    -- __func__ predefined identifier
-    -- va_copy macro
-    -- additional strftime conversion specifiers
-    -- LIA compatibility annex
-    -- deprecate ungetc at the beginning of a binary file
-    -- remove deprecation of aliased array parameters
-    -- conversion of array to pointer not limited to lvalues
-    -- relaxed constraints on aggregate and union initialization
-    -- relaxed restrictions on portable header names
-    -- return without expression not permitted in function that returns a value (and vice
-      versa)
-6   Annexes D and F form a normative part of this standard; annexes A, B, C, E, G, H, I, J,
-    the bibliography, and the index are for information only. In accordance with Part 3 of the
-    ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples are
-    also for information only.
-
-[<a name="pxiii" href="#pxiii">page xiii</a>] (<a href="#Contents">Contents</a>)
-
-<a name="Introduction" href="#Introduction"><b>    Introduction</b></a>
-1   With the introduction of new devices and extended character sets, new features may be
-    added to this International Standard. Subclauses in the language and library clauses warn
-    implementors and programmers of usages which, though valid in themselves, may
-    conflict with future additions.
-2   Certain features are obsolescent, which means that they may be considered for
-    withdrawal in future revisions of this International Standard. They are retained because
-    of their widespread use, but their use in new implementations (for implementation
-    features) or new programs (for language [6.11] or library features [7.26]) is discouraged.
-3   This International Standard is divided into four major subdivisions:
-    -- preliminary elements (clauses 1-4);
-    -- the characteristics of environments that translate and execute C programs (clause 5);
-    -- the language syntax, constraints, and semantics (clause 6);
-    -- the library facilities (clause 7).
-4   Examples are provided to illustrate possible forms of the constructions described.
-    Footnotes are provided to emphasize consequences of the rules described in that
-    subclause or elsewhere in this International Standard. References are used to refer to
-    other related subclauses. Recommendations are provided to give advice or guidance to
-    implementors. Annexes provide additional information and summarize the information
-    contained in this International Standard. A bibliography lists documents that were
-    referred to during the preparation of the standard.
-5   The language clause (clause 6) is derived from ''The C Reference Manual''.
-6   The library clause (clause 7) is based on the 1984 /usr/group Standard.
-
-[<a name="pxiv" href="#pxiv">page xiv</a>] (<a href="#Contents">Contents</a>)
-
-
-
-    Programming languages -- C
-
-
-
-
-<a name="1" href="#1"><b>    1. Scope</b></a>
-1   This International Standard specifies the form and establishes the interpretation of
-    programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
-    -- the representation of C programs;
-    -- the syntax and constraints of the C language;
-    -- the semantic rules for interpreting C programs;
-    -- the representation of input data to be processed by C programs;
-    -- the representation of output data produced by C programs;
-    -- the restrictions and limits imposed by a conforming implementation of C.
-2   This International Standard does not specify
-    -- the mechanism by which C programs are transformed for use by a data-processing
-      system;
-    -- the mechanism by which C programs are invoked for use by a data-processing
-      system;
-    -- the mechanism by which input data are transformed for use by a C program;
-    -- the mechanism by which output data are transformed after being produced by a C
-      program;
-    -- the size or complexity of a program and its data that will exceed the capacity of any
-      specific data-processing system or the capacity of a particular processor;
-
-
-    <sup><a name="note1" href="#note1"><b>1)</b></a></sup>   This International Standard is designed to promote the portability of C programs among a variety of
-         data-processing systems. It is intended for use by implementors and programmers.
-
-[<a name="p1" href="#p1">page 1</a>] (<a href="#Contents">Contents</a>)
-
-    -- all minimal requirements of a data-processing system that is capable of supporting a
-      conforming implementation.
-
-<a name="2" href="#2"><b>    2. Normative references</b></a>
-1   The following normative documents contain provisions which, through reference in this
-    text, constitute provisions of this International Standard. For dated references,
-    subsequent amendments to, or revisions of, any of these publications do not apply.
-    However, parties to agreements based on this International Standard are encouraged to
-    investigate the possibility of applying the most recent editions of the normative
-    documents indicated below. For undated references, the latest edition of the normative
-    document referred to applies. Members of ISO and IEC maintain registers of currently
-    valid International Standards.
-2   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and symbols for
-    use in the physical sciences and technology.
-3   ISO/IEC 646, Information technology -- ISO 7-bit coded character set for information
-    interchange.
-4   ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1: Fundamental
-    terms.
-5   ISO 4217, Codes for the representation of currencies and funds.
-6   ISO 8601, Data elements and interchange formats -- Information interchange --
-    Representation of dates and times.
-7   ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
-    Character Set (UCS).
-8   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously
-    designated IEC 559:1989).
-
-[<a name="p2" href="#p2">page 2</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="3" href="#3"><b>    3. Terms, definitions, and symbols</b></a>
-1   For the purposes of this International Standard, the following definitions apply. Other
-    terms are defined where they appear in italic type or on the left side of a syntax rule.
-    Terms explicitly defined in this International Standard are not to be presumed to refer
-    implicitly to similar terms defined elsewhere. Terms not defined in this International
-    Standard are to be interpreted according to ISO/IEC 2382-1. Mathematical symbols not
-    defined in this International Standard are to be interpreted according to ISO 31-11.
-<a name="3.1" href="#3.1"><b>    3.1</b></a>
-1   access
-    &lt;execution-time action&gt; to read or modify the value of an object
-2   NOTE 1   Where only one of these two actions is meant, ''read'' or ''modify'' is used.
-
-3   NOTE 2   "Modify'' includes the case where the new value being stored is the same as the previous value.
-
-4   NOTE 3   Expressions that are not evaluated do not access objects.
-
-<a name="3.2" href="#3.2"><b>    3.2</b></a>
-1   alignment
-    requirement that objects of a particular type be located on storage boundaries with
-    addresses that are particular multiples of a byte address
-<a name="3.3" href="#3.3"><b>    3.3</b></a>
-1   argument
-    actual argument
-    actual parameter (deprecated)
-    expression in the comma-separated list bounded by the parentheses in a function call
-    expression, or a sequence of preprocessing tokens in the comma-separated list bounded
-    by the parentheses in a function-like macro invocation
-<a name="3.4" href="#3.4"><b>    3.4</b></a>
-1   behavior
-    external appearance or action
-<a name="3.4.1" href="#3.4.1"><b>    3.4.1</b></a>
-1   implementation-defined behavior
-    unspecified behavior where each implementation documents how the choice is made
-2   EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
-    when a signed integer is shifted right.
-
-<a name="3.4.2" href="#3.4.2"><b>    3.4.2</b></a>
-1   locale-specific behavior
-    behavior that depends on local conventions of nationality, culture, and language that each
-    implementation documents
-
-[<a name="p3" href="#p3">page 3</a>] (<a href="#Contents">Contents</a>)
-
-2   EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
-    characters other than the 26 lowercase Latin letters.
-
-<a name="3.4.3" href="#3.4.3"><b>    3.4.3</b></a>
-1   undefined behavior
-    behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
-    for which this International Standard imposes no requirements
-2   NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
-    results, to behaving during translation or program execution in a documented manner characteristic of the
-    environment (with or without the issuance of a diagnostic message), to terminating a translation or
-    execution (with the issuance of a diagnostic message).
-
-3   EXAMPLE        An example of undefined behavior is the behavior on integer overflow.
-
-<a name="3.4.4" href="#3.4.4"><b>    3.4.4</b></a>
-1   unspecified behavior
-    use of an unspecified value, or other behavior where this International Standard provides
-    two or more possibilities and imposes no further requirements on which is chosen in any
-    instance
-2   EXAMPLE        An example of unspecified behavior is the order in which the arguments to a function are
-    evaluated.
-
-<a name="3.5" href="#3.5"><b>    3.5</b></a>
-1   bit
-    unit of data storage in the execution environment large enough to hold an object that may
-    have one of two values
-2   NOTE     It need not be possible to express the address of each individual bit of an object.
-
-<a name="3.6" href="#3.6"><b>    3.6</b></a>
-1   byte
-    addressable unit of data storage large enough to hold any member of the basic character
-    set of the execution environment
-2   NOTE 1 It is possible to express the address of each individual byte of an object uniquely.
-
-3   NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
-    defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
-    bit.
-
-<a name="3.7" href="#3.7"><b>    3.7</b></a>
-1   character
-    &lt;abstract&gt; member of a set of elements used for the organization, control, or
-    representation of data
-<a name="3.7.1" href="#3.7.1"><b>    3.7.1</b></a>
-1   character
-    single-byte character
-    &lt;C&gt; bit representation that fits in a byte
-
-[<a name="p4" href="#p4">page 4</a>] (<a href="#Contents">Contents</a>)
-
-<a name="3.7.2" href="#3.7.2"><b>    3.7.2</b></a>
-1   multibyte character
-    sequence of one or more bytes representing a member of the extended character set of
-    either the source or the execution environment
-2   NOTE    The extended character set is a superset of the basic character set.
-
-<a name="3.7.3" href="#3.7.3"><b>    3.7.3</b></a>
-1   wide character
-    bit representation that fits in an object of type wchar_t, capable of representing any
-    character in the current locale
-<a name="3.8" href="#3.8"><b>    3.8</b></a>
-1   constraint
-    restriction, either syntactic or semantic, by which the exposition of language elements is
-    to be interpreted
-<a name="3.9" href="#3.9"><b>    3.9</b></a>
-1   correctly rounded result
-    representation in the result format that is nearest in value, subject to the current rounding
-    mode, to what the result would be given unlimited range and precision
-<a name="3.10" href="#3.10"><b>    3.10</b></a>
-1   diagnostic message
-    message belonging to an implementation-defined subset of the implementation's message
-    output
-<a name="3.11" href="#3.11"><b>    3.11</b></a>
-1   forward reference
-    reference to a later subclause of this International Standard that contains additional
-    information relevant to this subclause
-<a name="3.12" href="#3.12"><b>    3.12</b></a>
-1   implementation
-    particular set of software, running in a particular translation environment under particular
-    control options, that performs translation of programs for, and supports execution of
-    functions in, a particular execution environment
-<a name="3.13" href="#3.13"><b>    3.13</b></a>
-1   implementation limit
-    restriction imposed upon programs by the implementation
-<a name="3.14" href="#3.14"><b>    3.14</b></a>
-1   object
-    region of data storage in the execution environment, the contents of which can represent
-    values
-
-[<a name="p5" href="#p5">page 5</a>] (<a href="#Contents">Contents</a>)
-
-2   NOTE     When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
-
-<a name="3.15" href="#3.15"><b>    3.15</b></a>
-1   parameter
-    formal parameter
-    formal argument (deprecated)
-    object declared as part of a function declaration or definition that acquires a value on
-    entry to the function, or an identifier from the comma-separated list bounded by the
-    parentheses immediately following the macro name in a function-like macro definition
-<a name="3.16" href="#3.16"><b>    3.16</b></a>
-1   recommended practice
-    specification that is strongly recommended as being in keeping with the intent of the
-    standard, but that may be impractical for some implementations
-<a name="3.17" href="#3.17"><b>    3.17</b></a>
-1   value
-    precise meaning of the contents of an object when interpreted as having a specific type
-<a name="3.17.1" href="#3.17.1"><b>    3.17.1</b></a>
-1   implementation-defined value
-    unspecified value where each implementation documents how the choice is made
-<a name="3.17.2" href="#3.17.2"><b>    3.17.2</b></a>
-1   indeterminate value
-    either an unspecified value or a trap representation
-<a name="3.17.3" href="#3.17.3"><b>    3.17.3</b></a>
-1   unspecified value
-    valid value of the relevant type where this International Standard imposes no
-    requirements on which value is chosen in any instance
-2   NOTE     An unspecified value cannot be a trap representation.
-
-<a name="3.18" href="#3.18"><b>    3.18</b></a>
-1   ??? x???
-    ceiling of x: the least integer greater than or equal to x
-2   EXAMPLE       ???2.4??? is 3, ???-2.4??? is -2.
-
-<a name="3.19" href="#3.19"><b>    3.19</b></a>
-1   ??? x???
-    floor of x: the greatest integer less than or equal to x
-2   EXAMPLE       ???2.4??? is 2, ???-2.4??? is -3.
-
-[<a name="p6" href="#p6">page 6</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="4" href="#4"><b>    4. Conformance</b></a>
-1   In this International Standard, ''shall'' is to be interpreted as a requirement on an
-    implementation or on a program; conversely, ''shall not'' is to be interpreted as a
-    prohibition.
-2   If a ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated, the
-    behavior is undefined. Undefined behavior is otherwise indicated in this International
-    Standard by the words ''undefined behavior'' or by the omission of any explicit definition
-    of behavior. There is no difference in emphasis among these three; they all describe
-    ''behavior that is undefined''.
-3   A program that is correct in all other aspects, operating on correct data, containing
-    unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
-4   The implementation shall not successfully translate a preprocessing translation unit
-    containing a #error preprocessing directive unless it is part of a group skipped by
-    conditional inclusion.
-5   A strictly conforming program shall use only those features of the language and library
-    specified in this International Standard.<sup><a href="#note2"><b>2)</b></a></sup> It shall not produce output dependent on any
-    unspecified, undefined, or implementation-defined behavior, and shall not exceed any
-    minimum implementation limit.
-6   The two forms of conforming implementation are hosted and freestanding. A conforming
-    hosted implementation shall accept any strictly conforming program. A conforming
-    freestanding implementation shall accept any strictly conforming program that does not
-    use complex types and in which the use of the features specified in the library clause
-    (clause 7) is confined to the contents of the standard headers <a href="#7.7">&lt;float.h&gt;</a>,
-    <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#7.15">&lt;stdarg.h&gt;</a>, <a href="#7.16">&lt;stdbool.h&gt;</a>, <a href="#7.17">&lt;stddef.h&gt;</a>, and
-    <a href="#7.18">&lt;stdint.h&gt;</a>. A conforming implementation may have extensions (including additional
-    library functions), provided they do not alter the behavior of any strictly conforming
-    program.<sup><a href="#note3"><b>3)</b></a></sup>
-
-
-
-    <sup><a name="note2" href="#note2"><b>2)</b></a></sup>   A strictly conforming program can use conditional features (such as those in <a href="#F">annex F</a>) provided the
-         use is guarded by a #ifdef directive with the appropriate macro. For example:
-                 #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
-                    /* ... */
-                    fesetround(FE_UPWARD);
-                    /* ... */
-                 #endif
-
-    <sup><a name="note3" href="#note3"><b>3)</b></a></sup>   This implies that a conforming implementation reserves no identifiers other than those explicitly
-         reserved in this International Standard.
-
-[<a name="p7" href="#p7">page 7</a>] (<a href="#Contents">Contents</a>)
-
-7   A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note4"><b>4)</b></a></sup>
-8   An implementation shall be accompanied by a document that defines all implementation-
-    defined and locale-specific characteristics and all extensions.
-    Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
-    characteristics of floating types <a href="#7.7">&lt;float.h&gt;</a> (<a href="#7.7">7.7</a>), alternative spellings <a href="#7.9">&lt;iso646.h&gt;</a>
-    (<a href="#7.9">7.9</a>), sizes of integer types <a href="#7.10">&lt;limits.h&gt;</a> (<a href="#7.10">7.10</a>), variable arguments <a href="#7.15">&lt;stdarg.h&gt;</a>
-    (<a href="#7.15">7.15</a>), boolean type and values <a href="#7.16">&lt;stdbool.h&gt;</a> (<a href="#7.16">7.16</a>), common definitions
-    <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), integer types <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#7.18">7.18</a>).
-
-
-
-
-    <sup><a name="note4" href="#note4"><b>4)</b></a></sup>   Strictly conforming programs are intended to be maximally portable among conforming
-         implementations. Conforming programs may depend upon nonportable features of a conforming
-         implementation.
-
-[<a name="p8" href="#p8">page 8</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="5" href="#5"><b>    5. Environment</b></a>
-1   An implementation translates C source files and executes C programs in two data-
-    processing-system environments, which will be called the translation environment and
-    the execution environment in this International Standard. Their characteristics define and
-    constrain the results of executing conforming C programs constructed according to the
-    syntactic and semantic rules for conforming implementations.
-    Forward references: In this clause, only a few of many possible forward references
-    have been noted.
-<a name="5.1" href="#5.1"><b>    5.1 Conceptual models</b></a>
-<a name="5.1.1" href="#5.1.1"><b>    5.1.1 Translation environment</b></a>
-<a name="5.1.1.1" href="#5.1.1.1"><b>    5.1.1.1 Program structure</b></a>
-1   A C program need not all be translated at the same time. The text of the program is kept
-    in units called source files, (or preprocessing files) in this International Standard. A
-    source file together with all the headers and source files included via the preprocessing
-    directive #include is known as a preprocessing translation unit. After preprocessing, a
-    preprocessing translation unit is called a translation unit. Previously translated translation
-    units may be preserved individually or in libraries. The separate translation units of a
-    program communicate by (for example) calls to functions whose identifiers have external
-    linkage, manipulation of objects whose identifiers have external linkage, or manipulation
-    of data files. Translation units may be separately translated and then later linked to
-    produce an executable program.
-    Forward references: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
-    preprocessing directives (<a href="#6.10">6.10</a>).
-<a name="5.1.1.2" href="#5.1.1.2"><b>    5.1.1.2 Translation phases</b></a>
-1   The precedence among the syntax rules of translation is specified by the following
-    phases.<sup><a href="#note5"><b>5)</b></a></sup>
-         1. Physical source file multibyte characters are mapped, in an implementation-
-            defined manner, to the source character set (introducing new-line characters for
-            end-of-line indicators) if necessary. Trigraph sequences are replaced by
-            corresponding single-character internal representations.
-
-
-
-    <sup><a name="note5" href="#note5"><b>5)</b></a></sup>    Implementations shall behave as if these separate phases occur, even though many are typically folded
-          together in practice. Source files, translation units, and translated translation units need not
-          necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
-          and any external representation. The description is conceptual only, and does not specify any
-          particular implementation.
-
-[<a name="p9" href="#p9">page 9</a>] (<a href="#Contents">Contents</a>)
-
-     2. Each instance of a backslash character (\) immediately followed by a new-line
-        character is deleted, splicing physical source lines to form logical source lines.
-        Only the last backslash on any physical source line shall be eligible for being part
-        of such a splice. A source file that is not empty shall end in a new-line character,
-        which shall not be immediately preceded by a backslash character before any such
-        splicing takes place.
-     3. The source file is decomposed into preprocessing tokens<sup><a href="#note6"><b>6)</b></a></sup> and sequences of
-        white-space characters (including comments). A source file shall not end in a
-        partial preprocessing token or in a partial comment. Each comment is replaced by
-        one space character. New-line characters are retained. Whether each nonempty
-        sequence of white-space characters other than new-line is retained or replaced by
-        one space character is implementation-defined.
-     4.   Preprocessing directives are executed, macro invocations are expanded, and
-          _Pragma unary operator expressions are executed. If a character sequence that
-          matches the syntax of a universal character name is produced by token
-          concatenation (<a href="#6.10.3.3">6.10.3.3</a>), the behavior is undefined. A #include preprocessing
-          directive causes the named header or source file to be processed from phase 1
-          through phase 4, recursively. All preprocessing directives are then deleted.
-     5.   Each source character set member and escape sequence in character constants and
-          string literals is converted to the corresponding member of the execution character
-          set; if there is no corresponding member, it is converted to an implementation-
-          defined member other than the null (wide) character.<sup><a href="#note7"><b>7)</b></a></sup>
-     6. Adjacent string literal tokens are concatenated.
-     7. White-space characters separating tokens are no longer significant. Each
-        preprocessing token is converted into a token. The resulting tokens are
-        syntactically and semantically analyzed and translated as a translation unit.
-     8. All external object and function references are resolved. Library components are
-        linked to satisfy external references to functions and objects not defined in the
-        current translation. All such translator output is collected into a program image
-        which contains information needed for execution in its execution environment.
-Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
-preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href="#5.2.1.1">5.2.1.1</a>), external definitions (<a href="#6.9">6.9</a>).
-
-
-
-<sup><a name="note6" href="#note6"><b>6)</b></a></sup>    As described in <a href="#6.4">6.4</a>, the process of dividing a source file's characters into preprocessing tokens is
-      context-dependent. For example, see the handling of &lt; within a #include preprocessing directive.
-<sup><a name="note7" href="#note7"><b>7)</b></a></sup>    An implementation need not convert all non-corresponding source characters to the same execution
-      character.
-
-[<a name="p10" href="#p10">page 10</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.1.1.3" href="#5.1.1.3"><b>    5.1.1.3 Diagnostics</b></a>
-1   A conforming implementation shall produce at least one diagnostic message (identified in
-    an implementation-defined manner) if a preprocessing translation unit or translation unit
-    contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
-    specified as undefined or implementation-defined. Diagnostic messages need not be
-    produced in other circumstances.<sup><a href="#note8"><b>8)</b></a></sup>
-2   EXAMPLE        An implementation shall issue a diagnostic for the translation unit:
-             char i;
-             int i;
-    because in those cases where wording in this International Standard describes the behavior for a construct
-    as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
-
-<a name="5.1.2" href="#5.1.2"><b>    5.1.2 Execution environments</b></a>
-1   Two execution environments are defined: freestanding and hosted. In both cases,
-    program startup occurs when a designated C function is called by the execution
-    environment. All objects with static storage duration shall be initialized (set to their
-    initial values) before program startup. The manner and timing of such initialization are
-    otherwise unspecified. Program termination returns control to the execution
-    environment.
-    Forward references: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.8">6.7.8</a>).
-<a name="5.1.2.1" href="#5.1.2.1"><b>    5.1.2.1 Freestanding environment</b></a>
-1   In a freestanding environment (in which C program execution may take place without any
-    benefit of an operating system), the name and type of the function called at program
-    startup are implementation-defined. Any library facilities available to a freestanding
-    program, other than the minimal set required by clause 4, are implementation-defined.
-2   The effect of program termination in a freestanding environment is implementation-
-    defined.
-<a name="5.1.2.2" href="#5.1.2.2"><b>    5.1.2.2 Hosted environment</b></a>
-1   A hosted environment need not be provided, but shall conform to the following
-    specifications if present.
-
-
-
-
-    <sup><a name="note8" href="#note8"><b>8)</b></a></sup>   The intent is that an implementation should identify the nature of, and where possible localize, each
-         violation. Of course, an implementation is free to produce any number of diagnostics as long as a
-         valid program is still correctly translated. It may also successfully translate an invalid program.
-
-[<a name="p11" href="#p11">page 11</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.1.2.2.1" href="#5.1.2.2.1"><b>    5.1.2.2.1 Program startup</b></a>
-1   The function called at program startup is named main. The implementation declares no
-    prototype for this function. It shall be defined with a return type of int and with no
-    parameters:
-            int main(void) { /* ... */ }
-    or with two parameters (referred to here as argc and argv, though any names may be
-    used, as they are local to the function in which they are declared):
-            int main(int argc, char *argv[]) { /* ... */ }
-    or equivalent;<sup><a href="#note9"><b>9)</b></a></sup> or in some other implementation-defined manner.
-2   If they are declared, the parameters to the main function shall obey the following
-    constraints:
-    -- The value of argc shall be nonnegative.
-    -- argv[argc] shall be a null pointer.
-    -- If the value of argc is greater than zero, the array members argv[0] through
-      argv[argc-1] inclusive shall contain pointers to strings, which are given
-      implementation-defined values by the host environment prior to program startup. The
-      intent is to supply to the program information determined prior to program startup
-      from elsewhere in the hosted environment. If the host environment is not capable of
-      supplying strings with letters in both uppercase and lowercase, the implementation
-      shall ensure that the strings are received in lowercase.
-    -- If the value of argc is greater than zero, the string pointed to by argv[0]
-      represents the program name; argv[0][0] shall be the null character if the
-      program name is not available from the host environment. If the value of argc is
-      greater than one, the strings pointed to by argv[1] through argv[argc-1]
-      represent the program parameters.
-    -- The parameters argc and argv and the strings pointed to by the argv array shall
-      be modifiable by the program, and retain their last-stored values between program
-      startup and program termination.
-<a name="5.1.2.2.2" href="#5.1.2.2.2"><b>    5.1.2.2.2 Program execution</b></a>
-1   In a hosted environment, a program may use all the functions, macros, type definitions,
-    and objects described in the library clause (clause 7).
-
-
-
-    <sup><a name="note9" href="#note9"><b>9)</b></a></sup>   Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
-         char ** argv, and so on.
-
-[<a name="p12" href="#p12">page 12</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.1.2.2.3" href="#5.1.2.2.3"><b>    5.1.2.2.3 Program termination</b></a>
-1   If the return type of the main function is a type compatible with int, a return from the
-    initial call to the main function is equivalent to calling the exit function with the value
-    returned by the main function as its argument;<sup><a href="#note10"><b>10)</b></a></sup> reaching the } that terminates the
-    main function returns a value of 0. If the return type is not compatible with int, the
-    termination status returned to the host environment is unspecified.
-    Forward references: definition of terms (<a href="#7.1.1">7.1.1</a>), the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
-<a name="5.1.2.3" href="#5.1.2.3"><b>    5.1.2.3 Program execution</b></a>
-1   The semantic descriptions in this International Standard describe the behavior of an
-    abstract machine in which issues of optimization are irrelevant.
-2   Accessing a volatile object, modifying an object, modifying a file, or calling a function
-    that does any of those operations are all side effects,<sup><a href="#note11"><b>11)</b></a></sup> which are changes in the state of
-    the execution environment. Evaluation of an expression may produce side effects. At
-    certain specified points in the execution sequence called sequence points, all side effects
-    of previous evaluations shall be complete and no side effects of subsequent evaluations
-    shall have taken place. (A summary of the sequence points is given in <a href="#C">annex C</a>.)
-3   In the abstract machine, all expressions are evaluated as specified by the semantics. An
-    actual implementation need not evaluate part of an expression if it can deduce that its
-    value is not used and that no needed side effects are produced (including any caused by
-    calling a function or accessing a volatile object).
-4   When the processing of the abstract machine is interrupted by receipt of a signal, only the
-    values of objects as of the previous sequence point may be relied on. Objects that may be
-    modified between the previous sequence point and the next sequence point need not have
-    received their correct values yet.
-5   The least requirements on a conforming implementation are:
-    -- At sequence points, volatile objects are stable in the sense that previous accesses are
-      complete and subsequent accesses have not yet occurred.
-
-
-
-
-    <sup><a name="note10" href="#note10"><b>10)</b></a></sup> In accordance with <a href="#6.2.4">6.2.4</a>, the lifetimes of objects with automatic storage duration declared in main
-        will have ended in the former case, even where they would not have in the latter.
-    <sup><a name="note11" href="#note11"><b>11)</b></a></sup> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
-        flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
-        values of floating-point operations. Implementations that support such floating-point state are
-        required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
-        environment library <a href="#7.6">&lt;fenv.h&gt;</a> provides a programming facility for indicating when these side
-        effects matter, freeing the implementations in other cases.
-
-[<a name="p13" href="#p13">page 13</a>] (<a href="#Contents">Contents</a>)
-
-     -- At program termination, all data written into files shall be identical to the result that
-       execution of the program according to the abstract semantics would have produced.
-     -- The input and output dynamics of interactive devices shall take place as specified in
-<a name="7.19.3" href="#7.19.3"><b>       7.19.3. The intent of these requirements is that unbuffered or line-buffered output</b></a>
-       appear as soon as possible, to ensure that prompting messages actually appear prior to
-       a program waiting for input.
-6    What constitutes an interactive device is implementation-defined.
-7    More stringent correspondences between abstract and actual semantics may be defined by
-     each implementation.
-8    EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
-     semantics: at every sequence point, the values of the actual objects would agree with those specified by the
-     abstract semantics. The keyword volatile would then be redundant.
-9    Alternatively, an implementation might perform various optimizations within each translation unit, such
-     that the actual semantics would agree with the abstract semantics only when making function calls across
-     translation unit boundaries. In such an implementation, at the time of each function entry and function
-     return where the calling function and the called function are in different translation units, the values of all
-     externally linked objects and of all objects accessible via pointers therein would agree with the abstract
-     semantics. Furthermore, at the time of each such function entry the values of the parameters of the called
-     function and of all objects accessible via pointers therein would agree with the abstract semantics. In this
-     type of implementation, objects referred to by interrupt service routines activated by the signal function
-     would require explicit specification of volatile storage, as well as other implementation-defined
-     restrictions.
-
-10   EXAMPLE 2       In executing the fragment
-              char c1, c2;
-              /* ... */
-              c1 = c1 + c2;
-     the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
-     and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
-     overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
-     produce the same result, possibly omitting the promotions.
-
-11   EXAMPLE 3       Similarly, in the fragment
-              float f1, f2;
-              double d;
-              /* ... */
-              f1 = f2 * d;
-     the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
-     that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
-     were replaced by the constant 2.0, which has type double).
-
-[<a name="p14" href="#p14">page 14</a>] (<a href="#Contents">Contents</a>)
-
-12   EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
-     semantics. Values are independent of whether they are represented in a register or in memory. For
-     example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
-     is required to round to the precision of the storage type. In particular, casts and assignments are required to
-     perform their specified conversion. For the fragment
-              double d1, d2;
-              float f;
-              d1 = f = expression;
-              d2 = (float) expression;
-     the values assigned to d1 and d2 are required to have been converted to float.
-
-13   EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
-     precision as well as range. The implementation cannot generally apply the mathematical associative rules
-     for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
-     overflow and underflow. Likewise, implementations cannot generally replace decimal constants in order to
-     rearrange expressions. In the following fragment, rearrangements suggested by mathematical rules for real
-     numbers are often not valid (see <a href="#F.8">F.8</a>).
-              double x, y, z;
-              /* ... */
-              x = (x * y) * z;            //   not equivalent to x   *= y * z;
-              z = (x - y) + y ;           //   not equivalent to z   = x;
-              z = x + x * y;              //   not equivalent to z   = x * (1.0 + y);
-              y = x / 5.0;                //   not equivalent to y   = x * 0.2;
-
-14   EXAMPLE 6 To illustrate the grouping behavior of expressions, in the following fragment
-              int a, b;
-              /* ... */
-              a = a + 32760 + b + 5;
-     the expression statement behaves exactly the same as
-              a = (((a + 32760) + b) + 5);
-     due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
-     next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
-     which overflows produce an explicit trap and in which the range of values representable by an int is
-     [-32768, +32767], the implementation cannot rewrite this expression as
-              a = ((a + b) + 32765);
-     since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
-     while the original expression would not; nor can the expression be rewritten either as
-              a = ((a + 32765) + b);
-     or
-              a = (a + (b + 32765));
-     since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
-     in which overflow silently generates some value and where positive and negative overflows cancel, the
-     above expression statement can be rewritten by the implementation in any of the above ways because the
-     same result will occur.
-
-[<a name="p15" href="#p15">page 15</a>] (<a href="#Contents">Contents</a>)
-
-15   EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
-     following fragment
-              #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              int sum;
-              char *p;
-              /* ... */
-              sum = sum * 10 - '0' + (*p++ = getchar());
-     the expression statement is grouped as if it were written as
-              sum = (((sum * 10) - '0') + ((*(p++)) = (getchar())));
-     but the actual increment of p can occur at any time between the previous sequence point and the next
-     sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
-     value.
-
-     Forward references: expressions (<a href="#6.5">6.5</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>), statements (<a href="#6.8">6.8</a>), the
-     signal function (<a href="#7.14">7.14</a>), files (<a href="#7.19.3">7.19.3</a>).
-
-[<a name="p16" href="#p16">page 16</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.2" href="#5.2"><b>    5.2 Environmental considerations</b></a>
-<a name="5.2.1" href="#5.2.1"><b>    5.2.1 Character sets</b></a>
-1   Two sets of characters and their associated collating sequences shall be defined: the set in
-    which source files are written (the source character set), and the set interpreted in the
-    execution environment (the execution character set). Each set is further divided into a
-    basic character set, whose contents are given by this subclause, and a set of zero or more
-    locale-specific members (which are not members of the basic character set) called
-    extended characters. The combined set is also called the extended character set. The
-    values of the members of the execution character set are implementation-defined.
-2   In a character constant or string literal, members of the execution character set shall be
-    represented by corresponding members of the source character set or by escape
-    sequences consisting of the backslash \ followed by one or more characters. A byte with
-    all bits set to 0, called the null character, shall exist in the basic execution character set; it
-    is used to terminate a character string.
-3   Both the basic source and basic execution character sets shall have the following
-    members: the 26 uppercase letters of the Latin alphabet
-             A   B   C      D   E   F    G    H    I    J    K    L   M
-             N   O   P      Q   R   S    T    U    V    W    X    Y   Z
-    the 26 lowercase letters of the Latin alphabet
-             a   b   c      d   e   f    g    h    i    j    k    l   m
-             n   o   p      q   r   s    t    u    v    w    x    y   z
-    the 10 decimal digits
-             0   1   2      3   4   5    6    7    8    9
-    the following 29 graphic characters
-             !   "   #      %   &amp;   '    (    )    *    +    ,    -   .    /    :
-             ;   &lt;   =      &gt;   ?   [    \    ]    ^    _    {    |   }    ~
-    the space character, and control characters representing horizontal tab, vertical tab, and
-    form feed. The representation of each member of the source and execution basic
-    character sets shall fit in a byte. In both the source and execution basic character sets, the
-    value of each character after 0 in the above list of decimal digits shall be one greater than
-    the value of the previous. In source files, there shall be some way of indicating the end of
-    each line of text; this International Standard treats such an end-of-line indicator as if it
-    were a single new-line character. In the basic execution character set, there shall be
-    control characters representing alert, backspace, carriage return, and new line. If any
-    other characters are encountered in a source file (except in an identifier, a character
-    constant, a string literal, a header name, a comment, or a preprocessing token that is never
-
-[<a name="p17" href="#p17">page 17</a>] (<a href="#Contents">Contents</a>)
-
-    converted to a token), the behavior is undefined.
-4   A letter is an uppercase letter or a lowercase letter as defined above; in this International
-    Standard the term does not include other characters that are letters in other alphabets.
-5   The universal character name construct provides a way to name other characters.
-    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
-    preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
-<a name="5.2.1.1" href="#5.2.1.1"><b>    5.2.1.1 Trigraph sequences</b></a>
-1   Before any other processing takes place, each occurrence of one of the following
-    sequences of three characters (called trigraph sequences<sup><a href="#note12"><b>12)</b></a></sup>) is replaced with the
-    corresponding single character.
-           ??=      #                       ??)      ]                       ??!     |
-           ??(      [                       ??'      ^                       ??&gt;     }
-           ??/      \                       ??&lt;      {                       ??-     ~
-    No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
-    above is not changed.
-2   EXAMPLE 1
-              ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)
-    becomes
-              #define arraycheck(a, b) a[b] || b[a]
-
-3   EXAMPLE 2      The following source line
-              printf("Eh???/n");
-    becomes (after replacement of the trigraph sequence ??/)
-              printf("Eh?\n");
-
-<a name="5.2.1.2" href="#5.2.1.2"><b>    5.2.1.2 Multibyte characters</b></a>
-1   The source character set may contain multibyte characters, used to represent members of
-    the extended character set. The execution character set may also contain multibyte
-    characters, which need not have the same encoding as for the source character set. For
-    both character sets, the following shall hold:
-    -- The basic character set shall be present and each character shall be encoded as a
-      single byte.
-    -- The presence, meaning, and representation of any additional members is locale-
-      specific.
-
-    <sup><a name="note12" href="#note12"><b>12)</b></a></sup> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
-        described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
-
-[<a name="p18" href="#p18">page 18</a>] (<a href="#Contents">Contents</a>)
-
-    -- A multibyte character set may have a state-dependent encoding, wherein each
-      sequence of multibyte characters begins in an initial shift state and enters other
-      locale-specific shift states when specific multibyte characters are encountered in the
-      sequence. While in the initial shift state, all single-byte characters retain their usual
-      interpretation and do not alter the shift state. The interpretation for subsequent bytes
-      in the sequence is a function of the current shift state.
-    -- A byte with all bits zero shall be interpreted as a null character independent of shift
-      state. Such a byte shall not occur as part of any other multibyte character.
-2   For source files, the following shall hold:
-    -- An identifier, comment, string literal, character constant, or header name shall begin
-      and end in the initial shift state.
-    -- An identifier, comment, string literal, character constant, or header name shall consist
-      of a sequence of valid multibyte characters.
-<a name="5.2.2" href="#5.2.2"><b>    5.2.2 Character display semantics</b></a>
-1   The active position is that location on a display device where the next character output by
-    the fputc function would appear. The intent of writing a printing character (as defined
-    by the isprint function) to a display device is to display a graphic representation of
-    that character at the active position and then advance the active position to the next
-    position on the current line. The direction of writing is locale-specific. If the active
-    position is at the final position of a line (if there is one), the behavior of the display device
-    is unspecified.
-2   Alphabetic escape sequences representing nongraphic characters in the execution
-    character set are intended to produce actions on display devices as follows:
-    \a (alert) Produces an audible or visible alert without changing the active position.
-    \b (backspace) Moves the active position to the previous position on the current line. If
-       the active position is at the initial position of a line, the behavior of the display
-       device is unspecified.
-    \f ( form feed) Moves the active position to the initial position at the start of the next
-       logical page.
-    \n (new line) Moves the active position to the initial position of the next line.
-    \r (carriage return) Moves the active position to the initial position of the current line.
-    \t (horizontal tab) Moves the active position to the next horizontal tabulation position
-       on the current line. If the active position is at or past the last defined horizontal
-       tabulation position, the behavior of the display device is unspecified.
-    \v (vertical tab) Moves the active position to the initial position of the next vertical
-        tabulation position. If the active position is at or past the last defined vertical
-
-[<a name="p19" href="#p19">page 19</a>] (<a href="#Contents">Contents</a>)
-
-         tabulation position, the behavior of the display device is unspecified.
-3   Each of these escape sequences shall produce a unique implementation-defined value
-    which can be stored in a single char object. The external representations in a text file
-    need not be identical to the internal representations, and are outside the scope of this
-    International Standard.
-    Forward references: the isprint function (<a href="#7.4.1.8">7.4.1.8</a>), the fputc function (<a href="#7.19.7.3">7.19.7.3</a>).
-<a name="5.2.3" href="#5.2.3"><b>    5.2.3 Signals and interrupts</b></a>
-1   Functions shall be implemented such that they may be interrupted at any time by a signal,
-    or may be called by a signal handler, or both, with no alteration to earlier, but still active,
-    invocations' control flow (after the interruption), function return values, or objects with
-    automatic storage duration. All such objects shall be maintained outside the function
-    image (the instructions that compose the executable representation of a function) on a
-    per-invocation basis.
-<a name="5.2.4" href="#5.2.4"><b>    5.2.4 Environmental limits</b></a>
-1   Both the translation and execution environments constrain the implementation of
-    language translators and libraries. The following summarizes the language-related
-    environmental limits on a conforming implementation; the library-related limits are
-    discussed in clause 7.
-<a name="5.2.4.1" href="#5.2.4.1"><b>    5.2.4.1 Translation limits</b></a>
-1   The implementation shall be able to translate and execute at least one program that
-    contains at least one instance of every one of the following limits:<sup><a href="#note13"><b>13)</b></a></sup>
-    -- 127 nesting levels of blocks
-    -- 63 nesting levels of conditional inclusion
-    -- 12 pointer, array, and function declarators (in any combinations) modifying an
-      arithmetic, structure, union, or incomplete type in a declaration
-    -- 63 nesting levels of parenthesized declarators within a full declarator
-    -- 63 nesting levels of parenthesized expressions within a full expression
-    -- 63 significant initial characters in an internal identifier or a macro name (each
-      universal character name or extended source character is considered a single
-      character)
-    -- 31 significant initial characters in an external identifier (each universal character name
-      specifying a short identifier of 0000FFFF or less is considered 6 characters, each
-
-
-    <sup><a name="note13" href="#note13"><b>13)</b></a></sup> Implementations should avoid imposing fixed translation limits whenever possible.
-
-[<a name="p20" href="#p20">page 20</a>] (<a href="#Contents">Contents</a>)
-
-        universal character name specifying a short identifier of 00010000 or more is
-        considered 10 characters, and each extended source character is considered the same
-        number of characters as the corresponding universal character name, if any)<sup><a href="#note14"><b>14)</b></a></sup>
-    -- 4095 external identifiers in one translation unit
-    -- 511 identifiers with block scope declared in one block
-    -- 4095 macro identifiers simultaneously defined in one preprocessing translation unit
-    -- 127 parameters in one function definition
-    -- 127 arguments in one function call
-    -- 127 parameters in one macro definition
-    -- 127 arguments in one macro invocation
-    -- 4095 characters in a logical source line
-    -- 4095 characters in a character string literal or wide string literal (after concatenation)
-    -- 65535 bytes in an object (in a hosted environment only)
-    -- 15 nesting levels for #included files
-    -- 1023 case labels for a switch statement (excluding those for any nested switch
-      statements)
-    -- 1023 members in a single structure or union
-    -- 1023 enumeration constants in a single enumeration
-    -- 63 levels of nested structure or union definitions in a single struct-declaration-list
-<a name="5.2.4.2" href="#5.2.4.2"><b>    5.2.4.2 Numerical limits</b></a>
-1   An implementation is required to document all the limits specified in this subclause,
-    which are specified in the headers <a href="#7.10">&lt;limits.h&gt;</a> and <a href="#7.7">&lt;float.h&gt;</a>. Additional limits are
-    specified in <a href="#7.18">&lt;stdint.h&gt;</a>.
-    Forward references: integer types <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#7.18">7.18</a>).
-<a name="5.2.4.2.1" href="#5.2.4.2.1"><b>    5.2.4.2.1 Sizes of integer types &lt;limits.h&gt;</b></a>
-1   The values given below shall be replaced by constant expressions suitable for use in #if
-    preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
-    following shall be replaced by expressions that have the same type as would an
-    expression that is an object of the corresponding type converted according to the integer
-    promotions. Their implementation-defined values shall be equal or greater in magnitude
-
-
-    <sup><a name="note14" href="#note14"><b>14)</b></a></sup> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
-
-[<a name="p21" href="#p21">page 21</a>] (<a href="#Contents">Contents</a>)
-
-(absolute value) to those shown, with the same sign.
--- number of bits for smallest object that is not a bit-field (byte)
-  CHAR_BIT                                            8
--- minimum value for an object of type signed char
-  SCHAR_MIN                                -127 // -(27 - 1)
--- maximum value for an object of type signed char
-  SCHAR_MAX                                +127 // 27 - 1
--- maximum value for an object of type unsigned char
-  UCHAR_MAX                                 255 // 28 - 1
--- minimum value for an object of type char
-  CHAR_MIN                               see below
--- maximum value for an object of type char
-  CHAR_MAX                              see below
--- maximum number of bytes in a multibyte character, for any supported locale
-  MB_LEN_MAX                                    1
--- minimum value for an object of type short int
-  SHRT_MIN                               -32767 // -(215 - 1)
--- maximum value for an object of type short int
-  SHRT_MAX                               +32767 // 215 - 1
--- maximum value for an object of type unsigned short int
-  USHRT_MAX                               65535 // 216 - 1
--- minimum value for an object of type int
-  INT_MIN                                 -32767 // -(215 - 1)
--- maximum value for an object of type int
-  INT_MAX                                +32767 // 215 - 1
--- maximum value for an object of type unsigned int
-  UINT_MAX                                65535 // 216 - 1
--- minimum value for an object of type long int
-  LONG_MIN                         -2147483647 // -(231 - 1)
--- maximum value for an object of type long int
-  LONG_MAX                         +2147483647 // 231 - 1
--- maximum value for an object of type unsigned long int
-  ULONG_MAX                         4294967295 // 232 - 1
-
-[<a name="p22" href="#p22">page 22</a>] (<a href="#Contents">Contents</a>)
-
-    -- minimum value for an object of type long long int
-      LLONG_MIN          -9223372036854775807 // -(263 - 1)
-    -- maximum value for an object of type long long int
-      LLONG_MAX          +9223372036854775807 // 263 - 1
-    -- maximum value for an object of type unsigned long long int
-      ULLONG_MAX         18446744073709551615 // 264 - 1
-2   If the value of an object of type char is treated as a signed integer when used in an
-    expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
-    value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
-    CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
-    UCHAR_MAX.<sup><a href="#note15"><b>15)</b></a></sup> The value UCHAR_MAX shall equal 2CHAR_BIT - 1.
-    Forward references: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
-<a name="5.2.4.2.2" href="#5.2.4.2.2"><b>    5.2.4.2.2 Characteristics of floating types &lt;float.h&gt;</b></a>
-1   The characteristics of floating types are defined in terms of a model that describes a
-    representation of floating-point numbers and values that provide information about an
-    implementation's floating-point arithmetic.<sup><a href="#note16"><b>16)</b></a></sup> The following parameters are used to
-    define the model for each floating-point type:
-           s          sign ((+-)1)
-           b          base or radix of exponent representation (an integer &gt; 1)
-           e          exponent (an integer between a minimum emin and a maximum emax )
-           p          precision (the number of base-b digits in the significand)
-            fk        nonnegative integers less than b (the significand digits)
-2   A floating-point number (x) is defined by the following model:
-                       p
-           x = sb e   (Sum) f k b-k ,
-                      k=1
-                                     emin &lt;= e &lt;= emax
-
-3   In addition to normalized floating-point numbers ( f 1 &gt; 0 if x != 0), floating types may be
-    able to contain other kinds of floating-point numbers, such as subnormal floating-point
-    numbers (x != 0, e = emin , f 1 = 0) and unnormalized floating-point numbers (x != 0,
-    e &gt; emin , f 1 = 0), and values that are not floating-point numbers, such as infinities and
-    NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates
-    through almost every arithmetic operation without raising a floating-point exception; a
-    signaling NaN generally raises a floating-point exception when occurring as an
-
-
-    <sup><a name="note15" href="#note15"><b>15)</b></a></sup> See <a href="#6.2.5">6.2.5</a>.
-    <sup><a name="note16" href="#note16"><b>16)</b></a></sup> The floating-point model is intended to clarify the description of each floating-point characteristic and
-        does not require the floating-point arithmetic of the implementation to be identical.
-
-[<a name="p23" href="#p23">page 23</a>] (<a href="#Contents">Contents</a>)
-
-    arithmetic operand.<sup><a href="#note17"><b>17)</b></a></sup>
-4   An implementation may give zero and non-numeric values (such as infinities and NaNs) a
-    sign or may leave them unsigned. Wherever such values are unsigned, any requirement
-    in this International Standard to retrieve the sign shall produce an unspecified sign, and
-    any requirement to set the sign shall be ignored.
-5   The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
-    <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results is implementation-
-    defined, as is the accuracy of the conversion between floating-point internal
-    representations and string representations performed by the library functions in
-    <a href="#7.19">&lt;stdio.h&gt;</a>, <a href="#7.20">&lt;stdlib.h&gt;</a>, and <a href="#7.24">&lt;wchar.h&gt;</a>. The implementation may state that the
-    accuracy is unknown.
-6   All integer values in the <a href="#7.7">&lt;float.h&gt;</a> header, except FLT_ROUNDS, shall be constant
-    expressions suitable for use in #if preprocessing directives; all floating values shall be
-    constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
-    and FLT_ROUNDS have separate names for all three floating-point types. The floating-
-    point model representation is provided for all values except FLT_EVAL_METHOD and
-    FLT_ROUNDS.
-7   The rounding mode for floating-point addition is characterized by the implementation-
-    defined value of FLT_ROUNDS:<sup><a href="#note18"><b>18)</b></a></sup>
-          -1      indeterminable
-           0      toward zero
-           1      to nearest
-           2      toward positive infinity
-           3      toward negative infinity
-    All other values for FLT_ROUNDS characterize implementation-defined rounding
-    behavior.
-8   Except for assignment and cast (which remove all extra range and precision), the values
-    of operations with floating operands and values subject to the usual arithmetic
-    conversions and of floating constants are evaluated to a format whose range and precision
-    may be greater than required by the type. The use of evaluation formats is characterized
-    by the implementation-defined value of FLT_EVAL_METHOD:<sup><a href="#note19"><b>19)</b></a></sup>
-
-
-
-    <sup><a name="note17" href="#note17"><b>17)</b></a></sup> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
-        IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
-        similar behavior.
-    <sup><a name="note18" href="#note18"><b>18)</b></a></sup> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
-        the function fesetround in <a href="#7.6">&lt;fenv.h&gt;</a>.
-
-[<a name="p24" href="#p24">page 24</a>] (<a href="#Contents">Contents</a>)
-
-           -1        indeterminable;
-            0        evaluate all operations and constants just to the range and precision of the
-                     type;
-            1        evaluate operations and constants of type float and double to the
-                     range and precision of the double type, evaluate long double
-                     operations and constants to the range and precision of the long double
-                     type;
-            2        evaluate all operations and constants to the range and precision of the
-                     long double type.
-    All other negative values for FLT_EVAL_METHOD characterize implementation-defined
-    behavior.
-9   The values given in the following list shall be replaced by constant expressions with
-    implementation-defined values that are greater or equal in magnitude (absolute value) to
-    those shown, with the same sign:
-    -- radix of exponent representation, b
-      FLT_RADIX                                                 2
-    -- number of base-FLT_RADIX digits in the floating-point significand, p
-        FLT_MANT_DIG
-        DBL_MANT_DIG
-        LDBL_MANT_DIG
-    -- number of decimal digits, n, such that any floating-point number in the widest
-      supported floating type with pmax radix b digits can be rounded to a floating-point
-      number with n decimal digits and back again without change to the value,
-           ??? pmax log10 b       if b is a power of 10
-           ???
-           ??? ???1 + pmax log10 b??? otherwise
-        DECIMAL_DIG                                            10
-    -- number of decimal digits, q, such that any floating-point number with q decimal digits
-      can be rounded into a floating-point number with p radix b digits and back again
-      without change to the q decimal digits,
-
-
-
-
-    <sup><a name="note19" href="#note19"><b>19)</b></a></sup> The evaluation method determines evaluation formats of expressions involving all floating types, not
-        just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
-        _Complex operands is represented in the double _Complex format, and its parts are evaluated to
-        double.
-
-[<a name="p25" href="#p25">page 25</a>] (<a href="#Contents">Contents</a>)
-
-            ??? p log10 b          if b is a power of 10
-            ???
-            ??? ???( p - 1) log10 b??? otherwise
-        FLT_DIG                                         6
-        DBL_DIG                                        10
-        LDBL_DIG                                       10
-     -- minimum negative integer such that FLT_RADIX raised to one less than that power is
-       a normalized floating-point number, emin
-        FLT_MIN_EXP
-        DBL_MIN_EXP
-        LDBL_MIN_EXP
-     -- minimum negative integer such that 10 raised to that power is in the range of
-       normalized floating-point numbers, ???log10 b emin -1 ???
-                                         ???                ???
-       FLT_MIN_10_EXP                                 -37
-       DBL_MIN_10_EXP                                 -37
-       LDBL_MIN_10_EXP                                -37
-     -- maximum integer such that FLT_RADIX raised to one less than that power is a
-       representable finite floating-point number, emax
-        FLT_MAX_EXP
-        DBL_MAX_EXP
-        LDBL_MAX_EXP
-     -- maximum integer such that 10 raised to that power is in the range of representable
-       finite floating-point numbers, ???log10 ((1 - b- p )b emax )???
-        FLT_MAX_10_EXP                                 +37
-        DBL_MAX_10_EXP                                 +37
-        LDBL_MAX_10_EXP                                +37
-10   The values given in the following list shall be replaced by constant expressions with
-     implementation-defined values that are greater than or equal to those shown:
-     -- maximum representable finite floating-point number, (1 - b- p )b emax
-        FLT_MAX                                     1E+37
-        DBL_MAX                                     1E+37
-        LDBL_MAX                                    1E+37
-11   The values given in the following list shall be replaced by constant expressions with
-     implementation-defined (positive) values that are less than or equal to those shown:
-     -- the difference between 1 and the least value greater than 1 that is representable in the
-        given floating point type, b1- p
-
-[<a name="p26" href="#p26">page 26</a>] (<a href="#Contents">Contents</a>)
-
-         FLT_EPSILON                                         1E-5
-         DBL_EPSILON                                         1E-9
-         LDBL_EPSILON                                        1E-9
-     -- minimum normalized positive floating-point number, b emin -1
-         FLT_MIN                                            1E-37
-         DBL_MIN                                            1E-37
-         LDBL_MIN                                           1E-37
-     Recommended practice
-12   Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
-     should be the identity function.
-13   EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
-     requirements of this International Standard, and the appropriate values in a <a href="#7.7">&lt;float.h&gt;</a> header for type
-     float:
-                        6
-           x = s16e    (Sum) f k 16-k ,
-                       k=1
-                                       -31 &lt;= e &lt;= +32
-
-             FLT_RADIX                                  16
-             FLT_MANT_DIG                                6
-             FLT_EPSILON                   9.53674316E-07F
-             FLT_DIG                                     6
-             FLT_MIN_EXP                               -31
-             FLT_MIN                       2.93873588E-39F
-             FLT_MIN_10_EXP                            -38
-             FLT_MAX_EXP                               +32
-             FLT_MAX                       3.40282347E+38F
-             FLT_MAX_10_EXP                            +38
-
-14   EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
-     single-precision and double-precision normalized numbers in IEC 60559,<sup><a href="#note20"><b>20)</b></a></sup> and the appropriate values in a
-     <a href="#7.7">&lt;float.h&gt;</a> header for types float and double:
-                       24
-           x f = s2e   (Sum) f k 2-k ,
-                       k=1
-                                      -125 &lt;= e &lt;= +128
-
-                       53
-           x d = s2e   (Sum) f k 2-k ,
-                       k=1
-                                      -1021 &lt;= e &lt;= +1024
-
-             FLT_RADIX                                   2
-             DECIMAL_DIG                                17
-             FLT_MANT_DIG                               24
-             FLT_EPSILON                   1.19209290E-07F // decimal constant
-             FLT_EPSILON                          0X1P-23F // hex constant
-
-
-     <sup><a name="note20" href="#note20"><b>20)</b></a></sup> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
-         limits are one less than shown here.
-
-[<a name="p27" href="#p27">page 27</a>] (<a href="#Contents">Contents</a>)
-
-        FLT_DIG                           6
-        FLT_MIN_EXP                    -125
-        FLT_MIN             1.17549435E-38F               // decimal constant
-        FLT_MIN                   0X1P-126F               // hex constant
-        FLT_MIN_10_EXP                  -37
-        FLT_MAX_EXP                    +128
-        FLT_MAX             3.40282347E+38F               // decimal constant
-        FLT_MAX             0X1.fffffeP127F               // hex constant
-        FLT_MAX_10_EXP                  +38
-        DBL_MANT_DIG                     53
-        DBL_EPSILON 2.2204460492503131E-16                // decimal constant
-        DBL_EPSILON                 0X1P-52               // hex constant
-        DBL_DIG                          15
-        DBL_MIN_EXP                   -1021
-        DBL_MIN     2.2250738585072014E-308               // decimal constant
-        DBL_MIN                   0X1P-1022               // hex constant
-        DBL_MIN_10_EXP                 -307
-        DBL_MAX_EXP                   +1024
-        DBL_MAX     1.7976931348623157E+308               // decimal constant
-        DBL_MAX      0X1.fffffffffffffP1023               // hex constant
-        DBL_MAX_10_EXP                 +308
-If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
-example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
-precision), then DECIMAL_DIG would be 21.
-
-Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
-<a href="#7.3">&lt;complex.h&gt;</a> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <a href="#7.24">&lt;wchar.h&gt;</a>
-(<a href="#7.24">7.24</a>), floating-point environment <a href="#7.6">&lt;fenv.h&gt;</a> (<a href="#7.6">7.6</a>), general utilities <a href="#7.20">&lt;stdlib.h&gt;</a>
-(<a href="#7.20">7.20</a>), input/output <a href="#7.19">&lt;stdio.h&gt;</a> (<a href="#7.19">7.19</a>), mathematics <a href="#7.12">&lt;math.h&gt;</a> (<a href="#7.12">7.12</a>).
-
-[<a name="p28" href="#p28">page 28</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="6" href="#6"><b>    6. Language</b></a>
-<a name="6.1" href="#6.1"><b>    6.1 Notation</b></a>
-1   In the syntax notation used in this clause, syntactic categories (nonterminals) are
-    indicated by italic type, and literal words and character set members (terminals) by bold
-    type. A colon (:) following a nonterminal introduces its definition. Alternative
-    definitions are listed on separate lines, except when prefaced by the words ''one of''. An
-    optional symbol is indicated by the subscript ''opt'', so that
-             { expressionopt }
-    indicates an optional expression enclosed in braces.
-2   When syntactic categories are referred to in the main text, they are not italicized and
-    words are separated by spaces instead of hyphens.
-3   A summary of the language syntax is given in <a href="#A">annex A</a>.
-<a name="6.2" href="#6.2"><b>    6.2 Concepts</b></a>
-<a name="6.2.1" href="#6.2.1"><b>    6.2.1 Scopes of identifiers</b></a>
-1   An identifier can denote an object; a function; a tag or a member of a structure, union, or
-    enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
-    same identifier can denote different entities at different points in the program. A member
-    of an enumeration is called an enumeration constant. Macro names and macro
-    parameters are not considered further here, because prior to the semantic phase of
-    program translation any occurrences of macro names in the source file are replaced by the
-    preprocessing token sequences that constitute their macro definitions.
-2   For each different entity that an identifier designates, the identifier is visible (i.e., can be
-    used) only within a region of program text called its scope. Different entities designated
-    by the same identifier either have different scopes, or are in different name spaces. There
-    are four kinds of scopes: function, file, block, and function prototype. (A function
-    prototype is a declaration of a function that declares the types of its parameters.)
-3   A label name is the only kind of identifier that has function scope. It can be used (in a
-    goto statement) anywhere in the function in which it appears, and is declared implicitly
-    by its syntactic appearance (followed by a : and a statement).
-4   Every other identifier has scope determined by the placement of its declaration (in a
-    declarator or type specifier). If the declarator or type specifier that declares the identifier
-    appears outside of any block or list of parameters, the identifier has file scope, which
-    terminates at the end of the translation unit. If the declarator or type specifier that
-    declares the identifier appears inside a block or within the list of parameter declarations in
-    a function definition, the identifier has block scope, which terminates at the end of the
-    associated block. If the declarator or type specifier that declares the identifier appears
-
-[<a name="p29" href="#p29">page 29</a>] (<a href="#Contents">Contents</a>)
-
-    within the list of parameter declarations in a function prototype (not part of a function
-    definition), the identifier has function prototype scope, which terminates at the end of the
-    function declarator. If an identifier designates two different entities in the same name
-    space, the scopes might overlap. If so, the scope of one entity (the inner scope) will be a
-    strict subset of the scope of the other entity (the outer scope). Within the inner scope, the
-    identifier designates the entity declared in the inner scope; the entity declared in the outer
-    scope is hidden (and not visible) within the inner scope.
-5   Unless explicitly stated otherwise, where this International Standard uses the term
-    ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
-    entity in the relevant name space whose declaration is visible at the point the identifier
-    occurs.
-6   Two identifiers have the same scope if and only if their scopes terminate at the same
-    point.
-7   Structure, union, and enumeration tags have scope that begins just after the appearance of
-    the tag in a type specifier that declares the tag. Each enumeration constant has scope that
-    begins just after the appearance of its defining enumerator in an enumerator list. Any
-    other identifier has scope that begins just after the completion of its declarator.
-    Forward references: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
-    (<a href="#6.9.1">6.9.1</a>), identifiers (<a href="#6.4.2">6.4.2</a>), name spaces of identifiers (<a href="#6.2.3">6.2.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>),
-    source file inclusion (<a href="#6.10.2">6.10.2</a>), statements (<a href="#6.8">6.8</a>).
-<a name="6.2.2" href="#6.2.2"><b>    6.2.2 Linkages of identifiers</b></a>
-1   An identifier declared in different scopes or in the same scope more than once can be
-    made to refer to the same object or function by a process called linkage.<sup><a href="#note21"><b>21)</b></a></sup> There are
-    three kinds of linkage: external, internal, and none.
-2   In the set of translation units and libraries that constitutes an entire program, each
-    declaration of a particular identifier with external linkage denotes the same object or
-    function. Within one translation unit, each declaration of an identifier with internal
-    linkage denotes the same object or function. Each declaration of an identifier with no
-    linkage denotes a unique entity.
-3   If the declaration of a file scope identifier for an object or a function contains the storage-
-    class specifier static, the identifier has internal linkage.<sup><a href="#note22"><b>22)</b></a></sup>
-4   For an identifier declared with the storage-class specifier extern in a scope in which a
-
-
-
-    <sup><a name="note21" href="#note21"><b>21)</b></a></sup> There is no linkage between different identifiers.
-    <sup><a name="note22" href="#note22"><b>22)</b></a></sup> A function declaration can contain the storage-class specifier static only if it is at file scope; see
-        <a href="#6.7.1">6.7.1</a>.
-
-[<a name="p30" href="#p30">page 30</a>] (<a href="#Contents">Contents</a>)
-
-    prior declaration of that identifier is visible,<sup><a href="#note23"><b>23)</b></a></sup> if the prior declaration specifies internal or
-    external linkage, the linkage of the identifier at the later declaration is the same as the
-    linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
-    declaration specifies no linkage, then the identifier has external linkage.
-5   If the declaration of an identifier for a function has no storage-class specifier, its linkage
-    is determined exactly as if it were declared with the storage-class specifier extern. If
-    the declaration of an identifier for an object has file scope and no storage-class specifier,
-    its linkage is external.
-6   The following identifiers have no linkage: an identifier declared to be anything other than
-    an object or a function; an identifier declared to be a function parameter; a block scope
-    identifier for an object declared without the storage-class specifier extern.
-7   If, within a translation unit, the same identifier appears with both internal and external
-    linkage, the behavior is undefined.
-    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
-    statements (<a href="#6.8">6.8</a>).
-<a name="6.2.3" href="#6.2.3"><b>    6.2.3 Name spaces of identifiers</b></a>
-1   If more than one declaration of a particular identifier is visible at any point in a
-    translation unit, the syntactic context disambiguates uses that refer to different entities.
-    Thus, there are separate name spaces for various categories of identifiers, as follows:
-    -- label names (disambiguated by the syntax of the label declaration and use);
-    -- the tags of structures, unions, and enumerations (disambiguated by following any<sup><a href="#note24"><b>24)</b></a></sup>
-      of the keywords struct, union, or enum);
-    -- the members of structures or unions; each structure or union has a separate name
-      space for its members (disambiguated by the type of the expression used to access the
-      member via the . or -&gt; operator);
-    -- all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
-      enumeration constants).
-    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
-    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>), tags
-    (<a href="#6.7.2.3">6.7.2.3</a>), the goto statement (<a href="#6.8.6.1">6.8.6.1</a>).
-
-
-
-
-    <sup><a name="note23" href="#note23"><b>23)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
-    <sup><a name="note24" href="#note24"><b>24)</b></a></sup> There is only one name space for tags even though three are possible.
-
-[<a name="p31" href="#p31">page 31</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.2.4" href="#6.2.4"><b>    6.2.4 Storage durations of objects</b></a>
-1   An object has a storage duration that determines its lifetime. There are three storage
-    durations: static, automatic, and allocated. Allocated storage is described in <a href="#7.20.3">7.20.3</a>.
-2   The lifetime of an object is the portion of program execution during which storage is
-    guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note25"><b>25)</b></a></sup> and retains
-    its last-stored value throughout its lifetime.<sup><a href="#note26"><b>26)</b></a></sup> If an object is referred to outside of its
-    lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
-    the object it points to reaches the end of its lifetime.
-3   An object whose identifier is declared with external or internal linkage, or with the
-    storage-class specifier static has static storage duration. Its lifetime is the entire
-    execution of the program and its stored value is initialized only once, prior to program
-    startup.
-4   An object whose identifier is declared with no linkage and without the storage-class
-    specifier static has automatic storage duration.
-5   For such an object that does not have a variable length array type, its lifetime extends
-    from entry into the block with which it is associated until execution of that block ends in
-    any way. (Entering an enclosed block or calling a function suspends, but does not end,
-    execution of the current block.) If the block is entered recursively, a new instance of the
-    object is created each time. The initial value of the object is indeterminate. If an
-    initialization is specified for the object, it is performed each time the declaration is
-    reached in the execution of the block; otherwise, the value becomes indeterminate each
-    time the declaration is reached.
-6   For such an object that does have a variable length array type, its lifetime extends from
-    the declaration of the object until execution of the program leaves the scope of the
-    declaration.<sup><a href="#note27"><b>27)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
-    each time. The initial value of the object is indeterminate.
-    Forward references: statements (<a href="#6.8">6.8</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), declarators (<a href="#6.7.5">6.7.5</a>), array
-    declarators (<a href="#6.7.5.2">6.7.5.2</a>), initialization (<a href="#6.7.8">6.7.8</a>).
-
-
-
-
-    <sup><a name="note25" href="#note25"><b>25)</b></a></sup> The term ''constant address'' means that two pointers to the object constructed at possibly different
-        times will compare equal. The address may be different during two different executions of the same
-        program.
-    <sup><a name="note26" href="#note26"><b>26)</b></a></sup> In the case of a volatile object, the last store need not be explicit in the program.
-    <sup><a name="note27" href="#note27"><b>27)</b></a></sup> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
-        embedded block prior to the declaration, leaves the scope of the declaration.
-
-[<a name="p32" href="#p32">page 32</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.2.5" href="#6.2.5"><b>    6.2.5 Types</b></a>
-1   The meaning of a value stored in an object or returned by a function is determined by the
-    type of the expression used to access it. (An identifier declared to be an object is the
-    simplest such expression; the type is specified in the declaration of the identifier.) Types
-    are partitioned into object types (types that fully describe objects), function types (types
-    that describe functions), and incomplete types (types that describe objects but lack
-    information needed to determine their sizes).
-2   An object declared as type _Bool is large enough to store the values 0 and 1.
-3   An object declared as type char is large enough to store any member of the basic
-    execution character set. If a member of the basic execution character set is stored in a
-    char object, its value is guaranteed to be nonnegative. If any other character is stored in
-    a char object, the resulting value is implementation-defined but shall be within the range
-    of values that can be represented in that type.
-4   There are five standard signed integer types, designated as signed char, short
-    int, int, long int, and long long int. (These and other types may be
-    designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
-    implementation-defined extended signed integer types.<sup><a href="#note28"><b>28)</b></a></sup> The standard and extended
-    signed integer types are collectively called signed integer types.<sup><a href="#note29"><b>29)</b></a></sup>
-5   An object declared as type signed char occupies the same amount of storage as a
-    ''plain'' char object. A ''plain'' int object has the natural size suggested by the
-    architecture of the execution environment (large enough to contain any value in the range
-    INT_MIN to INT_MAX as defined in the header <a href="#7.10">&lt;limits.h&gt;</a>).
-6   For each of the signed integer types, there is a corresponding (but different) unsigned
-    integer type (designated with the keyword unsigned) that uses the same amount of
-    storage (including sign information) and has the same alignment requirements. The type
-    _Bool and the unsigned integer types that correspond to the standard signed integer
-    types are the standard unsigned integer types. The unsigned integer types that
-    correspond to the extended signed integer types are the extended unsigned integer types.
-    The standard and extended unsigned integer types are collectively called unsigned integer
-    types.<sup><a href="#note30"><b>30)</b></a></sup>
-
-
-
-    <sup><a name="note28" href="#note28"><b>28)</b></a></sup> Implementation-defined keywords shall have the form of an identifier reserved for any use as
-        described in <a href="#7.1.3">7.1.3</a>.
-    <sup><a name="note29" href="#note29"><b>29)</b></a></sup> Therefore, any statement in this Standard about signed integer types also applies to the extended
-        signed integer types.
-    <sup><a name="note30" href="#note30"><b>30)</b></a></sup> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
-        unsigned integer types.
-
-[<a name="p33" href="#p33">page 33</a>] (<a href="#Contents">Contents</a>)
-
-7    The standard signed integer types and standard unsigned integer types are collectively
-     called the standard integer types, the extended signed integer types and extended
-     unsigned integer types are collectively called the extended integer types.
-8    For any two integer types with the same signedness and different integer conversion rank
-     (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
-     subrange of the values of the other type.
-9    The range of nonnegative values of a signed integer type is a subrange of the
-     corresponding unsigned integer type, and the representation of the same value in each
-     type is the same.<sup><a href="#note31"><b>31)</b></a></sup> A computation involving unsigned operands can never overflow,
-     because a result that cannot be represented by the resulting unsigned integer type is
-     reduced modulo the number that is one greater than the largest value that can be
-     represented by the resulting type.
-10   There are three real floating types, designated as float, double, and long
-     double.<sup><a href="#note32"><b>32)</b></a></sup> The set of values of the type float is a subset of the set of values of the
-     type double; the set of values of the type double is a subset of the set of values of the
-     type long double.
-11   There are three complex types, designated as float _Complex, double
-     _Complex, and long double _Complex.<sup><a href="#note33"><b>33)</b></a></sup> The real floating and complex types
-     are collectively called the floating types.
-12   For each floating type there is a corresponding real type, which is always a real floating
-     type. For real floating types, it is the same type. For complex types, it is the type given
-     by deleting the keyword _Complex from the type name.
-13   Each complex type has the same representation and alignment requirements as an array
-     type containing exactly two elements of the corresponding real type; the first element is
-     equal to the real part, and the second element to the imaginary part, of the complex
-     number.
-14   The type char, the signed and unsigned integer types, and the floating types are
-     collectively called the basic types. Even if the implementation defines two or more basic
-     types to have the same representation, they are nevertheless different types.<sup><a href="#note34"><b>34)</b></a></sup>
-
-     <sup><a name="note31" href="#note31"><b>31)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
-         arguments to functions, return values from functions, and members of unions.
-     <sup><a name="note32" href="#note32"><b>32)</b></a></sup> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
-     <sup><a name="note33" href="#note33"><b>33)</b></a></sup> A specification for imaginary types is in informative <a href="#G">annex G</a>.
-     <sup><a name="note34" href="#note34"><b>34)</b></a></sup> An implementation may define new keywords that provide alternative ways to designate a basic (or
-         any other) type; this does not violate the requirement that all basic types be different.
-         Implementation-defined keywords shall have the form of an identifier reserved for any use as
-         described in <a href="#7.1.3">7.1.3</a>.
-
-[<a name="p34" href="#p34">page 34</a>] (<a href="#Contents">Contents</a>)
-
-15   The three types char, signed char, and unsigned char are collectively called
-     the character types. The implementation shall define char to have the same range,
-     representation, and behavior as either signed char or unsigned char.<sup><a href="#note35"><b>35)</b></a></sup>
-16   An enumeration comprises a set of named integer constant values. Each distinct
-     enumeration constitutes a different enumerated type.
-17   The type char, the signed and unsigned integer types, and the enumerated types are
-     collectively called integer types. The integer and real floating types are collectively called
-     real types.
-18   Integer and floating types are collectively called arithmetic types. Each arithmetic type
-     belongs to one type domain: the real type domain comprises the real types, the complex
-     type domain comprises the complex types.
-19   The void type comprises an empty set of values; it is an incomplete type that cannot be
-     completed.
-20   Any number of derived types can be constructed from the object, function, and
-     incomplete types, as follows:
-     -- An array type describes a contiguously allocated nonempty set of objects with a
-       particular member object type, called the element type.<sup><a href="#note36"><b>36)</b></a></sup> Array types are
-       characterized by their element type and by the number of elements in the array. An
-       array type is said to be derived from its element type, and if its element type is T , the
-       array type is sometimes called ''array of T ''. The construction of an array type from
-       an element type is called ''array type derivation''.
-     -- A structure type describes a sequentially allocated nonempty set of member objects
-       (and, in certain circumstances, an incomplete array), each of which has an optionally
-       specified name and possibly distinct type.
-     -- A union type describes an overlapping nonempty set of member objects, each of
-       which has an optionally specified name and possibly distinct type.
-     -- A function type describes a function with specified return type. A function type is
-       characterized by its return type and the number and types of its parameters. A
-       function type is said to be derived from its return type, and if its return type is T , the
-       function type is sometimes called ''function returning T ''. The construction of a
-       function type from a return type is called ''function type derivation''.
-
-
-
-     <sup><a name="note35" href="#note35"><b>35)</b></a></sup> CHAR_MIN, defined in <a href="#7.10">&lt;limits.h&gt;</a>, will have one of the values 0 or SCHAR_MIN, and this can be
-         used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
-         other two and is not compatible with either.
-     <sup><a name="note36" href="#note36"><b>36)</b></a></sup> Since object types do not include incomplete types, an array of incomplete type cannot be constructed.
-
-[<a name="p35" href="#p35">page 35</a>] (<a href="#Contents">Contents</a>)
-
-     -- A pointer type may be derived from a function type, an object type, or an incomplete
-       type, called the referenced type. A pointer type describes an object whose value
-       provides a reference to an entity of the referenced type. A pointer type derived from
-       the referenced type T is sometimes called ''pointer to T ''. The construction of a
-       pointer type from a referenced type is called ''pointer type derivation''.
-     These methods of constructing derived types can be applied recursively.
-21   Arithmetic types and pointer types are collectively called scalar types. Array and
-     structure types are collectively called aggregate types.<sup><a href="#note37"><b>37)</b></a></sup>
-22   An array type of unknown size is an incomplete type. It is completed, for an identifier of
-     that type, by specifying the size in a later declaration (with internal or external linkage).
-     A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
-     type. It is completed, for all declarations of that type, by declaring the same structure or
-     union tag with its defining content later in the same scope.
-23   A type has known constant size if the type is not incomplete and is not a variable length
-     array type.
-24   Array, function, and pointer types are collectively called derived declarator types. A
-     declarator type derivation from a type T is the construction of a derived declarator type
-     from T by the application of an array-type, a function-type, or a pointer-type derivation to
-     T.
-25   A type is characterized by its type category, which is either the outermost derivation of a
-     derived type (as noted above in the construction of derived types), or the type itself if the
-     type consists of no derived types.
-26   Any type so far mentioned is an unqualified type. Each unqualified type has several
-     qualified versions of its type,<sup><a href="#note38"><b>38)</b></a></sup> corresponding to the combinations of one, two, or all
-     three of the const, volatile, and restrict qualifiers. The qualified or unqualified
-     versions of a type are distinct types that belong to the same type category and have the
-     same representation and alignment requirements.<sup><a href="#note39"><b>39)</b></a></sup> A derived type is not qualified by the
-     qualifiers (if any) of the type from which it is derived.
-27   A pointer to void shall have the same representation and alignment requirements as a
-     pointer to a character type.39) Similarly, pointers to qualified or unqualified versions of
-     compatible types shall have the same representation and alignment requirements. All
-
-
-     <sup><a name="note37" href="#note37"><b>37)</b></a></sup> Note that aggregate type does not include union type because an object with union type can only
-         contain one member at a time.
-     <sup><a name="note38" href="#note38"><b>38)</b></a></sup> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
-     <sup><a name="note39" href="#note39"><b>39)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
-         arguments to functions, return values from functions, and members of unions.
-
-[<a name="p36" href="#p36">page 36</a>] (<a href="#Contents">Contents</a>)
-
-     pointers to structure types shall have the same representation and alignment requirements
-     as each other. All pointers to union types shall have the same representation and
-     alignment requirements as each other. Pointers to other types need not have the same
-     representation or alignment requirements.
-28   EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
-     pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
-     whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
-     qualified float'' and is a pointer to a qualified type.
-
-29   EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
-     function returning struct tag''. The array has length five and the function has a single parameter of type
-     float. Its type category is array.
-
-     Forward references: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
-<a name="6.2.6" href="#6.2.6"><b>     6.2.6 Representations of types</b></a>
-<a name="6.2.6.1" href="#6.2.6.1"><b>     6.2.6.1 General</b></a>
-1    The representations of all types are unspecified except as stated in this subclause.
-2    Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
-     the number, order, and encoding of which are either explicitly specified or
-     implementation-defined.
-3    Values stored in unsigned bit-fields and objects of type unsigned char shall be
-     represented using a pure binary notation.<sup><a href="#note40"><b>40)</b></a></sup>
-4    Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
-     bits, where n is the size of an object of that type, in bytes. The value may be copied into
-     an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
-     called the object representation of the value. Values stored in bit-fields consist of m bits,
-     where m is the size specified for the bit-field. The object representation is the set of m
-     bits the bit-field comprises in the addressable storage unit holding it. Two values (other
-     than NaNs) with the same object representation compare equal, but values that compare
-     equal may have different object representations.
-5    Certain object representations need not represent a value of the object type. If the stored
-     value of an object has such a representation and is read by an lvalue expression that does
-     not have character type, the behavior is undefined. If such a representation is produced
-     by a side effect that modifies all or any part of the object by an lvalue expression that
-     does not have character type, the behavior is undefined.<sup><a href="#note41"><b>41)</b></a></sup> Such a representation is called
-
-     <sup><a name="note40" href="#note40"><b>40)</b></a></sup> A positional representation for integers that uses the binary digits 0 and 1, in which the values
-         represented by successive bits are additive, begin with 1, and are multiplied by successive integral
-         powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
-         Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
-         type unsigned char range from 0 to 2
-                                                   CHAR_BIT
-                                                             - 1.
-
-[<a name="p37" href="#p37">page 37</a>] (<a href="#Contents">Contents</a>)
-
-    a trap representation.
-6   When a value is stored in an object of structure or union type, including in a member
-    object, the bytes of the object representation that correspond to any padding bytes take
-    unspecified values.<sup><a href="#note42"><b>42)</b></a></sup> The value of a structure or union object is never a trap
-    representation, even though the value of a member of the structure or union object may be
-    a trap representation.
-7   When a value is stored in a member of an object of union type, the bytes of the object
-    representation that do not correspond to that member but do correspond to other members
-    take unspecified values.
-8   Where an operator is applied to a value that has more than one object representation,
-    which object representation is used shall not affect the value of the result.<sup><a href="#note43"><b>43)</b></a></sup> Where a
-    value is stored in an object using a type that has more than one object representation for
-    that value, it is unspecified which representation is used, but a trap representation shall
-    not be generated.
-    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
-    designators (<a href="#6.3.2.1">6.3.2.1</a>).
-<a name="6.2.6.2" href="#6.2.6.2"><b>    6.2.6.2 Integer types</b></a>
-1   For unsigned integer types other than unsigned char, the bits of the object
-    representation shall be divided into two groups: value bits and padding bits (there need
-    not be any of the latter). If there are N value bits, each bit shall represent a different
-    power of 2 between 1 and 2 N -1 , so that objects of that type shall be capable of
-    representing values from 0 to 2 N - 1 using a pure binary representation; this shall be
-    known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note44"><b>44)</b></a></sup>
-2   For signed integer types, the bits of the object representation shall be divided into three
-    groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
-
-    <sup><a name="note41" href="#note41"><b>41)</b></a></sup> Thus, an automatic variable can be initialized to a trap representation without causing undefined
-        behavior, but the value of the variable cannot be used until a proper value is stored in it.
-    <sup><a name="note42" href="#note42"><b>42)</b></a></sup> Thus, for example, structure assignment need not copy any padding bits.
-    <sup><a name="note43" href="#note43"><b>43)</b></a></sup> It is possible for objects x and y with the same effective type T to have the same value when they are
-        accessed as objects of type T, but to have different values in other contexts. In particular, if == is
-        defined for type T, then x == y does not imply that memcmp(&amp;x, &amp;y, sizeof (T)) == 0.
-        Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
-        on values of type T may distinguish between them.
-    <sup><a name="note44" href="#note44"><b>44)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
-        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
-        representation other than as part of an exceptional condition such as an overflow, and this cannot occur
-        with unsigned types. All other combinations of padding bits are alternative object representations of
-        the value specified by the value bits.
-
-[<a name="p38" href="#p38">page 38</a>] (<a href="#Contents">Contents</a>)
-
-    there shall be exactly one sign bit. Each bit that is a value bit shall have the same value as
-    the same bit in the object representation of the corresponding unsigned type (if there are
-    M value bits in the signed type and N in the unsigned type, then M &lt;= N ). If the sign bit
-    is zero, it shall not affect the resulting value. If the sign bit is one, the value shall be
-    modified in one of the following ways:
-    -- the corresponding value with sign bit 0 is negated (sign and magnitude);
-    -- the sign bit has the value -(2 N ) (two's complement);
-    -- the sign bit has the value -(2 N - 1) (ones' complement ).
-    Which of these applies is implementation-defined, as is whether the value with sign bit 1
-    and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones'
-    complement), is a trap representation or a normal value. In the case of sign and
-    magnitude and ones' complement, if this representation is a normal value it is called a
-    negative zero.
-3   If the implementation supports negative zeros, they shall be generated only by:
-    -- the &amp;, |, ^, ~, &lt;&lt;, and &gt;&gt; operators with arguments that produce such a value;
-    -- the +, -, *, /, and % operators where one argument is a negative zero and the result is
-      zero;
-    -- compound assignment operators based on the above cases.
-    It is unspecified whether these cases actually generate a negative zero or a normal zero,
-    and whether a negative zero becomes a normal zero when stored in an object.
-4   If the implementation does not support negative zeros, the behavior of the &amp;, |, ^, ~, &lt;&lt;,
-    and &gt;&gt; operators with arguments that would produce such a value is undefined.
-5   The values of any padding bits are unspecified.<sup><a href="#note45"><b>45)</b></a></sup> A valid (non-trap) object representation
-    of a signed integer type where the sign bit is zero is a valid object representation of the
-    corresponding unsigned type, and shall represent the same value. For any integer type,
-    the object representation where all the bits are zero shall be a representation of the value
-    zero in that type.
-6   The precision of an integer type is the number of bits it uses to represent values,
-    excluding any sign and padding bits. The width of an integer type is the same but
-    including any sign bit; thus for unsigned integer types the two values are the same, while
-
-
-    <sup><a name="note45" href="#note45"><b>45)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
-        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
-        representation other than as part of an exceptional condition such as an overflow. All other
-        combinations of padding bits are alternative object representations of the value specified by the value
-        bits.
-
-[<a name="p39" href="#p39">page 39</a>] (<a href="#Contents">Contents</a>)
-
-    for signed integer types the width is one greater than the precision.
-<a name="6.2.7" href="#6.2.7"><b>    6.2.7 Compatible type and composite type</b></a>
-1   Two types have compatible type if their types are the same. Additional rules for
-    determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
-    in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.5">6.7.5</a> for declarators.<sup><a href="#note46"><b>46)</b></a></sup> Moreover, two structure,
-    union, or enumerated types declared in separate translation units are compatible if their
-    tags and members satisfy the following requirements: If one is declared with a tag, the
-    other shall be declared with the same tag. If both are complete types, then the following
-    additional requirements apply: there shall be a one-to-one correspondence between their
-    members such that each pair of corresponding members are declared with compatible
-    types, and such that if one member of a corresponding pair is declared with a name, the
-    other member is declared with the same name. For two structures, corresponding
-    members shall be declared in the same order. For two structures or unions, corresponding
-    bit-fields shall have the same widths. For two enumerations, corresponding members
-    shall have the same values.
-2   All declarations that refer to the same object or function shall have compatible type;
-    otherwise, the behavior is undefined.
-3   A composite type can be constructed from two types that are compatible; it is a type that
-    is compatible with both of the two types and satisfies the following conditions:
-    -- If one type is an array of known constant size, the composite type is an array of that
-      size; otherwise, if one type is a variable length array, the composite type is that type.
-    -- If only one type is a function type with a parameter type list (a function prototype),
-      the composite type is a function prototype with the parameter type list.
-    -- If both types are function types with parameter type lists, the type of each parameter
-      in the composite parameter type list is the composite type of the corresponding
-      parameters.
-    These rules apply recursively to the types from which the two types are derived.
-4   For an identifier with internal or external linkage declared in a scope in which a prior
-    declaration of that identifier is visible,<sup><a href="#note47"><b>47)</b></a></sup> if the prior declaration specifies internal or
-    external linkage, the type of the identifier at the later declaration becomes the composite
-    type.
-
-
-
-
-    <sup><a name="note46" href="#note46"><b>46)</b></a></sup> Two types need not be identical to be compatible.
-    <sup><a name="note47" href="#note47"><b>47)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
-
-[<a name="p40" href="#p40">page 40</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE        Given the following two file scope declarations:
-             int f(int (*)(), double (*)[3]);
-             int f(int (*)(char *), double (*)[]);
-    The resulting composite type for the function is:
-             int f(int (*)(char *), double (*)[3]);
-
-[<a name="p41" href="#p41">page 41</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.3" href="#6.3"><b>    6.3 Conversions</b></a>
-1   Several operators convert operand values from one type to another automatically. This
-    subclause specifies the result required from such an implicit conversion, as well as those
-    that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
-    the conversions performed by most ordinary operators; it is supplemented as required by
-    the discussion of each operator in <a href="#6.5">6.5</a>.
-2   Conversion of an operand value to a compatible type causes no change to the value or the
-    representation.
-    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>).
-<a name="6.3.1" href="#6.3.1"><b>    6.3.1 Arithmetic operands</b></a>
-<a name="6.3.1.1" href="#6.3.1.1"><b>    6.3.1.1 Boolean, characters, and integers</b></a>
-1   Every integer type has an integer conversion rank defined as follows:
-    -- No two signed integer types shall have the same rank, even if they have the same
-      representation.
-    -- The rank of a signed integer type shall be greater than the rank of any signed integer
-      type with less precision.
-    -- The rank of long long int shall be greater than the rank of long int, which
-      shall be greater than the rank of int, which shall be greater than the rank of short
-      int, which shall be greater than the rank of signed char.
-    -- The rank of any unsigned integer type shall equal the rank of the corresponding
-      signed integer type, if any.
-    -- The rank of any standard integer type shall be greater than the rank of any extended
-      integer type with the same width.
-    -- The rank of char shall equal the rank of signed char and unsigned char.
-    -- The rank of _Bool shall be less than the rank of all other standard integer types.
-    -- The rank of any enumerated type shall equal the rank of the compatible integer type
-      (see <a href="#6.7.2.2">6.7.2.2</a>).
-    -- The rank of any extended signed integer type relative to another extended signed
-      integer type with the same precision is implementation-defined, but still subject to the
-      other rules for determining the integer conversion rank.
-    -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
-      greater rank than T3, then T1 has greater rank than T3.
-2   The following may be used in an expression wherever an int or unsigned int may
-    be used:
-
-[<a name="p42" href="#p42">page 42</a>] (<a href="#Contents">Contents</a>)
-
-    -- An object or expression with an integer type whose integer conversion rank is less
-      than or equal to the rank of int and unsigned int.
-    -- A bit-field of type _Bool, int, signed int, or unsigned int.
-    If an int can represent all values of the original type, the value is converted to an int;
-    otherwise, it is converted to an unsigned int. These are called the integer
-    promotions.<sup><a href="#note48"><b>48)</b></a></sup> All other types are unchanged by the integer promotions.
-3   The integer promotions preserve value including sign. As discussed earlier, whether a
-    ''plain'' char is treated as signed is implementation-defined.
-    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
-    (<a href="#6.7.2.1">6.7.2.1</a>).
-<a name="6.3.1.2" href="#6.3.1.2"><b>    6.3.1.2 Boolean type</b></a>
-1   When any scalar value is converted to _Bool, the result is 0 if the value compares equal
-    to 0; otherwise, the result is 1.
-<a name="6.3.1.3" href="#6.3.1.3"><b>    6.3.1.3 Signed and unsigned integers</b></a>
-1   When a value with integer type is converted to another integer type other than _Bool, if
-    the value can be represented by the new type, it is unchanged.
-2   Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
-    subtracting one more than the maximum value that can be represented in the new type
-    until the value is in the range of the new type.<sup><a href="#note49"><b>49)</b></a></sup>
-3   Otherwise, the new type is signed and the value cannot be represented in it; either the
-    result is implementation-defined or an implementation-defined signal is raised.
-<a name="6.3.1.4" href="#6.3.1.4"><b>    6.3.1.4 Real floating and integer</b></a>
-1   When a finite value of real floating type is converted to an integer type other than _Bool,
-    the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
-    the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup>
-2   When a value of integer type is converted to a real floating type, if the value being
-    converted can be represented exactly in the new type, it is unchanged. If the value being
-    converted is in the range of values that can be represented but cannot be represented
-
-    <sup><a name="note48" href="#note48"><b>48)</b></a></sup> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
-        argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
-        shift operators, as specified by their respective subclauses.
-    <sup><a name="note49" href="#note49"><b>49)</b></a></sup> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
-    <sup><a name="note50" href="#note50"><b>50)</b></a></sup> The remaindering operation performed when a value of integer type is converted to unsigned type
-        need not be performed when a value of real floating type is converted to unsigned type. Thus, the
-        range of portable real floating values is (-1, Utype_MAX+1).
-
-[<a name="p43" href="#p43">page 43</a>] (<a href="#Contents">Contents</a>)
-
-    exactly, the result is either the nearest higher or nearest lower representable value, chosen
-    in an implementation-defined manner. If the value being converted is outside the range of
-    values that can be represented, the behavior is undefined.
-<a name="6.3.1.5" href="#6.3.1.5"><b>    6.3.1.5 Real floating types</b></a>
-1   When a float is promoted to double or long double, or a double is promoted
-    to long double, its value is unchanged (if the source value is represented in the
-    precision and range of its type).
-2   When a double is demoted to float, a long double is demoted to double or
-    float, or a value being represented in greater precision and range than required by its
-    semantic type (see <a href="#6.3.1.8">6.3.1.8</a>) is explicitly converted (including to its own type), if the value
-    being converted can be represented exactly in the new type, it is unchanged. If the value
-    being converted is in the range of values that can be represented but cannot be
-    represented exactly, the result is either the nearest higher or nearest lower representable
-    value, chosen in an implementation-defined manner. If the value being converted is
-    outside the range of values that can be represented, the behavior is undefined.
-<a name="6.3.1.6" href="#6.3.1.6"><b>    6.3.1.6 Complex types</b></a>
-1   When a value of complex type is converted to another complex type, both the real and
-    imaginary parts follow the conversion rules for the corresponding real types.
-<a name="6.3.1.7" href="#6.3.1.7"><b>    6.3.1.7 Real and complex</b></a>
-1   When a value of real type is converted to a complex type, the real part of the complex
-    result value is determined by the rules of conversion to the corresponding real type and
-    the imaginary part of the complex result value is a positive zero or an unsigned zero.
-2   When a value of complex type is converted to a real type, the imaginary part of the
-    complex value is discarded and the value of the real part is converted according to the
-    conversion rules for the corresponding real type.
-<a name="6.3.1.8" href="#6.3.1.8"><b>    6.3.1.8 Usual arithmetic conversions</b></a>
-1   Many operators that expect operands of arithmetic type cause conversions and yield result
-    types in a similar way. The purpose is to determine a common real type for the operands
-    and result. For the specified operands, each operand is converted, without change of type
-    domain, to a type whose corresponding real type is the common real type. Unless
-    explicitly stated otherwise, the common real type is also the corresponding real type of
-    the result, whose type domain is the type domain of the operands if they are the same,
-    and complex otherwise. This pattern is called the usual arithmetic conversions:
-          First, if the corresponding real type of either operand is long double, the other
-          operand is converted, without change of type domain, to a type whose
-          corresponding real type is long double.
-
-[<a name="p44" href="#p44">page 44</a>] (<a href="#Contents">Contents</a>)
-
-          Otherwise, if the corresponding real type of either operand is double, the other
-          operand is converted, without change of type domain, to a type whose
-          corresponding real type is double.
-          Otherwise, if the corresponding real type of either operand is float, the other
-          operand is converted, without change of type domain, to a type whose
-          corresponding real type is float.<sup><a href="#note51"><b>51)</b></a></sup>
-          Otherwise, the integer promotions are performed on both operands. Then the
-          following rules are applied to the promoted operands:
-                 If both operands have the same type, then no further conversion is needed.
-                 Otherwise, if both operands have signed integer types or both have unsigned
-                 integer types, the operand with the type of lesser integer conversion rank is
-                 converted to the type of the operand with greater rank.
-                 Otherwise, if the operand that has unsigned integer type has rank greater or
-                 equal to the rank of the type of the other operand, then the operand with
-                 signed integer type is converted to the type of the operand with unsigned
-                 integer type.
-                 Otherwise, if the type of the operand with signed integer type can represent
-                 all of the values of the type of the operand with unsigned integer type, then
-                 the operand with unsigned integer type is converted to the type of the
-                 operand with signed integer type.
-                 Otherwise, both operands are converted to the unsigned integer type
-                 corresponding to the type of the operand with signed integer type.
-2   The values of floating operands and of the results of floating expressions may be
-    represented in greater precision and range than that required by the type; the types are not
-    changed thereby.<sup><a href="#note52"><b>52)</b></a></sup>
-
-
-
-
-    <sup><a name="note51" href="#note51"><b>51)</b></a></sup> For example, addition of a double _Complex and a float entails just the conversion of the
-        float operand to double (and yields a double _Complex result).
-    <sup><a name="note52" href="#note52"><b>52)</b></a></sup> The cast and assignment operators are still required to perform their specified conversions as
-        described in <a href="#6.3.1.4">6.3.1.4</a> and <a href="#6.3.1.5">6.3.1.5</a>.
-
-[<a name="p45" href="#p45">page 45</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.3.2" href="#6.3.2"><b>    6.3.2 Other operands</b></a>
-<a name="6.3.2.1" href="#6.3.2.1"><b>    6.3.2.1 Lvalues, arrays, and function designators</b></a>
-1   An lvalue is an expression with an object type or an incomplete type other than void;<sup><a href="#note53"><b>53)</b></a></sup>
-    if an lvalue does not designate an object when it is evaluated, the behavior is undefined.
-    When an object is said to have a particular type, the type is specified by the lvalue used to
-    designate the object. A modifiable lvalue is an lvalue that does not have array type, does
-    not have an incomplete type, does not have a const-qualified type, and if it is a structure
-    or union, does not have any member (including, recursively, any member or element of
-    all contained aggregates or unions) with a const-qualified type.
-2   Except when it is the operand of the sizeof operator, the unary &amp; operator, the ++
-    operator, the -- operator, or the left operand of the . operator or an assignment operator,
-    an lvalue that does not have array type is converted to the value stored in the designated
-    object (and is no longer an lvalue). If the lvalue has qualified type, the value has the
-    unqualified version of the type of the lvalue; otherwise, the value has the type of the
-    lvalue. If the lvalue has an incomplete type and does not have array type, the behavior is
-    undefined.
-3   Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a
-    string literal used to initialize an array, an expression that has type ''array of type'' is
-    converted to an expression with type ''pointer to type'' that points to the initial element of
-    the array object and is not an lvalue. If the array object has register storage class, the
-    behavior is undefined.
-4   A function designator is an expression that has function type. Except when it is the
-    operand of the sizeof operator<sup><a href="#note54"><b>54)</b></a></sup> or the unary &amp; operator, a function designator with
-    type ''function returning type'' is converted to an expression that has type ''pointer to
-    function returning type''.
-    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
-    (<a href="#6.5.16">6.5.16</a>), common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), initialization (<a href="#6.7.8">6.7.8</a>), postfix
-    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
-    (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>).
-
-
-    <sup><a name="note53" href="#note53"><b>53)</b></a></sup> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
-        operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
-        object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
-        as the ''value of an expression''.
-         An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
-         expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
-    <sup><a name="note54" href="#note54"><b>54)</b></a></sup> Because this conversion does not occur, the operand of the sizeof operator remains a function
-        designator and violates the constraint in <a href="#6.5.3.4">6.5.3.4</a>.
-
-[<a name="p46" href="#p46">page 46</a>] (<a href="#Contents">Contents</a>)
-
-    <a href="#6.3.2.2">6.3.2.2</a> void
-1   The (nonexistent) value of a void expression (an expression that has type void) shall not
-    be used in any way, and implicit or explicit conversions (except to void) shall not be
-    applied to such an expression. If an expression of any other type is evaluated as a void
-    expression, its value or designator is discarded. (A void expression is evaluated for its
-    side effects.)
-<a name="6.3.2.3" href="#6.3.2.3"><b>    6.3.2.3 Pointers</b></a>
-1   A pointer to void may be converted to or from a pointer to any incomplete or object
-    type. A pointer to any incomplete or object type may be converted to a pointer to void
-    and back again; the result shall compare equal to the original pointer.
-2   For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
-    the q-qualified version of the type; the values stored in the original and converted pointers
-    shall compare equal.
-3   An integer constant expression with the value 0, or such an expression cast to type
-    void *, is called a null pointer constant.<sup><a href="#note55"><b>55)</b></a></sup> If a null pointer constant is converted to a
-    pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
-    to a pointer to any object or function.
-4   Conversion of a null pointer to another pointer type yields a null pointer of that type.
-    Any two null pointers shall compare equal.
-5   An integer may be converted to any pointer type. Except as previously specified, the
-    result is implementation-defined, might not be correctly aligned, might not point to an
-    entity of the referenced type, and might be a trap representation.<sup><a href="#note56"><b>56)</b></a></sup>
-6   Any pointer type may be converted to an integer type. Except as previously specified, the
-    result is implementation-defined. If the result cannot be represented in the integer type,
-    the behavior is undefined. The result need not be in the range of values of any integer
-    type.
-7   A pointer to an object or incomplete type may be converted to a pointer to a different
-    object or incomplete type. If the resulting pointer is not correctly aligned<sup><a href="#note57"><b>57)</b></a></sup> for the
-    pointed-to type, the behavior is undefined. Otherwise, when converted back again, the
-    result shall compare equal to the original pointer. When a pointer to an object is
-
-
-    <sup><a name="note55" href="#note55"><b>55)</b></a></sup> The macro NULL is defined in <a href="#7.17">&lt;stddef.h&gt;</a> (and other headers) as a null pointer constant; see <a href="#7.17">7.17</a>.
-    <sup><a name="note56" href="#note56"><b>56)</b></a></sup> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
-        be consistent with the addressing structure of the execution environment.
-    <sup><a name="note57" href="#note57"><b>57)</b></a></sup> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
-        pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
-        correctly aligned for a pointer to type C.
-
-[<a name="p47" href="#p47">page 47</a>] (<a href="#Contents">Contents</a>)
-
-    converted to a pointer to a character type, the result points to the lowest addressed byte of
-    the object. Successive increments of the result, up to the size of the object, yield pointers
-    to the remaining bytes of the object.
-8   A pointer to a function of one type may be converted to a pointer to a function of another
-    type and back again; the result shall compare equal to the original pointer. If a converted
-    pointer is used to call a function whose type is not compatible with the pointed-to type,
-    the behavior is undefined.
-    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
-    capable of holding object pointers (<a href="#7.18.1.4">7.18.1.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
-
-[<a name="p48" href="#p48">page 48</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4" href="#6.4"><b>    6.4 Lexical elements</b></a>
-<b>    Syntax</b>
-1            token:
-                      keyword
-                      identifier
-                      constant
-                      string-literal
-                      punctuator
-             preprocessing-token:
-                    header-name
-                    identifier
-                    pp-number
-                    character-constant
-                    string-literal
-                    punctuator
-                    each non-white-space character that cannot be one of the above
-<b>    Constraints</b>
-2   Each preprocessing token that is converted to a token shall have the lexical form of a
-    keyword, an identifier, a constant, a string literal, or a punctuator.
-<b>    Semantics</b>
-3   A token is the minimal lexical element of the language in translation phases 7 and 8. The
-    categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
-    A preprocessing token is the minimal lexical element of the language in translation
-    phases 3 through 6. The categories of preprocessing tokens are: header names,
-    identifiers, preprocessing numbers, character constants, string literals, punctuators, and
-    single non-white-space characters that do not lexically match the other preprocessing
-    token categories.<sup><a href="#note58"><b>58)</b></a></sup> If a ' or a " character matches the last category, the behavior is
-    undefined. Preprocessing tokens can be separated by white space; this consists of
-    comments (described later), or white-space characters (space, horizontal tab, new-line,
-    vertical tab, and form-feed), or both. As described in <a href="#6.10">6.10</a>, in certain circumstances
-    during translation phase 4, white space (or the absence thereof) serves as more than
-    preprocessing token separation. White space may appear within a preprocessing token
-    only as part of a header name or between the quotation characters in a character constant
-    or string literal.
-
-
-
-    <sup><a name="note58" href="#note58"><b>58)</b></a></sup> An additional category, placemarkers, is used internally in translation phase 4 (see <a href="#6.10.3.3">6.10.3.3</a>); it cannot
-        occur in source files.
-
-[<a name="p49" href="#p49">page 49</a>] (<a href="#Contents">Contents</a>)
-
-4   If the input stream has been parsed into preprocessing tokens up to a given character, the
-    next preprocessing token is the longest sequence of characters that could constitute a
-    preprocessing token. There is one exception to this rule: header name preprocessing
-    tokens are recognized only within #include preprocessing directives and in
-    implementation-defined locations within #pragma directives. In such contexts, a
-    sequence of characters that could be either a header name or a string literal is recognized
-    as the former.
-5   EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
-    valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
-    might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
-    fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
-    not E is a macro name.
-
-6   EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
-    increment operators, even though the parse x ++ + ++ y might yield a correct expression.
-
-    Forward references: character constants (<a href="#6.4.4.4">6.4.4.4</a>), comments (<a href="#6.4.9">6.4.9</a>), expressions (<a href="#6.5">6.5</a>),
-    floating constants (<a href="#6.4.4.2">6.4.4.2</a>), header names (<a href="#6.4.7">6.4.7</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), postfix
-    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
-    (<a href="#6.5.3.1">6.5.3.1</a>), preprocessing directives (<a href="#6.10">6.10</a>), preprocessing numbers (<a href="#6.4.8">6.4.8</a>), string literals
-    (<a href="#6.4.5">6.4.5</a>).
-<a name="6.4.1" href="#6.4.1"><b>    6.4.1 Keywords</b></a>
-<b>    Syntax</b>
-1            keyword: one of
-                   auto                    enum                  restrict              unsigned
-                   break                   extern                return                void
-                   case                    float                 short                 volatile
-                   char                    for                   signed                while
-                   const                   goto                  sizeof                _Bool
-                   continue                if                    static                _Complex
-                   default                 inline                struct                _Imaginary
-                   do                      int                   switch
-                   double                  long                  typedef
-                   else                    register              union
-<b>    Semantics</b>
-2   The above tokens (case sensitive) are reserved (in translation phases 7 and 8) for use as
-    keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
-    specifying imaginary types.<sup><a href="#note59"><b>59)</b></a></sup>
-
-
-
-    <sup><a name="note59" href="#note59"><b>59)</b></a></sup> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
-
-[<a name="p50" href="#p50">page 50</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.2" href="#6.4.2"><b>    6.4.2 Identifiers</b></a>
-<a name="6.4.2.1" href="#6.4.2.1"><b>    6.4.2.1 General</b></a>
-<b>    Syntax</b>
-1            identifier:
-                    identifier-nondigit
-                     identifier identifier-nondigit
-                    identifier digit
-             identifier-nondigit:
-                     nondigit
-                     universal-character-name
-                    other implementation-defined characters
-             nondigit: one of
-                    _ a b            c    d    e    f     g    h    i    j     k    l    m
-                        n o          p    q    r    s     t    u    v    w     x    y    z
-                        A B          C    D    E    F     G    H    I    J     K    L    M
-                        N O          P    Q    R    S     T    U    V    W     X    Y    Z
-             digit: one of
-                    0 1        2     3    4    5    6     7    8    9
-<b>    Semantics</b>
-2   An identifier is a sequence of nondigit characters (including the underscore _, the
-    lowercase and uppercase Latin letters, and other characters) and digits, which designates
-    one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
-    There is no specific limit on the maximum length of an identifier.
-3   Each universal character name in an identifier shall designate a character whose encoding
-    in ISO/IEC 10646 falls into one of the ranges specified in <a href="#D">annex D</a>.<sup><a href="#note60"><b>60)</b></a></sup> The initial
-    character shall not be a universal character name designating a digit. An implementation
-    may allow multibyte characters that are not part of the basic source character set to
-    appear in identifiers; which characters and their correspondence to universal character
-    names is implementation-defined.
-4   When preprocessing tokens are converted to tokens during translation phase 7, if a
-    preprocessing token could be converted to either a keyword or an identifier, it is converted
-    to a keyword.
-
-
-    <sup><a name="note60" href="#note60"><b>60)</b></a></sup> On systems in which linkers cannot accept extended characters, an encoding of the universal character
-        name may be used in forming valid external identifiers. For example, some otherwise unused
-        character or sequence of characters may be used to encode the \u in a universal character name.
-        Extended characters may produce a long external identifier.
-
-[<a name="p51" href="#p51">page 51</a>] (<a href="#Contents">Contents</a>)
-
-    Implementation limits
-5   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
-    characters in an identifier; the limit for an external name (an identifier that has external
-    linkage) may be more restrictive than that for an internal name (a macro name or an
-    identifier that does not have external linkage). The number of significant characters in an
-    identifier is implementation-defined.
-6   Any identifiers that differ in a significant character are different identifiers. If two
-    identifiers differ only in nonsignificant characters, the behavior is undefined.
-    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
-<a name="6.4.2.2" href="#6.4.2.2"><b>    6.4.2.2 Predefined identifiers</b></a>
-<b>    Semantics</b>
-1   The identifier __func__ shall be implicitly declared by the translator as if,
-    immediately following the opening brace of each function definition, the declaration
-             static const char __func__[] = "function-name";
-    appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note61"><b>61)</b></a></sup>
-2   This name is encoded as if the implicit declaration had been written in the source
-    character set and then translated into the execution character set as indicated in translation
-    phase 5.
-3   EXAMPLE        Consider the code fragment:
-             #include <a href="#7.19">&lt;stdio.h&gt;</a>
-             void myfunc(void)
-             {
-                   printf("%s\n", __func__);
-                   /* ... */
-             }
-    Each time the function is called, it will print to the standard output stream:
-             myfunc
-
-    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
-
-
-
-
-    <sup><a name="note61" href="#note61"><b>61)</b></a></sup> Since the name __func__ is reserved for any use by the implementation (<a href="#7.1.3">7.1.3</a>), if any other
-        identifier is explicitly declared using the name __func__, the behavior is undefined.
-
-[<a name="p52" href="#p52">page 52</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.3" href="#6.4.3"><b>    6.4.3 Universal character names</b></a>
-<b>    Syntax</b>
-1            universal-character-name:
-                    \u hex-quad
-                    \U hex-quad hex-quad
-             hex-quad:
-                    hexadecimal-digit hexadecimal-digit
-                                 hexadecimal-digit hexadecimal-digit
-<b>    Constraints</b>
-2   A universal character name shall not specify a character whose short identifier is less than
-    00A0 other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through
-    DFFF inclusive.<sup><a href="#note62"><b>62)</b></a></sup>
-<b>    Description</b>
-3   Universal character names may be used in identifiers, character constants, and string
-    literals to designate characters that are not in the basic character set.
-<b>    Semantics</b>
-4   The universal character name \Unnnnnnnn designates the character whose eight-digit
-    short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note63"><b>63)</b></a></sup> Similarly, the universal
-    character name \unnnn designates the character whose four-digit short identifier is nnnn
-    (and whose eight-digit short identifier is 0000nnnn).
-
-
-
-
-    <sup><a name="note62" href="#note62"><b>62)</b></a></sup> The disallowed characters are the characters in the basic character set and the code positions reserved
-        by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
-        UTF-16).
-    <sup><a name="note63" href="#note63"><b>63)</b></a></sup> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
-
-[<a name="p53" href="#p53">page 53</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.4" href="#6.4.4"><b>    6.4.4 Constants</b></a>
-<b>    Syntax</b>
-1            constant:
-                    integer-constant
-                    floating-constant
-                    enumeration-constant
-                    character-constant
-<b>    Constraints</b>
-2   Each constant shall have a type and the value of a constant shall be in the range of
-    representable values for its type.
-<b>    Semantics</b>
-3   Each constant has a type, determined by its form and value, as detailed later.
-<a name="6.4.4.1" href="#6.4.4.1"><b>    6.4.4.1 Integer constants</b></a>
-<b>    Syntax</b>
-1            integer-constant:
-                     decimal-constant integer-suffixopt
-                     octal-constant integer-suffixopt
-                     hexadecimal-constant integer-suffixopt
-             decimal-constant:
-                   nonzero-digit
-                   decimal-constant digit
-             octal-constant:
-                    0
-                    octal-constant octal-digit
-             hexadecimal-constant:
-                   hexadecimal-prefix hexadecimal-digit
-                   hexadecimal-constant hexadecimal-digit
-             hexadecimal-prefix: one of
-                   0x 0X
-             nonzero-digit: one of
-                    1 2 3 4          5     6     7   8    9
-             octal-digit: one of
-                     0 1 2 3         4     5     6   7
-
-[<a name="p54" href="#p54">page 54</a>] (<a href="#Contents">Contents</a>)
-
-           hexadecimal-digit:   one of
-                 0 1 2           3 4      5    6   7     8   9
-                 a b c           d e      f
-                 A B C           D E      F
-           integer-suffix:
-                   unsigned-suffix long-suffixopt
-                   unsigned-suffix long-long-suffix
-                   long-suffix unsigned-suffixopt
-                   long-long-suffix unsigned-suffixopt
-           unsigned-suffix: one of
-                  u U
-           long-suffix: one of
-                  l L
-           long-long-suffix: one of
-                  ll LL
-<b>    Description</b>
-2   An integer constant begins with a digit, but has no period or exponent part. It may have a
-    prefix that specifies its base and a suffix that specifies its type.
-3   A decimal constant begins with a nonzero digit and consists of a sequence of decimal
-    digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
-    digits 0 through 7 only. A hexadecimal constant consists of the prefix 0x or 0X followed
-    by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
-    10 through 15 respectively.
-<b>    Semantics</b>
-4   The value of a decimal constant is computed base 10; that of an octal constant, base 8;
-    that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
-5   The type of an integer constant is the first of the corresponding list in which its value can
-    be represented.
-
-[<a name="p55" href="#p55">page 55</a>] (<a href="#Contents">Contents</a>)
-
-                                                                     Octal or Hexadecimal
-    Suffix                       Decimal Constant                           Constant
-
-    none                int                                    int
-                        long int                               unsigned int
-                        long long int                          long int
-                                                               unsigned long int
-                                                               long long int
-                                                               unsigned long long int
-
-    u or U              unsigned int                           unsigned int
-                        unsigned long int                      unsigned long int
-                        unsigned long long int                 unsigned long long int
-
-    l or L              long int                               long int
-                        long long int                          unsigned long int
-                                                               long long int
-                                                               unsigned long long int
-
-    Both u or U         unsigned long int                      unsigned long int
-    and l or L          unsigned long long int                 unsigned long long int
-
-    ll or LL            long long int                          long long int
-                                                               unsigned long long int
-
-    Both u or U         unsigned long long int                 unsigned long long int
-    and ll or LL
-6   If an integer constant cannot be represented by any type in its list, it may have an
-    extended integer type, if the extended integer type can represent its value. If all of the
-    types in the list for the constant are signed, the extended integer type shall be signed. If
-    all of the types in the list for the constant are unsigned, the extended integer type shall be
-    unsigned. If the list contains both signed and unsigned types, the extended integer type
-    may be signed or unsigned. If an integer constant cannot be represented by any type in
-    its list and has no extended integer type, then the integer constant has no type.
-
-[<a name="p56" href="#p56">page 56</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.4.2" href="#6.4.4.2"><b>    6.4.4.2 Floating constants</b></a>
-<b>    Syntax</b>
-1            floating-constant:
-                    decimal-floating-constant
-                    hexadecimal-floating-constant
-             decimal-floating-constant:
-                   fractional-constant exponent-partopt floating-suffixopt
-                   digit-sequence exponent-part floating-suffixopt
-             hexadecimal-floating-constant:
-                   hexadecimal-prefix hexadecimal-fractional-constant
-                                  binary-exponent-part floating-suffixopt
-                   hexadecimal-prefix hexadecimal-digit-sequence
-                                  binary-exponent-part floating-suffixopt
-             fractional-constant:
-                     digit-sequenceopt . digit-sequence
-                     digit-sequence .
-             exponent-part:
-                   e signopt digit-sequence
-                   E signopt digit-sequence
-             sign: one of
-                    + -
-             digit-sequence:
-                     digit
-                     digit-sequence digit
-             hexadecimal-fractional-constant:
-                   hexadecimal-digit-sequenceopt .
-                                  hexadecimal-digit-sequence
-                   hexadecimal-digit-sequence .
-             binary-exponent-part:
-                    p signopt digit-sequence
-                    P signopt digit-sequence
-             hexadecimal-digit-sequence:
-                   hexadecimal-digit
-                   hexadecimal-digit-sequence hexadecimal-digit
-             floating-suffix: one of
-                    f l F L
-
-[<a name="p57" href="#p57">page 57</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   A floating constant has a significand part that may be followed by an exponent part and a
-    suffix that specifies its type. The components of the significand part may include a digit
-    sequence representing the whole-number part, followed by a period (.), followed by a
-    digit sequence representing the fraction part. The components of the exponent part are an
-    e, E, p, or P followed by an exponent consisting of an optionally signed digit sequence.
-    Either the whole-number part or the fraction part has to be present; for decimal floating
-    constants, either the period or the exponent part has to be present.
-<b>    Semantics</b>
-3   The significand part is interpreted as a (decimal or hexadecimal) rational number; the
-    digit sequence in the exponent part is interpreted as a decimal integer. For decimal
-    floating constants, the exponent indicates the power of 10 by which the significand part is
-    to be scaled. For hexadecimal floating constants, the exponent indicates the power of 2
-    by which the significand part is to be scaled. For decimal floating constants, and also for
-    hexadecimal floating constants when FLT_RADIX is not a power of 2, the result is either
-    the nearest representable value, or the larger or smaller representable value immediately
-    adjacent to the nearest representable value, chosen in an implementation-defined manner.
-    For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
-    correctly rounded.
-4   An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
-    type float. If suffixed by the letter l or L, it has type long double.
-5   Floating constants are converted to internal format as if at translation-time. The
-    conversion of a floating constant shall not raise an exceptional condition or a floating-
-    point exception at execution time.
-    Recommended practice
-6   The implementation should produce a diagnostic message if a hexadecimal constant
-    cannot be represented exactly in its evaluation format; the implementation should then
-    proceed with the translation of the program.
-7   The translation-time conversion of floating constants should match the execution-time
-    conversion of character strings by library functions, such as strtod, given matching
-    inputs suitable for both conversions, the same result format, and default execution-time
-    rounding.<sup><a href="#note64"><b>64)</b></a></sup>
-
-
-
-
-    <sup><a name="note64" href="#note64"><b>64)</b></a></sup> The specification for the library functions recommends more accurate conversion than required for
-        floating constants (see <a href="#7.20.1.3">7.20.1.3</a>).
-
-[<a name="p58" href="#p58">page 58</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.4.3" href="#6.4.4.3"><b>    6.4.4.3 Enumeration constants</b></a>
-<b>    Syntax</b>
-1            enumeration-constant:
-                   identifier
-<b>    Semantics</b>
-2   An identifier declared as an enumeration constant has type int.
-    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
-<a name="6.4.4.4" href="#6.4.4.4"><b>    6.4.4.4 Character constants</b></a>
-<b>    Syntax</b>
-1            character-constant:
-                    ' c-char-sequence '
-                    L' c-char-sequence '
-             c-char-sequence:
-                    c-char
-                    c-char-sequence c-char
-             c-char:
-                       any member of the source character set except
-                                    the single-quote ', backslash \, or new-line character
-                       escape-sequence
-             escape-sequence:
-                    simple-escape-sequence
-                    octal-escape-sequence
-                    hexadecimal-escape-sequence
-                    universal-character-name
-             simple-escape-sequence: one of
-                    \' \" \? \\
-                    \a \b \f \n \r                  \t    \v
-             octal-escape-sequence:
-                     \ octal-digit
-                     \ octal-digit octal-digit
-                     \ octal-digit octal-digit octal-digit
-             hexadecimal-escape-sequence:
-                   \x hexadecimal-digit
-                   hexadecimal-escape-sequence hexadecimal-digit
-
-[<a name="p59" href="#p59">page 59</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   An integer character constant is a sequence of one or more multibyte characters enclosed
-    in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
-    letter L. With a few exceptions detailed later, the elements of the sequence are any
-    members of the source character set; they are mapped in an implementation-defined
-    manner to members of the execution character set.
-3   The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
-    arbitrary integer values are representable according to the following table of escape
-    sequences:
-           single quote '                 \'
-           double quote "                 \"
-           question mark ?                \?
-           backslash \                    \\
-           octal character                \octal digits
-           hexadecimal character          \x hexadecimal digits
-4   The double-quote " and question-mark ? are representable either by themselves or by the
-    escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
-    shall be represented, respectively, by the escape sequences \' and \\.
-5   The octal digits that follow the backslash in an octal escape sequence are taken to be part
-    of the construction of a single character for an integer character constant or of a single
-    wide character for a wide character constant. The numerical value of the octal integer so
-    formed specifies the value of the desired character or wide character.
-6   The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
-    sequence are taken to be part of the construction of a single character for an integer
-    character constant or of a single wide character for a wide character constant. The
-    numerical value of the hexadecimal integer so formed specifies the value of the desired
-    character or wide character.
-7   Each octal or hexadecimal escape sequence is the longest sequence of characters that can
-    constitute the escape sequence.
-8   In addition, characters not in the basic character set are representable by universal
-    character names and certain nongraphic characters are representable by escape sequences
-    consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
-    and \v.<sup><a href="#note65"><b>65)</b></a></sup>
-
-
-
-
-    <sup><a name="note65" href="#note65"><b>65)</b></a></sup> The semantics of these characters were discussed in <a href="#5.2.2">5.2.2</a>. If any other character follows a backslash,
-        the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
-
-[<a name="p60" href="#p60">page 60</a>] (<a href="#Contents">Contents</a>)
-
-<b>     Constraints</b>
-9    The value of an octal or hexadecimal escape sequence shall be in the range of
-     representable values for the type unsigned char for an integer character constant, or
-     the unsigned type corresponding to wchar_t for a wide character constant.
-<b>     Semantics</b>
-10   An integer character constant has type int. The value of an integer character constant
-     containing a single character that maps to a single-byte execution character is the
-     numerical value of the representation of the mapped character interpreted as an integer.
-     The value of an integer character constant containing more than one character (e.g.,
-     'ab'), or containing a character or escape sequence that does not map to a single-byte
-     execution character, is implementation-defined. If an integer character constant contains
-     a single character or escape sequence, its value is the one that results when an object with
-     type char whose value is that of the single character or escape sequence is converted to
-     type int.
-11   A wide character constant has type wchar_t, an integer type defined in the
-     <a href="#7.17">&lt;stddef.h&gt;</a> header. The value of a wide character constant containing a single
-     multibyte character that maps to a member of the extended execution character set is the
-     wide character corresponding to that multibyte character, as defined by the mbtowc
-     function, with an implementation-defined current locale. The value of a wide character
-     constant containing more than one multibyte character, or containing a multibyte
-     character or escape sequence not represented in the extended execution character set, is
-     implementation-defined.
-12   EXAMPLE 1      The construction '\0' is commonly used to represent the null character.
-
-13   EXAMPLE 2 Consider implementations that use two's-complement representation for integers and eight
-     bits for objects that have type char. In an implementation in which type char has the same range of
-     values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
-     same range of values as unsigned char, the character constant '\xFF' has the value +255.
-
-14   EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
-     specifies an integer character constant containing only one character, since a hexadecimal escape sequence
-     is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
-     two characters whose values are '\x12' and '3', the construction '\0223' may be used, since an octal
-     escape sequence is terminated after three octal digits. (The value of this two-character integer character
-     constant is implementation-defined.)
-
-15   EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
-     L'\1234' specifies the implementation-defined value that results from the combination of the values
-     0123 and '4'.
-
-     Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), the mbtowc function
-     (<a href="#7.20.7.2">7.20.7.2</a>).
-
-[<a name="p61" href="#p61">page 61</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.5" href="#6.4.5"><b>    6.4.5 String literals</b></a>
-<b>    Syntax</b>
-1            string-literal:
-                     " s-char-sequenceopt "
-                     L" s-char-sequenceopt "
-             s-char-sequence:
-                    s-char
-                    s-char-sequence s-char
-             s-char:
-                       any member of the source character set except
-                                    the double-quote ", backslash \, or new-line character
-                       escape-sequence
-<b>    Description</b>
-2   A character string literal is a sequence of zero or more multibyte characters enclosed in
-    double-quotes, as in "xyz". A wide string literal is the same, except prefixed by the
-    letter L.
-3   The same considerations apply to each element of the sequence in a character string
-    literal or a wide string literal as if it were in an integer character constant or a wide
-    character constant, except that the single-quote ' is representable either by itself or by the
-    escape sequence \', but the double-quote " shall be represented by the escape sequence
-    \".
-<b>    Semantics</b>
-4   In translation phase 6, the multibyte character sequences specified by any sequence of
-    adjacent character and wide string literal tokens are concatenated into a single multibyte
-    character sequence. If any of the tokens are wide string literal tokens, the resulting
-    multibyte character sequence is treated as a wide string literal; otherwise, it is treated as a
-    character string literal.
-5   In translation phase 7, a byte or code of value zero is appended to each multibyte
-    character sequence that results from a string literal or literals.<sup><a href="#note66"><b>66)</b></a></sup> The multibyte character
-    sequence is then used to initialize an array of static storage duration and length just
-    sufficient to contain the sequence. For character string literals, the array elements have
-    type char, and are initialized with the individual bytes of the multibyte character
-    sequence; for wide string literals, the array elements have type wchar_t, and are
-    initialized with the sequence of wide characters corresponding to the multibyte character
-
-    <sup><a name="note66" href="#note66"><b>66)</b></a></sup> A character string literal need not be a string (see <a href="#7.1.1">7.1.1</a>), because a null character may be embedded in
-        it by a \0 escape sequence.
-
-[<a name="p62" href="#p62">page 62</a>] (<a href="#Contents">Contents</a>)
-
-    sequence, as defined by the mbstowcs function with an implementation-defined current
-    locale. The value of a string literal containing a multibyte character or escape sequence
-    not represented in the execution character set is implementation-defined.
-6   It is unspecified whether these arrays are distinct provided their elements have the
-    appropriate values. If the program attempts to modify such an array, the behavior is
-    undefined.
-7   EXAMPLE       This pair of adjacent character string literals
-             "\x12" "3"
-    produces a single character string literal containing the two characters whose values are '\x12' and '3',
-    because escape sequences are converted into single members of the execution character set just prior to
-    adjacent string literal concatenation.
-
-    Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), the mbstowcs
-    function (<a href="#7.20.8.1">7.20.8.1</a>).
-<a name="6.4.6" href="#6.4.6"><b>    6.4.6 Punctuators</b></a>
-<b>    Syntax</b>
-1            punctuator: one of
-                    [ ] ( ) { } . -&gt;
-                    ++ -- &amp; * + - ~ !
-                    / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                               ==     !=     ^    |     &amp;&amp;     ||
-                    ? : ; ...
-                    = *= /= %= += -= &lt;&lt;=                              &gt;&gt;=      &amp;=       ^=   |=
-                    , # ##
-                    &lt;: :&gt; &lt;% %&gt; %: %:%:
-<b>    Semantics</b>
-2   A punctuator is a symbol that has independent syntactic and semantic significance.
-    Depending on context, it may specify an operation to be performed (which in turn may
-    yield a value or a function designator, produce a side effect, or some combination thereof)
-    in which case it is known as an operator (other forms of operator also exist in some
-    contexts). An operand is an entity on which an operator acts.
-
-[<a name="p63" href="#p63">page 63</a>] (<a href="#Contents">Contents</a>)
-
-3   In all aspects of the language, the six tokens<sup><a href="#note67"><b>67)</b></a></sup>
-             &lt;:    :&gt;      &lt;%    %&gt;     %:     %:%:
-    behave, respectively, the same as the six tokens
-             [     ]       {     }      #      ##
-    except for their spelling.<sup><a href="#note68"><b>68)</b></a></sup>
-    Forward references: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
-    (<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
-<a name="6.4.7" href="#6.4.7"><b>    6.4.7 Header names</b></a>
-<b>    Syntax</b>
-1            header-name:
-                    &lt; h-char-sequence &gt;
-                    " q-char-sequence "
-             h-char-sequence:
-                    h-char
-                    h-char-sequence h-char
-             h-char:
-                       any member of the source character set except
-                                    the new-line character and &gt;
-             q-char-sequence:
-                    q-char
-                    q-char-sequence q-char
-             q-char:
-                       any member of the source character set except
-                                    the new-line character and "
-<b>    Semantics</b>
-2   The sequences in both forms of header names are mapped in an implementation-defined
-    manner to headers or external source file names as specified in <a href="#6.10.2">6.10.2</a>.
-3   If the characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt; delimiters,
-    the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
-
-
-
-
-    <sup><a name="note67" href="#note67"><b>67)</b></a></sup> These tokens are sometimes called ''digraphs''.
-    <sup><a name="note68" href="#note68"><b>68)</b></a></sup> Thus [ and &lt;: behave differently when ''stringized'' (see <a href="#6.10.3.2">6.10.3.2</a>), but can otherwise be freely
-        interchanged.
-
-[<a name="p64" href="#p64">page 64</a>] (<a href="#Contents">Contents</a>)
-
-    sequence between the " delimiters, the behavior is undefined.<sup><a href="#note69"><b>69)</b></a></sup> Header name
-    preprocessing tokens are recognized only within #include preprocessing directives and
-    in implementation-defined locations within #pragma directives.<sup><a href="#note70"><b>70)</b></a></sup>
-4   EXAMPLE       The following sequence of characters:
-             0x3&lt;1/a.h&gt;1e2
-             #include &lt;1/a.h&gt;
-             #define const.member@$
-    forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
-    by a { on the left and a } on the right).
-             {0x3}{&lt;}{1}{/}{a}{.}{h}{&gt;}{1e2}
-             {#}{include} {&lt;1/a.h&gt;}
-             {#}{define} {const}{.}{member}{@}{$}
-
-    Forward references: source file inclusion (<a href="#6.10.2">6.10.2</a>).
-<a name="6.4.8" href="#6.4.8"><b>    6.4.8 Preprocessing numbers</b></a>
-<b>    Syntax</b>
-1            pp-number:
-                   digit
-                   . digit
-                   pp-number       digit
-                   pp-number       identifier-nondigit
-                   pp-number       e sign
-                   pp-number       E sign
-                   pp-number       p sign
-                   pp-number       P sign
-                   pp-number       .
-<b>    Description</b>
-2   A preprocessing number begins with a digit optionally preceded by a period (.) and may
-    be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
-    p+, p-, P+, or P-.
-3   Preprocessing number tokens lexically include all floating and integer constant tokens.
-<b>    Semantics</b>
-4   A preprocessing number does not have type or a value; it acquires both after a successful
-    conversion (as part of translation phase 7) to a floating constant token or an integer
-    constant token.
-
-
-    <sup><a name="note69" href="#note69"><b>69)</b></a></sup> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
-    <sup><a name="note70" href="#note70"><b>70)</b></a></sup> For an example of a header name preprocessing token used in a #pragma directive, see <a href="#6.10.9">6.10.9</a>.
-
-[<a name="p65" href="#p65">page 65</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.9" href="#6.4.9"><b>    6.4.9 Comments</b></a>
-1   Except within a character constant, a string literal, or a comment, the characters /*
-    introduce a comment. The contents of such a comment are examined only to identify
-    multibyte characters and to find the characters */ that terminate it.<sup><a href="#note71"><b>71)</b></a></sup>
-2   Except within a character constant, a string literal, or a comment, the characters //
-    introduce a comment that includes all multibyte characters up to, but not including, the
-    next new-line character. The contents of such a comment are examined only to identify
-    multibyte characters and to find the terminating new-line character.
-3   EXAMPLE
-            "a//b"                              //   four-character string literal
-            #include "//e"                      //   undefined behavior
-            // */                               //   comment, not syntax error
-            f = g/**//h;                        //   equivalent to f = g / h;
-            //\
-            i();                                // part of a two-line comment
-            /\
-            / j();                              // part of a two-line comment
-            #define glue(x,y) x##y
-            glue(/,/) k();                      // syntax error, not comment
-            /*//*/ l();                         // equivalent to l();
-            m = n//**/o
-               + p;                             // equivalent to m = n + p;
-
-
-
-
-    <sup><a name="note71" href="#note71"><b>71)</b></a></sup> Thus, /* ... */ comments do not nest.
-
-[<a name="p66" href="#p66">page 66</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5" href="#6.5"><b>    6.5 Expressions</b></a>
-1   An expression is a sequence of operators and operands that specifies computation of a
-    value, or that designates an object or a function, or that generates side effects, or that
-    performs a combination thereof.
-2   Between the previous and next sequence point an object shall have its stored value
-    modified at most once by the evaluation of an expression.<sup><a href="#note72"><b>72)</b></a></sup> Furthermore, the prior value
-    shall be read only to determine the value to be stored.<sup><a href="#note73"><b>73)</b></a></sup>
-3   The grouping of operators and operands is indicated by the syntax.<sup><a href="#note74"><b>74)</b></a></sup> Except as specified
-    later (for the function-call (), &amp;&amp;, ||, ?:, and comma operators), the order of evaluation
-    of subexpressions and the order in which side effects take place are both unspecified.
-4   Some operators (the unary operator ~, and the binary operators &lt;&lt;, &gt;&gt;, &amp;, ^, and |,
-    collectively described as bitwise operators) are required to have operands that have
-    integer type. These operators yield values that depend on the internal representations of
-    integers, and have implementation-defined and undefined aspects for signed types.
-5   If an exceptional condition occurs during the evaluation of an expression (that is, if the
-    result is not mathematically defined or not in the range of representable values for its
-    type), the behavior is undefined.
-6   The effective type of an object for an access to its stored value is the declared type of the
-    object, if any.<sup><a href="#note75"><b>75)</b></a></sup> If a value is stored into an object having no declared type through an
-    lvalue having a type that is not a character type, then the type of the lvalue becomes the
-
-
-    <sup><a name="note72" href="#note72"><b>72)</b></a></sup> A floating-point status flag is not an object and can be set more than once within an expression.
-    <sup><a name="note73" href="#note73"><b>73)</b></a></sup> This paragraph renders undefined statement expressions such as
-                   i = ++i + 1;
-                   a[i++] = i;
-           while allowing
-                   i = i + 1;
-                   a[i] = i;
-
-    <sup><a name="note74" href="#note74"><b>74)</b></a></sup> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
-        as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
-        expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
-        <a href="#6.5.1">6.5.1</a> through <a href="#6.5.6">6.5.6</a>. The exceptions are cast expressions (<a href="#6.5.4">6.5.4</a>) as operands of unary operators
-        (<a href="#6.5.3">6.5.3</a>), and an operand contained between any of the following pairs of operators: grouping
-        parentheses () (<a href="#6.5.1">6.5.1</a>), subscripting brackets [] (<a href="#6.5.2.1">6.5.2.1</a>), function-call parentheses () (<a href="#6.5.2.2">6.5.2.2</a>), and
-        the conditional operator ?: (<a href="#6.5.15">6.5.15</a>).
-           Within each major subclause, the operators have the same precedence. Left- or right-associativity is
-           indicated in each subclause by the syntax for the expressions discussed therein.
-    <sup><a name="note75" href="#note75"><b>75)</b></a></sup> Allocated objects have no declared type.
-
-[<a name="p67" href="#p67">page 67</a>] (<a href="#Contents">Contents</a>)
-
-    effective type of the object for that access and for subsequent accesses that do not modify
-    the stored value. If a value is copied into an object having no declared type using
-    memcpy or memmove, or is copied as an array of character type, then the effective type
-    of the modified object for that access and for subsequent accesses that do not modify the
-    value is the effective type of the object from which the value is copied, if it has one. For
-    all other accesses to an object having no declared type, the effective type of the object is
-    simply the type of the lvalue used for the access.
-7   An object shall have its stored value accessed only by an lvalue expression that has one of
-    the following types:<sup><a href="#note76"><b>76)</b></a></sup>
-    -- a type compatible with the effective type of the object,
-    -- a qualified version of a type compatible with the effective type of the object,
-    -- a type that is the signed or unsigned type corresponding to the effective type of the
-      object,
-    -- a type that is the signed or unsigned type corresponding to a qualified version of the
-      effective type of the object,
-    -- an aggregate or union type that includes one of the aforementioned types among its
-      members (including, recursively, a member of a subaggregate or contained union), or
-    -- a character type.
-8   A floating expression may be contracted, that is, evaluated as though it were an atomic
-    operation, thereby omitting rounding errors implied by the source code and the
-    expression evaluation method.<sup><a href="#note77"><b>77)</b></a></sup> The FP_CONTRACT pragma in <a href="#7.12">&lt;math.h&gt;</a> provides a
-    way to disallow contracted expressions. Otherwise, whether and how expressions are
-    contracted is implementation-defined.<sup><a href="#note78"><b>78)</b></a></sup>
-    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.21.2">7.21.2</a>).
-
-
-
-
-    <sup><a name="note76" href="#note76"><b>76)</b></a></sup> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
-    <sup><a name="note77" href="#note77"><b>77)</b></a></sup> A contracted expression might also omit the raising of floating-point exceptions.
-    <sup><a name="note78" href="#note78"><b>78)</b></a></sup> This license is specifically intended to allow implementations to exploit fast machine instructions that
-        combine multiple C operators. As contractions potentially undermine predictability, and can even
-        decrease accuracy for containing expressions, their use needs to be well-defined and clearly
-        documented.
-
-[<a name="p68" href="#p68">page 68</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.1" href="#6.5.1"><b>    6.5.1 Primary expressions</b></a>
-<b>    Syntax</b>
-1            primary-expression:
-                    identifier
-                    constant
-                    string-literal
-                    ( expression )
-<b>    Semantics</b>
-2   An identifier is a primary expression, provided it has been declared as designating an
-    object (in which case it is an lvalue) or a function (in which case it is a function
-    designator).<sup><a href="#note79"><b>79)</b></a></sup>
-3   A constant is a primary expression. Its type depends on its form and value, as detailed in
-    <a href="#6.4.4">6.4.4</a>.
-4   A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
-5   A parenthesized expression is a primary expression. Its type and value are identical to
-    those of the unparenthesized expression. It is an lvalue, a function designator, or a void
-    expression if the unparenthesized expression is, respectively, an lvalue, a function
-    designator, or a void expression.
-    Forward references: declarations (<a href="#6.7">6.7</a>).
-<a name="6.5.2" href="#6.5.2"><b>    6.5.2 Postfix operators</b></a>
-<b>    Syntax</b>
-1            postfix-expression:
-                    primary-expression
-                    postfix-expression [ expression ]
-                    postfix-expression ( argument-expression-listopt )
-                    postfix-expression . identifier
-                    postfix-expression -&gt; identifier
-                    postfix-expression ++
-                    postfix-expression --
-                    ( type-name ) { initializer-list }
-                    ( type-name ) { initializer-list , }
-
-
-
-
-    <sup><a name="note79" href="#note79"><b>79)</b></a></sup> Thus, an undeclared identifier is a violation of the syntax.
-
-[<a name="p69" href="#p69">page 69</a>] (<a href="#Contents">Contents</a>)
-
-             argument-expression-list:
-                   assignment-expression
-                   argument-expression-list , assignment-expression
-<a name="6.5.2.1" href="#6.5.2.1"><b>    6.5.2.1 Array subscripting</b></a>
-<b>    Constraints</b>
-1   One of the expressions shall have type ''pointer to object type'', the other expression shall
-    have integer type, and the result has type ''type''.
-<b>    Semantics</b>
-2   A postfix expression followed by an expression in square brackets [] is a subscripted
-    designation of an element of an array object. The definition of the subscript operator []
-    is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
-    apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
-    initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
-    element of E1 (counting from zero).
-3   Successive subscript operators designate an element of a multidimensional array object.
-    If E is an n-dimensional array (n &gt;= 2) with dimensions i x j x . . . x k, then E (used as
-    other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
-    dimensions j x . . . x k. If the unary * operator is applied to this pointer explicitly, or
-    implicitly as a result of subscripting, the result is the pointed-to (n - 1)-dimensional array,
-    which itself is converted into a pointer if used as other than an lvalue. It follows from this
-    that arrays are stored in row-major order (last subscript varies fastest).
-4   EXAMPLE        Consider the array object defined by the declaration
-             int x[3][5];
-    Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
-    array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
-    a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
-    entails multiplying i by the size of the object to which the pointer points, namely an array of five int
-    objects. The results are added and indirection is applied to yield an array of five ints. When used in the
-    expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
-    yields an int.
-
-    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
-    (<a href="#6.5.3.2">6.5.3.2</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
-
-[<a name="p70" href="#p70">page 70</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.2.2" href="#6.5.2.2"><b>    6.5.2.2 Function calls</b></a>
-<b>    Constraints</b>
-1   The expression that denotes the called function<sup><a href="#note80"><b>80)</b></a></sup> shall have type pointer to function
-    returning void or returning an object type other than an array type.
-2   If the expression that denotes the called function has a type that includes a prototype, the
-    number of arguments shall agree with the number of parameters. Each argument shall
-    have a type such that its value may be assigned to an object with the unqualified version
-    of the type of its corresponding parameter.
-<b>    Semantics</b>
-3   A postfix expression followed by parentheses () containing a possibly empty, comma-
-    separated list of expressions is a function call. The postfix expression denotes the called
-    function. The list of expressions specifies the arguments to the function.
-4   An argument may be an expression of any object type. In preparing for the call to a
-    function, the arguments are evaluated, and each parameter is assigned the value of the
-    corresponding argument.<sup><a href="#note81"><b>81)</b></a></sup>
-5   If the expression that denotes the called function has type pointer to function returning an
-    object type, the function call expression has the same type as that object type, and has the
-    value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void. If
-    an attempt is made to modify the result of a function call or to access it after the next
-    sequence point, the behavior is undefined.
-6   If the expression that denotes the called function has a type that does not include a
-    prototype, the integer promotions are performed on each argument, and arguments that
-    have type float are promoted to double. These are called the default argument
-    promotions. If the number of arguments does not equal the number of parameters, the
-    behavior is undefined. If the function is defined with a type that includes a prototype, and
-    either the prototype ends with an ellipsis (, ...) or the types of the arguments after
-    promotion are not compatible with the types of the parameters, the behavior is undefined.
-    If the function is defined with a type that does not include a prototype, and the types of
-    the arguments after promotion are not compatible with those of the parameters after
-    promotion, the behavior is undefined, except for the following cases:
-
-
-
-
-    <sup><a name="note80" href="#note80"><b>80)</b></a></sup> Most often, this is the result of converting an identifier that is a function designator.
-    <sup><a name="note81" href="#note81"><b>81)</b></a></sup> A function may change the values of its parameters, but these changes cannot affect the values of the
-        arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
-        change the value of the object pointed to. A parameter declared to have array or function type is
-        adjusted to have a pointer type as described in <a href="#6.9.1">6.9.1</a>.
-
-[<a name="p71" href="#p71">page 71</a>] (<a href="#Contents">Contents</a>)
-
-     -- one promoted type is a signed integer type, the other promoted type is the
-       corresponding unsigned integer type, and the value is representable in both types;
-     -- both types are pointers to qualified or unqualified versions of a character type or
-       void.
-7    If the expression that denotes the called function has a type that does include a prototype,
-     the arguments are implicitly converted, as if by assignment, to the types of the
-     corresponding parameters, taking the type of each parameter to be the unqualified version
-     of its declared type. The ellipsis notation in a function prototype declarator causes
-     argument type conversion to stop after the last declared parameter. The default argument
-     promotions are performed on trailing arguments.
-8    No other conversions are performed implicitly; in particular, the number and types of
-     arguments are not compared with those of the parameters in a function definition that
-     does not include a function prototype declarator.
-9    If the function is defined with a type that is not compatible with the type (of the
-     expression) pointed to by the expression that denotes the called function, the behavior is
-     undefined.
-10   The order of evaluation of the function designator, the actual arguments, and
-     subexpressions within the actual arguments is unspecified, but there is a sequence point
-     before the actual call.
-11   Recursive function calls shall be permitted, both directly and indirectly through any chain
-     of other functions.
-12   EXAMPLE       In the function call
-             (*pf[f1()]) (f2(), f3() + f4())
-     the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
-     the function pointed to by pf[f1()] is called.
-
-     Forward references: function declarators (including prototypes) (<a href="#6.7.5.3">6.7.5.3</a>), function
-     definitions (<a href="#6.9.1">6.9.1</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
-<a name="6.5.2.3" href="#6.5.2.3"><b>     6.5.2.3 Structure and union members</b></a>
-<b>     Constraints</b>
-1    The first operand of the . operator shall have a qualified or unqualified structure or union
-     type, and the second operand shall name a member of that type.
-2    The first operand of the -&gt; operator shall have type ''pointer to qualified or unqualified
-     structure'' or ''pointer to qualified or unqualified union'', and the second operand shall
-     name a member of the type pointed to.
-
-[<a name="p72" href="#p72">page 72</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Semantics</b>
-3   A postfix expression followed by the . operator and an identifier designates a member of
-    a structure or union object. The value is that of the named member,<sup><a href="#note82"><b>82)</b></a></sup> and is an lvalue if
-    the first expression is an lvalue. If the first expression has qualified type, the result has
-    the so-qualified version of the type of the designated member.
-4   A postfix expression followed by the -&gt; operator and an identifier designates a member
-    of a structure or union object. The value is that of the named member of the object to
-    which the first expression points, and is an lvalue.<sup><a href="#note83"><b>83)</b></a></sup> If the first expression is a pointer to
-    a qualified type, the result has the so-qualified version of the type of the designated
-    member.
-5   One special guarantee is made in order to simplify the use of unions: if a union contains
-    several structures that share a common initial sequence (see below), and if the union
-    object currently contains one of these structures, it is permitted to inspect the common
-    initial part of any of them anywhere that a declaration of the complete type of the union is
-    visible. Two structures share a common initial sequence if corresponding members have
-    compatible types (and, for bit-fields, the same widths) for a sequence of one or more
-    initial members.
-6   EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
-    union, f().x is a valid postfix expression but is not an lvalue.
-
-7   EXAMPLE 2 In:
-             struct s { int i; const int ci; };
-             struct s s;
-             const struct s cs;
-             volatile struct s vs;
-    the various members have the types:
-             s.i        int
-             s.ci       const int
-             cs.i       const int
-             cs.ci      const int
-             vs.i       volatile int
-             vs.ci      volatile const int
-
-
-
-
-    <sup><a name="note82" href="#note82"><b>82)</b></a></sup> If the member used to access the contents of a union object is not the same as the member last used to
-        store a value in the object, the appropriate part of the object representation of the value is reinterpreted
-        as an object representation in the new type as described in <a href="#6.2.6">6.2.6</a> (a process sometimes called "type
-        punning"). This might be a trap representation.
-    <sup><a name="note83" href="#note83"><b>83)</b></a></sup> If &amp;E is a valid pointer expression (where &amp; is the ''address-of '' operator, which generates a pointer to
-        its operand), the expression (&amp;E)-&gt;MOS is the same as E.MOS.
-
-[<a name="p73" href="#p73">page 73</a>] (<a href="#Contents">Contents</a>)
-
-8   EXAMPLE 3       The following is a valid fragment:
-             union {
-                     struct {
-                           int      alltypes;
-                     } n;
-                     struct {
-                           int      type;
-                           int      intnode;
-                     } ni;
-                     struct {
-                           int      type;
-                           double doublenode;
-                     } nf;
-             } u;
-             u.nf.type = 1;
-             u.nf.doublenode = <a href="#3.14">3.14</a>;
-             /* ... */
-             if (u.n.alltypes == 1)
-                     if (sin(u.nf.doublenode) == 0.0)
-                           /* ... */
-    The following is not a valid fragment (because the union type is not visible within function f):
-             struct t1 { int m; };
-             struct t2 { int m; };
-             int f(struct t1 *p1, struct t2 *p2)
-             {
-                   if (p1-&gt;m &lt; 0)
-                           p2-&gt;m = -p2-&gt;m;
-                   return p1-&gt;m;
-             }
-             int g()
-             {
-                   union {
-                           struct t1 s1;
-                           struct t2 s2;
-                   } u;
-                   /* ... */
-                   return f(&amp;u.s1, &amp;u.s2);
-             }
-
-    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
-    specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
-
-[<a name="p74" href="#p74">page 74</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.2.4" href="#6.5.2.4"><b>    6.5.2.4 Postfix increment and decrement operators</b></a>
-<b>    Constraints</b>
-1   The operand of the postfix increment or decrement operator shall have qualified or
-    unqualified real or pointer type and shall be a modifiable lvalue.
-<b>    Semantics</b>
-2   The result of the postfix ++ operator is the value of the operand. After the result is
-    obtained, the value of the operand is incremented. (That is, the value 1 of the appropriate
-    type is added to it.) See the discussions of additive operators and compound assignment
-    for information on constraints, types, and conversions and the effects of operations on
-    pointers. The side effect of updating the stored value of the operand shall occur between
-    the previous and the next sequence point.
-3   The postfix -- operator is analogous to the postfix ++ operator, except that the value of
-    the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
-    it).
-    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
-<a name="6.5.2.5" href="#6.5.2.5"><b>    6.5.2.5 Compound literals</b></a>
-<b>    Constraints</b>
-1   The type name shall specify an object type or an array of unknown size, but not a variable
-    length array type.
-2   No initializer shall attempt to provide a value for an object not contained within the entire
-    unnamed object specified by the compound literal.
-3   If the compound literal occurs outside the body of a function, the initializer list shall
-    consist of constant expressions.
-<b>    Semantics</b>
-4   A postfix expression that consists of a parenthesized type name followed by a brace-
-    enclosed list of initializers is a compound literal. It provides an unnamed object whose
-    value is given by the initializer list.<sup><a href="#note84"><b>84)</b></a></sup>
-5   If the type name specifies an array of unknown size, the size is determined by the
-    initializer list as specified in <a href="#6.7.8">6.7.8</a>, and the type of the compound literal is that of the
-    completed array type. Otherwise (when the type name specifies an object type), the type
-    of the compound literal is that specified by the type name. In either case, the result is an
-    lvalue.
-
-
-    <sup><a name="note84" href="#note84"><b>84)</b></a></sup> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
-        or void only, and the result of a cast expression is not an lvalue.
-
-[<a name="p75" href="#p75">page 75</a>] (<a href="#Contents">Contents</a>)
-
-6    The value of the compound literal is that of an unnamed object initialized by the
-     initializer list. If the compound literal occurs outside the body of a function, the object
-     has static storage duration; otherwise, it has automatic storage duration associated with
-     the enclosing block.
-7    All the semantic rules and constraints for initializer lists in <a href="#6.7.8">6.7.8</a> are applicable to
-     compound literals.<sup><a href="#note85"><b>85)</b></a></sup>
-8    String literals, and compound literals with const-qualified types, need not designate
-     distinct objects.<sup><a href="#note86"><b>86)</b></a></sup>
-9    EXAMPLE 1       The file scope definition
-              int *p = (int []){2, 4};
-     initializes p to point to the first element of an array of two ints, the first having the value two and the
-     second, four. The expressions in this compound literal are required to be constant. The unnamed object
-     has static storage duration.
-
-10   EXAMPLE 2       In contrast, in
-              void f(void)
-              {
-                    int *p;
-                    /*...*/
-                    p = (int [2]){*p};
-                    /*...*/
-              }
-     p is assigned the address of the first element of an array of two ints, the first having the value previously
-     pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
-     unnamed object has automatic storage duration.
-
-11   EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
-     created using compound literals can be passed to functions without depending on member order:
-              drawline((struct point){.x=1, .y=1},
-                    (struct point){.x=3, .y=4});
-     Or, if drawline instead expected pointers to struct point:
-              drawline(&amp;(struct point){.x=1, .y=1},
-                    &amp;(struct point){.x=3, .y=4});
-
-12   EXAMPLE 4       A read-only compound literal can be specified through constructions like:
-              (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}
-
-
-
-
-     <sup><a name="note85" href="#note85"><b>85)</b></a></sup> For example, subobjects without explicit initializers are initialized to zero.
-     <sup><a name="note86" href="#note86"><b>86)</b></a></sup> This allows implementations to share storage for string literals and constant compound literals with
-         the same or overlapping representations.
-
-[<a name="p76" href="#p76">page 76</a>] (<a href="#Contents">Contents</a>)
-
-13   EXAMPLE 5        The following three expressions have different meanings:
-              "/tmp/fileXXXXXX"
-              (char []){"/tmp/fileXXXXXX"}
-              (const char []){"/tmp/fileXXXXXX"}
-     The first always has static storage duration and has type array of char, but need not be modifiable; the last
-     two have automatic storage duration when they occur within the body of a function, and the first of these
-     two is modifiable.
-
-14   EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
-     and can even be shared. For example,
-              (const char []){"abc"} == "abc"
-     might yield 1 if the literals' storage is shared.
-
-15   EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
-     linked object. For example, there is no way to write a self-referential compound literal that could be used
-     as the function argument in place of the named object endless_zeros below:
-              struct int_list { int car; struct int_list *cdr; };
-              struct int_list endless_zeros = {0, &amp;endless_zeros};
-              eval(endless_zeros);
-
-16   EXAMPLE 8        Each compound literal creates only a single object in a given scope:
-              struct s { int i; };
-              int f (void)
-              {
-                    struct s *p = 0, *q;
-                    int j = 0;
-              again:
-                    q = p, p = &amp;((struct s){ j++ });
-                    if (j &lt; 2) goto again;
-                        return p == q &amp;&amp; q-&gt;i == 1;
-              }
-     The function f() always returns the value 1.
-17   Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
-     lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
-     have an indeterminate value, which would result in undefined behavior.
-
-     Forward references: type names (<a href="#6.7.6">6.7.6</a>), initialization (<a href="#6.7.8">6.7.8</a>).
-
-[<a name="p77" href="#p77">page 77</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.3" href="#6.5.3"><b>    6.5.3 Unary operators</b></a>
-<b>    Syntax</b>
-1            unary-expression:
-                    postfix-expression
-                    ++ unary-expression
-                    -- unary-expression
-                    unary-operator cast-expression
-                    sizeof unary-expression
-                    sizeof ( type-name )
-             unary-operator: one of
-                    &amp; * + - ~             !
-<a name="6.5.3.1" href="#6.5.3.1"><b>    6.5.3.1 Prefix increment and decrement operators</b></a>
-<b>    Constraints</b>
-1   The operand of the prefix increment or decrement operator shall have qualified or
-    unqualified real or pointer type and shall be a modifiable lvalue.
-<b>    Semantics</b>
-2   The value of the operand of the prefix ++ operator is incremented. The result is the new
-    value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
-    See the discussions of additive operators and compound assignment for information on
-    constraints, types, side effects, and conversions and the effects of operations on pointers.
-3   The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
-    operand is decremented.
-    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
-<a name="6.5.3.2" href="#6.5.3.2"><b>    6.5.3.2 Address and indirection operators</b></a>
-<b>    Constraints</b>
-1   The operand of the unary &amp; operator shall be either a function designator, the result of a
-    [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
-    not declared with the register storage-class specifier.
-2   The operand of the unary * operator shall have pointer type.
-<b>    Semantics</b>
-3   The unary &amp; operator yields the address of its operand. If the operand has type ''type'',
-    the result has type ''pointer to type''. If the operand is the result of a unary * operator,
-    neither that operator nor the &amp; operator is evaluated and the result is as if both were
-    omitted, except that the constraints on the operators still apply and the result is not an
-    lvalue. Similarly, if the operand is the result of a [] operator, neither the &amp; operator nor
-
-[<a name="p78" href="#p78">page 78</a>] (<a href="#Contents">Contents</a>)
-
-    the unary * that is implied by the [] is evaluated and the result is as if the &amp; operator
-    were removed and the [] operator were changed to a + operator. Otherwise, the result is
-    a pointer to the object or function designated by its operand.
-4   The unary * operator denotes indirection. If the operand points to a function, the result is
-    a function designator; if it points to an object, the result is an lvalue designating the
-    object. If the operand has type ''pointer to type'', the result has type ''type''. If an
-    invalid value has been assigned to the pointer, the behavior of the unary * operator is
-    undefined.<sup><a href="#note87"><b>87)</b></a></sup>
-    Forward references: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
-    (<a href="#6.7.2.1">6.7.2.1</a>).
-<a name="6.5.3.3" href="#6.5.3.3"><b>    6.5.3.3 Unary arithmetic operators</b></a>
-<b>    Constraints</b>
-1   The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
-    integer type; of the ! operator, scalar type.
-<b>    Semantics</b>
-2   The result of the unary + operator is the value of its (promoted) operand. The integer
-    promotions are performed on the operand, and the result has the promoted type.
-3   The result of the unary - operator is the negative of its (promoted) operand. The integer
-    promotions are performed on the operand, and the result has the promoted type.
-4   The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
-    each bit in the result is set if and only if the corresponding bit in the converted operand is
-    not set). The integer promotions are performed on the operand, and the result has the
-    promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
-    to the maximum value representable in that type minus E.
-5   The result of the logical negation operator ! is 0 if the value of its operand compares
-    unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int.
-    The expression !E is equivalent to (0==E).
-
-
-
-
-    <sup><a name="note87" href="#note87"><b>87)</b></a></sup> Thus, &amp;*E is equivalent to E (even if E is a null pointer), and &amp;(E1[E2]) to ((E1)+(E2)). It is
-        always true that if E is a function designator or an lvalue that is a valid operand of the unary &amp;
-        operator, *&amp;E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
-        an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
-         Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
-         address inappropriately aligned for the type of object pointed to, and the address of an object after the
-         end of its lifetime.
-
-[<a name="p79" href="#p79">page 79</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.3.4" href="#6.5.3.4"><b>    6.5.3.4 The sizeof operator</b></a>
-<b>    Constraints</b>
-1   The sizeof operator shall not be applied to an expression that has function type or an
-    incomplete type, to the parenthesized name of such a type, or to an expression that
-    designates a bit-field member.
-<b>    Semantics</b>
-2   The sizeof operator yields the size (in bytes) of its operand, which may be an
-    expression or the parenthesized name of a type. The size is determined from the type of
-    the operand. The result is an integer. If the type of the operand is a variable length array
-    type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
-    integer constant.
-3   When applied to an operand that has type char, unsigned char, or signed char,
-    (or a qualified version thereof) the result is 1. When applied to an operand that has array
-    type, the result is the total number of bytes in the array.<sup><a href="#note88"><b>88)</b></a></sup> When applied to an operand
-    that has structure or union type, the result is the total number of bytes in such an object,
-    including internal and trailing padding.
-4   The value of the result is implementation-defined, and its type (an unsigned integer type)
-    is size_t, defined in <a href="#7.17">&lt;stddef.h&gt;</a> (and other headers).
-5   EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
-    allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
-    allocate and return a pointer to void. For example:
-            extern void *alloc(size_t);
-            double *dp = alloc(sizeof *dp);
-    The implementation of the alloc function should ensure that its return value is aligned suitably for
-    conversion to a pointer to double.
-
-6   EXAMPLE 2      Another use of the sizeof operator is to compute the number of elements in an array:
-            sizeof array / sizeof array[0]
-
-7   EXAMPLE 3      In this example, the size of a variable length array is computed and returned from a
-    function:
-            #include <a href="#7.17">&lt;stddef.h&gt;</a>
-            size_t fsize3(int n)
-            {
-                  char b[n+3];                  // variable length array
-                  return sizeof b;              // execution time sizeof
-            }
-
-
-
-    <sup><a name="note88" href="#note88"><b>88)</b></a></sup> When applied to a parameter declared to have array or function type, the sizeof operator yields the
-        size of the adjusted (pointer) type (see <a href="#6.9.1">6.9.1</a>).
-
-[<a name="p80" href="#p80">page 80</a>] (<a href="#Contents">Contents</a>)
-
-             int main()
-             {
-                   size_t size;
-                   size = fsize3(10); // fsize3 returns 13
-                   return 0;
-             }
-
-    Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), declarations (<a href="#6.7">6.7</a>),
-    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.6">6.7.6</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
-<a name="6.5.4" href="#6.5.4"><b>    6.5.4 Cast operators</b></a>
-<b>    Syntax</b>
-1            cast-expression:
-                    unary-expression
-                    ( type-name ) cast-expression
-<b>    Constraints</b>
-2   Unless the type name specifies a void type, the type name shall specify qualified or
-    unqualified scalar type and the operand shall have scalar type.
-3   Conversions that involve pointers, other than where permitted by the constraints of
-    <a href="#6.5.16.1">6.5.16.1</a>, shall be specified by means of an explicit cast.
-<b>    Semantics</b>
-4   Preceding an expression by a parenthesized type name converts the value of the
-    expression to the named type. This construction is called a cast.<sup><a href="#note89"><b>89)</b></a></sup> A cast that specifies
-    no conversion has no effect on the type or value of an expression.
-5   If the value of the expression is represented with greater precision or range than required
-    by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
-    type of the expression is the same as the named type.
-    Forward references: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
-    prototypes) (<a href="#6.7.5.3">6.7.5.3</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>), type names (<a href="#6.7.6">6.7.6</a>).
-
-
-
-
-    <sup><a name="note89" href="#note89"><b>89)</b></a></sup> A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the
-        unqualified version of the type.
-
-[<a name="p81" href="#p81">page 81</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.5" href="#6.5.5"><b>    6.5.5 Multiplicative operators</b></a>
-<b>    Syntax</b>
-1            multiplicative-expression:
-                     cast-expression
-                     multiplicative-expression * cast-expression
-                     multiplicative-expression / cast-expression
-                     multiplicative-expression % cast-expression
-<b>    Constraints</b>
-2   Each of the operands shall have arithmetic type. The operands of the % operator shall
-    have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the binary * operator is the product of the operands.
-5   The result of the / operator is the quotient from the division of the first operand by the
-    second; the result of the % operator is the remainder. In both operations, if the value of
-    the second operand is zero, the behavior is undefined.
-6   When integers are divided, the result of the / operator is the algebraic quotient with any
-    fractional part discarded.<sup><a href="#note90"><b>90)</b></a></sup> If the quotient a/b is representable, the expression
-    (a/b)*b + a%b shall equal a.
-<a name="6.5.6" href="#6.5.6"><b>    6.5.6 Additive operators</b></a>
-<b>    Syntax</b>
-1            additive-expression:
-                     multiplicative-expression
-                     additive-expression + multiplicative-expression
-                     additive-expression - multiplicative-expression
-<b>    Constraints</b>
-2   For addition, either both operands shall have arithmetic type, or one operand shall be a
-    pointer to an object type and the other shall have integer type. (Incrementing is
-    equivalent to adding 1.)
-3   For subtraction, one of the following shall hold:
-    -- both operands have arithmetic type;
-
-
-
-    <sup><a name="note90" href="#note90"><b>90)</b></a></sup> This is often called ''truncation toward zero''.
-
-[<a name="p82" href="#p82">page 82</a>] (<a href="#Contents">Contents</a>)
-
-    -- both operands are pointers to qualified or unqualified versions of compatible object
-      types; or
-    -- the left operand is a pointer to an object type and the right operand has integer type.
-    (Decrementing is equivalent to subtracting 1.)
-<b>    Semantics</b>
-4   If both operands have arithmetic type, the usual arithmetic conversions are performed on
-    them.
-5   The result of the binary + operator is the sum of the operands.
-6   The result of the binary - operator is the difference resulting from the subtraction of the
-    second operand from the first.
-7   For the purposes of these operators, a pointer to an object that is not an element of an
-    array behaves the same as a pointer to the first element of an array of length one with the
-    type of the object as its element type.
-8   When an expression that has integer type is added to or subtracted from a pointer, the
-    result has the type of the pointer operand. If the pointer operand points to an element of
-    an array object, and the array is large enough, the result points to an element offset from
-    the original element such that the difference of the subscripts of the resulting and original
-    array elements equals the integer expression. In other words, if the expression P points to
-    the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and
-    (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of
-    the array object, provided they exist. Moreover, if the expression P points to the last
-    element of an array object, the expression (P)+1 points one past the last element of the
-    array object, and if the expression Q points one past the last element of an array object,
-    the expression (Q)-1 points to the last element of the array object. If both the pointer
-    operand and the result point to elements of the same array object, or one past the last
-    element of the array object, the evaluation shall not produce an overflow; otherwise, the
-    behavior is undefined. If the result points one past the last element of the array object, it
-    shall not be used as the operand of a unary * operator that is evaluated.
-9   When two pointers are subtracted, both shall point to elements of the same array object,
-    or one past the last element of the array object; the result is the difference of the
-    subscripts of the two array elements. The size of the result is implementation-defined,
-    and its type (a signed integer type) is ptrdiff_t defined in the <a href="#7.17">&lt;stddef.h&gt;</a> header.
-    If the result is not representable in an object of that type, the behavior is undefined. In
-    other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
-    an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
-    object of type ptrdiff_t. Moreover, if the expression P points either to an element of
-    an array object or one past the last element of an array object, and the expression Q points
-    to the last element of the same array object, the expression ((Q)+1)-(P) has the same
-
-[<a name="p83" href="#p83">page 83</a>] (<a href="#Contents">Contents</a>)
-
-     value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the
-     expression P points one past the last element of the array object, even though the
-     expression (Q)+1 does not point to an element of the array object.<sup><a href="#note91"><b>91)</b></a></sup>
-10   EXAMPLE        Pointer arithmetic is well defined with pointers to variable length array types.
-              {
-                       int n = 4, m = 3;
-                       int a[n][m];
-                       int (*p)[m] = a;            //   p == &amp;a[0]
-                       p += 1;                     //   p == &amp;a[1]
-                       (*p)[2] = 99;               //   a[1][2] == 99
-                       n = p - a;                  //   n == 1
-              }
-11   If array a in the above example were declared to be an array of known constant size, and pointer p were
-     declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
-     the same.
-
-     Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), common definitions <a href="#7.17">&lt;stddef.h&gt;</a>
-     (<a href="#7.17">7.17</a>).
-<a name="6.5.7" href="#6.5.7"><b>     6.5.7 Bitwise shift operators</b></a>
-<b>     Syntax</b>
-1             shift-expression:
-                      additive-expression
-                      shift-expression &lt;&lt; additive-expression
-                      shift-expression &gt;&gt; additive-expression
-<b>     Constraints</b>
-2    Each of the operands shall have integer type.
-<b>     Semantics</b>
-3    The integer promotions are performed on each of the operands. The type of the result is
-     that of the promoted left operand. If the value of the right operand is negative or is
-     greater than or equal to the width of the promoted left operand, the behavior is undefined.
-
-
-
-
-     <sup><a name="note91" href="#note91"><b>91)</b></a></sup> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
-         this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
-         by the size of the object originally pointed to, and the resulting pointer is converted back to the
-         original type. For pointer subtraction, the result of the difference between the character pointers is
-         similarly divided by the size of the object originally pointed to.
-          When viewed in this way, an implementation need only provide one extra byte (which may overlap
-          another object in the program) just after the end of the object in order to satisfy the ''one past the last
-          element'' requirements.
-
-[<a name="p84" href="#p84">page 84</a>] (<a href="#Contents">Contents</a>)
-
-4   The result of E1 &lt;&lt; E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
-    zeros. If E1 has an unsigned type, the value of the result is E1 x 2E2 , reduced modulo
-    one more than the maximum value representable in the result type. If E1 has a signed
-    type and nonnegative value, and E1 x 2E2 is representable in the result type, then that is
-    the resulting value; otherwise, the behavior is undefined.
-5   The result of E1 &gt;&gt; E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
-    or if E1 has a signed type and a nonnegative value, the value of the result is the integral
-    part of the quotient of E1 / 2E2 . If E1 has a signed type and a negative value, the
-    resulting value is implementation-defined.
-<a name="6.5.8" href="#6.5.8"><b>    6.5.8 Relational operators</b></a>
-<b>    Syntax</b>
-1            relational-expression:
-                     shift-expression
-                     relational-expression   &lt;    shift-expression
-                     relational-expression   &gt;    shift-expression
-                     relational-expression   &lt;=   shift-expression
-                     relational-expression   &gt;=   shift-expression
-<b>    Constraints</b>
-2   One of the following shall hold:
-    -- both operands have real type;
-    -- both operands are pointers to qualified or unqualified versions of compatible object
-      types; or
-    -- both operands are pointers to qualified or unqualified versions of compatible
-      incomplete types.
-<b>    Semantics</b>
-3   If both of the operands have arithmetic type, the usual arithmetic conversions are
-    performed.
-4   For the purposes of these operators, a pointer to an object that is not an element of an
-    array behaves the same as a pointer to the first element of an array of length one with the
-    type of the object as its element type.
-5   When two pointers are compared, the result depends on the relative locations in the
-    address space of the objects pointed to. If two pointers to object or incomplete types both
-    point to the same object, or both point one past the last element of the same array object,
-    they compare equal. If the objects pointed to are members of the same aggregate object,
-    pointers to structure members declared later compare greater than pointers to members
-    declared earlier in the structure, and pointers to array elements with larger subscript
-
-[<a name="p85" href="#p85">page 85</a>] (<a href="#Contents">Contents</a>)
-
-    values compare greater than pointers to elements of the same array with lower subscript
-    values. All pointers to members of the same union object compare equal. If the
-    expression P points to an element of an array object and the expression Q points to the
-    last element of the same array object, the pointer expression Q+1 compares greater than
-    P. In all other cases, the behavior is undefined.
-6   Each of the operators &lt; (less than), &gt; (greater than), &lt;= (less than or equal to), and &gt;=
-    (greater than or equal to) shall yield 1 if the specified relation is true and 0 if it is false.<sup><a href="#note92"><b>92)</b></a></sup>
-    The result has type int.
-<a name="6.5.9" href="#6.5.9"><b>    6.5.9 Equality operators</b></a>
-<b>    Syntax</b>
-1            equality-expression:
-                     relational-expression
-                    equality-expression == relational-expression
-                    equality-expression != relational-expression
-<b>    Constraints</b>
-2   One of the following shall hold:
-    -- both operands have arithmetic type;
-    -- both operands are pointers to qualified or unqualified versions of compatible types;
-    -- one operand is a pointer to an object or incomplete type and the other is a pointer to a
-      qualified or unqualified version of void; or
-    -- one operand is a pointer and the other is a null pointer constant.
-<b>    Semantics</b>
-3   The == (equal to) and != (not equal to) operators are analogous to the relational
-    operators except for their lower precedence.<sup><a href="#note93"><b>93)</b></a></sup> Each of the operators yields 1 if the
-    specified relation is true and 0 if it is false. The result has type int. For any pair of
-    operands, exactly one of the relations is true.
-4   If both of the operands have arithmetic type, the usual arithmetic conversions are
-    performed. Values of complex types are equal if and only if both their real parts are equal
-    and also their imaginary parts are equal. Any two values of arithmetic types from
-    different type domains are equal if and only if the results of their conversions to the
-    (complex) result type determined by the usual arithmetic conversions are equal.
-
-
-    <sup><a name="note92" href="#note92"><b>92)</b></a></sup> The expression a&lt;b&lt;c is not interpreted as in ordinary mathematics. As the syntax indicates, it
-        means (a&lt;b)&lt;c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
-    <sup><a name="note93" href="#note93"><b>93)</b></a></sup> Because of the precedences, a&lt;b == c&lt;d is 1 whenever a&lt;b and c&lt;d have the same truth-value.
-
-[<a name="p86" href="#p86">page 86</a>] (<a href="#Contents">Contents</a>)
-
-5   Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
-    null pointer constant, the null pointer constant is converted to the type of the pointer. If
-    one operand is a pointer to an object or incomplete type and the other is a pointer to a
-    qualified or unqualified version of void, the former is converted to the type of the latter.
-6   Two pointers compare equal if and only if both are null pointers, both are pointers to the
-    same object (including a pointer to an object and a subobject at its beginning) or function,
-    both are pointers to one past the last element of the same array object, or one is a pointer
-    to one past the end of one array object and the other is a pointer to the start of a different
-    array object that happens to immediately follow the first array object in the address
-    space.<sup><a href="#note94"><b>94)</b></a></sup>
-7   For the purposes of these operators, a pointer to an object that is not an element of an
-    array behaves the same as a pointer to the first element of an array of length one with the
-    type of the object as its element type.
-<a name="6.5.10" href="#6.5.10"><b>    6.5.10 Bitwise AND operator</b></a>
-<b>    Syntax</b>
-1            AND-expression:
-                   equality-expression
-                   AND-expression &amp; equality-expression
-<b>    Constraints</b>
-2   Each of the operands shall have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the binary &amp; operator is the bitwise AND of the operands (that is, each bit in
-    the result is set if and only if each of the corresponding bits in the converted operands is
-    set).
-
-
-
-
-    <sup><a name="note94" href="#note94"><b>94)</b></a></sup> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
-        adjacent members of a structure with no padding between them, or because the implementation chose
-        to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
-        outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
-        behavior.
-
-[<a name="p87" href="#p87">page 87</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.11" href="#6.5.11"><b>    6.5.11 Bitwise exclusive OR operator</b></a>
-<b>    Syntax</b>
-1            exclusive-OR-expression:
-                     AND-expression
-                     exclusive-OR-expression ^ AND-expression
-<b>    Constraints</b>
-2   Each of the operands shall have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
-    in the result is set if and only if exactly one of the corresponding bits in the converted
-    operands is set).
-<a name="6.5.12" href="#6.5.12"><b>    6.5.12 Bitwise inclusive OR operator</b></a>
-<b>    Syntax</b>
-1            inclusive-OR-expression:
-                     exclusive-OR-expression
-                     inclusive-OR-expression | exclusive-OR-expression
-<b>    Constraints</b>
-2   Each of the operands shall have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
-    the result is set if and only if at least one of the corresponding bits in the converted
-    operands is set).
-
-[<a name="p88" href="#p88">page 88</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.13" href="#6.5.13"><b>    6.5.13 Logical AND operator</b></a>
-<b>    Syntax</b>
-1             logical-AND-expression:
-                      inclusive-OR-expression
-                      logical-AND-expression &amp;&amp; inclusive-OR-expression
-<b>    Constraints</b>
-2   Each of the operands shall have scalar type.
-<b>    Semantics</b>
-3   The &amp;&amp; operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
-    yields 0. The result has type int.
-4   Unlike the bitwise binary &amp; operator, the &amp;&amp; operator guarantees left-to-right evaluation;
-    there is a sequence point after the evaluation of the first operand. If the first operand
-    compares equal to 0, the second operand is not evaluated.
-<a name="6.5.14" href="#6.5.14"><b>    6.5.14 Logical OR operator</b></a>
-<b>    Syntax</b>
-1             logical-OR-expression:
-                      logical-AND-expression
-                      logical-OR-expression || logical-AND-expression
-<b>    Constraints</b>
-2   Each of the operands shall have scalar type.
-<b>    Semantics</b>
-3   The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
-    yields 0. The result has type int.
-4   Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; there is
-    a sequence point after the evaluation of the first operand. If the first operand compares
-    unequal to 0, the second operand is not evaluated.
-
-[<a name="p89" href="#p89">page 89</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.15" href="#6.5.15"><b>    6.5.15 Conditional operator</b></a>
-<b>    Syntax</b>
-1            conditional-expression:
-                    logical-OR-expression
-                    logical-OR-expression ? expression : conditional-expression
-<b>    Constraints</b>
-2   The first operand shall have scalar type.
-3   One of the following shall hold for the second and third operands:
-    -- both operands have arithmetic type;
-    -- both operands have the same structure or union type;
-    -- both operands have void type;
-    -- both operands are pointers to qualified or unqualified versions of compatible types;
-    -- one operand is a pointer and the other is a null pointer constant; or
-    -- one operand is a pointer to an object or incomplete type and the other is a pointer to a
-      qualified or unqualified version of void.
-<b>    Semantics</b>
-4   The first operand is evaluated; there is a sequence point after its evaluation. The second
-    operand is evaluated only if the first compares unequal to 0; the third operand is evaluated
-    only if the first compares equal to 0; the result is the value of the second or third operand
-    (whichever is evaluated), converted to the type described below.<sup><a href="#note95"><b>95)</b></a></sup> If an attempt is made
-    to modify the result of a conditional operator or to access it after the next sequence point,
-    the behavior is undefined.
-5   If both the second and third operands have arithmetic type, the result type that would be
-    determined by the usual arithmetic conversions, were they applied to those two operands,
-    is the type of the result. If both the operands have structure or union type, the result has
-    that type. If both operands have void type, the result has void type.
-6   If both the second and third operands are pointers or one is a null pointer constant and the
-    other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
-    of the types pointed-to by both operands. Furthermore, if both operands are pointers to
-    compatible types or to differently qualified versions of compatible types, the result type is
-    a pointer to an appropriately qualified version of the composite type; if one operand is a
-    null pointer constant, the result has the type of the other operand; otherwise, one operand
-    is a pointer to void or a qualified version of void, in which case the result type is a
-
-    <sup><a name="note95" href="#note95"><b>95)</b></a></sup> A conditional expression does not yield an lvalue.
-
-[<a name="p90" href="#p90">page 90</a>] (<a href="#Contents">Contents</a>)
-
-    pointer to an appropriately qualified version of void.
-7   EXAMPLE The common type that results when the second and third operands are pointers is determined
-    in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
-    pointers have compatible types.
-8   Given the declarations
-             const void *c_vp;
-             void *vp;
-             const int *c_ip;
-             volatile int *v_ip;
-             int *ip;
-             const char *c_cp;
-    the third column in the following table is the common type that is the result of a conditional expression in
-    which the first two columns are the second and third operands (in either order):
-             c_vp     c_ip      const void *
-             v_ip     0         volatile int *
-             c_ip     v_ip      const volatile int *
-             vp       c_cp      const void *
-             ip       c_ip      const int *
-             vp       ip        void *
-
-<a name="6.5.16" href="#6.5.16"><b>    6.5.16 Assignment operators</b></a>
-<b>    Syntax</b>
-1            assignment-expression:
-                    conditional-expression
-                    unary-expression assignment-operator assignment-expression
-             assignment-operator: one of
-                    = *= /= %= +=                       -=     &lt;&lt;=      &gt;&gt;=      &amp;=     ^=     |=
-<b>    Constraints</b>
-2   An assignment operator shall have a modifiable lvalue as its left operand.
-<b>    Semantics</b>
-3   An assignment operator stores a value in the object designated by the left operand. An
-    assignment expression has the value of the left operand after the assignment, but is not an
-    lvalue. The type of an assignment expression is the type of the left operand unless the
-    left operand has qualified type, in which case it is the unqualified version of the type of
-    the left operand. The side effect of updating the stored value of the left operand shall
-    occur between the previous and the next sequence point.
-4   The order of evaluation of the operands is unspecified. If an attempt is made to modify
-    the result of an assignment operator or to access it after the next sequence point, the
-    behavior is undefined.
-
-[<a name="p91" href="#p91">page 91</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.16.1" href="#6.5.16.1"><b>    6.5.16.1 Simple assignment</b></a>
-<b>    Constraints</b>
-1   One of the following shall hold:<sup><a href="#note96"><b>96)</b></a></sup>
-    -- the left operand has qualified or unqualified arithmetic type and the right has
-      arithmetic type;
-    -- the left operand has a qualified or unqualified version of a structure or union type
-      compatible with the type of the right;
-    -- both operands are pointers to qualified or unqualified versions of compatible types,
-      and the type pointed to by the left has all the qualifiers of the type pointed to by the
-      right;
-    -- one operand is a pointer to an object or incomplete type and the other is a pointer to a
-      qualified or unqualified version of void, and the type pointed to by the left has all
-      the qualifiers of the type pointed to by the right;
-    -- the left operand is a pointer and the right is a null pointer constant; or
-    -- the left operand has type _Bool and the right is a pointer.
-<b>    Semantics</b>
-2   In simple assignment (=), the value of the right operand is converted to the type of the
-    assignment expression and replaces the value stored in the object designated by the left
-    operand.
-3   If the value being stored in an object is read from another object that overlaps in any way
-    the storage of the first object, then the overlap shall be exact and the two objects shall
-    have qualified or unqualified versions of a compatible type; otherwise, the behavior is
-    undefined.
-4   EXAMPLE 1       In the program fragment
-            int f(void);
-            char c;
+</pre>
+
+<a name="Contents" href="#Contents"><h2>Contents</h2></a>
+<pre>
+Foreword       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                   xi
+Introduction     . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                  xiv
+1. Scope       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                    1
+2. Normative references      . . . . . . . . . . . . . . . . . . . . . . .                                  2
+3. Terms, definitions, and symbols     . . . . . . . . . . . . . . . . . . .                                 3
+4. Conformance       . . . . . . . . . . . . . . . . . . . . . . . . . .                                    7
+5. Environment    . . . . . . . . . . .        . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9
+   5.1 Conceptual models      . . . . . .      . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9
+        5.1.1  Translation environment .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9
+        5.1.2  Execution environments     .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .   11
+   5.2 Environmental considerations    . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   17
+        5.2.1 Character sets     . . . . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   17
+        5.2.2  Character display semantics       .   .   .   .   .   .   .   .    .   .   .   .   .   .   19
+        5.2.3 Signals and interrupts . .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .   20
+        5.2.4  Environmental limits    . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   20
+6. Language . . . . . . . . . . . . . . . .              .   .   .   .   .   .    .   .   .   .   .   .   29
+   6.1 Notation . . . . . . . . . . . . . .              .   .   .   .   .   .    .   .   .   .   .   .   29
+   6.2 Concepts      . . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   29
+        6.2.1 Scopes of identifiers      . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   29
+        6.2.2   Linkages of identifiers . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   30
+        6.2.3 Name spaces of identifiers      . . .       .   .   .   .   .   .    .   .   .   .   .   .   31
+        6.2.4 Storage durations of objects     . .       .   .   .   .   .   .    .   .   .   .   .   .   32
+        6.2.5 Types       . . . . . . . . . . .          .   .   .   .   .   .    .   .   .   .   .   .   33
+        6.2.6 Representations of types . . . .           .   .   .   .   .   .    .   .   .   .   .   .   37
+        6.2.7 Compatible type and composite type             .   .   .   .   .    .   .   .   .   .   .   40
+   6.3 Conversions     . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   42
+        6.3.1 Arithmetic operands       . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   42
+        6.3.2 Other operands        . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   46
+   6.4 Lexical elements      . . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   49
+        6.4.1 Keywords . . . . . . . . . .               .   .   .   .   .   .    .   .   .   .   .   .   50
+        6.4.2 Identifiers . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .   51
+        6.4.3 Universal character names      . . .       .   .   .   .   .   .    .   .   .   .   .   .   53
+        6.4.4   Constants . . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .   54
+        6.4.5 String literals     . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   62
+        6.4.6   Punctuators . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .   63
+        6.4.7 Header names        . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   64
+        6.4.8 Preprocessing numbers        . . . .       .   .   .   .   .   .    .   .   .   .   .   .   65
+        6.4.9 Comments         . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   66
+   6.5 Expressions     . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   67
+<!--page 2 indent -1-->
+          6.5.1   Primary expressions      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    69
+          6.5.2 Postfix operators . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .    69
+          6.5.3   Unary operators      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    78
+          6.5.4 Cast operators . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .    81
+          6.5.5   Multiplicative operators   . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    82
+          6.5.6 Additive operators       . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    82
+          6.5.7 Bitwise shift operators . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .    84
+          6.5.8   Relational operators . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    85
+          6.5.9 Equality operators       . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    86
+          6.5.10 Bitwise AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    87
+          6.5.11 Bitwise exclusive OR operator         .   .   .   .   .   .   .   .   .   .   .   .   .    88
+          6.5.12 Bitwise inclusive OR operator     .   .   .   .   .   .   .   .   .   .   .   .   .   .    88
+          6.5.13 Logical AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    89
+          6.5.14 Logical OR operator       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    89
+          6.5.15 Conditional operator      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    90
+          6.5.16 Assignment operators . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    91
+          6.5.17 Comma operator . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .    94
+     6.6 Constant expressions . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    95
+     6.7 Declarations     . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .    97
+          6.7.1 Storage-class specifiers      . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    98
+          6.7.2   Type specifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    99
+          6.7.3 Type qualifiers . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   108
+          6.7.4   Function specifiers     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112
+          6.7.5 Declarators        . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   114
+          6.7.6 Type names . . . . . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   122
+          6.7.7   Type definitions      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   123
+          6.7.8 Initialization       . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   125
+     6.8 Statements and blocks       . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   131
+          6.8.1   Labeled statements     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   131
+          6.8.2 Compound statement         . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   132
+          6.8.3 Expression and null statements         .   .   .   .   .   .   .   .   .   .   .   .   .   132
+          6.8.4 Selection statements       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   133
+          6.8.5 Iteration statements . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   135
+          6.8.6 Jump statements        . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   136
+     6.9 External definitions       . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   140
+          6.9.1   Function definitions . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   141
+          6.9.2 External object definitions     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   143
+     6.10 Preprocessing directives     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   145
+          6.10.1 Conditional inclusion     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147
+          6.10.2 Source file inclusion      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   149
+          6.10.3 Macro replacement . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   151
+          6.10.4 Line control . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   158
+          6.10.5 Error directive . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   159
+          6.10.6 Pragma directive . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   159
+<!--page 3 indent 0-->
+       6.10.7 Null directive      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   160
+       6.10.8 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   160
+       6.10.9 Pragma operator       . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   161
+  6.11 Future language directions     . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.1 Floating types      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.2 Linkages of identifiers . .      .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.3 External names        . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.4 Character escape sequences          .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.5 Storage-class specifiers     .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.6 Function declarators      . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.7 Function definitions . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.8 Pragma directives       . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+       6.11.9 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163
+7. Library . . . . . . . . . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   164
+   7.1 Introduction     . . . . . . . . . . . . . . .                 . .     .    .   .   .   .   .   .   164
+         7.1.1 Definitions of terms . . . . . . . . .                  . .     .    .   .   .   .   .   .   164
+         7.1.2 Standard headers . . . . . . . . . .                   . .     .    .   .   .   .   .   .   165
+         7.1.3 Reserved identifiers . . . . . . . . .                  . .     .    .   .   .   .   .   .   166
+         7.1.4 Use of library functions    . . . . . . .              . .     .    .   .   .   .   .   .   166
+   7.2 Diagnostics &lt;assert.h&gt;          . . . . . . . . .              . .     .    .   .   .   .   .   .   169
+         7.2.1 Program diagnostics       . . . . . . . .              . .     .    .   .   .   .   .   .   169
+   7.3 Complex arithmetic &lt;complex.h&gt;           . . . . .             . .     .    .   .   .   .   .   .   170
+         7.3.1 Introduction . . . . . . . . . . . .                   . .     .    .   .   .   .   .   .   170
+         7.3.2 Conventions . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   171
+         7.3.3 Branch cuts . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   171
+         7.3.4 The CX_LIMITED_RANGE pragma              . .           . .     .    .   .   .   .   .   .   171
+         7.3.5 Trigonometric functions . . . . . . .                  . .     .    .   .   .   .   .   .   172
+         7.3.6 Hyperbolic functions      . . . . . . . .              . .     .    .   .   .   .   .   .   174
+         7.3.7 Exponential and logarithmic functions      .           . .     .    .   .   .   .   .   .   176
+         7.3.8 Power and absolute-value functions       . .           . .     .    .   .   .   .   .   .   177
+         7.3.9 Manipulation functions      . . . . . . .              . .     .    .   .   .   .   .   .   178
+   7.4 Character handling &lt;ctype.h&gt; . . . . . . .                     . .     .    .   .   .   .   .   .   181
+         7.4.1 Character classification functions      . . .           . .     .    .   .   .   .   .   .   181
+         7.4.2 Character case mapping functions       . . .           . .     .    .   .   .   .   .   .   184
+   7.5 Errors &lt;errno.h&gt;         . . . . . . . . . . . .               . .     .    .   .   .   .   .   .   186
+   7.6 Floating-point environment &lt;fenv.h&gt;         . . . .            . .     .    .   .   .   .   .   .   187
+         7.6.1 The FENV_ACCESS pragma           . . . . .             . .     .    .   .   .   .   .   .   189
+         7.6.2 Floating-point exceptions      . . . . . .             . .     .    .   .   .   .   .   .   190
+         7.6.3 Rounding . . . . . . . . . . . . .                     . .     .    .   .   .   .   .   .   193
+         7.6.4 Environment        . . . . . . . . . . .               . .     .    .   .   .   .   .   .   194
+   7.7 Characteristics of floating types &lt;float.h&gt; . .                 . .     .    .   .   .   .   .   .   197
+   7.8 Format conversion of integer types &lt;inttypes.h&gt;                  .     .    .   .   .   .   .   .   198
+         7.8.1 Macros for format specifiers      . . . . .             . .     .    .   .   .   .   .   .   198
+         7.8.2 Functions for greatest-width integer types             . .     .    .   .   .   .   .   .   199
+<!--page 4 indent -1-->
+     7.9 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . .         .   .   .   .   202
+     7.10 Sizes of integer types &lt;limits.h&gt;       . . . . . . . . . .   .   .   .   .   203
+     7.11 Localization &lt;locale.h&gt; . . . . . . . . . . . . . .           .   .   .   .   204
+          7.11.1 Locale control . . . . . . . . . . . . . . . .         .   .   .   .   205
+          7.11.2 Numeric formatting convention inquiry . . . . . .      .   .   .   .   206
+     7.12 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .            .   .   .   .   212
+          7.12.1 Treatment of error conditions . . . . . . . . . .      .   .   .   .   214
+          7.12.2 The FP_CONTRACT pragma           . . . . . . . . . .   .   .   .   .   215
+          7.12.3 Classification macros      . . . . . . . . . . . . .    .   .   .   .   216
+          7.12.4 Trigonometric functions . . . . . . . . . . . .        .   .   .   .   218
+          7.12.5 Hyperbolic functions      . . . . . . . . . . . . .    .   .   .   .   221
+          7.12.6 Exponential and logarithmic functions    . . . . . .   .   .   .   .   223
+          7.12.7 Power and absolute-value functions     . . . . . . .   .   .   .   .   228
+          7.12.8 Error and gamma functions . . . . . . . . . . .        .   .   .   .   230
+          7.12.9 Nearest integer functions . . . . . . . . . . . .      .   .   .   .   231
+          7.12.10 Remainder functions      . . . . . . . . . . . . .    .   .   .   .   235
+          7.12.11 Manipulation functions      . . . . . . . . . . . .   .   .   .   .   236
+          7.12.12 Maximum, minimum, and positive difference functions       .   .   .   238
+          7.12.13 Floating multiply-add . . . . . . . . . . . . .       .   .   .   .   239
+          7.12.14 Comparison macros . . . . . . . . . . . . . .         .   .   .   .   240
+     7.13 Nonlocal jumps &lt;setjmp.h&gt;           . . . . . . . . . . . .   .   .   .   .   243
+          7.13.1 Save calling environment       . . . . . . . . . . .   .   .   .   .   243
+          7.13.2 Restore calling environment      . . . . . . . . . .   .   .   .   .   244
+     7.14 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . .          .   .   .   .   246
+          7.14.1 Specify signal handling      . . . . . . . . . . . .   .   .   .   .   247
+          7.14.2 Send signal       . . . . . . . . . . . . . . . . .    .   .   .   .   248
+     7.15 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . .   .   .   .   .   249
+          7.15.1 Variable argument list access macros . . . . . . .     .   .   .   .   249
+     7.16 Boolean type and values &lt;stdbool.h&gt;         . . . . . . . .   .   .   .   .   253
+     7.17 Common definitions &lt;stddef.h&gt; . . . . . . . . . . .            .   .   .   .   254
+     7.18 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . .          .   .   .   .   255
+          7.18.1 Integer types       . . . . . . . . . . . . . . . .    .   .   .   .   255
+          7.18.2 Limits of specified-width integer types   . . . . . .   .   .   .   .   257
+          7.18.3 Limits of other integer types    . . . . . . . . . .   .   .   .   .   259
+          7.18.4 Macros for integer constants     . . . . . . . . . .   .   .   .   .   260
+     7.19 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . .    .   .   .   .   262
+          7.19.1 Introduction . . . . . . . . . . . . . . . . .         .   .   .   .   262
+          7.19.2 Streams         . . . . . . . . . . . . . . . . . .    .   .   .   .   264
+          7.19.3 Files . . . . . . . . . . . . . . . . . . . .          .   .   .   .   266
+          7.19.4 Operations on files      . . . . . . . . . . . . . .    .   .   .   .   268
+          7.19.5 File access functions     . . . . . . . . . . . . .    .   .   .   .   270
+          7.19.6 Formatted input/output functions     . . . . . . . .   .   .   .   .   274
+          7.19.7 Character input/output functions . . . . . . . . .     .   .   .   .   296
+          7.19.8 Direct input/output functions    . . . . . . . . . .   .   .   .   .   301
+<!--page 5 indent -1-->
+         7.19.9 File positioning functions      . . . . . . . . . . . .     .   .   .   302
+         7.19.10 Error-handling functions . . . . . . . . . . . . .         .   .   .   304
+  7.20   General utilities &lt;stdlib.h&gt;         . . . . . . . . . . . . .     .   .   .   306
+         7.20.1 Numeric conversion functions . . . . . . . . . . .          .   .   .   307
+         7.20.2 Pseudo-random sequence generation functions       . . . .   .   .   .   312
+         7.20.3 Memory management functions . . . . . . . . . .             .   .   .   313
+         7.20.4 Communication with the environment          . . . . . . .   .   .   .   315
+         7.20.5 Searching and sorting utilities . . . . . . . . . . .       .   .   .   318
+         7.20.6 Integer arithmetic functions      . . . . . . . . . . .     .   .   .   320
+         7.20.7 Multibyte/wide character conversion functions     . . . .   .   .   .   321
+         7.20.8 Multibyte/wide string conversion functions      . . . . .   .   .   .   323
+  7.21   String handling &lt;string.h&gt; . . . . . . . . . . . . . .             .   .   .   325
+         7.21.1 String function conventions . . . . . . . . . . . .         .   .   .   325
+         7.21.2 Copying functions       . . . . . . . . . . . . . . .       .   .   .   325
+         7.21.3 Concatenation functions . . . . . . . . . . . . .           .   .   .   327
+         7.21.4 Comparison functions . . . . . . . . . . . . . .            .   .   .   328
+         7.21.5 Search functions      . . . . . . . . . . . . . . . .       .   .   .   330
+         7.21.6 Miscellaneous functions . . . . . . . . . . . . .           .   .   .   333
+  7.22   Type-generic math &lt;tgmath.h&gt;           . . . . . . . . . . . .     .   .   .   335
+  7.23   Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .       .   .   .   338
+         7.23.1 Components of time         . . . . . . . . . . . . . .      .   .   .   338
+         7.23.2 Time manipulation functions       . . . . . . . . . . .     .   .   .   339
+         7.23.3 Time conversion functions       . . . . . . . . . . . .     .   .   .   341
+  7.24   Extended multibyte and wide character utilities &lt;wchar.h&gt; . .      .   .   .   348
+         7.24.1 Introduction . . . . . . . . . . . . . . . . . .            .   .   .   348
+         7.24.2 Formatted wide character input/output functions     . . .   .   .   .   349
+         7.24.3 Wide character input/output functions       . . . . . . .   .   .   .   367
+         7.24.4 General wide string utilities     . . . . . . . . . . .     .   .   .   371
+         7.24.5 Wide character time conversion functions      . . . . . .   .   .   .   385
+         7.24.6 Extended multibyte/wide character conversion utilities .    .   .   .   386
+  7.25   Wide character classification and mapping utilities &lt;wctype.h&gt;      .   .   .   393
+         7.25.1 Introduction . . . . . . . . . . . . . . . . . .            .   .   .   393
+         7.25.2 Wide character classification utilities . . . . . . . .      .   .   .   394
+         7.25.3 Wide character case mapping utilities . . . . . . . .       .   .   .   399
+  7.26   Future library directions    . . . . . . . . . . . . . . . .       .   .   .   401
+         7.26.1 Complex arithmetic &lt;complex.h&gt; . . . . . . . .              .   .   .   401
+         7.26.2 Character handling &lt;ctype.h&gt;           . . . . . . . . .    .   .   .   401
+         7.26.3 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .      .   .   .   401
+         7.26.4 Format conversion of integer types &lt;inttypes.h&gt;         .   .   .   .   401
+         7.26.5 Localization &lt;locale.h&gt;           . . . . . . . . . . .     .   .   .   401
+         7.26.6 Signal handling &lt;signal.h&gt;           . . . . . . . . . .    .   .   .   401
+         7.26.7 Boolean type and values &lt;stdbool.h&gt;           . . . . . .   .   .   .   401
+         7.26.8 Integer types &lt;stdint.h&gt;          . . . . . . . . . . .     .   .   .   401
+         7.26.9 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .     .   .   .   402
+<!--page 6 indent 0-->
+        7.26.10 General utilities &lt;stdlib.h&gt;      . . . . . . .            . . . . . . 402
+        7.26.11 String handling &lt;string.h&gt;        . . . . . . .            . . . . . . 402
+        7.26.12 Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;          . . . . . . . . . . . . . .             . . . . . . 402
+        7.26.13 Wide character classification and mapping utilities
+                &lt;wctype.h&gt; . . . . . . . . . . . . . .                     . . . . . . 402
+Annex A (informative) Language syntax summary   . .       .    .   .   .   .   .   .   .   .   .   403
+  A.1 Lexical grammar       . . . . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   403
+  A.2 Phrase structure grammar . . . . . . . . .          .    .   .   .   .   .   .   .   .   .   409
+  A.3 Preprocessing directives    . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   416
+Annex B (informative) Library summary     . . . . . . . . . . . . .                    .   .   .   419
+  B.1 Diagnostics &lt;assert.h&gt;          . . . . . . . . . . . . . . .                    .   .   .   419
+  B.2 Complex &lt;complex.h&gt; . . . . . . . . . . . . . . . .                              .   .   .   419
+  B.3 Character handling &lt;ctype.h&gt; . . . . . . . . . . . . .                           .   .   .   421
+  B.4 Errors &lt;errno.h&gt;         . . . . . . . . . . . . . . . . . .                     .   .   .   421
+  B.5 Floating-point environment &lt;fenv.h&gt;          . . . . . . . . . .                 .   .   .   421
+  B.6 Characteristics of floating types &lt;float.h&gt; . . . . . . . .                       .   .   .   422
+  B.7 Format conversion of integer types &lt;inttypes.h&gt; . . . . .                        .   .   .   422
+  B.8 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . . .                         .   .   .   423
+  B.9 Sizes of integer types &lt;limits.h&gt;          . . . . . . . . . . .                 .   .   .   423
+  B.10 Localization &lt;locale.h&gt; . . . . . . . . . . . . . . .                           .   .   .   423
+  B.11 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . . .                            .   .   .   423
+  B.12 Nonlocal jumps &lt;setjmp.h&gt;          . . . . . . . . . . . . .                    .   .   .   428
+  B.13 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . . .                          .   .   .   428
+  B.14 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . . .                   .   .   .   428
+  B.15 Boolean type and values &lt;stdbool.h&gt;           . . . . . . . . .                 .   .   .   428
+  B.16 Common definitions &lt;stddef.h&gt; . . . . . . . . . . . .                            .   .   .   429
+  B.17 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . . .                          .   .   .   429
+  B.18 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   429
+  B.19 General utilities &lt;stdlib.h&gt;       . . . . . . . . . . . . .                    .   .   .   431
+  B.20 String handling &lt;string.h&gt; . . . . . . . . . . . . . .                          .   .   .   433
+  B.21 Type-generic math &lt;tgmath.h&gt;          . . . . . . . . . . . .                   .   .   .   434
+  B.22 Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   434
+  B.23 Extended multibyte/wide character utilities &lt;wchar.h&gt;     . . .                 .   .   .   435
+  B.24 Wide character classification and mapping utilities &lt;wctype.h&gt;                   .   .   .   437
+Annex C (informative) Sequence points     . . . . . . . . . . . . . . . . . 439
+Annex D (normative) Universal character names for identifiers           . . . . . . . 440
+Annex E (informative) Implementation limits        . . . . . . . . . . . . . . 442
+Annex F (normative) IEC 60559 floating-point arithmetic    .    .   .   .   .   .   .   .   .   .   444
+  F.1 Introduction     . . . . . . . . . . . . . .        .    .   .   .   .   .   .   .   .   .   444
+  F.2 Types . . . . . . . . . . . . . . . . .             .    .   .   .   .   .   .   .   .   .   444
+  F.3 Operators and functions     . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   445
+<!--page 7 indent 0-->
+   F.4   Floating to integer conversion       .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   447
+   F.5   Binary-decimal conversion        .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   447
+   F.6   Contracted expressions . .       .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   448
+   F.7   Floating-point environment       .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   448
+   F.8   Optimization . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   451
+   F.9   Mathematics &lt;math.h&gt; .           .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   454
+Annex G (informative) IEC 60559-compatible complex arithmetic                              .   .   .   .   .   .   467
+  G.1 Introduction      . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   467
+  G.2 Types . . . . . . . . . . . . . . . . . . . .                                   .    .   .   .   .   .   .   467
+  G.3 Conventions       . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   467
+  G.4 Conversions       . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   468
+  G.5 Binary operators      . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   468
+  G.6 Complex arithmetic &lt;complex.h&gt;          . . . . . . .                           .    .   .   .   .   .   .   472
+  G.7 Type-generic math &lt;tgmath.h&gt;          . . . . . . . .                           .    .   .   .   .   .   .   480
+Annex H (informative) Language independent arithmetic . .                         .   .    .   .   .   .   .   .   481
+  H.1 Introduction     . . . . . . . . . . . . . . . .                            .   .    .   .   .   .   .   .   481
+  H.2 Types . . . . . . . . . . . . . . . . . . .                                 .   .    .   .   .   .   .   .   481
+  H.3 Notification      . . . . . . . . . . . . . . . .                            .   .    .   .   .   .   .   .   485
+Annex I (informative) Common warnings             . . . . . . . . . . . . . . . . 487
+Annex J (informative) Portability issues      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   489
+  J.1 Unspecified behavior . . . .             . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   489
+  J.2 Undefined behavior          . . . .      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   492
+  J.3 Implementation-defined behavior            . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   505
+  J.4 Locale-specific behavior         . .     . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   512
+  J.5 Common extensions          . . . .      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   513
+Bibliography      . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
+Index     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
+<!--page 8 indent 0-->
+<!--page 9 indent 4-->
+</pre>
+
+<a name="Foreword" href="#Foreword"><h2>Foreword</h2></a>
+<p><!--para 1-->
+ ISO (the International Organization for Standardization) and IEC (the International
+ Electrotechnical Commission) form the specialized system for worldwide
+ standardization. National bodies that are member of ISO or IEC participate in the
+ development of International Standards through technical committees established by the
+ respective organization to deal with particular fields of technical activity. ISO and IEC
+ technical committees collaborate in fields of mutual interest. Other international
+ organizations, governmental and non-governmental, in liaison with ISO and IEC, also
+ take part in the work.
+<p><!--para 2-->
+ International Standards are drafted in accordance with the rules given in the ISO/IEC
+ Directives, Part 3.
+<p><!--para 3-->
+ In the field of information technology, ISO and IEC have established a joint technical
+ committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
+ committee are circulated to national bodies for voting. Publication as an International
+ Standard requires approval by at least 75% of the national bodies casting a vote.
+<p><!--para 4-->
+ International Standard ISO/IEC 9899 was prepared by Joint Technical Committee
+ ISO/IEC JTC 1, Information technology, Subcommittee SC 22, Programming languages,
+ their environments and system software interfaces. The Working Group responsible for
+ this standard (WG 14) maintains a site on the World Wide Web at
+ http://www.open-std.org/JTC1/SC22/WG14/                        containing      additional
+ information relevant to this standard such as a Rationale for many of the decisions made
+ during its preparation and a log of Defect Reports and Responses.
+<p><!--para 5-->
+ This second edition cancels and replaces the first edition, ISO/IEC 9899:1990, as
+ amended and corrected by ISO/IEC 9899/COR1:1994, ISO/IEC 9899/AMD1:1995, and
+ ISO/IEC 9899/COR2:1996. Major changes from the previous edition include:
+<ul>
+<li>  restricted character set support via digraphs and &lt;iso646.h&gt; (originally specified
+ in AMD1)
+<li>  wide character library support in &lt;wchar.h&gt; and &lt;wctype.h&gt; (originally
+ specified in AMD1)
+<li>  more precise aliasing rules via effective type
+<li>  restricted pointers
+<li>  variable length arrays
+<li>  flexible array members
+<li>  static and type qualifiers in parameter array declarators
+<li>  complex (and imaginary) support in &lt;complex.h&gt;
+<li>  type-generic math macros in &lt;tgmath.h&gt;
+<li>  the long long int type and library functions
+<!--page 10 indent 0-->
+<li>  increased minimum translation limits
+<li>  additional floating-point characteristics in &lt;float.h&gt;
+<li>  remove implicit int
+<li>  reliable integer division
+<li>  universal character names (\u and \U)
+<li>  extended identifiers
+<li>  hexadecimal floating-point constants and %a and %A printf/scanf conversion
+ specifiers
+<li>  compound literals
+<li>  designated initializers
+<li>  // comments
+<li>  extended integer types and library functions in &lt;inttypes.h&gt; and &lt;stdint.h&gt;
+<li>  remove implicit function declaration
+<li>  preprocessor arithmetic done in intmax_t/uintmax_t
+<li>  mixed declarations and code
+<li>  new block scopes for selection and iteration statements
+<li>  integer constant type rules
+<li>  integer promotion rules
+<li>  macros with a variable number of arguments
+<li>  the vscanf family of functions in &lt;stdio.h&gt; and &lt;wchar.h&gt;
+<li>  additional math library functions in &lt;math.h&gt;
+<li>  treatment of error conditions by math library functions (math_errhandling)
+<li>  floating-point environment access in &lt;fenv.h&gt;
+<li>  IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
+<li>  trailing comma allowed in enum declaration
+<li>  %lf conversion specifier allowed in printf
+<li>  inline functions
+<li>  the snprintf family of functions in &lt;stdio.h&gt;
+<li>  boolean type in &lt;stdbool.h&gt;
+<li>  idempotent type qualifiers
+<li>  empty macro arguments
+<!--page 11 indent 4-->
+<li>  new structure type compatibility rules (tag compatibility)
+<li>  additional predefined macro names
+<li>  _Pragma preprocessing operator
+<li>  standard pragmas
+<li>  __func__ predefined identifier
+<li>  va_copy macro
+<li>  additional strftime conversion specifiers
+<li>  LIA compatibility annex
+<li>  deprecate ungetc at the beginning of a binary file
+<li>  remove deprecation of aliased array parameters
+<li>  conversion of array to pointer not limited to lvalues
+<li>  relaxed constraints on aggregate and union initialization
+<li>  relaxed restrictions on portable header names
+<li>  return without expression not permitted in function that returns a value (and vice
+ versa)
+</ul>
+<p><!--para 6-->
+ Annexes D and F form a normative part of this standard; annexes A, B, C, E, G, H, I, J,
+ the bibliography, and the index are for information only. In accordance with Part 3 of the
+ ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples are
+ also for information only.
+<!--page 12 indent 4-->
+
+<a name="Introduction" href="#Introduction"><h2>Introduction</h2></a>
+<p><!--para 1-->
+ With the introduction of new devices and extended character sets, new features may be
+ added to this International Standard. Subclauses in the language and library clauses warn
+ implementors and programmers of usages which, though valid in themselves, may
+ conflict with future additions.
+<p><!--para 2-->
+ Certain features are obsolescent, which means that they may be considered for
+ withdrawal in future revisions of this International Standard. They are retained because
+ of their widespread use, but their use in new implementations (for implementation
+ features) or new programs (for language [<a href="#6.11">6.11</a>] or library features [<a href="#7.26">7.26</a>]) is discouraged.
+<p><!--para 3-->
+ This International Standard is divided into four major subdivisions:
+<ul>
+<li>  preliminary elements (clauses 1-4);
+<li>  the characteristics of environments that translate and execute C programs (clause 5);
+<li>  the language syntax, constraints, and semantics (clause 6);
+<li>  the library facilities (clause 7).
+</ul>
+<p><!--para 4-->
+ Examples are provided to illustrate possible forms of the constructions described.
+ Footnotes are provided to emphasize consequences of the rules described in that
+ subclause or elsewhere in this International Standard. References are used to refer to
+ other related subclauses. Recommendations are provided to give advice or guidance to
+ implementors. Annexes provide additional information and summarize the information
+ contained in this International Standard. A bibliography lists documents that were
+ referred to during the preparation of the standard.
+<p><!--para 5-->
+ The language clause (clause 6) is derived from ''The C Reference Manual''.
+<p><!--para 6-->
+ The library clause (clause 7) is based on the 1984 /usr/group Standard.
+<!--page 13 indent 4-->
+
+<h1>Programming languages -- C</h1>
+ 
+ 
+ 
+ 
+
+<a name="1" href="#1"><h2>1. Scope</h2></a>
+<p><!--para 1-->
+ This International Standard specifies the form and establishes the interpretation of
+ programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
+<ul>
+<li>  the representation of C programs;
+<li>  the syntax and constraints of the C language;
+<li>  the semantic rules for interpreting C programs;
+<li>  the representation of input data to be processed by C programs;
+<li>  the representation of output data produced by C programs;
+<li>  the restrictions and limits imposed by a conforming implementation of C.
+</ul>
+<p><!--para 2-->
+ This International Standard does not specify
+<ul>
+<li>  the mechanism by which C programs are transformed for use by a data-processing
+ system;
+<li>  the mechanism by which C programs are invoked for use by a data-processing
+ system;
+<li>  the mechanism by which input data are transformed for use by a C program;
+<li>  the mechanism by which output data are transformed after being produced by a C
+ program;
+<li>  the size or complexity of a program and its data that will exceed the capacity of any
+ specific data-processing system or the capacity of a particular processor;
+ 
+ 
+<!--page 14 indent 4-->
+<li>  all minimal requirements of a data-processing system that is capable of supporting a
+ conforming implementation.
+ 
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note1">1)</a> This International Standard is designed to promote the portability of C programs among a variety of
+ data-processing systems. It is intended for use by implementors and programmers.
+
+
+<a name="2" href="#2"><h2>2. Normative references</h2></a>
+<p><!--para 1-->
+ The following normative documents contain provisions which, through reference in this
+ text, constitute provisions of this International Standard. For dated references,
+ subsequent amendments to, or revisions of, any of these publications do not apply.
+ However, parties to agreements based on this International Standard are encouraged to
+ investigate the possibility of applying the most recent editions of the normative
+ documents indicated below. For undated references, the latest edition of the normative
+ document referred to applies. Members of ISO and IEC maintain registers of currently
+ valid International Standards.
+<p><!--para 2-->
+ ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and symbols for
+ use in the physical sciences and technology.
+<p><!--para 3-->
+ ISO/IEC 646, Information technology -- ISO 7-bit coded character set for information
+ interchange.
+<p><!--para 4-->
+ ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1: Fundamental
+ terms.
+<p><!--para 5-->
+ ISO 4217, Codes for the representation of currencies and funds.
+<p><!--para 6-->
+ ISO 8601, Data elements and interchange formats -- Information interchange --
+ Representation of dates and times.
+<p><!--para 7-->
+ ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
+ Character Set (UCS).
+<p><!--para 8-->
+ IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously
+ designated IEC 559:1989).
+<!--page 15 indent 4-->
+
+<a name="3" href="#3"><h2>3. Terms, definitions, and symbols</h2></a>
+<p><!--para 1-->
+ For the purposes of this International Standard, the following definitions apply. Other
+ terms are defined where they appear in italic type or on the left side of a syntax rule.
+ Terms explicitly defined in this International Standard are not to be presumed to refer
+ implicitly to similar terms defined elsewhere. Terms not defined in this International
+ Standard are to be interpreted according to ISO/IEC 2382-1. Mathematical symbols not
+ defined in this International Standard are to be interpreted according to ISO 31-11.
+
+<a name="3.1" href="#3.1"><h3>3.1</h3></a>
+<p><!--para 1-->
+ access
+ &lt;execution-time action&gt; to read or modify the value of an object
+<p><!--para 2-->
+ NOTE 1   Where only one of these two actions is meant, ''read'' or ''modify'' is used.
+ 
+<p><!--para 3-->
+ NOTE 2   "Modify'' includes the case where the new value being stored is the same as the previous value.
+ 
+<p><!--para 4-->
+ NOTE 3   Expressions that are not evaluated do not access objects.
+ 
+
+<a name="3.2" href="#3.2"><h3>3.2</h3></a>
+<p><!--para 1-->
+ alignment
+ requirement that objects of a particular type be located on storage boundaries with
+ addresses that are particular multiples of a byte address
+
+<a name="3.3" href="#3.3"><h3>3.3</h3></a>
+<p><!--para 1-->
+ argument
+ actual argument
+ actual parameter (deprecated)
+ expression in the comma-separated list bounded by the parentheses in a function call
+ expression, or a sequence of preprocessing tokens in the comma-separated list bounded
+ by the parentheses in a function-like macro invocation
+
+<a name="3.4" href="#3.4"><h3>3.4</h3></a>
+<p><!--para 1-->
+ behavior
+ external appearance or action
+
+<a name="3.4.1" href="#3.4.1"><h4>3.4.1</h4></a>
+<p><!--para 1-->
+ implementation-defined behavior
+ unspecified behavior where each implementation documents how the choice is made
+<p><!--para 2-->
+ EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
+ when a signed integer is shifted right.
+ 
+
+<a name="3.4.2" href="#3.4.2"><h4>3.4.2</h4></a>
+<p><!--para 1-->
+ locale-specific behavior
+ behavior that depends on local conventions of nationality, culture, and language that each
+ implementation documents
+<!--page 16 indent 4-->
+<p><!--para 2-->
+ EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
+ characters other than the 26 lowercase Latin letters.
+ 
+
+<a name="3.4.3" href="#3.4.3"><h4>3.4.3</h4></a>
+<p><!--para 1-->
+ undefined behavior
+ behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
+ for which this International Standard imposes no requirements
+<p><!--para 2-->
+ NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
+ results, to behaving during translation or program execution in a documented manner characteristic of the
+ environment (with or without the issuance of a diagnostic message), to terminating a translation or
+ execution (with the issuance of a diagnostic message).
+ 
+<p><!--para 3-->
+ EXAMPLE        An example of undefined behavior is the behavior on integer overflow.
+ 
+
+<a name="3.4.4" href="#3.4.4"><h4>3.4.4</h4></a>
+<p><!--para 1-->
+ unspecified behavior
+ use of an unspecified value, or other behavior where this International Standard provides
+ two or more possibilities and imposes no further requirements on which is chosen in any
+ instance
+<p><!--para 2-->
+ EXAMPLE        An example of unspecified behavior is the order in which the arguments to a function are
+ evaluated.
+ 
+
+<a name="3.5" href="#3.5"><h3>3.5</h3></a>
+<p><!--para 1-->
+ bit
+ unit of data storage in the execution environment large enough to hold an object that may
+ have one of two values
+<p><!--para 2-->
+ NOTE     It need not be possible to express the address of each individual bit of an object.
+ 
+
+<a name="3.6" href="#3.6"><h3>3.6</h3></a>
+<p><!--para 1-->
+ byte
+ addressable unit of data storage large enough to hold any member of the basic character
+ set of the execution environment
+<p><!--para 2-->
+ NOTE 1 It is possible to express the address of each individual byte of an object uniquely.
+ 
+<p><!--para 3-->
+ NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
+ defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
+ bit.
+ 
+
+<a name="3.7" href="#3.7"><h3>3.7</h3></a>
+<p><!--para 1-->
+ character
+ &lt;abstract&gt; member of a set of elements used for the organization, control, or
+ representation of data
+
+<a name="3.7.1" href="#3.7.1"><h4>3.7.1</h4></a>
+<p><!--para 1-->
+ character
+ single-byte character
+ &lt;C&gt; bit representation that fits in a byte
+<!--page 17 indent 4-->
+
+<a name="3.7.2" href="#3.7.2"><h4>3.7.2</h4></a>
+<p><!--para 1-->
+ multibyte character
+ sequence of one or more bytes representing a member of the extended character set of
+ either the source or the execution environment
+<p><!--para 2-->
+ NOTE    The extended character set is a superset of the basic character set.
+ 
+
+<a name="3.7.3" href="#3.7.3"><h4>3.7.3</h4></a>
+<p><!--para 1-->
+ wide character
+ bit representation that fits in an object of type wchar_t, capable of representing any
+ character in the current locale
+
+<a name="3.8" href="#3.8"><h3>3.8</h3></a>
+<p><!--para 1-->
+ constraint
+ restriction, either syntactic or semantic, by which the exposition of language elements is
+ to be interpreted
+
+<a name="3.9" href="#3.9"><h3>3.9</h3></a>
+<p><!--para 1-->
+ correctly rounded result
+ representation in the result format that is nearest in value, subject to the current rounding
+ mode, to what the result would be given unlimited range and precision
+
+<a name="3.10" href="#3.10"><h3>3.10</h3></a>
+<p><!--para 1-->
+ diagnostic message
+ message belonging to an implementation-defined subset of the implementation's message
+ output
+
+<a name="3.11" href="#3.11"><h3>3.11</h3></a>
+<p><!--para 1-->
+ forward reference
+ reference to a later subclause of this International Standard that contains additional
+ information relevant to this subclause
+
+<a name="3.12" href="#3.12"><h3>3.12</h3></a>
+<p><!--para 1-->
+ implementation
+ particular set of software, running in a particular translation environment under particular
+ control options, that performs translation of programs for, and supports execution of
+ functions in, a particular execution environment
+
+<a name="3.13" href="#3.13"><h3>3.13</h3></a>
+<p><!--para 1-->
+ implementation limit
+ restriction imposed upon programs by the implementation
+
+<a name="3.14" href="#3.14"><h3>3.14</h3></a>
+<p><!--para 1-->
+ object
+ region of data storage in the execution environment, the contents of which can represent
+ values
+<!--page 18 indent 4-->
+<p><!--para 2-->
+ NOTE     When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
+ 
+
+<a name="3.15" href="#3.15"><h3>3.15</h3></a>
+<p><!--para 1-->
+ parameter
+ formal parameter
+ formal argument (deprecated)
+ object declared as part of a function declaration or definition that acquires a value on
+ entry to the function, or an identifier from the comma-separated list bounded by the
+ parentheses immediately following the macro name in a function-like macro definition
+
+<a name="3.16" href="#3.16"><h3>3.16</h3></a>
+<p><!--para 1-->
+ recommended practice
+ specification that is strongly recommended as being in keeping with the intent of the
+ standard, but that may be impractical for some implementations
+
+<a name="3.17" href="#3.17"><h3>3.17</h3></a>
+<p><!--para 1-->
+ value
+ precise meaning of the contents of an object when interpreted as having a specific type
+
+<a name="3.17.1" href="#3.17.1"><h4>3.17.1</h4></a>
+<p><!--para 1-->
+ implementation-defined value
+ unspecified value where each implementation documents how the choice is made
+
+<a name="3.17.2" href="#3.17.2"><h4>3.17.2</h4></a>
+<p><!--para 1-->
+ indeterminate value
+ either an unspecified value or a trap representation
+
+<a name="3.17.3" href="#3.17.3"><h4>3.17.3</h4></a>
+<p><!--para 1-->
+ unspecified value
+ valid value of the relevant type where this International Standard imposes no
+ requirements on which value is chosen in any instance
+<p><!--para 2-->
+ NOTE     An unspecified value cannot be a trap representation.
+ 
+
+<a name="3.18" href="#3.18"><h3>3.18</h3></a>
+<p><!--para 1-->
+ ??? x???
+ ceiling of x: the least integer greater than or equal to x
+<p><!--para 2-->
+ EXAMPLE       ???2.4??? is 3, ???-2.4??? is -2.
+ 
+
+<a name="3.19" href="#3.19"><h3>3.19</h3></a>
+<p><!--para 1-->
+ ??? x???
+ floor of x: the greatest integer less than or equal to x
+<p><!--para 2-->
+ EXAMPLE       ???2.4??? is 2, ???-2.4??? is -3.
+<!--page 19 indent 4-->
+
+<a name="4" href="#4"><h2>4. Conformance</h2></a>
+<p><!--para 1-->
+ In this International Standard, ''shall'' is to be interpreted as a requirement on an
+ implementation or on a program; conversely, ''shall not'' is to be interpreted as a
+ prohibition.
+<p><!--para 2-->
+ If a ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated, the
+ behavior is undefined. Undefined behavior is otherwise indicated in this International
+ Standard by the words ''undefined behavior'' or by the omission of any explicit definition
+ of behavior. There is no difference in emphasis among these three; they all describe
+ ''behavior that is undefined''.
+<p><!--para 3-->
+ A program that is correct in all other aspects, operating on correct data, containing
+ unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
+<p><!--para 4-->
+ The implementation shall not successfully translate a preprocessing translation unit
+ containing a #error preprocessing directive unless it is part of a group skipped by
+ conditional inclusion.
+<p><!--para 5-->
+ A strictly conforming program shall use only those features of the language and library
+ specified in this International Standard.<sup><a href="#note2"><b>2)</b></a></sup> It shall not produce output dependent on any
+ unspecified, undefined, or implementation-defined behavior, and shall not exceed any
+ minimum implementation limit.
+<p><!--para 6-->
+ The two forms of conforming implementation are hosted and freestanding. A conforming
+ hosted implementation shall accept any strictly conforming program. A conforming
+ freestanding implementation shall accept any strictly conforming program that does not
+ use complex types and in which the use of the features specified in the library clause
+ (clause 7) is confined to the contents of the standard headers &lt;float.h&gt;,
+ &lt;iso646.h&gt;, &lt;limits.h&gt;, &lt;stdarg.h&gt;, &lt;stdbool.h&gt;, &lt;stddef.h&gt;, and
+ &lt;stdint.h&gt;. A conforming implementation may have extensions (including additional
+ library functions), provided they do not alter the behavior of any strictly conforming
+ program.<sup><a href="#note3"><b>3)</b></a></sup>
+ 
+ 
+ 
+<!--page 20 indent 4-->
+<p><!--para 7-->
+ A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note4"><b>4)</b></a></sup>
+<p><!--para 8-->
+ An implementation shall be accompanied by a document that defines all implementation-
+ defined and locale-specific characteristics and all extensions.
+ Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
+ characteristics of floating types &lt;float.h&gt; (<a href="#7.7">7.7</a>), alternative spellings &lt;iso646.h&gt;
+ (<a href="#7.9">7.9</a>), sizes of integer types &lt;limits.h&gt; (<a href="#7.10">7.10</a>), variable arguments &lt;stdarg.h&gt;
+ (<a href="#7.15">7.15</a>), boolean type and values &lt;stdbool.h&gt; (<a href="#7.16">7.16</a>), common definitions
+ &lt;stddef.h&gt; (<a href="#7.17">7.17</a>), integer types &lt;stdint.h&gt; (<a href="#7.18">7.18</a>).
+ 
+ 
+ 
+ 
+<!--page 21 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note2">2)</a> A strictly conforming program can use conditional features (such as those in <a href="#F">annex F</a>) provided the
+ use is guarded by a #ifdef directive with the appropriate macro. For example:
+
+<pre>
+         #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
             /* ... */
-            if ((c = f()) == -1)
-                    /* ... */
-    the int value returned by the function may be truncated when stored in the char, and then converted back
-    to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
-    values as unsigned char (and char is narrower than int), the result of the conversion cannot be
-
-
-
-    <sup><a name="note96" href="#note96"><b>96)</b></a></sup> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
-        (specified in <a href="#6.3.2.1">6.3.2.1</a>) that changes lvalues to ''the value of the expression'' and thus removes any type
-        qualifiers that were applied to the type category of the expression (for example, it removes const but
-        not volatile from the type int volatile * const).
-
-[<a name="p92" href="#p92">page 92</a>] (<a href="#Contents">Contents</a>)
-
-    negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
-    variable c should be declared as int.
-
-5   EXAMPLE 2       In the fragment:
-            char c;
-            int i;
-            long l;
-            l = (c = i);
-    the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
-    of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
-    that is, long int type.
-
-6   EXAMPLE 3       Consider the fragment:
-            const char **cpp;
-            char *p;
-            const char c = 'A';
-            cpp = &amp;p;                  // constraint violation
-            *cpp = &amp;c;                 // valid
-            *p = 0;                    // valid
-    The first assignment is unsafe because it would allow the following valid code to attempt to change the
-    value of the const object c.
-
-<a name="6.5.16.2" href="#6.5.16.2"><b>    6.5.16.2 Compound assignment</b></a>
-<b>    Constraints</b>
-1   For the operators += and -= only, either the left operand shall be a pointer to an object
-    type and the right shall have integer type, or the left operand shall have qualified or
-    unqualified arithmetic type and the right shall have arithmetic type.
-2   For the other operators, each operand shall have arithmetic type consistent with those
-    allowed by the corresponding binary operator.
-<b>    Semantics</b>
-3   A compound assignment of the form E1 op = E2 differs from the simple assignment
-    expression E1 = E1 op (E2) only in that the lvalue E1 is evaluated only once.
-
-[<a name="p93" href="#p93">page 93</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.17" href="#6.5.17"><b>    6.5.17 Comma operator</b></a>
-<b>    Syntax</b>
-1            expression:
-                    assignment-expression
-                    expression , assignment-expression
-<b>    Semantics</b>
-2   The left operand of a comma operator is evaluated as a void expression; there is a
-    sequence point after its evaluation. Then the right operand is evaluated; the result has its
-    type and value.<sup><a href="#note97"><b>97)</b></a></sup> If an attempt is made to modify the result of a comma operator or to
-    access it after the next sequence point, the behavior is undefined.
-3   EXAMPLE As indicated by the syntax, the comma operator (as described in this subclause) cannot
-    appear in contexts where a comma is used to separate items in a list (such as arguments to functions or lists
-    of initializers). On the other hand, it can be used within a parenthesized expression or within the second
-    expression of a conditional operator in such contexts. In the function call
-             f(a, (t=3, t+2), c)
-    the function has three arguments, the second of which has the value 5.
-
-    Forward references: initialization (<a href="#6.7.8">6.7.8</a>).
-
-
-
-
-    <sup><a name="note97" href="#note97"><b>97)</b></a></sup> A comma operator does not yield an lvalue.
-
-[<a name="p94" href="#p94">page 94</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.6" href="#6.6"><b>    6.6 Constant expressions</b></a>
-<b>    Syntax</b>
-1            constant-expression:
-                    conditional-expression
-<b>    Description</b>
-2   A constant expression can be evaluated during translation rather than runtime, and
-    accordingly may be used in any place that a constant may be.
-<b>    Constraints</b>
-3   Constant expressions shall not contain assignment, increment, decrement, function-call,
-    or comma operators, except when they are contained within a subexpression that is not
-    evaluated.<sup><a href="#note98"><b>98)</b></a></sup>
-4   Each constant expression shall evaluate to a constant that is in the range of representable
-    values for its type.
-<b>    Semantics</b>
-5   An expression that evaluates to a constant is required in several contexts. If a floating
-    expression is evaluated in the translation environment, the arithmetic precision and range
-    shall be at least as great as if the expression were being evaluated in the execution
-    environment.
-6   An integer constant expression<sup><a href="#note99"><b>99)</b></a></sup> shall have integer type and shall only have operands
-    that are integer constants, enumeration constants, character constants, sizeof
-    expressions whose results are integer constants, and floating constants that are the
-    immediate operands of casts. Cast operators in an integer constant expression shall only
-    convert arithmetic types to integer types, except as part of an operand to the sizeof
-    operator.
-7   More latitude is permitted for constant expressions in initializers. Such a constant
-    expression shall be, or evaluate to, one of the following:
-    -- an arithmetic constant expression,
-    -- a null pointer constant,
-
-
-
-
-    <sup><a name="note98" href="#note98"><b>98)</b></a></sup> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
-    <sup><a name="note99" href="#note99"><b>99)</b></a></sup> An integer constant expression is used to specify the size of a bit-field member of a structure, the
-        value of an enumeration constant, the size of an array, or the value of a case constant. Further
-        constraints that apply to the integer constant expressions used in conditional-inclusion preprocessing
-        directives are discussed in <a href="#6.10.1">6.10.1</a>.
-
-[<a name="p95" href="#p95">page 95</a>] (<a href="#Contents">Contents</a>)
-
-     -- an address constant, or
-     -- an address constant for an object type plus or minus an integer constant expression.
-8    An arithmetic constant expression shall have arithmetic type and shall only have
-     operands that are integer constants, floating constants, enumeration constants, character
-     constants, and sizeof expressions. Cast operators in an arithmetic constant expression
-     shall only convert arithmetic types to arithmetic types, except as part of an operand to a
-     sizeof operator whose result is an integer constant.
-9    An address constant is a null pointer, a pointer to an lvalue designating an object of static
-     storage duration, or a pointer to a function designator; it shall be created explicitly using
-     the unary &amp; operator or an integer constant cast to pointer type, or implicitly by the use of
-     an expression of array or function type. The array-subscript [] and member-access .
-     and -&gt; operators, the address &amp; and indirection * unary operators, and pointer casts may
-     be used in the creation of an address constant, but the value of an object shall not be
-     accessed by use of these operators.
-10   An implementation may accept other forms of constant expressions.
-11   The semantic rules for the evaluation of a constant expression are the same as for
-     nonconstant expressions.<sup><a href="#note100"><b>100)</b></a></sup>
-     Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), initialization (<a href="#6.7.8">6.7.8</a>).
-
-
-
-
-     <sup><a name="note100" href="#note100"><b>100)</b></a></sup> Thus, in the following initialization,
-                   static int i = 2 || 1 / 0;
-          the expression is a valid integer constant expression with value one.
-
-[<a name="p96" href="#p96">page 96</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7" href="#6.7"><b>    6.7 Declarations</b></a>
-<b>    Syntax</b>
-1            declaration:
-                    declaration-specifiers init-declarator-listopt ;
-             declaration-specifiers:
-                    storage-class-specifier declaration-specifiersopt
-                    type-specifier declaration-specifiersopt
-                    type-qualifier declaration-specifiersopt
-                    function-specifier declaration-specifiersopt
-             init-declarator-list:
-                     init-declarator
-                     init-declarator-list , init-declarator
-             init-declarator:
-                     declarator
-                     declarator = initializer
-<b>    Constraints</b>
-2   A declaration shall declare at least a declarator (other than the parameters of a function or
-    the members of a structure or union), a tag, or the members of an enumeration.
-3   If an identifier has no linkage, there shall be no more than one declaration of the identifier
-    (in a declarator or type specifier) with the same scope and in the same name space, except
-    for tags as specified in <a href="#6.7.2.3">6.7.2.3</a>.
-4   All declarations in the same scope that refer to the same object or function shall specify
-    compatible types.
-<b>    Semantics</b>
-5   A declaration specifies the interpretation and attributes of a set of identifiers. A definition
-    of an identifier is a declaration for that identifier that:
-    -- for an object, causes storage to be reserved for that object;
-    -- for a function, includes the function body;<sup><a href="#note101"><b>101)</b></a></sup>
-    -- for an enumeration constant or typedef name, is the (only) declaration of the
-      identifier.
-6   The declaration specifiers consist of a sequence of specifiers that indicate the linkage,
-    storage duration, and part of the type of the entities that the declarators denote. The init-
-    declarator-list is a comma-separated sequence of declarators, each of which may have
-
-    <sup><a name="note101" href="#note101"><b>101)</b></a></sup> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
-
-[<a name="p97" href="#p97">page 97</a>] (<a href="#Contents">Contents</a>)
-
-    additional type information, or an initializer, or both. The declarators contain the
-    identifiers (if any) being declared.
-7   If an identifier for an object is declared with no linkage, the type for the object shall be
-    complete by the end of its declarator, or by the end of its init-declarator if it has an
-    initializer; in the case of function parameters (including in prototypes), it is the adjusted
-    type (see <a href="#6.7.5.3">6.7.5.3</a>) that is required to be complete.
-    Forward references: declarators (<a href="#6.7.5">6.7.5</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
-    (<a href="#6.7.8">6.7.8</a>).
-<a name="6.7.1" href="#6.7.1"><b>    6.7.1 Storage-class specifiers</b></a>
-<b>    Syntax</b>
-1            storage-class-specifier:
-                    typedef
-                    extern
-                    static
-                    auto
-                    register
-<b>    Constraints</b>
-2   At most, one storage-class specifier may be given in the declaration specifiers in a
-    declaration.<sup><a href="#note102"><b>102)</b></a></sup>
-<b>    Semantics</b>
-3   The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
-    only; it is discussed in <a href="#6.7.7">6.7.7</a>. The meanings of the various linkages and storage durations
-    were discussed in <a href="#6.2.2">6.2.2</a> and <a href="#6.2.4">6.2.4</a>.
-4   A declaration of an identifier for an object with storage-class specifier register
-    suggests that access to the object be as fast as possible. The extent to which such
-    suggestions are effective is implementation-defined.<sup><a href="#note103"><b>103)</b></a></sup>
-5   The declaration of an identifier for a function that has block scope shall have no explicit
-    storage-class specifier other than extern.
-
-
-
-    <sup><a name="note102" href="#note102"><b>102)</b></a></sup> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
-    <sup><a name="note103" href="#note103"><b>103)</b></a></sup> The implementation may treat any register declaration simply as an auto declaration. However,
-         whether or not addressable storage is actually used, the address of any part of an object declared with
-         storage-class specifier register cannot be computed, either explicitly (by use of the unary &amp;
-         operator as discussed in <a href="#6.5.3.2">6.5.3.2</a>) or implicitly (by converting an array name to a pointer as discussed in
-         <a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operator that can be applied to an array declared with storage-class specifier
-         register is sizeof.
-
-[<a name="p98" href="#p98">page 98</a>] (<a href="#Contents">Contents</a>)
-
-6   If an aggregate or union object is declared with a storage-class specifier other than
-    typedef, the properties resulting from the storage-class specifier, except with respect to
-    linkage, also apply to the members of the object, and so on recursively for any aggregate
-    or union member objects.
-    Forward references: type definitions (<a href="#6.7.7">6.7.7</a>).
-<a name="6.7.2" href="#6.7.2"><b>    6.7.2 Type specifiers</b></a>
-<b>    Syntax</b>
-1            type-specifier:
-                    void
-                    char
-                    short
-                    int
-                    long
-                    float
-                    double
-                    signed
-                    unsigned
-                    _Bool
-                    _Complex
-                    struct-or-union-specifier                                                      *
-                    enum-specifier
-                    typedef-name
-<b>    Constraints</b>
-2   At least one type specifier shall be given in the declaration specifiers in each declaration,
-    and in the specifier-qualifier list in each struct declaration and type name. Each list of
-    type specifiers shall be one of the following sets (delimited by commas, when there is
-    more than one set on a line); the type specifiers may occur in any order, possibly
-    intermixed with the other declaration specifiers.
-    -- void
-    -- char
-    -- signed char
-    -- unsigned char
-    -- short, signed short, short int, or signed short int
-    -- unsigned short, or unsigned short int
-    -- int, signed, or signed int
-
-[<a name="p99" href="#p99">page 99</a>] (<a href="#Contents">Contents</a>)
-
-    -- unsigned, or unsigned int
-    -- long, signed long, long int, or signed long int
-    -- unsigned long, or unsigned long int
-    -- long long, signed long long, long long int, or
-      signed long long int
-    -- unsigned long long, or unsigned long long int
-    -- float
-    -- double
-    -- long double
-    -- _Bool
-    -- float _Complex
-    -- double _Complex
-    -- long double _Complex
-    -- struct or union specifier                                                                    *
-    -- enum specifier
-    -- typedef name
-3   The type specifier _Complex shall not be used if the implementation does not provide
-    complex types.<sup><a href="#note104"><b>104)</b></a></sup>
-<b>    Semantics</b>
-4   Specifiers for structures, unions, and enumerations are discussed in <a href="#6.7.2.1">6.7.2.1</a> through
-<a name="6.7.2.3" href="#6.7.2.3"><b>    6.7.2.3. Declarations of typedef names are discussed in 6.7.7. The characteristics of the</b></a>
-    other types are discussed in <a href="#6.2.5">6.2.5</a>.
-5   Each of the comma-separated sets designates the same type, except that for bit-fields, it is
-    implementation-defined whether the specifier int designates the same type as signed
-    int or the same type as unsigned int.
-    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
-    (<a href="#6.7.2.1">6.7.2.1</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>), type definitions (<a href="#6.7.7">6.7.7</a>).
-
-
-
-
-    <sup><a name="note104" href="#note104"><b>104)</b></a></sup> Freestanding implementations are not required to provide complex types.                  *
-
-[<a name="p100" href="#p100">page 100</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.2.1" href="#6.7.2.1"><b>    6.7.2.1 Structure and union specifiers</b></a>
-<b>    Syntax</b>
-1            struct-or-union-specifier:
-                     struct-or-union identifieropt { struct-declaration-list }
-                     struct-or-union identifier
-             struct-or-union:
-                     struct
-                     union
-             struct-declaration-list:
-                     struct-declaration
-                     struct-declaration-list struct-declaration
-             struct-declaration:
-                     specifier-qualifier-list struct-declarator-list ;
-             specifier-qualifier-list:
-                    type-specifier specifier-qualifier-listopt
-                    type-qualifier specifier-qualifier-listopt
-             struct-declarator-list:
-                     struct-declarator
-                     struct-declarator-list , struct-declarator
-             struct-declarator:
-                     declarator
-                     declaratoropt : constant-expression
-<b>    Constraints</b>
-2   A structure or union shall not contain a member with incomplete or function type (hence,
-    a structure shall not contain an instance of itself, but may contain a pointer to an instance
-    of itself), except that the last member of a structure with more than one named member
-    may have incomplete array type; such a structure (and any union containing, possibly
-    recursively, a member that is such a structure) shall not be a member of a structure or an
-    element of an array.
-3   The expression that specifies the width of a bit-field shall be an integer constant
-    expression with a nonnegative value that does not exceed the width of an object of the
-    type that would be specified were the colon and expression omitted. If the value is zero,
-    the declaration shall have no declarator.
-4   A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
-    int, unsigned int, or some other implementation-defined type.
-
-[<a name="p101" href="#p101">page 101</a>] (<a href="#Contents">Contents</a>)
-
-<b>     Semantics</b>
-5    As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
-     storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
-     of members whose storage overlap.
-6    Structure and union specifiers have the same form. The keywords struct and union
-     indicate that the type being specified is, respectively, a structure type or a union type.
-7    The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
-     within a translation unit. The struct-declaration-list is a sequence of declarations for the
-     members of the structure or union. If the struct-declaration-list contains no named
-     members, the behavior is undefined. The type is incomplete until after the } that
-     terminates the list.
-8    A member of a structure or union may have any object type other than a variably
-     modified type.<sup><a href="#note105"><b>105)</b></a></sup> In addition, a member may be declared to consist of a specified
-     number of bits (including a sign bit, if any). Such a member is called a bit-field;<sup><a href="#note106"><b>106)</b></a></sup> its
-     width is preceded by a colon.
-9    A bit-field is interpreted as a signed or unsigned integer type consisting of the specified
-     number of bits.<sup><a href="#note107"><b>107)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of type
-     _Bool, the value of the bit-field shall compare equal to the value stored.
-10   An implementation may allocate any addressable storage unit large enough to hold a bit-
-     field. If enough space remains, a bit-field that immediately follows another bit-field in a
-     structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
-     whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is
-     implementation-defined. The order of allocation of bit-fields within a unit (high-order to
-     low-order or low-order to high-order) is implementation-defined. The alignment of the
-     addressable storage unit is unspecified.
-11   A bit-field declaration with no declarator, but only a colon and a width, indicates an
-     unnamed bit-field.<sup><a href="#note108"><b>108)</b></a></sup> As a special case, a bit-field structure member with a width of 0
-     indicates that no further bit-field is to be packed into the unit in which the previous bit-
-     field, if any, was placed.
-
-
-     <sup><a name="note105" href="#note105"><b>105)</b></a></sup> A structure or union can not contain a member with a variably modified type because member names
-          are not ordinary identifiers as defined in <a href="#6.2.3">6.2.3</a>.
-     <sup><a name="note106" href="#note106"><b>106)</b></a></sup> The unary &amp; (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
-          or arrays of bit-field objects.
-     <sup><a name="note107" href="#note107"><b>107)</b></a></sup> As specified in <a href="#6.7.2">6.7.2</a> above, if the actual type specifier used is int or a typedef-name defined as int,
-          then it is implementation-defined whether the bit-field is signed or unsigned.
-     <sup><a name="note108" href="#note108"><b>108)</b></a></sup> An unnamed bit-field structure member is useful for padding to conform to externally imposed
-          layouts.
-
-[<a name="p102" href="#p102">page 102</a>] (<a href="#Contents">Contents</a>)
-
-12   Each non-bit-field member of a structure or union object is aligned in an implementation-
-     defined manner appropriate to its type.
-13   Within a structure object, the non-bit-field members and the units in which bit-fields
-     reside have addresses that increase in the order in which they are declared. A pointer to a
-     structure object, suitably converted, points to its initial member (or if that member is a
-     bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
-     padding within a structure object, but not at its beginning.
-14   The size of a union is sufficient to contain the largest of its members. The value of at
-     most one of the members can be stored in a union object at any time. A pointer to a
-     union object, suitably converted, points to each of its members (or if a member is a bit-
-     field, then to the unit in which it resides), and vice versa.
-15   There may be unnamed padding at the end of a structure or union.
-16   As a special case, the last element of a structure with more than one named member may
-     have an incomplete array type; this is called a flexible array member. In most situations,
-     the flexible array member is ignored. In particular, the size of the structure is as if the
-     flexible array member were omitted except that it may have more trailing padding than
-     the omission would imply. However, when a . (or -&gt;) operator has a left operand that is
-     (a pointer to) a structure with a flexible array member and the right operand names that
-     member, it behaves as if that member were replaced with the longest array (with the same
-     element type) that would not make the structure larger than the object being accessed; the
-     offset of the array shall remain that of the flexible array member, even if this would differ
-     from that of the replacement array. If this array would have no elements, it behaves as if
-     it had one element but the behavior is undefined if any attempt is made to access that
-     element or to generate a pointer one past it.
-17   EXAMPLE       After the declaration:
-             struct s { int n; double d[]; };
-     the structure struct s has a flexible array member d. A typical way to use this is:
-             int m = /* some value */;
-             struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));
-     and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
-     p had been declared as:
-             struct { int n; double d[m]; } *p;
-     (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
-     not be the same).
-18   Following the above declaration:
-
-[<a name="p103" href="#p103">page 103</a>] (<a href="#Contents">Contents</a>)
-
-              struct s t1 = { 0 };                        //   valid
-              struct s t2 = { 1, { <a href="#4.2">4.2</a> }};                //   invalid
-              t1.n = 4;                                   //   valid
-              t1.d[0] = <a href="#4.2">4.2</a>;                              //   might be undefined behavior
-     The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
-     contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
-              sizeof (struct s) &gt;= offsetof(struct s, d) + sizeof (double)
-     in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
-     code.
-19   After the further declaration:
-              struct ss { int n; };
-     the expressions:
-              sizeof (struct s) &gt;= sizeof (struct ss)
-              sizeof (struct s) &gt;= offsetof(struct s, d)
-     are always equal to 1.
-20   If sizeof (double) is 8, then after the following code is executed:
-              struct s *s1;
-              struct s *s2;
-              s1 = malloc(sizeof (struct s) + 64);
-              s2 = malloc(sizeof (struct s) + 46);
-     and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
-     purposes, as if the identifiers had been declared as:
-              struct { int n; double d[8]; } *s1;
-              struct { int n; double d[5]; } *s2;
-21   Following the further successful assignments:
-              s1 = malloc(sizeof (struct s) + 10);
-              s2 = malloc(sizeof (struct s) + 6);
-     they then behave as if the declarations were:
-              struct { int n; double d[1]; } *s1, *s2;
-     and:
-              double *dp;
-              dp = &amp;(s1-&gt;d[0]);           //   valid
-              *dp = 42;                   //   valid
-              dp = &amp;(s2-&gt;d[0]);           //   valid
-              *dp = 42;                   //   undefined behavior
-22   The assignment:
-              *s1 = *s2;
-     only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
-     of the structure, they might be copied or simply overwritten with indeterminate values.
-
-     Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
-
-[<a name="p104" href="#p104">page 104</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.2.2" href="#6.7.2.2"><b>    6.7.2.2 Enumeration specifiers</b></a>
-<b>    Syntax</b>
-1            enum-specifier:
-                   enum identifieropt { enumerator-list }
-                   enum identifieropt { enumerator-list , }
-                   enum identifier
-             enumerator-list:
-                   enumerator
-                   enumerator-list , enumerator
-             enumerator:
-                   enumeration-constant
-                   enumeration-constant = constant-expression
-<b>    Constraints</b>
-2   The expression that defines the value of an enumeration constant shall be an integer
-    constant expression that has a value representable as an int.
-<b>    Semantics</b>
-3   The identifiers in an enumerator list are declared as constants that have type int and
-    may appear wherever such are permitted.<sup><a href="#note109"><b>109)</b></a></sup> An enumerator with = defines its
-    enumeration constant as the value of the constant expression. If the first enumerator has
-    no =, the value of its enumeration constant is 0. Each subsequent enumerator with no =
-    defines its enumeration constant as the value of the constant expression obtained by
-    adding 1 to the value of the previous enumeration constant. (The use of enumerators with
-    = may produce enumeration constants with values that duplicate other values in the same
-    enumeration.) The enumerators of an enumeration are also known as its members.
-4   Each enumerated type shall be compatible with char, a signed integer type, or an
-    unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note110"><b>110)</b></a></sup> but shall be
-    capable of representing the values of all the members of the enumeration. The
-    enumerated type is incomplete until after the } that terminates the list of enumerator
-    declarations.
-
-
-
-
-    <sup><a name="note109" href="#note109"><b>109)</b></a></sup> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
-         each other and from other identifiers declared in ordinary declarators.
-    <sup><a name="note110" href="#note110"><b>110)</b></a></sup> An implementation may delay the choice of which integer type until all enumeration constants have
-         been seen.
-
-[<a name="p105" href="#p105">page 105</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE       The following fragment:
-            enum hue { chartreuse, burgundy, claret=20, winedark };
-            enum hue col, *cp;
-            col = claret;
-            cp = &amp;col;
-            if (*cp != burgundy)
-                  /* ... */
-    makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
-    pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
-
-    Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
-<a name="6.7.2.3" href="#6.7.2.3"><b>    6.7.2.3 Tags</b></a>
-<b>    Constraints</b>
-1   A specific type shall have its content defined at most once.
-2   Where two declarations that use the same tag declare the same type, they shall both use
-    the same choice of struct, union, or enum.
-3   A type specifier of the form
-            enum identifier
-    without an enumerator list shall only appear after the type it specifies is complete.
-<b>    Semantics</b>
-4   All declarations of structure, union, or enumerated types that have the same scope and
-    use the same tag declare the same type. The type is incomplete<sup><a href="#note111"><b>111)</b></a></sup> until the closing brace
-    of the list defining the content, and complete thereafter.
-5   Two declarations of structure, union, or enumerated types which are in different scopes or
-    use different tags declare distinct types. Each declaration of a structure, union, or
-    enumerated type which does not include a tag declares a distinct type.
-6   A type specifier of the form
-            struct-or-union identifieropt { struct-declaration-list }
-    or
-            enum identifier { enumerator-list }
-    or
-            enum identifier { enumerator-list , }
-    declares a structure, union, or enumerated type. The list defines the structure content,
-
-    <sup><a name="note111" href="#note111"><b>111)</b></a></sup> An incomplete type may only by used when the size of an object of that type is not needed. It is not
-         needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
-         when a pointer to or a function returning a structure or union is being declared. (See incomplete types
-         in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
-
-[<a name="p106" href="#p106">page 106</a>] (<a href="#Contents">Contents</a>)
-
-     union content, or enumeration content. If an identifier is provided,<sup><a href="#note112"><b>112)</b></a></sup> the type specifier
-     also declares the identifier to be the tag of that type.
-7    A declaration of the form
-              struct-or-union identifier ;
-     specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note113"><b>113)</b></a></sup>
-8    If a type specifier of the form
-              struct-or-union identifier
-     occurs other than as part of one of the above forms, and no other declaration of the
-     identifier as a tag is visible, then it declares an incomplete structure or union type, and
-     declares the identifier as the tag of that type.113)
-9    If a type specifier of the form
-              struct-or-union identifier
-     or
-              enum identifier
-     occurs other than as part of one of the above forms, and a declaration of the identifier as a
-     tag is visible, then it specifies the same type as that other declaration, and does not
-     redeclare the tag.
-10   EXAMPLE 1       This mechanism allows declaration of a self-referential structure.
-              struct tnode {
-                    int count;
-                    struct tnode *left, *right;
-              };
-     specifies a structure that contains an integer and two pointers to objects of the same type. Once this
-     declaration has been given, the declaration
-              struct tnode s, *sp;
-     declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
-     these declarations, the expression sp-&gt;left refers to the left struct tnode pointer of the object to
-     which sp points; the expression s.right-&gt;count designates the count member of the right struct
-     tnode pointed to from s.
-11   The following alternative formulation uses the typedef mechanism:
-
-
-
-
-     <sup><a name="note112" href="#note112"><b>112)</b></a></sup> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
-          of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
-          can make use of that typedef name to declare objects having the specified structure, union, or
-          enumerated type.
-     <sup><a name="note113" href="#note113"><b>113)</b></a></sup> A similar construction with enum does not exist.
-
-[<a name="p107" href="#p107">page 107</a>] (<a href="#Contents">Contents</a>)
-
-              typedef struct tnode TNODE;
-              struct tnode {
-                    int count;
-                    TNODE *left, *right;
-              };
-              TNODE s, *sp;
-
-12   EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
-     structures, the declarations
-              struct s1 { struct s2 *s2p; /* ... */ }; // D1
-              struct s2 { struct s1 *s1p; /* ... */ }; // D2
-     specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
-     declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
-     D2. To eliminate this context sensitivity, the declaration
-              struct s2;
-     may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
-     completes the specification of the new type.
-
-     Forward references: declarators (<a href="#6.7.5">6.7.5</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>), type definitions
-     (<a href="#6.7.7">6.7.7</a>).
-<a name="6.7.3" href="#6.7.3"><b>     6.7.3 Type qualifiers</b></a>
-<b>     Syntax</b>
-1             type-qualifier:
-                     const
-                     restrict
-                     volatile
-<b>     Constraints</b>
-2    Types other than pointer types derived from object or incomplete types shall not be
-     restrict-qualified.
-<b>     Semantics</b>
-3    The properties associated with qualified types are meaningful only for expressions that
-     are lvalues.<sup><a href="#note114"><b>114)</b></a></sup>
-4    If the same qualifier appears more than once in the same specifier-qualifier-list, either
-     directly or via one or more typedefs, the behavior is the same as if it appeared only
-     once.
-
-
-
-
-     <sup><a name="note114" href="#note114"><b>114)</b></a></sup> The implementation may place a const object that is not volatile in a read-only region of
-          storage. Moreover, the implementation need not allocate storage for such an object if its address is
-          never used.
-
-[<a name="p108" href="#p108">page 108</a>] (<a href="#Contents">Contents</a>)
-
-5    If an attempt is made to modify an object defined with a const-qualified type through use
-     of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
-     made to refer to an object defined with a volatile-qualified type through use of an lvalue
-     with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note115"><b>115)</b></a></sup>
-6    An object that has volatile-qualified type may be modified in ways unknown to the
-     implementation or have other unknown side effects. Therefore any expression referring
-     to such an object shall be evaluated strictly according to the rules of the abstract machine,
-     as described in <a href="#5.1.2.3">5.1.2.3</a>. Furthermore, at every sequence point the value last stored in the
-     object shall agree with that prescribed by the abstract machine, except as modified by the
-     unknown factors mentioned previously.<sup><a href="#note116"><b>116)</b></a></sup> What constitutes an access to an object that
-     has volatile-qualified type is implementation-defined.
-7    An object that is accessed through a restrict-qualified pointer has a special association
-     with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
-     that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note117"><b>117)</b></a></sup> The intended
-     use of the restrict qualifier (like the register storage class) is to promote
-     optimization, and deleting all instances of the qualifier from all preprocessing translation
-     units composing a conforming program does not change its meaning (i.e., observable
-     behavior).
-8    If the specification of an array type includes any type qualifiers, the element type is so-
-     qualified, not the array type. If the specification of a function type includes any type
-     qualifiers, the behavior is undefined.<sup><a href="#note118"><b>118)</b></a></sup>
-9    For two qualified types to be compatible, both shall have the identically qualified version
-     of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
-     does not affect the specified type.
-10   EXAMPLE 1       An object declared
-              extern const volatile int real_time_clock;
-     may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
-
-
-
-
-     <sup><a name="note115" href="#note115"><b>115)</b></a></sup> This applies to those objects that behave as if they were defined with qualified types, even if they are
-          never actually defined as objects in the program (such as an object at a memory-mapped input/output
-          address).
-     <sup><a name="note116" href="#note116"><b>116)</b></a></sup> A volatile declaration may be used to describe an object corresponding to a memory-mapped
-          input/output port or an object accessed by an asynchronously interrupting function. Actions on
-          objects so declared shall not be ''optimized out'' by an implementation or reordered except as
-          permitted by the rules for evaluating expressions.
-     <sup><a name="note117" href="#note117"><b>117)</b></a></sup> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
-          association between the allocated object and the pointer.
-     <sup><a name="note118" href="#note118"><b>118)</b></a></sup> Both of these can occur through the use of typedefs.
-
-[<a name="p109" href="#p109">page 109</a>] (<a href="#Contents">Contents</a>)
-
-11   EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
-     modify an aggregate type:
-             const struct s { int mem; } cs = { 1 };
-             struct s ncs; // the object ncs is modifiable
-             typedef int A[2][3];
-             const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
-             int *pi;
-             const int *pci;
-             ncs = cs;             //   valid
-             cs = ncs;             //   violates modifiable lvalue constraint for =
-             pi = &amp;ncs.mem;        //   valid
-             pi = &amp;cs.mem;         //   violates type constraints for =
-             pci = &amp;cs.mem;        //   valid
-             pi = a[0];            //   invalid: a[0] has type ''const int *''
-
-<a name="6.7.3.1" href="#6.7.3.1"><b>     6.7.3.1 Formal definition of restrict</b></a>
-1    Let D be a declaration of an ordinary identifier that provides a means of designating an
-     object P as a restrict-qualified pointer to type T.
-2    If D appears inside a block and does not have storage class extern, let B denote the
-     block. If D appears in the list of parameter declarations of a function definition, let B
-     denote the associated block. Otherwise, let B denote the block of main (or the block of
-     whatever function is called at program startup in a freestanding environment).
-3    In what follows, a pointer expression E is said to be based on object P if (at some
-     sequence point in the execution of B prior to the evaluation of E) modifying P to point to
-     a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note119"><b>119)</b></a></sup>
-     Note that ''based'' is defined only for expressions with pointer types.
-4    During each execution of B, let L be any lvalue that has &amp;L based on P. If L is used to
-     access the value of the object X that it designates, and X is also modified (by any means),
-     then the following requirements apply: T shall not be const-qualified. Every other lvalue
-     used to access the value of X shall also have its address based on P. Every access that
-     modifies X shall be considered also to modify P, for the purposes of this subclause. If P
-     is assigned the value of a pointer expression E that is based on another restricted pointer
-     object P2, associated with block B2, then either the execution of B2 shall begin before
-     the execution of B, or the execution of B2 shall end prior to the assignment. If these
-     requirements are not met, then the behavior is undefined.
-5    Here an execution of B means that portion of the execution of the program that would
-     correspond to the lifetime of an object with scalar type and automatic storage duration
-
-     <sup><a name="note119" href="#note119"><b>119)</b></a></sup> In other words, E depends on the value of P itself rather than on the value of an object referenced
-          indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
-          expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
-          expressions *p and p[1] are not.
-
-[<a name="p110" href="#p110">page 110</a>] (<a href="#Contents">Contents</a>)
-
-     associated with B.
-6    A translator is free to ignore any or all aliasing implications of uses of restrict.
-7    EXAMPLE 1       The file scope declarations
-              int * restrict a;
-              int * restrict b;
-              extern int c[];
-     assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
-     program, then it is never accessed using either of the other two.
-
-8    EXAMPLE 2 The function parameter declarations in the following example
-             void f(int n, int * restrict p, int * restrict q)
-             {
-                   while (n-- &gt; 0)
-                         *p++ = *q++;
-             }
-     assert that, during each execution of the function, if an object is accessed through one of the pointer
-     parameters, then it is not also accessed through the other.
-9    The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
-     analysis of function f without examining any of the calls of f in the program. The cost is that the
-     programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
-     second call of f in g has undefined behavior because each of d[1] through d[49] is accessed through
-     both p and q.
-             void g(void)
-             {
-                   extern int d[100];
-                   f(50, d + 50, d); // valid
-                   f(50, d + 1, d); // undefined behavior
-             }
-
-10   EXAMPLE 3       The function parameter declarations
-             void h(int n, int * restrict p, int * restrict q, int * restrict r)
-             {
-                   int i;
-                   for (i = 0; i &lt; n; i++)
-                          p[i] = q[i] + r[i];
-             }
-     illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
-     are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
-     modified within function h.
-
-11   EXAMPLE 4 The rule limiting assignments between restricted pointers does not distinguish between a
-     function call and an equivalent nested block. With one exception, only ''outer-to-inner'' assignments
-     between restricted pointers declared in nested blocks have defined behavior.
-
-[<a name="p111" href="#p111">page 111</a>] (<a href="#Contents">Contents</a>)
-
-              {
-                       int * restrict p1;
-                       int * restrict q1;
-                       p1 = q1; // undefined behavior
-                       {
-                             int * restrict p2 = p1; // valid
-                             int * restrict q2 = q1; // valid
-                             p1 = q2;                // undefined behavior
-                             p2 = q2;                // undefined behavior
-                       }
-              }
-12   The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
-     precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
-     example, this permits new_vector to return a vector.
-              typedef struct { int n; float * restrict v; } vector;
-              vector new_vector(int n)
-              {
-                    vector t;
-                    t.n = n;
-                    t.v = malloc(n * sizeof (float));
-                    return t;
-              }
-
-<a name="6.7.4" href="#6.7.4"><b>     6.7.4 Function specifiers</b></a>
-<b>     Syntax</b>
-1             function-specifier:
-                     inline
-<b>     Constraints</b>
-2    Function specifiers shall be used only in the declaration of an identifier for a function.
-3    An inline definition of a function with external linkage shall not contain a definition of a
-     modifiable object with static storage duration, and shall not contain a reference to an
-     identifier with internal linkage.
-4    In a hosted environment, the inline function specifier shall not appear in a declaration
-     of main.
-<b>     Semantics</b>
-5    A function declared with an inline function specifier is an inline function. The
-     function specifier may appear more than once; the behavior is the same as if it appeared
-     only once. Making a function an inline function suggests that calls to the function be as
-     fast as possible.<sup><a href="#note120"><b>120)</b></a></sup> The extent to which such suggestions are effective is
-     implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
-6    Any function with internal linkage can be an inline function. For a function with external
-     linkage, the following restrictions apply: If a function is declared with an inline
-
-[<a name="p112" href="#p112">page 112</a>] (<a href="#Contents">Contents</a>)
-
-    function specifier, then it shall also be defined in the same translation unit. If all of the
-    file scope declarations for a function in a translation unit include the inline function
-    specifier without extern, then the definition in that translation unit is an inline
-    definition. An inline definition does not provide an external definition for the function,
-    and does not forbid an external definition in another translation unit. An inline definition
-    provides an alternative to an external definition, which a translator may use to implement
-    any call to the function in the same translation unit. It is unspecified whether a call to the
-    function uses the inline definition or the external definition.<sup><a href="#note122"><b>122)</b></a></sup>
-7   EXAMPLE The declaration of an inline function with external linkage can result in either an external
-    definition, or a definition available for use only within the translation unit. A file scope declaration with
-    extern creates an external definition. The following example shows an entire translation unit.
-             inline double fahr(double t)
-             {
-                   return (9.0 * t) / 5.0 + 32.0;
-             }
-             inline double cels(double t)
-             {
-                   return (5.0 * (t - 32.0)) / 9.0;
-             }
-             extern double fahr(double);                  // creates an external definition
-             double convert(int is_fahr, double temp)
-             {
-                   /* A translator may perform inline substitutions */
-                   return is_fahr ? cels(temp) : fahr(temp);
-             }
-8   Note that the definition of fahr is an external definition because fahr is also declared with extern, but
-    the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
-    external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
-    definition are distinct and either may be used for the call.
-
-    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
-
-
-    <sup><a name="note120" href="#note120"><b>120)</b></a></sup> By using, for example, an alternative to the usual function call mechanism, such as ''inline
-         substitution''. Inline substitution is not textual substitution, nor does it create a new function.
-         Therefore, for example, the expansion of a macro used within the body of the function uses the
-         definition it had at the point the function body appears, and not where the function is called; and
-         identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
-         single address, regardless of the number of inline definitions that occur in addition to the external
-         definition.
-    <sup><a name="note121" href="#note121"><b>121)</b></a></sup> For example, an implementation might never perform inline substitution, or might only perform inline
-         substitutions to calls in the scope of an inline declaration.
-    <sup><a name="note122" href="#note122"><b>122)</b></a></sup> Since an inline definition is distinct from the corresponding external definition and from any other
-         corresponding inline definitions in other translation units, all corresponding objects with static storage
-         duration are also distinct in each of the definitions.
-
-[<a name="p113" href="#p113">page 113</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.5" href="#6.7.5"><b>    6.7.5 Declarators</b></a>
-<b>    Syntax</b>
-1            declarator:
-                    pointeropt direct-declarator
-             direct-declarator:
-                     identifier
-                     ( declarator )
-                     direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
-                     direct-declarator [ static type-qualifier-listopt assignment-expression ]
-                     direct-declarator [ type-qualifier-list static assignment-expression ]
-                     direct-declarator [ type-qualifier-listopt * ]
-                     direct-declarator ( parameter-type-list )
-                     direct-declarator ( identifier-listopt )
-             pointer:
-                    * type-qualifier-listopt
-                    * type-qualifier-listopt pointer
-             type-qualifier-list:
-                    type-qualifier
-                    type-qualifier-list type-qualifier
-             parameter-type-list:
-                   parameter-list
-                   parameter-list , ...
-             parameter-list:
-                   parameter-declaration
-                   parameter-list , parameter-declaration
-             parameter-declaration:
-                   declaration-specifiers declarator
-                   declaration-specifiers abstract-declaratoropt
-             identifier-list:
-                     identifier
-                     identifier-list , identifier
-<b>    Semantics</b>
-2   Each declarator declares one identifier, and asserts that when an operand of the same
-    form as the declarator appears in an expression, it designates a function or object with the
-    scope, storage duration, and type indicated by the declaration specifiers.
-3   A full declarator is a declarator that is not part of another declarator. The end of a full
-    declarator is a sequence point. If, in the nested sequence of declarators in a full
-
-[<a name="p114" href="#p114">page 114</a>] (<a href="#Contents">Contents</a>)
-
-    declarator, there is a declarator specifying a variable length array type, the type specified
-    by the full declarator is said to be variably modified. Furthermore, any type derived by
-    declarator type derivation from a variably modified type is itself variably modified.
-4   In the following subclauses, consider a declaration
-            T D1
-    where T contains the declaration specifiers that specify a type T (such as int) and D1 is
-    a declarator that contains an identifier ident. The type specified for the identifier ident in
-    the various forms of declarator is described inductively using this notation.
-5   If, in the declaration ''T D1'', D1 has the form
-            identifier
-    then the type specified for ident is T .
-6   If, in the declaration ''T D1'', D1 has the form
-            ( D )
-    then ident has the type specified by the declaration ''T D''. Thus, a declarator in
-    parentheses is identical to the unparenthesized declarator, but the binding of complicated
-    declarators may be altered by parentheses.
-    Implementation limits
-7   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
-    function declarators that modify an arithmetic, structure, union, or incomplete type, either
-    directly or via one or more typedefs.
-    Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), type definitions (<a href="#6.7.7">6.7.7</a>).
-<a name="6.7.5.1" href="#6.7.5.1"><b>    6.7.5.1 Pointer declarators</b></a>
-<b>    Semantics</b>
-1   If, in the declaration ''T D1'', D1 has the form
-            * type-qualifier-listopt D
-    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
-    T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
-    pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
-2   For two pointer types to be compatible, both shall be identically qualified and both shall
-    be pointers to compatible types.
-3   EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
-    to a constant value'' and a ''constant pointer to a variable value''.
-
-[<a name="p115" href="#p115">page 115</a>] (<a href="#Contents">Contents</a>)
-
-             const int *ptr_to_constant;
-             int *const constant_ptr;
-    The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
-    but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
-    int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
-    same location.
-4   The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
-    type ''pointer to int''.
-             typedef int *int_ptr;
-             const int_ptr constant_ptr;
-    declares constant_ptr as an object that has type ''const-qualified pointer to int''.
-
-<a name="6.7.5.2" href="#6.7.5.2"><b>    6.7.5.2 Array declarators</b></a>
-<b>    Constraints</b>
-1   In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
-    an expression or *. If they delimit an expression (which specifies the size of an array), the
-    expression shall have an integer type. If the expression is a constant expression, it shall
-    have a value greater than zero. The element type shall not be an incomplete or function
-    type. The optional type qualifiers and the keyword static shall appear only in a
-    declaration of a function parameter with an array type, and then only in the outermost
-    array type derivation.
-2   An ordinary identifier (as defined in <a href="#6.2.3">6.2.3</a>) that has a variably modified type shall have
-    either block scope and no linkage or function prototype scope. If an identifier is declared
-    to be an object with static storage duration, it shall not have a variable length array type.
-<b>    Semantics</b>
-3   If, in the declaration ''T D1'', D1 has one of the forms:
-             D[ type-qualifier-listopt assignment-expressionopt ]
-             D[ static type-qualifier-listopt assignment-expression ]
-             D[ type-qualifier-list static assignment-expression ]
-             D[ type-qualifier-listopt * ]
-    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
-    T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note123"><b>123)</b></a></sup>
-    (See <a href="#6.7.5.3">6.7.5.3</a> for the meaning of the optional type qualifiers and the keyword static.)
-4   If the size is not present, the array type is an incomplete type. If the size is * instead of
-    being an expression, the array type is a variable length array type of unspecified size,
-    which can only be used in declarations with function prototype scope;<sup><a href="#note124"><b>124)</b></a></sup> such arrays are
-    nonetheless complete types. If the size is an integer constant expression and the element
-
-    <sup><a name="note123" href="#note123"><b>123)</b></a></sup> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
-
-[<a name="p116" href="#p116">page 116</a>] (<a href="#Contents">Contents</a>)
-
-    type has a known constant size, the array type is not a variable length array type;
-    otherwise, the array type is a variable length array type.
-5   If the size is an expression that is not an integer constant expression: if it occurs in a
-    declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
-    each time it is evaluated it shall have a value greater than zero. The size of each instance
-    of a variable length array type does not change during its lifetime. Where a size
-    expression is part of the operand of a sizeof operator and changing the value of the
-    size expression would not affect the result of the operator, it is unspecified whether or not
-    the size expression is evaluated.
-6   For two array types to be compatible, both shall have compatible element types, and if
-    both size specifiers are present, and are integer constant expressions, then both size
-    specifiers shall have the same constant value. If the two array types are used in a context
-    which requires them to be compatible, it is undefined behavior if the two size specifiers
-    evaluate to unequal values.
-7   EXAMPLE 1
-             float fa[11], *afp[17];
-    declares an array of float numbers and an array of pointers to float numbers.
-
-8   EXAMPLE 2       Note the distinction between the declarations
-             extern int *x;
-             extern int y[];
-    The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
-    (an incomplete type), the storage for which is defined elsewhere.
-
-9   EXAMPLE 3       The following declarations demonstrate the compatibility rules for variably modified types.
-             extern int n;
-             extern int m;
-             void fcompat(void)
-             {
-                   int a[n][6][m];
-                   int (*p)[4][n+1];
-                   int c[n][n][6][m];
-                   int (*r)[n][n][n+1];
-                   p = a;      // invalid: not compatible because 4 != 6
-                   r = c;      // compatible, but defined behavior only if
-                               // n == 6 and m == n+1
-             }
-
-
-
-
-    <sup><a name="note124" href="#note124"><b>124)</b></a></sup> Thus, * can be used only in function declarations that are not definitions (see <a href="#6.7.5.3">6.7.5.3</a>).
-
-[<a name="p117" href="#p117">page 117</a>] (<a href="#Contents">Contents</a>)
-
-10   EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
-     function prototype scope. Array objects declared with the static or extern storage-class specifier
-     cannot have a variable length array (VLA) type. However, an object declared with the static storage-
-     class specifier can have a VM type (that is, a pointer to a VLA type). Finally, all identifiers declared with a
-     VM type have to be ordinary identifiers and cannot, therefore, be members of structures or unions.
-              extern int n;
-              int A[n];                                             // invalid: file scope VLA
-              extern int (*p2)[n];                                  // invalid: file scope VM
-              int B[100];                                           // valid: file scope but not VM
-              void fvla(int m, int C[m][m]);                        // valid: VLA with prototype scope
-              void fvla(int m, int C[m][m])                         // valid: adjusted to auto pointer to VLA
-              {
-                    typedef int VLA[m][m];                          // valid: block scope typedef VLA
-                       struct tag {
-                             int (*y)[n];                           // invalid: y not ordinary identifier
-                             int z[n];                              // invalid: z not ordinary identifier
-                       };
-                       int D[m];                                    //   valid: auto VLA
-                       static int E[m];                             //   invalid: static block scope VLA
-                       extern int F[m];                             //   invalid: F has linkage and is VLA
-                       int (*s)[m];                                 //   valid: auto pointer to VLA
-                       extern int (*r)[m];                          //   invalid: r has linkage and points to VLA
-                       static int (*q)[m] = &amp;B;                     //   valid: q is a static block pointer to VLA
-              }
-
-     Forward references:            function declarators (<a href="#6.7.5.3">6.7.5.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
-     initialization (<a href="#6.7.8">6.7.8</a>).
-<a name="6.7.5.3" href="#6.7.5.3"><b>     6.7.5.3 Function declarators (including prototypes)</b></a>
-<b>     Constraints</b>
-1    A function declarator shall not specify a return type that is a function type or an array
-     type.
-2    The only storage-class specifier that shall occur in a parameter declaration is register.
-3    An identifier list in a function declarator that is not part of a definition of that function
-     shall be empty.
-4    After adjustment, the parameters in a parameter type list in a function declarator that is
-     part of a definition of that function shall not have incomplete type.
-<b>     Semantics</b>
-5    If, in the declaration ''T D1'', D1 has the form
-              D( parameter-type-list )
-     or
-              D( identifier-listopt )
-
-[<a name="p118" href="#p118">page 118</a>] (<a href="#Contents">Contents</a>)
-
-     and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
-     T '', then the type specified for ident is ''derived-declarator-type-list function returning
-     T ''.
-6    A parameter type list specifies the types of, and may declare identifiers for, the
-     parameters of the function.
-7    A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
-     type'', where the type qualifiers (if any) are those specified within the [ and ] of the
-     array type derivation. If the keyword static also appears within the [ and ] of the
-     array type derivation, then for each call to the function, the value of the corresponding
-     actual argument shall provide access to the first element of an array with at least as many
-     elements as specified by the size expression.
-8    A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
-     function returning type'', as in <a href="#6.3.2.1">6.3.2.1</a>.
-9    If the list terminates with an ellipsis (, ...), no information about the number or types
-     of the parameters after the comma is supplied.<sup><a href="#note125"><b>125)</b></a></sup>
-10   The special case of an unnamed parameter of type void as the only item in the list
-     specifies that the function has no parameters.
-11   If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
-     parameter name, it shall be taken as a typedef name.
-12   If the function declarator is not part of a definition of that function, parameters may have
-     incomplete type and may use the [*] notation in their sequences of declarator specifiers
-     to specify variable length array types.
-13   The storage-class specifier in the declaration specifiers for a parameter declaration, if
-     present, is ignored unless the declared parameter is one of the members of the parameter
-     type list for a function definition.
-14   An identifier list declares only the identifiers of the parameters of the function. An empty
-     list in a function declarator that is part of a definition of that function specifies that the
-     function has no parameters. The empty list in a function declarator that is not part of a
-     definition of that function specifies that no information about the number or types of the
-     parameters is supplied.<sup><a href="#note126"><b>126)</b></a></sup>
-15   For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note127"><b>127)</b></a></sup>
-
-
-     <sup><a name="note125" href="#note125"><b>125)</b></a></sup> The macros defined in the <a href="#7.15">&lt;stdarg.h&gt;</a> header (<a href="#7.15">7.15</a>) may be used to access arguments that
-          correspond to the ellipsis.
-     <sup><a name="note126" href="#note126"><b>126)</b></a></sup> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
-     <sup><a name="note127" href="#note127"><b>127)</b></a></sup> If both function types are ''old style'', parameter types are not compared.
-
-[<a name="p119" href="#p119">page 119</a>] (<a href="#Contents">Contents</a>)
-
-     Moreover, the parameter type lists, if both are present, shall agree in the number of
-     parameters and in use of the ellipsis terminator; corresponding parameters shall have
-     compatible types. If one type has a parameter type list and the other type is specified by a
-     function declarator that is not part of a function definition and that contains an empty
-     identifier list, the parameter list shall not have an ellipsis terminator and the type of each
-     parameter shall be compatible with the type that results from the application of the
-     default argument promotions. If one type has a parameter type list and the other type is
-     specified by a function definition that contains a (possibly empty) identifier list, both shall
-     agree in the number of parameters, and the type of each prototype parameter shall be
-     compatible with the type that results from the application of the default argument
-     promotions to the type of the corresponding identifier. (In the determination of type
-     compatibility and of a composite type, each parameter declared with function or array
-     type is taken as having the adjusted type and each parameter declared with qualified type
-     is taken as having the unqualified version of its declared type.)
-16   EXAMPLE 1       The declaration
-              int f(void), *fip(), (*pfi)();
-     declares a function f with no parameters returning an int, a function fip with no parameter specification
-     returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
-     int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
-     declaration suggests, and the same construction in an expression requires, the calling of a function fip,
-     and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
-     extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
-     designator, which is then used to call the function; it returns an int.
-17   If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
-     declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
-     internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
-     the identifier of the pointer pfi has block scope and no linkage.
-
-18   EXAMPLE 2       The declaration
-              int (*apfi[3])(int *x, int *y);
-     declares an array apfi of three pointers to functions returning int. Each of these functions has two
-     parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
-     go out of scope at the end of the declaration of apfi.
-
-19   EXAMPLE 3       The declaration
-              int (*fpfi(int (*)(long), int))(int, ...);
-     declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
-     parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
-     The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
-     additional arguments of any type.
-
-[<a name="p120" href="#p120">page 120</a>] (<a href="#Contents">Contents</a>)
-
-20   EXAMPLE 4        The following prototype has a variably modified parameter.
-               void addscalar(int n, int m,
-                     double a[n][n*m+300], double x);
-               int main()
-               {
-                     double b[4][308];
-                     addscalar(4, 2, b, <a href="#2.17">2.17</a>);
-                     return 0;
-               }
-               void addscalar(int n, int m,
-                     double a[n][n*m+300], double x)
-               {
-                     for (int i = 0; i &lt; n; i++)
-                           for (int j = 0, k = n*m+300; j &lt; k; j++)
-                                 // a is a pointer to a VLA with n*m+300 elements
-                                 a[i][j] += x;
-               }
-
-21   EXAMPLE 5        The following are all compatible function prototype declarators.
-               double    maximum(int       n,   int   m,   double   a[n][m]);
-               double    maximum(int       n,   int   m,   double   a[*][*]);
-               double    maximum(int       n,   int   m,   double   a[ ][*]);
-               double    maximum(int       n,   int   m,   double   a[ ][m]);
-     as are:
-               void   f(double     (* restrict a)[5]);
-               void   f(double     a[restrict][5]);
-               void   f(double     a[restrict 3][5]);
-               void   f(double     a[restrict static 3][5]);
-     (Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
-     non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
-
-     Forward references: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.6">6.7.6</a>).
-
-[<a name="p121" href="#p121">page 121</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.6" href="#6.7.6"><b>    6.7.6 Type names</b></a>
-<b>    Syntax</b>
-1            type-name:
-                    specifier-qualifier-list abstract-declaratoropt
-             abstract-declarator:
-                    pointer
-                    pointeropt direct-abstract-declarator
-             direct-abstract-declarator:
-                     ( abstract-declarator )
-                     direct-abstract-declaratoropt [ type-qualifier-listopt
-                                    assignment-expressionopt ]
-                     direct-abstract-declaratoropt [ static type-qualifier-listopt
-                                    assignment-expression ]
-                     direct-abstract-declaratoropt [ type-qualifier-list static
-                                    assignment-expression ]
-                     direct-abstract-declaratoropt [ * ]
-                     direct-abstract-declaratoropt ( parameter-type-listopt )
-<b>    Semantics</b>
-2   In several contexts, it is necessary to specify a type. This is accomplished using a type
-    name, which is syntactically a declaration for a function or an object of that type that
-    omits the identifier.<sup><a href="#note128"><b>128)</b></a></sup>
-3   EXAMPLE        The constructions
-             (a)      int
-             (b)      int   *
-             (c)      int   *[3]
-             (d)      int   (*)[3]
-             (e)      int   (*)[*]
-             (f)      int   *()
-             (g)      int   (*)(void)
-             (h)      int   (*const [])(unsigned int, ...)
-    name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
-    array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
-    with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
-    returning an int, and (h) array of an unspecified number of constant pointers to functions, each with one
-    parameter that has type unsigned int and an unspecified number of other parameters, returning an
-    int.
-
-
-
-
-    <sup><a name="note128" href="#note128"><b>128)</b></a></sup> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
-         parameter specification'', rather than redundant parentheses around the omitted identifier.
-
-[<a name="p122" href="#p122">page 122</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.7" href="#6.7.7"><b>    6.7.7 Type definitions</b></a>
-<b>    Syntax</b>
-1            typedef-name:
-                    identifier
-<b>    Constraints</b>
-2   If a typedef name specifies a variably modified type then it shall have block scope.
-<b>    Semantics</b>
-3   In a declaration whose storage-class specifier is typedef, each declarator defines an
-    identifier to be a typedef name that denotes the type specified for the identifier in the way
-    described in <a href="#6.7.5">6.7.5</a>. Any array size expressions associated with variable length array
-    declarators are evaluated each time the declaration of the typedef name is reached in the
-    order of execution. A typedef declaration does not introduce a new type, only a
-    synonym for the type so specified. That is, in the following declarations:
-             typedef T type_ident;
-             type_ident D;
-    type_ident is defined as a typedef name with the type specified by the declaration
-    specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
-    type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
-    typedef name shares the same name space as other identifiers declared in ordinary
-    declarators.
-4   EXAMPLE 1       After
-             typedef int MILES, KLICKSP();
-             typedef struct { double hi, lo; } range;
-    the constructions
-             MILES distance;
-             extern KLICKSP *metricp;
-             range x;
-             range z, *zp;
-    are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
-    parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
-    such a structure. The object distance has a type compatible with any other int object.
-
-5   EXAMPLE 2       After the declarations
-             typedef struct s1 { int x; } t1, *tp1;
-             typedef struct s2 { int x; } t2, *tp2;
-    type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
-    s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
-
-[<a name="p123" href="#p123">page 123</a>] (<a href="#Contents">Contents</a>)
-
-6   EXAMPLE 3       The following obscure constructions
-            typedef signed int t;
-            typedef int plain;
-            struct tag {
-                  unsigned t:4;
-                  const t:5;
-                  plain r:5;
-            };
-    declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
-    with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
-    qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
-    [-16, +15], and one named r that contains values in one of the ranges [0, 31], [-15, +15], or [-16, +15].
-    (The choice of range is implementation-defined.) The first two bit-field declarations differ in that
-    unsigned is a type specifier (which forces t to be the name of a structure member), while const is a
-    type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed
-    in an inner scope by
-            t f(t (t));
-            long t;
-    then a function f is declared with type ''function returning signed int with one unnamed parameter
-    with type pointer to function returning signed int with one unnamed parameter with type signed
-    int'', and an identifier t with type long int.
-
-7   EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
-    following declarations of the signal function specify exactly the same type, the first without making use
-    of any typedef names.
-            typedef void fv(int), (*pfv)(int);
-            void (*signal(int, void (*)(int)))(int);
-            fv *signal(int, fv *);
-            pfv signal(int, pfv);
-
-8   EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
-    time the typedef name is defined, not each time it is used:
-            void copyt(int n)
-            {
-                  typedef int B[n];    //               B is n ints, n evaluated now
-                  n += 1;
-                  B a;                //                a is n ints, n without += 1
-                  int b[n];           //                a and b are different sizes
-                  for (int i = 1; i &lt; n;                i++)
-                        a[i-1] = b[i];
-            }
-
-[<a name="p124" href="#p124">page 124</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.8" href="#6.7.8"><b>    6.7.8 Initialization</b></a>
-<b>    Syntax</b>
-1            initializer:
-                      assignment-expression
-                      { initializer-list }
-                      { initializer-list , }
-             initializer-list:
-                      designationopt initializer
-                      initializer-list , designationopt initializer
-             designation:
-                    designator-list =
-             designator-list:
-                    designator
-                    designator-list designator
-             designator:
-                    [ constant-expression ]
-                    . identifier
-<b>    Constraints</b>
-2   No initializer shall attempt to provide a value for an object not contained within the entity
-    being initialized.
-3   The type of the entity to be initialized shall be an array of unknown size or an object type
-    that is not a variable length array type.
-4   All the expressions in an initializer for an object that has static storage duration shall be
-    constant expressions or string literals.
-5   If the declaration of an identifier has block scope, and the identifier has external or
-    internal linkage, the declaration shall have no initializer for the identifier.
-6   If a designator has the form
-             [ constant-expression ]
-    then the current object (defined below) shall have array type and the expression shall be
-    an integer constant expression. If the array is of unknown size, any nonnegative value is
-    valid.
-7   If a designator has the form
-             . identifier
-    then the current object (defined below) shall have structure or union type and the
-    identifier shall be the name of a member of that type.
-
-[<a name="p125" href="#p125">page 125</a>] (<a href="#Contents">Contents</a>)
-
-<b>     Semantics</b>
-8    An initializer specifies the initial value stored in an object.
-9    Except where explicitly stated otherwise, for the purposes of this subclause unnamed
-     members of objects of structure and union type do not participate in initialization.
-     Unnamed members of structure objects have indeterminate value even after initialization.
-10   If an object that has automatic storage duration is not initialized explicitly, its value is
-     indeterminate. If an object that has static storage duration is not initialized explicitly,
-     then:
-     -- if it has pointer type, it is initialized to a null pointer;
-     -- if it has arithmetic type, it is initialized to (positive or unsigned) zero;
-     -- if it is an aggregate, every member is initialized (recursively) according to these rules;
-     -- if it is a union, the first named member is initialized (recursively) according to these
-       rules.
-11   The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
-     initial value of the object is that of the expression (after conversion); the same type
-     constraints and conversions as for simple assignment apply, taking the type of the scalar
-     to be the unqualified version of its declared type.
-12   The rest of this subclause deals with initializers for objects that have aggregate or union
-     type.
-13   The initializer for a structure or union object that has automatic storage duration shall be
-     either an initializer list as described below, or a single expression that has compatible
-     structure or union type. In the latter case, the initial value of the object, including
-     unnamed members, is that of the expression.
-14   An array of character type may be initialized by a character string literal, optionally
-     enclosed in braces. Successive characters of the character string literal (including the
-     terminating null character if there is room or if the array is of unknown size) initialize the
-     elements of the array.
-15   An array with element type compatible with wchar_t may be initialized by a wide
-     string literal, optionally enclosed in braces. Successive wide characters of the wide string
-     literal (including the terminating null wide character if there is room or if the array is of
-     unknown size) initialize the elements of the array.
-16   Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
-     enclosed list of initializers for the elements or named members.
-17   Each brace-enclosed initializer list has an associated current object. When no
-     designations are present, subobjects of the current object are initialized in order according
-     to the type of the current object: array elements in increasing subscript order, structure
-
-[<a name="p126" href="#p126">page 126</a>] (<a href="#Contents">Contents</a>)
-
-     members in declaration order, and the first named member of a union.<sup><a href="#note129"><b>129)</b></a></sup> In contrast, a
-     designation causes the following initializer to begin initialization of the subobject
-     described by the designator. Initialization then continues forward in order, beginning
-     with the next subobject after that described by the designator.<sup><a href="#note130"><b>130)</b></a></sup>
-18   Each designator list begins its description with the current object associated with the
-     closest surrounding brace pair. Each item in the designator list (in order) specifies a
-     particular member of its current object and changes the current object for the next
-     designator (if any) to be that member.<sup><a href="#note131"><b>131)</b></a></sup> The current object that results at the end of the
-     designator list is the subobject to be initialized by the following initializer.
-19   The initialization shall occur in initializer list order, each initializer provided for a
-     particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note132"><b>132)</b></a></sup>
-     all subobjects that are not initialized explicitly shall be initialized implicitly the same as
-     objects that have static storage duration.
-20   If the aggregate or union contains elements or members that are aggregates or unions,
-     these rules apply recursively to the subaggregates or contained unions. If the initializer of
-     a subaggregate or contained union begins with a left brace, the initializers enclosed by
-     that brace and its matching right brace initialize the elements or members of the
-     subaggregate or the contained union. Otherwise, only enough initializers from the list are
-     taken to account for the elements or members of the subaggregate or the first member of
-     the contained union; any remaining initializers are left to initialize the next element or
-     member of the aggregate of which the current subaggregate or contained union is a part.
-21   If there are fewer initializers in a brace-enclosed list than there are elements or members
-     of an aggregate, or fewer characters in a string literal used to initialize an array of known
-     size than there are elements in the array, the remainder of the aggregate shall be
-     initialized implicitly the same as objects that have static storage duration.
-22   If an array of unknown size is initialized, its size is determined by the largest indexed
-     element with an explicit initializer. At the end of its initializer list, the array no longer
-     has incomplete type.
-
-
-
-     <sup><a name="note129" href="#note129"><b>129)</b></a></sup> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
-          subobjects are initialized as usual, but the subaggregate or contained union does not become the
-          current object: current objects are associated only with brace-enclosed initializer lists.
-     <sup><a name="note130" href="#note130"><b>130)</b></a></sup> After a union member is initialized, the next object is not the next member of the union; instead, it is
-          the next subobject of an object containing the union.
-     <sup><a name="note131" href="#note131"><b>131)</b></a></sup> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
-          the surrounding brace pair. Note, too, that each separate designator list is independent.
-     <sup><a name="note132" href="#note132"><b>132)</b></a></sup> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
-          not be evaluated at all.
-
-[<a name="p127" href="#p127">page 127</a>] (<a href="#Contents">Contents</a>)
-
-23   The order in which any side effects occur among the initialization list expressions is
-     unspecified.<sup><a href="#note133"><b>133)</b></a></sup>
-24   EXAMPLE 1       Provided that <a href="#7.3">&lt;complex.h&gt;</a> has been #included, the declarations
-              int i = <a href="#3.5">3.5</a>;
-              double complex c = 5 + 3 * I;
-     define and initialize i with the value 3 and c with the value 5.0 + i3.0.
-
-25   EXAMPLE 2 The declaration
-              int x[] = { 1, 3, 5 };
-     defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
-     and there are three initializers.
-
-26   EXAMPLE 3       The declaration
-              int y[4][3] =         {
-                    { 1, 3,         5 },
-                    { 2, 4,         6 },
-                    { 3, 5,         7 },
-              };
-     is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
-     y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
-     y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
-     been achieved by
-              int y[4][3] = {
-                    1, 3, 5, 2, 4, 6, 3, 5, 7
-              };
-     The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
-     next three are taken successively for y[1] and y[2].
-
-27   EXAMPLE 4       The declaration
-              int z[4][3] = {
-                    { 1 }, { 2 }, { 3 }, { 4 }
-              };
-     initializes the first column of z as specified and initializes the rest with zeros.
-
-28   EXAMPLE 5       The declaration
-              struct { int a[3], b; } w[] = { { 1 }, 2 };
-     is a definition with an inconsistently bracketed initialization. It defines an array with two element
-     structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
-
-
-
-
-     <sup><a name="note133" href="#note133"><b>133)</b></a></sup> In particular, the evaluation order need not be the same as the order of subobject initialization.
-
-[<a name="p128" href="#p128">page 128</a>] (<a href="#Contents">Contents</a>)
-
-29   EXAMPLE 6         The declaration
-               short q[4][3][2] = {
-                     { 1 },
-                     { 2, 3 },
-                     { 4, 5, 6 }
-               };
-     contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
-     object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
-     q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
-     q[0][0] does not begin with a left brace, so up to six items from the current list may be used. There is
-     only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers
-     for q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their
-     respective two-dimensional subaggregates. If there had been more than six items in any of the lists, a
-     diagnostic message would have been issued. The same initialization result could have been achieved by:
-               short q[4][3][2] = {
-                     1, 0, 0, 0, 0, 0,
-                     2, 3, 0, 0, 0, 0,
-                     4, 5, 6
-               };
-     or by:
-               short q[4][3][2] = {
-                     {
-                           { 1 },
-                     },
-                     {
-                           { 2, 3 },
-                     },
-                     {
-                           { 4, 5 },
-                           { 6 },
-                     }
-               };
-     in a fully bracketed form.
-30   Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
-     cause confusion.
-
-31   EXAMPLE 7         One form of initialization that completes array types involves typedef names. Given the
-     declaration
-               typedef int A[];          // OK - declared with block scope
-     the declaration
-               A a = { 1, 2 }, b = { 3, 4, 5 };
-     is identical to
-               int a[] = { 1, 2 }, b[] = { 3, 4, 5 };
-     due to the rules for incomplete types.
-
-[<a name="p129" href="#p129">page 129</a>] (<a href="#Contents">Contents</a>)
-
-32   EXAMPLE 8       The declaration
-              char s[] = "abc", t[3] = "abc";
-     defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
-     This declaration is identical to
-              char s[] = { 'a', 'b', 'c', '\0' },
-                   t[] = { 'a', 'b', 'c' };
-     The contents of the arrays are modifiable. On the other hand, the declaration
-              char *p = "abc";
-     defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
-     with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
-     modify the contents of the array, the behavior is undefined.
-
-33   EXAMPLE 9       Arrays can be initialized to correspond to the elements of an enumeration by using
-     designators:
-              enum { member_one,           member_two };
-              const char *nm[] =           {
-                    [member_two]           = "member two",
-                    [member_one]           = "member one",
-              };
-
-34   EXAMPLE 10       Structure members can be initialized to nonzero values without depending on their order:
-              div_t answer = { .quot = 2, .rem = -1 };
-
-35   EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
-     might be misunderstood:
-              struct { int a[3], b; } w[] =
-                    { [0].a = {1}, [1].a[0] = 2 };
-
-36   EXAMPLE 12       Space can be ''allocated'' from both ends of an array by using a single designator:
-              int a[MAX] = {
-                    1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
-              };
-37   In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
-     than ten, some of the values provided by the first five initializers will be overridden by the second five.
-
-38   EXAMPLE 13       Any member of a union can be initialized:
-              union { /* ... */ } u = { .any_member = 42 };
-
-     Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>).
-
-[<a name="p130" href="#p130">page 130</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.8" href="#6.8"><b>    6.8 Statements and blocks</b></a>
-<b>    Syntax</b>
-1            statement:
-                    labeled-statement
-                    compound-statement
-                    expression-statement
-                    selection-statement
-                    iteration-statement
-                    jump-statement
-<b>    Semantics</b>
-2   A statement specifies an action to be performed. Except as indicated, statements are
-    executed in sequence.
-3   A block allows a set of declarations and statements to be grouped into one syntactic unit.
-    The initializers of objects that have automatic storage duration, and the variable length
-    array declarators of ordinary identifiers with block scope, are evaluated and the values are
-    stored in the objects (including storing an indeterminate value in objects without an
-    initializer) each time the declaration is reached in the order of execution, as if it were a
-    statement, and within each declaration in the order that declarators appear.
-4   A full expression is an expression that is not part of another expression or of a declarator.
-    Each of the following is a full expression: an initializer; the expression in an expression
-    statement; the controlling expression of a selection statement (if or switch); the
-    controlling expression of a while or do statement; each of the (optional) expressions of
-    a for statement; the (optional) expression in a return statement. The end of a full
-    expression is a sequence point.
-    Forward references: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
-    (<a href="#6.8.4">6.8.4</a>), iteration statements (<a href="#6.8.5">6.8.5</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>).
-<a name="6.8.1" href="#6.8.1"><b>    6.8.1 Labeled statements</b></a>
-<b>    Syntax</b>
-1            labeled-statement:
-                    identifier : statement
-                    case constant-expression : statement
-                    default : statement
-<b>    Constraints</b>
-2   A case or default label shall appear only in a switch statement. Further
-    constraints on such labels are discussed under the switch statement.
-
-[<a name="p131" href="#p131">page 131</a>] (<a href="#Contents">Contents</a>)
-
-3   Label names shall be unique within a function.
-<b>    Semantics</b>
-4   Any statement may be preceded by a prefix that declares an identifier as a label name.
-    Labels in themselves do not alter the flow of control, which continues unimpeded across
-    them.
-    Forward references: the goto statement (<a href="#6.8.6.1">6.8.6.1</a>), the switch statement (<a href="#6.8.4.2">6.8.4.2</a>).
-<a name="6.8.2" href="#6.8.2"><b>    6.8.2 Compound statement</b></a>
-<b>    Syntax</b>
-1            compound-statement:
-                   { block-item-listopt }
-             block-item-list:
-                     block-item
-                     block-item-list block-item
-             block-item:
-                     declaration
-                     statement
-<b>    Semantics</b>
-2   A compound statement is a block.
-<a name="6.8.3" href="#6.8.3"><b>    6.8.3 Expression and null statements</b></a>
-<b>    Syntax</b>
-1            expression-statement:
-                    expressionopt ;
-<b>    Semantics</b>
-2   The expression in an expression statement is evaluated as a void expression for its side
-    effects.<sup><a href="#note134"><b>134)</b></a></sup>
-3   A null statement (consisting of just a semicolon) performs no operations.
-4   EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
-    discarding of its value may be made explicit by converting the expression to a void expression by means of
-    a cast:
-             int p(int);
-             /* ... */
-             (void)p(0);
-
-
-
-    <sup><a name="note134" href="#note134"><b>134)</b></a></sup> Such as assignments, and function calls which have side effects.
-
-[<a name="p132" href="#p132">page 132</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE 2       In the program fragment
-             char *s;
-             /* ... */
-             while (*s++ != '\0')
-                     ;
-    a null statement is used to supply an empty loop body to the iteration statement.
-
-6   EXAMPLE 3       A null statement may also be used to carry a label just before the closing } of a compound
-    statement.
-             while (loop1) {
-                   /* ... */
-                   while (loop2) {
-                           /* ... */
-                           if (want_out)
-                                   goto end_loop1;
-                           /* ... */
-                   }
-                   /* ... */
-             end_loop1: ;
-             }
-
-    Forward references: iteration statements (<a href="#6.8.5">6.8.5</a>).
-<a name="6.8.4" href="#6.8.4"><b>    6.8.4 Selection statements</b></a>
-<b>    Syntax</b>
-1            selection-statement:
-                     if ( expression ) statement
-                     if ( expression ) statement else statement
-                     switch ( expression ) statement
-<b>    Semantics</b>
-2   A selection statement selects among a set of statements depending on the value of a
-    controlling expression.
-3   A selection statement is a block whose scope is a strict subset of the scope of its
-    enclosing block. Each associated substatement is also a block whose scope is a strict
-    subset of the scope of the selection statement.
-<a name="6.8.4.1" href="#6.8.4.1"><b>    6.8.4.1 The if statement</b></a>
-<b>    Constraints</b>
-1   The controlling expression of an if statement shall have scalar type.
-<b>    Semantics</b>
-2   In both forms, the first substatement is executed if the expression compares unequal to 0.
-    In the else form, the second substatement is executed if the expression compares equal
-
-[<a name="p133" href="#p133">page 133</a>] (<a href="#Contents">Contents</a>)
-
-    to 0. If the first substatement is reached via a label, the second substatement is not
-    executed.
-3   An else is associated with the lexically nearest preceding if that is allowed by the
-    syntax.
-<a name="6.8.4.2" href="#6.8.4.2"><b>    6.8.4.2 The switch statement</b></a>
-<b>    Constraints</b>
-1   The controlling expression of a switch statement shall have integer type.
-2   If a switch statement has an associated case or default label within the scope of an
-    identifier with a variably modified type, the entire switch statement shall be within the
-    scope of that identifier.<sup><a href="#note135"><b>135)</b></a></sup>
-3   The expression of each case label shall be an integer constant expression and no two of
-    the case constant expressions in the same switch statement shall have the same value
-    after conversion. There may be at most one default label in a switch statement.
-    (Any enclosed switch statement may have a default label or case constant
-    expressions with values that duplicate case constant expressions in the enclosing
-    switch statement.)
-<b>    Semantics</b>
-4   A switch statement causes control to jump to, into, or past the statement that is the
-    switch body, depending on the value of a controlling expression, and on the presence of a
-    default label and the values of any case labels on or in the switch body. A case or
-    default label is accessible only within the closest enclosing switch statement.
-5   The integer promotions are performed on the controlling expression. The constant
-    expression in each case label is converted to the promoted type of the controlling
-    expression. If a converted value matches that of the promoted controlling expression,
-    control jumps to the statement following the matched case label. Otherwise, if there is
-    a default label, control jumps to the labeled statement. If no converted case constant
-    expression matches and there is no default label, no part of the switch body is
-    executed.
-    Implementation limits
-6   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
-    switch statement.
-
-
-
-
-    <sup><a name="note135" href="#note135"><b>135)</b></a></sup> That is, the declaration either precedes the switch statement, or it follows the last case or
-         default label associated with the switch that is in the block containing the declaration.
-
-[<a name="p134" href="#p134">page 134</a>] (<a href="#Contents">Contents</a>)
-
-7   EXAMPLE        In the artificial program fragment
-             switch (expr)
-             {
-                   int i = 4;
-                   f(i);
-             case 0:
-                   i = 17;
-                   /* falls through into default code */
-             default:
-                   printf("%d\n", i);
-             }
-    the object whose identifier is i exists with automatic storage duration (within the block) but is never
-    initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
-    access an indeterminate value. Similarly, the call to the function f cannot be reached.
-
-<a name="6.8.5" href="#6.8.5"><b>    6.8.5 Iteration statements</b></a>
-<b>    Syntax</b>
-1            iteration-statement:
-                     while ( expression ) statement
-                     do statement while ( expression ) ;
-                     for ( expressionopt ; expressionopt ; expressionopt ) statement
-                     for ( declaration expressionopt ; expressionopt ) statement
-<b>    Constraints</b>
-2   The controlling expression of an iteration statement shall have scalar type.
-3   The declaration part of a for statement shall only declare identifiers for objects having
-    storage class auto or register.
-<b>    Semantics</b>
-4   An iteration statement causes a statement called the loop body to be executed repeatedly
-    until the controlling expression compares equal to 0. The repetition occurs regardless of
-    whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note136"><b>136)</b></a></sup>
-5   An iteration statement is a block whose scope is a strict subset of the scope of its
-    enclosing block. The loop body is also a block whose scope is a strict subset of the scope
-    of the iteration statement.
-
-
-
-
-    <sup><a name="note136" href="#note136"><b>136)</b></a></sup> Code jumped over is not executed. In particular, the controlling expression of a for or while
-         statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
-
-[<a name="p135" href="#p135">page 135</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.8.5.1" href="#6.8.5.1"><b>    6.8.5.1 The while statement</b></a>
-1   The evaluation of the controlling expression takes place before each execution of the loop
-    body.
-<a name="6.8.5.2" href="#6.8.5.2"><b>    6.8.5.2 The do statement</b></a>
-1   The evaluation of the controlling expression takes place after each execution of the loop
-    body.
-<a name="6.8.5.3" href="#6.8.5.3"><b>    6.8.5.3 The for statement</b></a>
-1   The statement
-             for ( clause-1 ; expression-2 ; expression-3 ) statement
-    behaves as follows: The expression expression-2 is the controlling expression that is
-    evaluated before each execution of the loop body. The expression expression-3 is
-    evaluated as a void expression after each execution of the loop body. If clause-1 is a
-    declaration, the scope of any identifiers it declares is the remainder of the declaration and
-    the entire loop, including the other two expressions; it is reached in the order of execution
-    before the first evaluation of the controlling expression. If clause-1 is an expression, it is
-    evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note137"><b>137)</b></a></sup>
-2   Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a
-    nonzero constant.
-<a name="6.8.6" href="#6.8.6"><b>    6.8.6 Jump statements</b></a>
-<b>    Syntax</b>
-1            jump-statement:
-                    goto identifier ;
-                    continue ;
-                    break ;
-                    return expressionopt ;
-<b>    Semantics</b>
-2   A jump statement causes an unconditional jump to another place.
-
-
-
-
-    <sup><a name="note137" href="#note137"><b>137)</b></a></sup> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
-         the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
-         such that execution of the loop continues until the expression compares equal to 0; and expression-3
-         specifies an operation (such as incrementing) that is performed after each iteration.
-
-[<a name="p136" href="#p136">page 136</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.8.6.1" href="#6.8.6.1"><b>    6.8.6.1 The goto statement</b></a>
-<b>    Constraints</b>
-1   The identifier in a goto statement shall name a label located somewhere in the enclosing
-    function. A goto statement shall not jump from outside the scope of an identifier having
-    a variably modified type to inside the scope of that identifier.
-<b>    Semantics</b>
-2   A goto statement causes an unconditional jump to the statement prefixed by the named
-    label in the enclosing function.
-3   EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
-    following outline presents one possible approach to a problem based on these three assumptions:
-      1.   The general initialization code accesses objects only visible to the current function.
-      2.   The general initialization code is too large to warrant duplication.
-      3.   The code to determine the next operation is at the head of the loop. (To allow it to be reached by
-           continue statements, for example.)
+            fesetround(FE_UPWARD);
             /* ... */
-            goto first_time;
-            for (;;) {
-                    // determine next operation
-                    /* ... */
-                    if (need to reinitialize) {
-                            // reinitialize-only code
-                            /* ... */
-                    first_time:
-                            // general initialization code
-                            /* ... */
-                            continue;
-                    }
-                    // handle other operations
-                    /* ... */
-            }
-
-[<a name="p137" href="#p137">page 137</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
-    modified types. A jump within the scope, however, is permitted.
-            goto lab3;                         // invalid: going INTO scope of VLA.
-            {
-                  double a[n];
-                  a[j] = <a href="#4.4">4.4</a>;
-            lab3:
-                  a[j] = <a href="#3.3">3.3</a>;
-                  goto lab4;                   // valid: going WITHIN scope of VLA.
-                  a[j] = <a href="#5.5">5.5</a>;
-            lab4:
-                  a[j] = <a href="#6.6">6.6</a>;
-            }
-            goto lab4;                         // invalid: going INTO scope of VLA.
-
-<a name="6.8.6.2" href="#6.8.6.2"><b>    6.8.6.2 The continue statement</b></a>
-<b>    Constraints</b>
-1   A continue statement shall appear only in or as a loop body.
-<b>    Semantics</b>
-2   A continue statement causes a jump to the loop-continuation portion of the smallest
-    enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
-    of the statements
-    while (/* ... */) {                  do {                                 for (/* ... */) {
-       /* ... */                            /* ... */                            /* ... */
-       continue;                            continue;                            continue;
-       /* ... */                            /* ... */                            /* ... */
-    contin: ;                            contin: ;                            contin: ;
-    }                                    } while (/* ... */);                 }
-    unless the continue statement shown is in an enclosed iteration statement (in which
-    case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note138"><b>138)</b></a></sup>
-<a name="6.8.6.3" href="#6.8.6.3"><b>    6.8.6.3 The break statement</b></a>
-<b>    Constraints</b>
-1   A break statement shall appear only in or as a switch body or loop body.
-<b>    Semantics</b>
-2   A break statement terminates execution of the smallest enclosing switch or iteration
-    statement.
-
-
-
-    <sup><a name="note138" href="#note138"><b>138)</b></a></sup> Following the contin: label is a null statement.
-
-[<a name="p138" href="#p138">page 138</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.8.6.4" href="#6.8.6.4"><b>    6.8.6.4 The return statement</b></a>
-<b>    Constraints</b>
-1   A return statement with an expression shall not appear in a function whose return type
-    is void. A return statement without an expression shall only appear in a function
-    whose return type is void.
-<b>    Semantics</b>
-2   A return statement terminates execution of the current function and returns control to
-    its caller. A function may have any number of return statements.
-3   If a return statement with an expression is executed, the value of the expression is
-    returned to the caller as the value of the function call expression. If the expression has a
-    type different from the return type of the function in which it appears, the value is
-    converted as if by assignment to an object having the return type of the function.<sup><a href="#note139"><b>139)</b></a></sup>
-4   EXAMPLE       In:
-            struct s { double i; } f(void);
-            union {
+         #endif</pre>
+ 
+
+<p><a name="note3">3)</a> This implies that a conforming implementation reserves no identifiers other than those explicitly
+ reserved in this International Standard.
+
+<p><a name="note4">4)</a> Strictly conforming programs are intended to be maximally portable among conforming
+ implementations. Conforming programs may depend upon nonportable features of a conforming
+ implementation.
+
+
+<a name="5" href="#5"><h2>5. Environment</h2></a>
+<p><!--para 1-->
+ An implementation translates C source files and executes C programs in two data-
+ processing-system environments, which will be called the translation environment and
+ the execution environment in this International Standard. Their characteristics define and
+ constrain the results of executing conforming C programs constructed according to the
+ syntactic and semantic rules for conforming implementations.
+ Forward references: In this clause, only a few of many possible forward references
+ have been noted.
+
+<a name="5.1" href="#5.1"><h3>5.1 Conceptual models</h3></a>
+
+<a name="5.1.1" href="#5.1.1"><h4>5.1.1 Translation environment</h4></a>
+
+<a name="5.1.1.1" href="#5.1.1.1"><h5>5.1.1.1 Program structure</h5></a>
+<p><!--para 1-->
+ A C program need not all be translated at the same time. The text of the program is kept
+ in units called source files, (or preprocessing files) in this International Standard. A
+ source file together with all the headers and source files included via the preprocessing
+ directive #include is known as a preprocessing translation unit. After preprocessing, a
+ preprocessing translation unit is called a translation unit. Previously translated translation
+ units may be preserved individually or in libraries. The separate translation units of a
+ program communicate by (for example) calls to functions whose identifiers have external
+ linkage, manipulation of objects whose identifiers have external linkage, or manipulation
+ of data files. Translation units may be separately translated and then later linked to
+ produce an executable program.
+ Forward references: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
+ preprocessing directives (<a href="#6.10">6.10</a>).
+
+<a name="5.1.1.2" href="#5.1.1.2"><h5>5.1.1.2 Translation phases</h5></a>
+<p><!--para 1-->
+ The precedence among the syntax rules of translation is specified by the following
+ phases.<sup><a href="#note5"><b>5)</b></a></sup>
+<ol>
+<li>  Physical source file multibyte characters are mapped, in an implementation-
+ defined manner, to the source character set (introducing new-line characters for
+ end-of-line indicators) if necessary. Trigraph sequences are replaced by
+ corresponding single-character internal representations.
+ 
+ 
+ 
+<!--page 22 indent 0-->
+<li>  Each instance of a backslash character (\) immediately followed by a new-line
+ character is deleted, splicing physical source lines to form logical source lines.
+ Only the last backslash on any physical source line shall be eligible for being part
+ of such a splice. A source file that is not empty shall end in a new-line character,
+ which shall not be immediately preceded by a backslash character before any such
+ splicing takes place.
+<li>  The source file is decomposed into preprocessing tokens<sup><a href="#note6"><b>6)</b></a></sup> and sequences of
+ white-space characters (including comments). A source file shall not end in a
+ partial preprocessing token or in a partial comment. Each comment is replaced by
+ one space character. New-line characters are retained. Whether each nonempty
+ sequence of white-space characters other than new-line is retained or replaced by
+ one space character is implementation-defined.
+<li>  Preprocessing directives are executed, macro invocations are expanded, and
+ _Pragma unary operator expressions are executed. If a character sequence that
+ matches the syntax of a universal character name is produced by token
+ concatenation (<a href="#6.10.3.3">6.10.3.3</a>), the behavior is undefined. A #include preprocessing
+ directive causes the named header or source file to be processed from phase 1
+ through phase 4, recursively. All preprocessing directives are then deleted.
+<li>  Each source character set member and escape sequence in character constants and
+ string literals is converted to the corresponding member of the execution character
+ set; if there is no corresponding member, it is converted to an implementation-
+ defined member other than the null (wide) character.<sup><a href="#note7"><b>7)</b></a></sup>
+<li>  Adjacent string literal tokens are concatenated.
+<li>  White-space characters separating tokens are no longer significant. Each
+ preprocessing token is converted into a token. The resulting tokens are
+ syntactically and semantically analyzed and translated as a translation unit.
+<li>  All external object and function references are resolved. Library components are
+ linked to satisfy external references to functions and objects not defined in the
+ current translation. All such translator output is collected into a program image
+ which contains information needed for execution in its execution environment.
+</ol>
+ Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
+ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href="#5.2.1.1">5.2.1.1</a>), external definitions (<a href="#6.9">6.9</a>).
+ 
+ 
+ 
+<!--page 23 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note5">5)</a> Implementations shall behave as if these separate phases occur, even though many are typically folded
+ together in practice. Source files, translation units, and translated translation units need not
+ necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
+ and any external representation. The description is conceptual only, and does not specify any
+ particular implementation.
+
+<p><a name="note6">6)</a> As described in <a href="#6.4">6.4</a>, the process of dividing a source file's characters into preprocessing tokens is
+ context-dependent. For example, see the handling of &lt; within a #include preprocessing directive.
+
+<p><a name="note7">7)</a> An implementation need not convert all non-corresponding source characters to the same execution
+ character.
+
+
+<a name="5.1.1.3" href="#5.1.1.3"><h5>5.1.1.3 Diagnostics</h5></a>
+<p><!--para 1-->
+ A conforming implementation shall produce at least one diagnostic message (identified in
+ an implementation-defined manner) if a preprocessing translation unit or translation unit
+ contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
+ specified as undefined or implementation-defined. Diagnostic messages need not be
+ produced in other circumstances.<sup><a href="#note8"><b>8)</b></a></sup>
+<p><!--para 2-->
+ EXAMPLE        An implementation shall issue a diagnostic for the translation unit:
+<pre>
+          char i;
+          int i;</pre>
+ because in those cases where wording in this International Standard describes the behavior for a construct
+ as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note8">8)</a> The intent is that an implementation should identify the nature of, and where possible localize, each
+ violation. Of course, an implementation is free to produce any number of diagnostics as long as a
+ valid program is still correctly translated. It may also successfully translate an invalid program.
+
+
+<a name="5.1.2" href="#5.1.2"><h4>5.1.2 Execution environments</h4></a>
+<p><!--para 1-->
+ Two execution environments are defined: freestanding and hosted. In both cases,
+ program startup occurs when a designated C function is called by the execution
+ environment. All objects with static storage duration shall be initialized (set to their
+ initial values) before program startup. The manner and timing of such initialization are
+ otherwise unspecified. Program termination returns control to the execution
+ environment.
+ Forward references: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+
+<a name="5.1.2.1" href="#5.1.2.1"><h5>5.1.2.1 Freestanding environment</h5></a>
+<p><!--para 1-->
+ In a freestanding environment (in which C program execution may take place without any
+ benefit of an operating system), the name and type of the function called at program
+ startup are implementation-defined. Any library facilities available to a freestanding
+ program, other than the minimal set required by clause 4, are implementation-defined.
+<p><!--para 2-->
+ The effect of program termination in a freestanding environment is implementation-
+ defined.
+
+<a name="5.1.2.2" href="#5.1.2.2"><h5>5.1.2.2 Hosted environment</h5></a>
+<p><!--para 1-->
+ A hosted environment need not be provided, but shall conform to the following
+ specifications if present.
+ 
+ 
+ 
+ 
+<!--page 24 indent 4-->
+
+<a name="5.1.2.2.1" href="#5.1.2.2.1"><h5>5.1.2.2.1 Program startup</h5></a>
+<p><!--para 1-->
+ The function called at program startup is named main. The implementation declares no
+ prototype for this function. It shall be defined with a return type of int and with no
+ parameters:
+<pre>
+         int main(void) { /* ... */ }</pre>
+ or with two parameters (referred to here as argc and argv, though any names may be
+ used, as they are local to the function in which they are declared):
+<pre>
+         int main(int argc, char *argv[]) { /* ... */ }</pre>
+ or equivalent;<sup><a href="#note9"><b>9)</b></a></sup> or in some other implementation-defined manner.
+<p><!--para 2-->
+ If they are declared, the parameters to the main function shall obey the following
+ constraints:
+<ul>
+<li>  The value of argc shall be nonnegative.
+<li>  argv[argc] shall be a null pointer.
+<li>  If the value of argc is greater than zero, the array members argv[0] through
+ argv[argc-1] inclusive shall contain pointers to strings, which are given
+ implementation-defined values by the host environment prior to program startup. The
+ intent is to supply to the program information determined prior to program startup
+ from elsewhere in the hosted environment. If the host environment is not capable of
+ supplying strings with letters in both uppercase and lowercase, the implementation
+ shall ensure that the strings are received in lowercase.
+<li>  If the value of argc is greater than zero, the string pointed to by argv[0]
+ represents the program name; argv[0][0] shall be the null character if the
+ program name is not available from the host environment. If the value of argc is
+ greater than one, the strings pointed to by argv[1] through argv[argc-1]
+ represent the program parameters.
+<li>  The parameters argc and argv and the strings pointed to by the argv array shall
+ be modifiable by the program, and retain their last-stored values between program
+ startup and program termination.
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note9">9)</a> Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
+ char ** argv, and so on.
+
+
+<a name="5.1.2.2.2" href="#5.1.2.2.2"><h5>5.1.2.2.2 Program execution</h5></a>
+<p><!--para 1-->
+ In a hosted environment, a program may use all the functions, macros, type definitions,
+ and objects described in the library clause (clause 7).
+ 
+ 
+ 
+<!--page 25 indent 4-->
+
+<a name="5.1.2.2.3" href="#5.1.2.2.3"><h5>5.1.2.2.3 Program termination</h5></a>
+<p><!--para 1-->
+ If the return type of the main function is a type compatible with int, a return from the
+ initial call to the main function is equivalent to calling the exit function with the value
+ returned by the main function as its argument;<sup><a href="#note10"><b>10)</b></a></sup> reaching the } that terminates the
+ main function returns a value of 0. If the return type is not compatible with int, the
+ termination status returned to the host environment is unspecified.
+ Forward references: definition of terms (<a href="#7.1.1">7.1.1</a>), the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note10">10)</a> In accordance with <a href="#6.2.4">6.2.4</a>, the lifetimes of objects with automatic storage duration declared in main
+ will have ended in the former case, even where they would not have in the latter.
+
+
+<a name="5.1.2.3" href="#5.1.2.3"><h5>5.1.2.3 Program execution</h5></a>
+<p><!--para 1-->
+ The semantic descriptions in this International Standard describe the behavior of an
+ abstract machine in which issues of optimization are irrelevant.
+<p><!--para 2-->
+ Accessing a volatile object, modifying an object, modifying a file, or calling a function
+ that does any of those operations are all side effects,<sup><a href="#note11"><b>11)</b></a></sup> which are changes in the state of
+ the execution environment. Evaluation of an expression may produce side effects. At
+ certain specified points in the execution sequence called sequence points, all side effects
+ of previous evaluations shall be complete and no side effects of subsequent evaluations
+ shall have taken place. (A summary of the sequence points is given in <a href="#C">annex C</a>.)
+<p><!--para 3-->
+ In the abstract machine, all expressions are evaluated as specified by the semantics. An
+ actual implementation need not evaluate part of an expression if it can deduce that its
+ value is not used and that no needed side effects are produced (including any caused by
+ calling a function or accessing a volatile object).
+<p><!--para 4-->
+ When the processing of the abstract machine is interrupted by receipt of a signal, only the
+ values of objects as of the previous sequence point may be relied on. Objects that may be
+ modified between the previous sequence point and the next sequence point need not have
+ received their correct values yet.
+<p><!--para 5-->
+ The least requirements on a conforming implementation are:
+<ul>
+<li>  At sequence points, volatile objects are stable in the sense that previous accesses are
+ complete and subsequent accesses have not yet occurred.
+ 
+ 
+ 
+ 
+<!--page 26 indent 5-->
+<li>  At program termination, all data written into files shall be identical to the result that
+ execution of the program according to the abstract semantics would have produced.
+<li>  The input and output dynamics of interactive devices shall take place as specified in
+ <a href="#7.19.3">7.19.3</a>. The intent of these requirements is that unbuffered or line-buffered output
+ appear as soon as possible, to ensure that prompting messages actually appear prior to
+ a program waiting for input.
+</ul>
+<p><!--para 6-->
+ What constitutes an interactive device is implementation-defined.
+<p><!--para 7-->
+ More stringent correspondences between abstract and actual semantics may be defined by
+ each implementation.
+<p><!--para 8-->
+ EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
+ semantics: at every sequence point, the values of the actual objects would agree with those specified by the
+ abstract semantics. The keyword volatile would then be redundant.
+<p><!--para 9-->
+ Alternatively, an implementation might perform various optimizations within each translation unit, such
+ that the actual semantics would agree with the abstract semantics only when making function calls across
+ translation unit boundaries. In such an implementation, at the time of each function entry and function
+ return where the calling function and the called function are in different translation units, the values of all
+ externally linked objects and of all objects accessible via pointers therein would agree with the abstract
+ semantics. Furthermore, at the time of each such function entry the values of the parameters of the called
+ function and of all objects accessible via pointers therein would agree with the abstract semantics. In this
+ type of implementation, objects referred to by interrupt service routines activated by the signal function
+ would require explicit specification of volatile storage, as well as other implementation-defined
+ restrictions.
+ 
+<p><!--para 10-->
+ EXAMPLE 2       In executing the fragment
+<pre>
+          char c1, c2;
+          /* ... */
+          c1 = c1 + c2;</pre>
+ the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
+ and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
+ overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
+ produce the same result, possibly omitting the promotions.
+ 
+<p><!--para 11-->
+ EXAMPLE 3       Similarly, in the fragment
+<pre>
+          float f1, f2;
+          double d;
+          /* ... */
+          f1 = f2 * d;</pre>
+ the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
+ that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
+ were replaced by the constant 2.0, which has type double).
+<!--page 27 indent 5-->
+<p><!--para 12-->
+ EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
+ semantics. Values are independent of whether they are represented in a register or in memory. For
+ example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
+ is required to round to the precision of the storage type. In particular, casts and assignments are required to
+ perform their specified conversion. For the fragment
+<pre>
+          double d1, d2;
+          float f;
+          d1 = f = expression;
+          d2 = (float) expression;</pre>
+ the values assigned to d1 and d2 are required to have been converted to float.
+ 
+<p><!--para 13-->
+ EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
+ precision as well as range. The implementation cannot generally apply the mathematical associative rules
+ for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
+ overflow and underflow. Likewise, implementations cannot generally replace decimal constants in order to
+ rearrange expressions. In the following fragment, rearrangements suggested by mathematical rules for real
+ numbers are often not valid (see <a href="#F.8">F.8</a>).
+<pre>
+          double x, y, z;
+          /* ... */
+          x = (x * y) * z;            //   not equivalent to x   *= y * z;
+          z = (x - y) + y ;           //   not equivalent to z   = x;
+          z = x + x * y;              //   not equivalent to z   = x * (1.0 + y);
+          y = x / 5.0;                //   not equivalent to y   = x * 0.2;</pre>
+ 
+<p><!--para 14-->
+ EXAMPLE 6 To illustrate the grouping behavior of expressions, in the following fragment
+<pre>
+          int a, b;
+          /* ... */
+          a = a + 32760 + b + 5;</pre>
+ the expression statement behaves exactly the same as
+<pre>
+          a = (((a + 32760) + b) + 5);</pre>
+ due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
+ next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
+ which overflows produce an explicit trap and in which the range of values representable by an int is
+ [-32768, +32767], the implementation cannot rewrite this expression as
+<pre>
+          a = ((a + b) + 32765);</pre>
+ since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
+ while the original expression would not; nor can the expression be rewritten either as
+<pre>
+          a = ((a + 32765) + b);</pre>
+ or
+<pre>
+          a = (a + (b + 32765));</pre>
+ since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
+ in which overflow silently generates some value and where positive and negative overflows cancel, the
+ above expression statement can be rewritten by the implementation in any of the above ways because the
+ same result will occur.
+<!--page 28 indent 5-->
+<p><!--para 15-->
+ EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
+ following fragment
+<pre>
+          #include &lt;stdio.h&gt;
+          int sum;
+          char *p;
+          /* ... */
+          sum = sum * 10 - '0' + (*p++ = getchar());</pre>
+ the expression statement is grouped as if it were written as
+<pre>
+          sum = (((sum * 10) - '0') + ((*(p++)) = (getchar())));</pre>
+ but the actual increment of p can occur at any time between the previous sequence point and the next
+ sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
+ value.
+ 
+ Forward references: expressions (<a href="#6.5">6.5</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>), statements (<a href="#6.8">6.8</a>), the
+ signal function (<a href="#7.14">7.14</a>), files (<a href="#7.19.3">7.19.3</a>).
+<!--page 29 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note11">11)</a> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
+ flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
+ values of floating-point operations. Implementations that support such floating-point state are
+ required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
+ environment library &lt;fenv.h&gt; provides a programming facility for indicating when these side
+ effects matter, freeing the implementations in other cases.
+
+
+<a name="5.2" href="#5.2"><h3>5.2 Environmental considerations</h3></a>
+
+<a name="5.2.1" href="#5.2.1"><h4>5.2.1 Character sets</h4></a>
+<p><!--para 1-->
+ Two sets of characters and their associated collating sequences shall be defined: the set in
+ which source files are written (the source character set), and the set interpreted in the
+ execution environment (the execution character set). Each set is further divided into a
+ basic character set, whose contents are given by this subclause, and a set of zero or more
+ locale-specific members (which are not members of the basic character set) called
+ extended characters. The combined set is also called the extended character set. The
+ values of the members of the execution character set are implementation-defined.
+<p><!--para 2-->
+ In a character constant or string literal, members of the execution character set shall be
+ represented by corresponding members of the source character set or by escape
+ sequences consisting of the backslash \ followed by one or more characters. A byte with
+ all bits set to 0, called the null character, shall exist in the basic execution character set; it
+ is used to terminate a character string.
+<p><!--para 3-->
+ Both the basic source and basic execution character sets shall have the following
+ members: the 26 uppercase letters of the Latin alphabet
+<pre>
+          A   B   C      D   E   F    G    H    I    J    K    L   M
+          N   O   P      Q   R   S    T    U    V    W    X    Y   Z</pre>
+ the 26 lowercase letters of the Latin alphabet
+<pre>
+          a   b   c      d   e   f    g    h    i    j    k    l   m
+          n   o   p      q   r   s    t    u    v    w    x    y   z</pre>
+ the 10 decimal digits
+<pre>
+          0   1   2      3   4   5    6    7    8    9</pre>
+ the following 29 graphic characters
+<pre>
+          !   "   #      %   &amp;   '    (    )    *    +    ,    -   .    /    :
+          ;   &lt;   =      &gt;   ?   [    \    ]    ^    _    {    |   }    ~</pre>
+ the space character, and control characters representing horizontal tab, vertical tab, and
+ form feed. The representation of each member of the source and execution basic
+ character sets shall fit in a byte. In both the source and execution basic character sets, the
+ value of each character after 0 in the above list of decimal digits shall be one greater than
+ the value of the previous. In source files, there shall be some way of indicating the end of
+ each line of text; this International Standard treats such an end-of-line indicator as if it
+ were a single new-line character. In the basic execution character set, there shall be
+ control characters representing alert, backspace, carriage return, and new line. If any
+ other characters are encountered in a source file (except in an identifier, a character
+ constant, a string literal, a header name, a comment, or a preprocessing token that is never
+<!--page 30 indent 4-->
+ converted to a token), the behavior is undefined.
+<p><!--para 4-->
+ A letter is an uppercase letter or a lowercase letter as defined above; in this International
+ Standard the term does not include other characters that are letters in other alphabets.
+<p><!--para 5-->
+ The universal character name construct provides a way to name other characters.
+ Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
+ preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
+
+<a name="5.2.1.1" href="#5.2.1.1"><h5>5.2.1.1 Trigraph sequences</h5></a>
+<p><!--para 1-->
+ Before any other processing takes place, each occurrence of one of the following
+ sequences of three characters (called trigraph sequences<sup><a href="#note12"><b>12)</b></a></sup>) is replaced with the
+ corresponding single character.
+<pre>
+        ??=      #                       ??)      ]                       ??!     |
+        ??(      [                       ??'      ^                       ??&gt;     }
+        ??/      \                       ??&lt;      {                       ??-     ~</pre>
+ No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
+ above is not changed.
+<p><!--para 2-->
+ EXAMPLE 1
+<pre>
+           ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)</pre>
+ becomes
+<pre>
+           #define arraycheck(a, b) a[b] || b[a]</pre>
+ 
+<p><!--para 3-->
+ EXAMPLE 2      The following source line
+<pre>
+           printf("Eh???/n");</pre>
+ becomes (after replacement of the trigraph sequence ??/)
+<pre>
+           printf("Eh?\n");</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note12">12)</a> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
+ described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
+
+
+<a name="5.2.1.2" href="#5.2.1.2"><h5>5.2.1.2 Multibyte characters</h5></a>
+<p><!--para 1-->
+ The source character set may contain multibyte characters, used to represent members of
+ the extended character set. The execution character set may also contain multibyte
+ characters, which need not have the same encoding as for the source character set. For
+ both character sets, the following shall hold:
+<ul>
+<li>  The basic character set shall be present and each character shall be encoded as a
+ single byte.
+<li>  The presence, meaning, and representation of any additional members is locale-
+ specific.
+ 
+<!--page 31 indent 4-->
+<li>  A multibyte character set may have a state-dependent encoding, wherein each
+ sequence of multibyte characters begins in an initial shift state and enters other
+ locale-specific shift states when specific multibyte characters are encountered in the
+ sequence. While in the initial shift state, all single-byte characters retain their usual
+ interpretation and do not alter the shift state. The interpretation for subsequent bytes
+ in the sequence is a function of the current shift state.
+<li>  A byte with all bits zero shall be interpreted as a null character independent of shift
+ state. Such a byte shall not occur as part of any other multibyte character.
+</ul>
+<p><!--para 2-->
+ For source files, the following shall hold:
+<ul>
+<li>  An identifier, comment, string literal, character constant, or header name shall begin
+ and end in the initial shift state.
+<li>  An identifier, comment, string literal, character constant, or header name shall consist
+ of a sequence of valid multibyte characters.
+</ul>
+
+<a name="5.2.2" href="#5.2.2"><h4>5.2.2 Character display semantics</h4></a>
+<p><!--para 1-->
+ The active position is that location on a display device where the next character output by
+ the fputc function would appear. The intent of writing a printing character (as defined
+ by the isprint function) to a display device is to display a graphic representation of
+ that character at the active position and then advance the active position to the next
+ position on the current line. The direction of writing is locale-specific. If the active
+ position is at the final position of a line (if there is one), the behavior of the display device
+ is unspecified.
+<p><!--para 2-->
+ Alphabetic escape sequences representing nongraphic characters in the execution
+ character set are intended to produce actions on display devices as follows:
+ \a (alert) Produces an audible or visible alert without changing the active position.
+ \b (backspace) Moves the active position to the previous position on the current line. If
+<pre>
+    the active position is at the initial position of a line, the behavior of the display
+    device is unspecified.</pre>
+ \f ( form feed) Moves the active position to the initial position at the start of the next
+<pre>
+    logical page.</pre>
+ \n (new line) Moves the active position to the initial position of the next line.
+ \r (carriage return) Moves the active position to the initial position of the current line.
+ \t (horizontal tab) Moves the active position to the next horizontal tabulation position
+<pre>
+    on the current line. If the active position is at or past the last defined horizontal
+    tabulation position, the behavior of the display device is unspecified.</pre>
+ \v (vertical tab) Moves the active position to the initial position of the next vertical
+<!--page 32 indent 4-->
+<p><!--para 3-->
+<pre>
+     tabulation position. If the active position is at or past the last defined vertical
+      tabulation position, the behavior of the display device is unspecified.</pre>
+ Each of these escape sequences shall produce a unique implementation-defined value
+ which can be stored in a single char object. The external representations in a text file
+ need not be identical to the internal representations, and are outside the scope of this
+ International Standard.
+ Forward references: the isprint function (<a href="#7.4.1.8">7.4.1.8</a>), the fputc function (<a href="#7.19.7.3">7.19.7.3</a>).
+
+<a name="5.2.3" href="#5.2.3"><h4>5.2.3 Signals and interrupts</h4></a>
+<p><!--para 1-->
+ Functions shall be implemented such that they may be interrupted at any time by a signal,
+ or may be called by a signal handler, or both, with no alteration to earlier, but still active,
+ invocations' control flow (after the interruption), function return values, or objects with
+ automatic storage duration. All such objects shall be maintained outside the function
+ image (the instructions that compose the executable representation of a function) on a
+ per-invocation basis.
+
+<a name="5.2.4" href="#5.2.4"><h4>5.2.4 Environmental limits</h4></a>
+<p><!--para 1-->
+ Both the translation and execution environments constrain the implementation of
+ language translators and libraries. The following summarizes the language-related
+ environmental limits on a conforming implementation; the library-related limits are
+ discussed in clause 7.
+
+<a name="5.2.4.1" href="#5.2.4.1"><h5>5.2.4.1 Translation limits</h5></a>
+<p><!--para 1-->
+ The implementation shall be able to translate and execute at least one program that
+ contains at least one instance of every one of the following limits:<sup><a href="#note13"><b>13)</b></a></sup>
+<ul>
+<li>  127 nesting levels of blocks
+<li>  63 nesting levels of conditional inclusion
+<li>  12 pointer, array, and function declarators (in any combinations) modifying an
+ arithmetic, structure, union, or incomplete type in a declaration
+<li>  63 nesting levels of parenthesized declarators within a full declarator
+<li>  63 nesting levels of parenthesized expressions within a full expression
+<li>  63 significant initial characters in an internal identifier or a macro name (each
+ universal character name or extended source character is considered a single
+ character)
+<li>  31 significant initial characters in an external identifier (each universal character name
+ specifying a short identifier of 0000FFFF or less is considered 6 characters, each
+ 
+ 
+<!--page 33 indent 4-->
+   universal character name specifying a short identifier of 00010000 or more is
+   considered 10 characters, and each extended source character is considered the same
+   number of characters as the corresponding universal character name, if any)<sup><a href="#note14"><b>14)</b></a></sup>
+<li>  4095 external identifiers in one translation unit
+<li>  511 identifiers with block scope declared in one block
+<li>  4095 macro identifiers simultaneously defined in one preprocessing translation unit
+<li>  127 parameters in one function definition
+<li>  127 arguments in one function call
+<li>  127 parameters in one macro definition
+<li>  127 arguments in one macro invocation
+<li>  4095 characters in a logical source line
+<li>  4095 characters in a character string literal or wide string literal (after concatenation)
+<li>  65535 bytes in an object (in a hosted environment only)
+<li>  15 nesting levels for #included files
+<li>  1023 case labels for a switch statement (excluding those for any nested switch
+ statements)
+<li>  1023 members in a single structure or union
+<li>  1023 enumeration constants in a single enumeration
+<li>  63 levels of nested structure or union definitions in a single struct-declaration-list
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note13">13)</a> Implementations should avoid imposing fixed translation limits whenever possible.
+
+<p><a name="note14">14)</a> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
+
+
+<a name="5.2.4.2" href="#5.2.4.2"><h5>5.2.4.2 Numerical limits</h5></a>
+<p><!--para 1-->
+ An implementation is required to document all the limits specified in this subclause,
+ which are specified in the headers &lt;limits.h&gt; and &lt;float.h&gt;. Additional limits are
+ specified in &lt;stdint.h&gt;.
+ Forward references: integer types &lt;stdint.h&gt; (<a href="#7.18">7.18</a>).
+
+<a name="5.2.4.2.1" href="#5.2.4.2.1"><h5>5.2.4.2.1 Sizes of integer types <limits.h></h5></a>
+<p><!--para 1-->
+ The values given below shall be replaced by constant expressions suitable for use in #if
+ preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
+ following shall be replaced by expressions that have the same type as would an
+ expression that is an object of the corresponding type converted according to the integer
+ promotions. Their implementation-defined values shall be equal or greater in magnitude
+ 
+ 
+<!--page 34 indent 0-->
+ (absolute value) to those shown, with the same sign.
+<ul>
+<li>  number of bits for smallest object that is not a bit-field (byte)
+ CHAR_BIT                                            8
+<li>  minimum value for an object of type signed char
+ SCHAR_MIN                                -127 // -(27 - 1)
+<li>  maximum value for an object of type signed char
+ SCHAR_MAX                                +127 // 27 - 1
+<li>  maximum value for an object of type unsigned char
+ UCHAR_MAX                                 255 // 28 - 1
+<li>  minimum value for an object of type char
+ CHAR_MIN                               see below
+<li>  maximum value for an object of type char
+ CHAR_MAX                              see below
+<li>  maximum number of bytes in a multibyte character, for any supported locale
+ MB_LEN_MAX                                    1
+<li>  minimum value for an object of type short int
+ SHRT_MIN                               -32767 // -(215 - 1)
+<li>  maximum value for an object of type short int
+ SHRT_MAX                               +32767 // 215 - 1
+<li>  maximum value for an object of type unsigned short int
+ USHRT_MAX                               65535 // 216 - 1
+<li>  minimum value for an object of type int
+ INT_MIN                                 -32767 // -(215 - 1)
+<li>  maximum value for an object of type int
+ INT_MAX                                +32767 // 215 - 1
+<li>  maximum value for an object of type unsigned int
+ UINT_MAX                                65535 // 216 - 1
+<li>  minimum value for an object of type long int
+ LONG_MIN                         -2147483647 // -(231 - 1)
+<li>  maximum value for an object of type long int
+ LONG_MAX                         +2147483647 // 231 - 1
+<li>  maximum value for an object of type unsigned long int
+ ULONG_MAX                         4294967295 // 232 - 1
+<!--page 35 indent 4-->
+<li>  minimum value for an object of type long long int
+ LLONG_MIN          -9223372036854775807 // -(263 - 1)
+<li>  maximum value for an object of type long long int
+ LLONG_MAX          +9223372036854775807 // 263 - 1
+<li>  maximum value for an object of type unsigned long long int
+ ULLONG_MAX         18446744073709551615 // 264 - 1
+</ul>
+<p><!--para 2-->
+ If the value of an object of type char is treated as a signed integer when used in an
+ expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
+ value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
+ CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
+ UCHAR_MAX.<sup><a href="#note15"><b>15)</b></a></sup> The value UCHAR_MAX shall equal 2CHAR_BIT - 1.
+ Forward references: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note15">15)</a> See <a href="#6.2.5">6.2.5</a>.
+
+
+<a name="5.2.4.2.2" href="#5.2.4.2.2"><h5>5.2.4.2.2 Characteristics of floating types <float.h></h5></a>
+<p><!--para 1-->
+ The characteristics of floating types are defined in terms of a model that describes a
+ representation of floating-point numbers and values that provide information about an
+ implementation's floating-point arithmetic.<sup><a href="#note16"><b>16)</b></a></sup> The following parameters are used to
+ define the model for each floating-point type:
+<p><!--para 2-->
+<pre>
+        s          sign ((+-)1)
+        b          base or radix of exponent representation (an integer &gt; 1)
+        e          exponent (an integer between a minimum emin and a maximum emax )
+        p          precision (the number of base-b digits in the significand)
+         fk        nonnegative integers less than b (the significand digits)</pre>
+ A floating-point number (x) is defined by the following model:
+<pre>
+                    p
+        x = sb e   (Sum) f k b-k ,
+                   k=1
+                                  emin &lt;= e &lt;= emax</pre>
+ 
+<p><!--para 3-->
+ In addition to normalized floating-point numbers ( f 1 &gt; 0 if x != 0), floating types may be
+ able to contain other kinds of floating-point numbers, such as subnormal floating-point
+ numbers (x != 0, e = emin , f 1 = 0) and unnormalized floating-point numbers (x != 0,
+ e &gt; emin , f 1 = 0), and values that are not floating-point numbers, such as infinities and
+ NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates
+ through almost every arithmetic operation without raising a floating-point exception; a
+ signaling NaN generally raises a floating-point exception when occurring as an
+ 
+ 
+<!--page 36 indent 4-->
+ arithmetic operand.<sup><a href="#note17"><b>17)</b></a></sup>
+<p><!--para 4-->
+ An implementation may give zero and non-numeric values (such as infinities and NaNs) a
+ sign or may leave them unsigned. Wherever such values are unsigned, any requirement
+ in this International Standard to retrieve the sign shall produce an unspecified sign, and
+ any requirement to set the sign shall be ignored.
+<p><!--para 5-->
+ The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
+ &lt;math.h&gt; and &lt;complex.h&gt; that return floating-point results is implementation-
+ defined, as is the accuracy of the conversion between floating-point internal
+ representations and string representations performed by the library functions in
+ &lt;stdio.h&gt;, &lt;stdlib.h&gt;, and &lt;wchar.h&gt;. The implementation may state that the
+ accuracy is unknown.
+<p><!--para 6-->
+ All integer values in the &lt;float.h&gt; header, except FLT_ROUNDS, shall be constant
+ expressions suitable for use in #if preprocessing directives; all floating values shall be
+ constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
+ and FLT_ROUNDS have separate names for all three floating-point types. The floating-
+ point model representation is provided for all values except FLT_EVAL_METHOD and
+ FLT_ROUNDS.
+<p><!--para 7-->
+ The rounding mode for floating-point addition is characterized by the implementation-
+ defined value of FLT_ROUNDS:<sup><a href="#note18"><b>18)</b></a></sup>
+<pre>
+       -1      indeterminable
+        0      toward zero
+        1      to nearest
+        2      toward positive infinity
+        3      toward negative infinity</pre>
+ All other values for FLT_ROUNDS characterize implementation-defined rounding
+ behavior.
+<p><!--para 8-->
+ Except for assignment and cast (which remove all extra range and precision), the values
+ of operations with floating operands and values subject to the usual arithmetic
+ conversions and of floating constants are evaluated to a format whose range and precision
+ may be greater than required by the type. The use of evaluation formats is characterized
+ by the implementation-defined value of FLT_EVAL_METHOD:<sup><a href="#note19"><b>19)</b></a></sup>
+ 
+ 
+ 
+<!--page 37 indent 4-->
+<pre>
+        -1        indeterminable;
+         0        evaluate all operations and constants just to the range and precision of the
+                  type;
+         1        evaluate operations and constants of type float and double to the
+                  range and precision of the double type, evaluate long double
+                  operations and constants to the range and precision of the long double
+                  type;
+         2        evaluate all operations and constants to the range and precision of the
+                  long double type.</pre>
+ All other negative values for FLT_EVAL_METHOD characterize implementation-defined
+ behavior.
+<p><!--para 9-->
+ The values given in the following list shall be replaced by constant expressions with
+ implementation-defined values that are greater or equal in magnitude (absolute value) to
+ those shown, with the same sign:
+<ul>
+<li>  radix of exponent representation, b
+ FLT_RADIX                                                 2
+<li>  number of base-FLT_RADIX digits in the floating-point significand, p
+   FLT_MANT_DIG
+   DBL_MANT_DIG
+   LDBL_MANT_DIG
+<li>  number of decimal digits, n, such that any floating-point number in the widest
+ supported floating type with pmax radix b digits can be rounded to a floating-point
+ number with n decimal digits and back again without change to the value,
+<pre>
+      ??? pmax log10 b       if b is a power of 10
+      ???
+      ??? ???1 + pmax log10 b??? otherwise</pre>
+   DECIMAL_DIG                                            10
+<li>  number of decimal digits, q, such that any floating-point number with q decimal digits
+ can be rounded into a floating-point number with p radix b digits and back again
+ without change to the q decimal digits,
+ 
+ 
+ 
+ 
+<!--page 38 indent 5-->
+<pre>
+      ??? p log10 b          if b is a power of 10
+      ???
+      ??? ???( p - 1) log10 b??? otherwise</pre>
+  FLT_DIG                                         6
+  DBL_DIG                                        10
+  LDBL_DIG                                       10
+<li>  minimum negative integer such that FLT_RADIX raised to one less than that power is
+ a normalized floating-point number, emin
+  FLT_MIN_EXP
+  DBL_MIN_EXP
+  LDBL_MIN_EXP
+<li>  minimum negative integer such that 10 raised to that power is in the range of
+ normalized floating-point numbers, ???log10 b emin -1 ???
+<pre>
+                                   ???                ???</pre>
+ FLT_MIN_10_EXP                                 -37
+ DBL_MIN_10_EXP                                 -37
+ LDBL_MIN_10_EXP                                -37
+<li>  maximum integer such that FLT_RADIX raised to one less than that power is a
+ representable finite floating-point number, emax
+  FLT_MAX_EXP
+  DBL_MAX_EXP
+  LDBL_MAX_EXP
+<li>  maximum integer such that 10 raised to that power is in the range of representable
+ finite floating-point numbers, ???log10 ((1 - b- p )b emax )???
+  FLT_MAX_10_EXP                                 +37
+  DBL_MAX_10_EXP                                 +37
+  LDBL_MAX_10_EXP                                +37
+</ul>
+<p><!--para 10-->
+ The values given in the following list shall be replaced by constant expressions with
+ implementation-defined values that are greater than or equal to those shown:
+<ul>
+<li>  maximum representable finite floating-point number, (1 - b- p )b emax
+  FLT_MAX                                     1E+37
+  DBL_MAX                                     1E+37
+  LDBL_MAX                                    1E+37
+</ul>
+<p><!--para 11-->
+ The values given in the following list shall be replaced by constant expressions with
+ implementation-defined (positive) values that are less than or equal to those shown:
+<ul>
+<li>  the difference between 1 and the least value greater than 1 that is representable in the
+  given floating point type, b1- p
+<!--page 39 indent 5-->
+   FLT_EPSILON                                         1E-5
+   DBL_EPSILON                                         1E-9
+   LDBL_EPSILON                                        1E-9
+<li>  minimum normalized positive floating-point number, b emin -1
+   FLT_MIN                                            1E-37
+   DBL_MIN                                            1E-37
+   LDBL_MIN                                           1E-37
+</ul>
+ Recommended practice
+<p><!--para 12-->
+ Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
+ should be the identity function.
+<p><!--para 13-->
+ EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
+ requirements of this International Standard, and the appropriate values in a &lt;float.h&gt; header for type
+ float:
+<pre>
+                    6
+       x = s16e    (Sum) f k 16-k ,
+                   k=1
+                                   -31 &lt;= e &lt;= +32</pre>
+ 
+<pre>
+         FLT_RADIX                                  16
+         FLT_MANT_DIG                                6
+         FLT_EPSILON                   9.53674316E-07F
+         FLT_DIG                                     6
+         FLT_MIN_EXP                               -31
+         FLT_MIN                       2.93873588E-39F
+         FLT_MIN_10_EXP                            -38
+         FLT_MAX_EXP                               +32
+         FLT_MAX                       3.40282347E+38F
+         FLT_MAX_10_EXP                            +38</pre>
+ 
+<p><!--para 14-->
+ EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
+ single-precision and double-precision normalized numbers in IEC 60559,<sup><a href="#note20"><b>20)</b></a></sup> and the appropriate values in a
+ &lt;float.h&gt; header for types float and double:
+<pre>
+                   24
+       x f = s2e   (Sum) f k 2-k ,
+                   k=1
+                                  -125 &lt;= e &lt;= +128</pre>
+ 
+<pre>
+                   53
+       x d = s2e   (Sum) f k 2-k ,
+                   k=1
+                                  -1021 &lt;= e &lt;= +1024</pre>
+ 
+<pre>
+         FLT_RADIX                                   2
+         DECIMAL_DIG                                17
+         FLT_MANT_DIG                               24
+         FLT_EPSILON                   1.19209290E-07F // decimal constant
+         FLT_EPSILON                          0X1P-23F // hex constant</pre>
+ 
+ 
+<!--page 40 indent 0-->
+<pre>
+         FLT_DIG                           6
+         FLT_MIN_EXP                    -125
+         FLT_MIN             1.17549435E-38F               // decimal constant
+         FLT_MIN                   0X1P-126F               // hex constant
+         FLT_MIN_10_EXP                  -37
+         FLT_MAX_EXP                    +128
+         FLT_MAX             3.40282347E+38F               // decimal constant
+         FLT_MAX             0X1.fffffeP127F               // hex constant
+         FLT_MAX_10_EXP                  +38
+         DBL_MANT_DIG                     53
+         DBL_EPSILON 2.2204460492503131E-16                // decimal constant
+         DBL_EPSILON                 0X1P-52               // hex constant
+         DBL_DIG                          15
+         DBL_MIN_EXP                   -1021
+         DBL_MIN     2.2250738585072014E-308               // decimal constant
+         DBL_MIN                   0X1P-1022               // hex constant
+         DBL_MIN_10_EXP                 -307
+         DBL_MAX_EXP                   +1024
+         DBL_MAX     1.7976931348623157E+308               // decimal constant
+         DBL_MAX      0X1.fffffffffffffP1023               // hex constant
+         DBL_MAX_10_EXP                 +308</pre>
+ If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
+ example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
+ precision), then DECIMAL_DIG would be 21.
+ 
+ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
+ &lt;complex.h&gt; (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities &lt;wchar.h&gt;
+ (<a href="#7.24">7.24</a>), floating-point environment &lt;fenv.h&gt; (<a href="#7.6">7.6</a>), general utilities &lt;stdlib.h&gt;
+ (<a href="#7.20">7.20</a>), input/output &lt;stdio.h&gt; (<a href="#7.19">7.19</a>), mathematics &lt;math.h&gt; (<a href="#7.12">7.12</a>).
+<!--page 41 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note16">16)</a> The floating-point model is intended to clarify the description of each floating-point characteristic and
+ does not require the floating-point arithmetic of the implementation to be identical.
+
+<p><a name="note17">17)</a> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
+ IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
+ similar behavior.
+
+<p><a name="note18">18)</a> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
+ the function fesetround in &lt;fenv.h&gt;.
+
+<p><a name="note19">19)</a> The evaluation method determines evaluation formats of expressions involving all floating types, not
+ just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
+ _Complex operands is represented in the double _Complex format, and its parts are evaluated to
+ double.
+
+<p><a name="note20">20)</a> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
+ limits are one less than shown here.
+
+
+<a name="6" href="#6"><h2>6. Language</h2></a>
+
+<a name="6.1" href="#6.1"><h3>6.1 Notation</h3></a>
+<p><!--para 1-->
+ In the syntax notation used in this clause, syntactic categories (nonterminals) are
+ indicated by italic type, and literal words and character set members (terminals) by bold
+ type. A colon (:) following a nonterminal introduces its definition. Alternative
+ definitions are listed on separate lines, except when prefaced by the words ''one of''. An
+ optional symbol is indicated by the subscript ''opt'', so that
+<pre>
+          { expressionopt }</pre>
+ indicates an optional expression enclosed in braces.
+<p><!--para 2-->
+ When syntactic categories are referred to in the main text, they are not italicized and
+ words are separated by spaces instead of hyphens.
+<p><!--para 3-->
+ A summary of the language syntax is given in <a href="#A">annex A</a>.
+
+<a name="6.2" href="#6.2"><h3>6.2 Concepts</h3></a>
+
+<a name="6.2.1" href="#6.2.1"><h4>6.2.1 Scopes of identifiers</h4></a>
+<p><!--para 1-->
+ An identifier can denote an object; a function; a tag or a member of a structure, union, or
+ enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
+ same identifier can denote different entities at different points in the program. A member
+ of an enumeration is called an enumeration constant. Macro names and macro
+ parameters are not considered further here, because prior to the semantic phase of
+ program translation any occurrences of macro names in the source file are replaced by the
+ preprocessing token sequences that constitute their macro definitions.
+<p><!--para 2-->
+ For each different entity that an identifier designates, the identifier is visible (i.e., can be
+ used) only within a region of program text called its scope. Different entities designated
+ by the same identifier either have different scopes, or are in different name spaces. There
+ are four kinds of scopes: function, file, block, and function prototype. (A function
+ prototype is a declaration of a function that declares the types of its parameters.)
+<p><!--para 3-->
+ A label name is the only kind of identifier that has function scope. It can be used (in a
+ goto statement) anywhere in the function in which it appears, and is declared implicitly
+ by its syntactic appearance (followed by a : and a statement).
+<p><!--para 4-->
+ Every other identifier has scope determined by the placement of its declaration (in a
+ declarator or type specifier). If the declarator or type specifier that declares the identifier
+ appears outside of any block or list of parameters, the identifier has file scope, which
+ terminates at the end of the translation unit. If the declarator or type specifier that
+ declares the identifier appears inside a block or within the list of parameter declarations in
+ a function definition, the identifier has block scope, which terminates at the end of the
+ associated block. If the declarator or type specifier that declares the identifier appears
+<!--page 42 indent 4-->
+ within the list of parameter declarations in a function prototype (not part of a function
+ definition), the identifier has function prototype scope, which terminates at the end of the
+ function declarator. If an identifier designates two different entities in the same name
+ space, the scopes might overlap. If so, the scope of one entity (the inner scope) will be a
+ strict subset of the scope of the other entity (the outer scope). Within the inner scope, the
+ identifier designates the entity declared in the inner scope; the entity declared in the outer
+ scope is hidden (and not visible) within the inner scope.
+<p><!--para 5-->
+ Unless explicitly stated otherwise, where this International Standard uses the term
+ ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
+ entity in the relevant name space whose declaration is visible at the point the identifier
+ occurs.
+<p><!--para 6-->
+ Two identifiers have the same scope if and only if their scopes terminate at the same
+ point.
+<p><!--para 7-->
+ Structure, union, and enumeration tags have scope that begins just after the appearance of
+ the tag in a type specifier that declares the tag. Each enumeration constant has scope that
+ begins just after the appearance of its defining enumerator in an enumerator list. Any
+ other identifier has scope that begins just after the completion of its declarator.
+ Forward references: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
+ (<a href="#6.9.1">6.9.1</a>), identifiers (<a href="#6.4.2">6.4.2</a>), name spaces of identifiers (<a href="#6.2.3">6.2.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>),
+ source file inclusion (<a href="#6.10.2">6.10.2</a>), statements (<a href="#6.8">6.8</a>).
+
+<a name="6.2.2" href="#6.2.2"><h4>6.2.2 Linkages of identifiers</h4></a>
+<p><!--para 1-->
+ An identifier declared in different scopes or in the same scope more than once can be
+ made to refer to the same object or function by a process called linkage.<sup><a href="#note21"><b>21)</b></a></sup> There are
+ three kinds of linkage: external, internal, and none.
+<p><!--para 2-->
+ In the set of translation units and libraries that constitutes an entire program, each
+ declaration of a particular identifier with external linkage denotes the same object or
+ function. Within one translation unit, each declaration of an identifier with internal
+ linkage denotes the same object or function. Each declaration of an identifier with no
+ linkage denotes a unique entity.
+<p><!--para 3-->
+ If the declaration of a file scope identifier for an object or a function contains the storage-
+ class specifier static, the identifier has internal linkage.<sup><a href="#note22"><b>22)</b></a></sup>
+<p><!--para 4-->
+ For an identifier declared with the storage-class specifier extern in a scope in which a
+ 
+ 
+ 
+<!--page 43 indent 4-->
+ prior declaration of that identifier is visible,<sup><a href="#note23"><b>23)</b></a></sup> if the prior declaration specifies internal or
+ external linkage, the linkage of the identifier at the later declaration is the same as the
+ linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
+ declaration specifies no linkage, then the identifier has external linkage.
+<p><!--para 5-->
+ If the declaration of an identifier for a function has no storage-class specifier, its linkage
+ is determined exactly as if it were declared with the storage-class specifier extern. If
+ the declaration of an identifier for an object has file scope and no storage-class specifier,
+ its linkage is external.
+<p><!--para 6-->
+ The following identifiers have no linkage: an identifier declared to be anything other than
+ an object or a function; an identifier declared to be a function parameter; a block scope
+ identifier for an object declared without the storage-class specifier extern.
+<p><!--para 7-->
+ If, within a translation unit, the same identifier appears with both internal and external
+ linkage, the behavior is undefined.
+ Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
+ statements (<a href="#6.8">6.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note21">21)</a> There is no linkage between different identifiers.
+
+<p><a name="note22">22)</a> A function declaration can contain the storage-class specifier static only if it is at file scope; see
+ <a href="#6.7.1">6.7.1</a>.
+
+<p><a name="note23">23)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+
+
+<a name="6.2.3" href="#6.2.3"><h4>6.2.3 Name spaces of identifiers</h4></a>
+<p><!--para 1-->
+ If more than one declaration of a particular identifier is visible at any point in a
+ translation unit, the syntactic context disambiguates uses that refer to different entities.
+ Thus, there are separate name spaces for various categories of identifiers, as follows:
+<ul>
+<li>  label names (disambiguated by the syntax of the label declaration and use);
+<li>  the tags of structures, unions, and enumerations (disambiguated by following any<sup><a href="#note24"><b>24)</b></a></sup>
+ of the keywords struct, union, or enum);
+<li>  the members of structures or unions; each structure or union has a separate name
+ space for its members (disambiguated by the type of the expression used to access the
+ member via the . or -&gt; operator);
+<li>  all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
+ enumeration constants).
+</ul>
+ Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
+ structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>), tags
+ (<a href="#6.7.2.3">6.7.2.3</a>), the goto statement (<a href="#6.8.6.1">6.8.6.1</a>).
+ 
+ 
+ 
+ 
+<!--page 44 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note24">24)</a> There is only one name space for tags even though three are possible.
+
+
+<a name="6.2.4" href="#6.2.4"><h4>6.2.4 Storage durations of objects</h4></a>
+<p><!--para 1-->
+ An object has a storage duration that determines its lifetime. There are three storage
+ durations: static, automatic, and allocated. Allocated storage is described in <a href="#7.20.3">7.20.3</a>.
+<p><!--para 2-->
+ The lifetime of an object is the portion of program execution during which storage is
+ guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note25"><b>25)</b></a></sup> and retains
+ its last-stored value throughout its lifetime.<sup><a href="#note26"><b>26)</b></a></sup> If an object is referred to outside of its
+ lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
+ the object it points to reaches the end of its lifetime.
+<p><!--para 3-->
+ An object whose identifier is declared with external or internal linkage, or with the
+ storage-class specifier static has static storage duration. Its lifetime is the entire
+ execution of the program and its stored value is initialized only once, prior to program
+ startup.
+<p><!--para 4-->
+ An object whose identifier is declared with no linkage and without the storage-class
+ specifier static has automatic storage duration.
+<p><!--para 5-->
+ For such an object that does not have a variable length array type, its lifetime extends
+ from entry into the block with which it is associated until execution of that block ends in
+ any way. (Entering an enclosed block or calling a function suspends, but does not end,
+ execution of the current block.) If the block is entered recursively, a new instance of the
+ object is created each time. The initial value of the object is indeterminate. If an
+ initialization is specified for the object, it is performed each time the declaration is
+ reached in the execution of the block; otherwise, the value becomes indeterminate each
+ time the declaration is reached.
+<p><!--para 6-->
+ For such an object that does have a variable length array type, its lifetime extends from
+ the declaration of the object until execution of the program leaves the scope of the
+ declaration.<sup><a href="#note27"><b>27)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
+ each time. The initial value of the object is indeterminate.
+ Forward references: statements (<a href="#6.8">6.8</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), declarators (<a href="#6.7.5">6.7.5</a>), array
+ declarators (<a href="#6.7.5.2">6.7.5.2</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+ 
+ 
+ 
+ 
+<!--page 45 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note25">25)</a> The term ''constant address'' means that two pointers to the object constructed at possibly different
+ times will compare equal. The address may be different during two different executions of the same
+ program.
+
+<p><a name="note26">26)</a> In the case of a volatile object, the last store need not be explicit in the program.
+
+<p><a name="note27">27)</a> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
+ embedded block prior to the declaration, leaves the scope of the declaration.
+
+
+<a name="6.2.5" href="#6.2.5"><h4>6.2.5 Types</h4></a>
+<p><!--para 1-->
+ The meaning of a value stored in an object or returned by a function is determined by the
+ type of the expression used to access it. (An identifier declared to be an object is the
+ simplest such expression; the type is specified in the declaration of the identifier.) Types
+ are partitioned into object types (types that fully describe objects), function types (types
+ that describe functions), and incomplete types (types that describe objects but lack
+ information needed to determine their sizes).
+<p><!--para 2-->
+ An object declared as type _Bool is large enough to store the values 0 and 1.
+<p><!--para 3-->
+ An object declared as type char is large enough to store any member of the basic
+ execution character set. If a member of the basic execution character set is stored in a
+ char object, its value is guaranteed to be nonnegative. If any other character is stored in
+ a char object, the resulting value is implementation-defined but shall be within the range
+ of values that can be represented in that type.
+<p><!--para 4-->
+ There are five standard signed integer types, designated as signed char, short
+ int, int, long int, and long long int. (These and other types may be
+ designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
+ implementation-defined extended signed integer types.<sup><a href="#note28"><b>28)</b></a></sup> The standard and extended
+ signed integer types are collectively called signed integer types.<sup><a href="#note29"><b>29)</b></a></sup>
+<p><!--para 5-->
+ An object declared as type signed char occupies the same amount of storage as a
+ ''plain'' char object. A ''plain'' int object has the natural size suggested by the
+ architecture of the execution environment (large enough to contain any value in the range
+ INT_MIN to INT_MAX as defined in the header &lt;limits.h&gt;).
+<p><!--para 6-->
+ For each of the signed integer types, there is a corresponding (but different) unsigned
+ integer type (designated with the keyword unsigned) that uses the same amount of
+ storage (including sign information) and has the same alignment requirements. The type
+ _Bool and the unsigned integer types that correspond to the standard signed integer
+ types are the standard unsigned integer types. The unsigned integer types that
+ correspond to the extended signed integer types are the extended unsigned integer types.
+ The standard and extended unsigned integer types are collectively called unsigned integer
+ types.<sup><a href="#note30"><b>30)</b></a></sup>
+ 
+ 
+ 
+<!--page 46 indent 5-->
+<p><!--para 7-->
+ The standard signed integer types and standard unsigned integer types are collectively
+ called the standard integer types, the extended signed integer types and extended
+ unsigned integer types are collectively called the extended integer types.
+<p><!--para 8-->
+ For any two integer types with the same signedness and different integer conversion rank
+ (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
+ subrange of the values of the other type.
+<p><!--para 9-->
+ The range of nonnegative values of a signed integer type is a subrange of the
+ corresponding unsigned integer type, and the representation of the same value in each
+ type is the same.<sup><a href="#note31"><b>31)</b></a></sup> A computation involving unsigned operands can never overflow,
+ because a result that cannot be represented by the resulting unsigned integer type is
+ reduced modulo the number that is one greater than the largest value that can be
+ represented by the resulting type.
+<p><!--para 10-->
+ There are three real floating types, designated as float, double, and long
+ double.<sup><a href="#note32"><b>32)</b></a></sup> The set of values of the type float is a subset of the set of values of the
+ type double; the set of values of the type double is a subset of the set of values of the
+ type long double.
+<p><!--para 11-->
+ There are three complex types, designated as float _Complex, double
+ _Complex, and long double _Complex.<sup><a href="#note33"><b>33)</b></a></sup> The real floating and complex types
+ are collectively called the floating types.
+<p><!--para 12-->
+ For each floating type there is a corresponding real type, which is always a real floating
+ type. For real floating types, it is the same type. For complex types, it is the type given
+ by deleting the keyword _Complex from the type name.
+<p><!--para 13-->
+ Each complex type has the same representation and alignment requirements as an array
+ type containing exactly two elements of the corresponding real type; the first element is
+ equal to the real part, and the second element to the imaginary part, of the complex
+ number.
+<p><!--para 14-->
+ The type char, the signed and unsigned integer types, and the floating types are
+ collectively called the basic types. Even if the implementation defines two or more basic
+ types to have the same representation, they are nevertheless different types.<sup><a href="#note34"><b>34)</b></a></sup>
+ 
+<!--page 47 indent 5-->
+<p><!--para 15-->
+ The three types char, signed char, and unsigned char are collectively called
+ the character types. The implementation shall define char to have the same range,
+ representation, and behavior as either signed char or unsigned char.<sup><a href="#note35"><b>35)</b></a></sup>
+<p><!--para 16-->
+ An enumeration comprises a set of named integer constant values. Each distinct
+ enumeration constitutes a different enumerated type.
+<p><!--para 17-->
+ The type char, the signed and unsigned integer types, and the enumerated types are
+ collectively called integer types. The integer and real floating types are collectively called
+ real types.
+<p><!--para 18-->
+ Integer and floating types are collectively called arithmetic types. Each arithmetic type
+ belongs to one type domain: the real type domain comprises the real types, the complex
+ type domain comprises the complex types.
+<p><!--para 19-->
+ The void type comprises an empty set of values; it is an incomplete type that cannot be
+ completed.
+<p><!--para 20-->
+ Any number of derived types can be constructed from the object, function, and
+ incomplete types, as follows:
+<ul>
+<li>  An array type describes a contiguously allocated nonempty set of objects with a
+ particular member object type, called the element type.<sup><a href="#note36"><b>36)</b></a></sup> Array types are
+ characterized by their element type and by the number of elements in the array. An
+ array type is said to be derived from its element type, and if its element type is T , the
+ array type is sometimes called ''array of T ''. The construction of an array type from
+ an element type is called ''array type derivation''.
+<li>  A structure type describes a sequentially allocated nonempty set of member objects
+ (and, in certain circumstances, an incomplete array), each of which has an optionally
+ specified name and possibly distinct type.
+<li>  A union type describes an overlapping nonempty set of member objects, each of
+ which has an optionally specified name and possibly distinct type.
+<li>  A function type describes a function with specified return type. A function type is
+ characterized by its return type and the number and types of its parameters. A
+ function type is said to be derived from its return type, and if its return type is T , the
+ function type is sometimes called ''function returning T ''. The construction of a
+ function type from a return type is called ''function type derivation''.
+ 
+ 
+ 
+<!--page 48 indent 5-->
+<li>  A pointer type may be derived from a function type, an object type, or an incomplete
+ type, called the referenced type. A pointer type describes an object whose value
+ provides a reference to an entity of the referenced type. A pointer type derived from
+ the referenced type T is sometimes called ''pointer to T ''. The construction of a
+ pointer type from a referenced type is called ''pointer type derivation''.
+</ul>
+ These methods of constructing derived types can be applied recursively.
+<p><!--para 21-->
+ Arithmetic types and pointer types are collectively called scalar types. Array and
+ structure types are collectively called aggregate types.<sup><a href="#note37"><b>37)</b></a></sup>
+<p><!--para 22-->
+ An array type of unknown size is an incomplete type. It is completed, for an identifier of
+ that type, by specifying the size in a later declaration (with internal or external linkage).
+ A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
+ type. It is completed, for all declarations of that type, by declaring the same structure or
+ union tag with its defining content later in the same scope.
+<p><!--para 23-->
+ A type has known constant size if the type is not incomplete and is not a variable length
+ array type.
+<p><!--para 24-->
+ Array, function, and pointer types are collectively called derived declarator types. A
+ declarator type derivation from a type T is the construction of a derived declarator type
+ from T by the application of an array-type, a function-type, or a pointer-type derivation to
+ T.
+<p><!--para 25-->
+ A type is characterized by its type category, which is either the outermost derivation of a
+ derived type (as noted above in the construction of derived types), or the type itself if the
+ type consists of no derived types.
+<p><!--para 26-->
+ Any type so far mentioned is an unqualified type. Each unqualified type has several
+ qualified versions of its type,<sup><a href="#note38"><b>38)</b></a></sup> corresponding to the combinations of one, two, or all
+ three of the const, volatile, and restrict qualifiers. The qualified or unqualified
+ versions of a type are distinct types that belong to the same type category and have the
+ same representation and alignment requirements.<sup><a href="#note39"><b>39)</b></a></sup> A derived type is not qualified by the
+ qualifiers (if any) of the type from which it is derived.
+<p><!--para 27-->
+ A pointer to void shall have the same representation and alignment requirements as a
+ pointer to a character type.39) Similarly, pointers to qualified or unqualified versions of
+ compatible types shall have the same representation and alignment requirements. All
+ 
+ 
+<!--page 49 indent 5-->
+ pointers to structure types shall have the same representation and alignment requirements
+ as each other. All pointers to union types shall have the same representation and
+ alignment requirements as each other. Pointers to other types need not have the same
+ representation or alignment requirements.
+<p><!--para 28-->
+ EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
+ pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
+ whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
+ qualified float'' and is a pointer to a qualified type.
+ 
+<p><!--para 29-->
+ EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
+ function returning struct tag''. The array has length five and the function has a single parameter of type
+ float. Its type category is array.
+ 
+ Forward references: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
+
+<h6>footnotes</h6>
+<p><a name="note28">28)</a> Implementation-defined keywords shall have the form of an identifier reserved for any use as
+ described in <a href="#7.1.3">7.1.3</a>.
+
+<p><a name="note29">29)</a> Therefore, any statement in this Standard about signed integer types also applies to the extended
+ signed integer types.
+
+<p><a name="note30">30)</a> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
+ unsigned integer types.
+
+<p><a name="note31">31)</a> The same representation and alignment requirements are meant to imply interchangeability as
+ arguments to functions, return values from functions, and members of unions.
+
+<p><a name="note32">32)</a> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
+
+<p><a name="note33">33)</a> A specification for imaginary types is in informative <a href="#G">annex G</a>.
+
+<p><a name="note34">34)</a> An implementation may define new keywords that provide alternative ways to designate a basic (or
+ any other) type; this does not violate the requirement that all basic types be different.
+ Implementation-defined keywords shall have the form of an identifier reserved for any use as
+ described in <a href="#7.1.3">7.1.3</a>.
+
+<p><a name="note35">35)</a> CHAR_MIN, defined in &lt;limits.h&gt;, will have one of the values 0 or SCHAR_MIN, and this can be
+ used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
+ other two and is not compatible with either.
+
+<p><a name="note36">36)</a> Since object types do not include incomplete types, an array of incomplete type cannot be constructed.
+
+<p><a name="note37">37)</a> Note that aggregate type does not include union type because an object with union type can only
+ contain one member at a time.
+
+<p><a name="note38">38)</a> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
+
+<p><a name="note39">39)</a> The same representation and alignment requirements are meant to imply interchangeability as
+ arguments to functions, return values from functions, and members of unions.
+
+
+<a name="6.2.6" href="#6.2.6"><h4>6.2.6 Representations of types</h4></a>
+
+<a name="6.2.6.1" href="#6.2.6.1"><h5>6.2.6.1 General</h5></a>
+<p><!--para 1-->
+ The representations of all types are unspecified except as stated in this subclause.
+<p><!--para 2-->
+ Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
+ the number, order, and encoding of which are either explicitly specified or
+ implementation-defined.
+<p><!--para 3-->
+ Values stored in unsigned bit-fields and objects of type unsigned char shall be
+ represented using a pure binary notation.<sup><a href="#note40"><b>40)</b></a></sup>
+<p><!--para 4-->
+ Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
+ bits, where n is the size of an object of that type, in bytes. The value may be copied into
+ an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
+ called the object representation of the value. Values stored in bit-fields consist of m bits,
+ where m is the size specified for the bit-field. The object representation is the set of m
+ bits the bit-field comprises in the addressable storage unit holding it. Two values (other
+ than NaNs) with the same object representation compare equal, but values that compare
+ equal may have different object representations.
+<p><!--para 5-->
+ Certain object representations need not represent a value of the object type. If the stored
+ value of an object has such a representation and is read by an lvalue expression that does
+ not have character type, the behavior is undefined. If such a representation is produced
+ by a side effect that modifies all or any part of the object by an lvalue expression that
+ does not have character type, the behavior is undefined.<sup><a href="#note41"><b>41)</b></a></sup> Such a representation is called
+ 
+<!--page 50 indent 4-->
+ a trap representation.
+<p><!--para 6-->
+ When a value is stored in an object of structure or union type, including in a member
+ object, the bytes of the object representation that correspond to any padding bytes take
+ unspecified values.<sup><a href="#note42"><b>42)</b></a></sup> The value of a structure or union object is never a trap
+ representation, even though the value of a member of the structure or union object may be
+ a trap representation.
+<p><!--para 7-->
+ When a value is stored in a member of an object of union type, the bytes of the object
+ representation that do not correspond to that member but do correspond to other members
+ take unspecified values.
+<p><!--para 8-->
+ Where an operator is applied to a value that has more than one object representation,
+ which object representation is used shall not affect the value of the result.<sup><a href="#note43"><b>43)</b></a></sup> Where a
+ value is stored in an object using a type that has more than one object representation for
+ that value, it is unspecified which representation is used, but a trap representation shall
+ not be generated.
+ Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
+ designators (<a href="#6.3.2.1">6.3.2.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note40">40)</a> A positional representation for integers that uses the binary digits 0 and 1, in which the values
+ represented by successive bits are additive, begin with 1, and are multiplied by successive integral
+ powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
+ Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
+ type unsigned char range from 0 to 2
+
+<pre>
+                                           CHAR_BIT
+                                                     - 1.</pre>
+
+<p><a name="note41">41)</a> Thus, an automatic variable can be initialized to a trap representation without causing undefined
+ behavior, but the value of the variable cannot be used until a proper value is stored in it.
+
+<p><a name="note42">42)</a> Thus, for example, structure assignment need not copy any padding bits.
+
+<p><a name="note43">43)</a> It is possible for objects x and y with the same effective type T to have the same value when they are
+ accessed as objects of type T, but to have different values in other contexts. In particular, if == is
+ defined for type T, then x == y does not imply that memcmp(&amp;x, &amp;y, sizeof (T)) == 0.
+ Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
+ on values of type T may distinguish between them.
+
+
+<a name="6.2.6.2" href="#6.2.6.2"><h5>6.2.6.2 Integer types</h5></a>
+<p><!--para 1-->
+ For unsigned integer types other than unsigned char, the bits of the object
+ representation shall be divided into two groups: value bits and padding bits (there need
+ not be any of the latter). If there are N value bits, each bit shall represent a different
+ power of 2 between 1 and 2 N -1 , so that objects of that type shall be capable of
+ representing values from 0 to 2 N - 1 using a pure binary representation; this shall be
+ known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note44"><b>44)</b></a></sup>
+<p><!--para 2-->
+ For signed integer types, the bits of the object representation shall be divided into three
+ groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
+ 
+<!--page 51 indent 4-->
+ there shall be exactly one sign bit. Each bit that is a value bit shall have the same value as
+ the same bit in the object representation of the corresponding unsigned type (if there are
+ M value bits in the signed type and N in the unsigned type, then M &lt;= N ). If the sign bit
+ is zero, it shall not affect the resulting value. If the sign bit is one, the value shall be
+ modified in one of the following ways:
+<ul>
+<li>  the corresponding value with sign bit 0 is negated (sign and magnitude);
+<li>  the sign bit has the value -(2 N ) (two's complement);
+<li>  the sign bit has the value -(2 N - 1) (ones' complement ).
+</ul>
+ Which of these applies is implementation-defined, as is whether the value with sign bit 1
+ and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones'
+ complement), is a trap representation or a normal value. In the case of sign and
+ magnitude and ones' complement, if this representation is a normal value it is called a
+ negative zero.
+<p><!--para 3-->
+ If the implementation supports negative zeros, they shall be generated only by:
+<ul>
+<li>  the &amp;, |, ^, ~, &lt;&lt;, and &gt;&gt; operators with arguments that produce such a value;
+<li>  the +, -, *, /, and % operators where one argument is a negative zero and the result is
+ zero;
+<li>  compound assignment operators based on the above cases.
+</ul>
+ It is unspecified whether these cases actually generate a negative zero or a normal zero,
+ and whether a negative zero becomes a normal zero when stored in an object.
+<p><!--para 4-->
+ If the implementation does not support negative zeros, the behavior of the &amp;, |, ^, ~, &lt;&lt;,
+ and &gt;&gt; operators with arguments that would produce such a value is undefined.
+<p><!--para 5-->
+ The values of any padding bits are unspecified.<sup><a href="#note45"><b>45)</b></a></sup> A valid (non-trap) object representation
+ of a signed integer type where the sign bit is zero is a valid object representation of the
+ corresponding unsigned type, and shall represent the same value. For any integer type,
+ the object representation where all the bits are zero shall be a representation of the value
+ zero in that type.
+<p><!--para 6-->
+ The precision of an integer type is the number of bits it uses to represent values,
+ excluding any sign and padding bits. The width of an integer type is the same but
+ including any sign bit; thus for unsigned integer types the two values are the same, while
+ 
+ 
+<!--page 52 indent 4-->
+ for signed integer types the width is one greater than the precision.
+
+<h6>footnotes</h6>
+<p><a name="note44">44)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
+ bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+ representation other than as part of an exceptional condition such as an overflow, and this cannot occur
+ with unsigned types. All other combinations of padding bits are alternative object representations of
+ the value specified by the value bits.
+
+<p><a name="note45">45)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
+ bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+ representation other than as part of an exceptional condition such as an overflow. All other
+ combinations of padding bits are alternative object representations of the value specified by the value
+ bits.
+
+
+<a name="6.2.7" href="#6.2.7"><h4>6.2.7 Compatible type and composite type</h4></a>
+<p><!--para 1-->
+ Two types have compatible type if their types are the same. Additional rules for
+ determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
+ in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.5">6.7.5</a> for declarators.<sup><a href="#note46"><b>46)</b></a></sup> Moreover, two structure,
+ union, or enumerated types declared in separate translation units are compatible if their
+ tags and members satisfy the following requirements: If one is declared with a tag, the
+ other shall be declared with the same tag. If both are complete types, then the following
+ additional requirements apply: there shall be a one-to-one correspondence between their
+ members such that each pair of corresponding members are declared with compatible
+ types, and such that if one member of a corresponding pair is declared with a name, the
+ other member is declared with the same name. For two structures, corresponding
+ members shall be declared in the same order. For two structures or unions, corresponding
+ bit-fields shall have the same widths. For two enumerations, corresponding members
+ shall have the same values.
+<p><!--para 2-->
+ All declarations that refer to the same object or function shall have compatible type;
+ otherwise, the behavior is undefined.
+<p><!--para 3-->
+ A composite type can be constructed from two types that are compatible; it is a type that
+ is compatible with both of the two types and satisfies the following conditions:
+<ul>
+<li>  If one type is an array of known constant size, the composite type is an array of that
+ size; otherwise, if one type is a variable length array, the composite type is that type.
+<li>  If only one type is a function type with a parameter type list (a function prototype),
+ the composite type is a function prototype with the parameter type list.
+<li>  If both types are function types with parameter type lists, the type of each parameter
+ in the composite parameter type list is the composite type of the corresponding
+ parameters.
+</ul>
+ These rules apply recursively to the types from which the two types are derived.
+<p><!--para 4-->
+ For an identifier with internal or external linkage declared in a scope in which a prior
+ declaration of that identifier is visible,<sup><a href="#note47"><b>47)</b></a></sup> if the prior declaration specifies internal or
+ external linkage, the type of the identifier at the later declaration becomes the composite
+ type.
+ 
+ 
+ 
+ 
+<!--page 53 indent 4-->
+<p><!--para 5-->
+ EXAMPLE        Given the following two file scope declarations:
+<pre>
+          int f(int (*)(), double (*)[3]);
+          int f(int (*)(char *), double (*)[]);</pre>
+ The resulting composite type for the function is:
+<!--page 54 indent 4-->
+<pre>
+          int f(int (*)(char *), double (*)[3]);</pre>
+
+<h6>footnotes</h6>
+<p><a name="note46">46)</a> Two types need not be identical to be compatible.
+
+<p><a name="note47">47)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+
+
+<a name="6.3" href="#6.3"><h3>6.3 Conversions</h3></a>
+<p><!--para 1-->
+ Several operators convert operand values from one type to another automatically. This
+ subclause specifies the result required from such an implicit conversion, as well as those
+ that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
+ the conversions performed by most ordinary operators; it is supplemented as required by
+ the discussion of each operator in <a href="#6.5">6.5</a>.
+<p><!--para 2-->
+ Conversion of an operand value to a compatible type causes no change to the value or the
+ representation.
+ Forward references: cast operators (<a href="#6.5.4">6.5.4</a>).
+
+<a name="6.3.1" href="#6.3.1"><h4>6.3.1 Arithmetic operands</h4></a>
+
+<a name="6.3.1.1" href="#6.3.1.1"><h5>6.3.1.1 Boolean, characters, and integers</h5></a>
+<p><!--para 1-->
+ Every integer type has an integer conversion rank defined as follows:
+<ul>
+<li>  No two signed integer types shall have the same rank, even if they have the same
+ representation.
+<li>  The rank of a signed integer type shall be greater than the rank of any signed integer
+ type with less precision.
+<li>  The rank of long long int shall be greater than the rank of long int, which
+ shall be greater than the rank of int, which shall be greater than the rank of short
+ int, which shall be greater than the rank of signed char.
+<li>  The rank of any unsigned integer type shall equal the rank of the corresponding
+ signed integer type, if any.
+<li>  The rank of any standard integer type shall be greater than the rank of any extended
+ integer type with the same width.
+<li>  The rank of char shall equal the rank of signed char and unsigned char.
+<li>  The rank of _Bool shall be less than the rank of all other standard integer types.
+<li>  The rank of any enumerated type shall equal the rank of the compatible integer type
+ (see <a href="#6.7.2.2">6.7.2.2</a>).
+<li>  The rank of any extended signed integer type relative to another extended signed
+ integer type with the same precision is implementation-defined, but still subject to the
+ other rules for determining the integer conversion rank.
+<li>  For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
+ greater rank than T3, then T1 has greater rank than T3.
+</ul>
+<p><!--para 2-->
+ The following may be used in an expression wherever an int or unsigned int may
+ be used:
+<!--page 55 indent 4-->
+<ul>
+<li>  An object or expression with an integer type whose integer conversion rank is less
+ than or equal to the rank of int and unsigned int.
+<li>  A bit-field of type _Bool, int, signed int, or unsigned int.
+</ul>
+ If an int can represent all values of the original type, the value is converted to an int;
+ otherwise, it is converted to an unsigned int. These are called the integer
+ promotions.<sup><a href="#note48"><b>48)</b></a></sup> All other types are unchanged by the integer promotions.
+<p><!--para 3-->
+ The integer promotions preserve value including sign. As discussed earlier, whether a
+ ''plain'' char is treated as signed is implementation-defined.
+ Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note48">48)</a> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
+ argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
+ shift operators, as specified by their respective subclauses.
+
+
+<a name="6.3.1.2" href="#6.3.1.2"><h5>6.3.1.2 Boolean type</h5></a>
+<p><!--para 1-->
+ When any scalar value is converted to _Bool, the result is 0 if the value compares equal
+ to 0; otherwise, the result is 1.
+
+<a name="6.3.1.3" href="#6.3.1.3"><h5>6.3.1.3 Signed and unsigned integers</h5></a>
+<p><!--para 1-->
+ When a value with integer type is converted to another integer type other than _Bool, if
+ the value can be represented by the new type, it is unchanged.
+<p><!--para 2-->
+ Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
+ subtracting one more than the maximum value that can be represented in the new type
+ until the value is in the range of the new type.<sup><a href="#note49"><b>49)</b></a></sup>
+<p><!--para 3-->
+ Otherwise, the new type is signed and the value cannot be represented in it; either the
+ result is implementation-defined or an implementation-defined signal is raised.
+
+<h6>footnotes</h6>
+<p><a name="note49">49)</a> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
+
+
+<a name="6.3.1.4" href="#6.3.1.4"><h5>6.3.1.4 Real floating and integer</h5></a>
+<p><!--para 1-->
+ When a finite value of real floating type is converted to an integer type other than _Bool,
+ the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
+ the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup>
+<p><!--para 2-->
+ When a value of integer type is converted to a real floating type, if the value being
+ converted can be represented exactly in the new type, it is unchanged. If the value being
+ converted is in the range of values that can be represented but cannot be represented
+ 
+<!--page 56 indent 4-->
+ exactly, the result is either the nearest higher or nearest lower representable value, chosen
+ in an implementation-defined manner. If the value being converted is outside the range of
+ values that can be represented, the behavior is undefined.
+
+<h6>footnotes</h6>
+<p><a name="note50">50)</a> The remaindering operation performed when a value of integer type is converted to unsigned type
+ need not be performed when a value of real floating type is converted to unsigned type. Thus, the
+ range of portable real floating values is (-1, Utype_MAX+1).
+
+
+<a name="6.3.1.5" href="#6.3.1.5"><h5>6.3.1.5 Real floating types</h5></a>
+<p><!--para 1-->
+ When a float is promoted to double or long double, or a double is promoted
+ to long double, its value is unchanged (if the source value is represented in the
+ precision and range of its type).
+<p><!--para 2-->
+ When a double is demoted to float, a long double is demoted to double or
+ float, or a value being represented in greater precision and range than required by its
+ semantic type (see <a href="#6.3.1.8">6.3.1.8</a>) is explicitly converted (including to its own type), if the value
+ being converted can be represented exactly in the new type, it is unchanged. If the value
+ being converted is in the range of values that can be represented but cannot be
+ represented exactly, the result is either the nearest higher or nearest lower representable
+ value, chosen in an implementation-defined manner. If the value being converted is
+ outside the range of values that can be represented, the behavior is undefined.
+
+<a name="6.3.1.6" href="#6.3.1.6"><h5>6.3.1.6 Complex types</h5></a>
+<p><!--para 1-->
+ When a value of complex type is converted to another complex type, both the real and
+ imaginary parts follow the conversion rules for the corresponding real types.
+
+<a name="6.3.1.7" href="#6.3.1.7"><h5>6.3.1.7 Real and complex</h5></a>
+<p><!--para 1-->
+ When a value of real type is converted to a complex type, the real part of the complex
+ result value is determined by the rules of conversion to the corresponding real type and
+ the imaginary part of the complex result value is a positive zero or an unsigned zero.
+<p><!--para 2-->
+ When a value of complex type is converted to a real type, the imaginary part of the
+ complex value is discarded and the value of the real part is converted according to the
+ conversion rules for the corresponding real type.
+
+<a name="6.3.1.8" href="#6.3.1.8"><h5>6.3.1.8 Usual arithmetic conversions</h5></a>
+<p><!--para 1-->
+ Many operators that expect operands of arithmetic type cause conversions and yield result
+ types in a similar way. The purpose is to determine a common real type for the operands
+ and result. For the specified operands, each operand is converted, without change of type
+ domain, to a type whose corresponding real type is the common real type. Unless
+ explicitly stated otherwise, the common real type is also the corresponding real type of
+ the result, whose type domain is the type domain of the operands if they are the same,
+ and complex otherwise. This pattern is called the usual arithmetic conversions:
+<!--page 57 indent 4-->
+<p><!--para 2-->
+<pre>
+       First, if the corresponding real type of either operand is long double, the other
+       operand is converted, without change of type domain, to a type whose
+       corresponding real type is long double.
+       Otherwise, if the corresponding real type of either operand is double, the other
+       operand is converted, without change of type domain, to a type whose
+       corresponding real type is double.
+       Otherwise, if the corresponding real type of either operand is float, the other
+       operand is converted, without change of type domain, to a type whose
+       corresponding real type is float.<sup><a href="#note51"><b>51)</b></a></sup>
+       Otherwise, the integer promotions are performed on both operands. Then the
+       following rules are applied to the promoted operands:
+              If both operands have the same type, then no further conversion is needed.
+              Otherwise, if both operands have signed integer types or both have unsigned
+              integer types, the operand with the type of lesser integer conversion rank is
+              converted to the type of the operand with greater rank.
+              Otherwise, if the operand that has unsigned integer type has rank greater or
+              equal to the rank of the type of the other operand, then the operand with
+              signed integer type is converted to the type of the operand with unsigned
+              integer type.
+              Otherwise, if the type of the operand with signed integer type can represent
+              all of the values of the type of the operand with unsigned integer type, then
+              the operand with unsigned integer type is converted to the type of the
+              operand with signed integer type.
+              Otherwise, both operands are converted to the unsigned integer type
+              corresponding to the type of the operand with signed integer type.</pre>
+ The values of floating operands and of the results of floating expressions may be
+ represented in greater precision and range than that required by the type; the types are not
+ changed thereby.<sup><a href="#note52"><b>52)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 58 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note51">51)</a> For example, addition of a double _Complex and a float entails just the conversion of the
+ float operand to double (and yields a double _Complex result).
+
+<p><a name="note52">52)</a> The cast and assignment operators are still required to perform their specified conversions as
+ described in <a href="#6.3.1.4">6.3.1.4</a> and <a href="#6.3.1.5">6.3.1.5</a>.
+
+
+<a name="6.3.2" href="#6.3.2"><h4>6.3.2 Other operands</h4></a>
+
+<a name="6.3.2.1" href="#6.3.2.1"><h5>6.3.2.1 Lvalues, arrays, and function designators</h5></a>
+<p><!--para 1-->
+ An lvalue is an expression with an object type or an incomplete type other than void;<sup><a href="#note53"><b>53)</b></a></sup>
+ if an lvalue does not designate an object when it is evaluated, the behavior is undefined.
+ When an object is said to have a particular type, the type is specified by the lvalue used to
+ designate the object. A modifiable lvalue is an lvalue that does not have array type, does
+ not have an incomplete type, does not have a const-qualified type, and if it is a structure
+ or union, does not have any member (including, recursively, any member or element of
+ all contained aggregates or unions) with a const-qualified type.
+<p><!--para 2-->
+ Except when it is the operand of the sizeof operator, the unary &amp; operator, the ++
+ operator, the -- operator, or the left operand of the . operator or an assignment operator,
+ an lvalue that does not have array type is converted to the value stored in the designated
+ object (and is no longer an lvalue). If the lvalue has qualified type, the value has the
+ unqualified version of the type of the lvalue; otherwise, the value has the type of the
+ lvalue. If the lvalue has an incomplete type and does not have array type, the behavior is
+ undefined.
+<p><!--para 3-->
+ Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a
+ string literal used to initialize an array, an expression that has type ''array of type'' is
+ converted to an expression with type ''pointer to type'' that points to the initial element of
+ the array object and is not an lvalue. If the array object has register storage class, the
+ behavior is undefined.
+<p><!--para 4-->
+ A function designator is an expression that has function type. Except when it is the
+ operand of the sizeof operator<sup><a href="#note54"><b>54)</b></a></sup> or the unary &amp; operator, a function designator with
+ type ''function returning type'' is converted to an expression that has type ''pointer to
+ function returning type''.
+ Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
+ (<a href="#6.5.16">6.5.16</a>), common definitions &lt;stddef.h&gt; (<a href="#7.17">7.17</a>), initialization (<a href="#6.7.8">6.7.8</a>), postfix
+ increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+ (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>).
+ 
+ 
+<!--page 59 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note53">53)</a> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
+ operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
+ object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
+ as the ''value of an expression''.
+  An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
+  expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
+
+<p><a name="note54">54)</a> Because this conversion does not occur, the operand of the sizeof operator remains a function
+ designator and violates the constraint in <a href="#6.5.3.4">6.5.3.4</a>.
+
+
+<a name="6.3.2.2" href="#6.3.2.2"><h5>6.3.2.2 void</h5></a>
+<p><!--para 1-->
+ The (nonexistent) value of a void expression (an expression that has type void) shall not
+ be used in any way, and implicit or explicit conversions (except to void) shall not be
+ applied to such an expression. If an expression of any other type is evaluated as a void
+ expression, its value or designator is discarded. (A void expression is evaluated for its
+ side effects.)
+
+<a name="6.3.2.3" href="#6.3.2.3"><h5>6.3.2.3 Pointers</h5></a>
+<p><!--para 1-->
+ A pointer to void may be converted to or from a pointer to any incomplete or object
+ type. A pointer to any incomplete or object type may be converted to a pointer to void
+ and back again; the result shall compare equal to the original pointer.
+<p><!--para 2-->
+ For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
+ the q-qualified version of the type; the values stored in the original and converted pointers
+ shall compare equal.
+<p><!--para 3-->
+ An integer constant expression with the value 0, or such an expression cast to type
+ void *, is called a null pointer constant.<sup><a href="#note55"><b>55)</b></a></sup> If a null pointer constant is converted to a
+ pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
+ to a pointer to any object or function.
+<p><!--para 4-->
+ Conversion of a null pointer to another pointer type yields a null pointer of that type.
+ Any two null pointers shall compare equal.
+<p><!--para 5-->
+ An integer may be converted to any pointer type. Except as previously specified, the
+ result is implementation-defined, might not be correctly aligned, might not point to an
+ entity of the referenced type, and might be a trap representation.<sup><a href="#note56"><b>56)</b></a></sup>
+<p><!--para 6-->
+ Any pointer type may be converted to an integer type. Except as previously specified, the
+ result is implementation-defined. If the result cannot be represented in the integer type,
+ the behavior is undefined. The result need not be in the range of values of any integer
+ type.
+<p><!--para 7-->
+ A pointer to an object or incomplete type may be converted to a pointer to a different
+ object or incomplete type. If the resulting pointer is not correctly aligned<sup><a href="#note57"><b>57)</b></a></sup> for the
+ pointed-to type, the behavior is undefined. Otherwise, when converted back again, the
+ result shall compare equal to the original pointer. When a pointer to an object is
+ 
+ 
+<!--page 60 indent 4-->
+ converted to a pointer to a character type, the result points to the lowest addressed byte of
+ the object. Successive increments of the result, up to the size of the object, yield pointers
+ to the remaining bytes of the object.
+<p><!--para 8-->
+ A pointer to a function of one type may be converted to a pointer to a function of another
+ type and back again; the result shall compare equal to the original pointer. If a converted
+ pointer is used to call a function whose type is not compatible with the pointed-to type,
+ the behavior is undefined.
+ Forward references: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
+ capable of holding object pointers (<a href="#7.18.1.4">7.18.1.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+<!--page 61 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note55">55)</a> The macro NULL is defined in &lt;stddef.h&gt; (and other headers) as a null pointer constant; see <a href="#7.17">7.17</a>.
+
+<p><a name="note56">56)</a> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
+ be consistent with the addressing structure of the execution environment.
+
+<p><a name="note57">57)</a> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
+ pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
+ correctly aligned for a pointer to type C.
+
+
+<a name="6.4" href="#6.4"><h3>6.4 Lexical elements</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          token:
+                   keyword
+                   identifier
+                   constant
+                   string-literal
+                   punctuator
+          preprocessing-token:
+                 header-name
+                 identifier
+                 pp-number
+                 character-constant
+                 string-literal
+                 punctuator
+                 each non-white-space character that cannot be one of the above</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each preprocessing token that is converted to a token shall have the lexical form of a
+ keyword, an identifier, a constant, a string literal, or a punctuator.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A token is the minimal lexical element of the language in translation phases 7 and 8. The
+ categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
+ A preprocessing token is the minimal lexical element of the language in translation
+ phases 3 through 6. The categories of preprocessing tokens are: header names,
+ identifiers, preprocessing numbers, character constants, string literals, punctuators, and
+ single non-white-space characters that do not lexically match the other preprocessing
+ token categories.<sup><a href="#note58"><b>58)</b></a></sup> If a ' or a " character matches the last category, the behavior is
+ undefined. Preprocessing tokens can be separated by white space; this consists of
+ comments (described later), or white-space characters (space, horizontal tab, new-line,
+ vertical tab, and form-feed), or both. As described in <a href="#6.10">6.10</a>, in certain circumstances
+ during translation phase 4, white space (or the absence thereof) serves as more than
+ preprocessing token separation. White space may appear within a preprocessing token
+ only as part of a header name or between the quotation characters in a character constant
+ or string literal.
+ 
+ 
+ 
+<!--page 62 indent 4-->
+<p><!--para 4-->
+ If the input stream has been parsed into preprocessing tokens up to a given character, the
+ next preprocessing token is the longest sequence of characters that could constitute a
+ preprocessing token. There is one exception to this rule: header name preprocessing
+ tokens are recognized only within #include preprocessing directives and in
+ implementation-defined locations within #pragma directives. In such contexts, a
+ sequence of characters that could be either a header name or a string literal is recognized
+ as the former.
+<p><!--para 5-->
+ EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
+ valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
+ might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
+ fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
+ not E is a macro name.
+ 
+<p><!--para 6-->
+ EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
+ increment operators, even though the parse x ++ + ++ y might yield a correct expression.
+ 
+ Forward references: character constants (<a href="#6.4.4.4">6.4.4.4</a>), comments (<a href="#6.4.9">6.4.9</a>), expressions (<a href="#6.5">6.5</a>),
+ floating constants (<a href="#6.4.4.2">6.4.4.2</a>), header names (<a href="#6.4.7">6.4.7</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), postfix
+ increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+ (<a href="#6.5.3.1">6.5.3.1</a>), preprocessing directives (<a href="#6.10">6.10</a>), preprocessing numbers (<a href="#6.4.8">6.4.8</a>), string literals
+ (<a href="#6.4.5">6.4.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note58">58)</a> An additional category, placemarkers, is used internally in translation phase 4 (see <a href="#6.10.3.3">6.10.3.3</a>); it cannot
+ occur in source files.
+
+
+<a name="6.4.1" href="#6.4.1"><h4>6.4.1 Keywords</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          keyword: one of
+                auto                    enum                  restrict              unsigned
+                break                   extern                return                void
+                case                    float                 short                 volatile
+                char                    for                   signed                while
+                const                   goto                  sizeof                _Bool
+                continue                if                    static                _Complex
+                default                 inline                struct                _Imaginary
+                do                      int                   switch
+                double                  long                  typedef
+                else                    register              union</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The above tokens (case sensitive) are reserved (in translation phases 7 and 8) for use as
+ keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
+ specifying imaginary types.<sup><a href="#note59"><b>59)</b></a></sup>
+ 
+ 
+ 
+<!--page 63 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note59">59)</a> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
+
+
+<a name="6.4.2" href="#6.4.2"><h4>6.4.2 Identifiers</h4></a>
+
+<a name="6.4.2.1" href="#6.4.2.1"><h5>6.4.2.1 General</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          identifier:
+                 identifier-nondigit
+                  identifier identifier-nondigit
+                 identifier digit
+          identifier-nondigit:
+                  nondigit
+                  universal-character-name
+                 other implementation-defined characters
+          nondigit: one of
+                 _ a b            c    d    e    f     g    h    i    j     k    l    m
+                     n o          p    q    r    s     t    u    v    w     x    y    z
+                     A B          C    D    E    F     G    H    I    J     K    L    M
+                     N O          P    Q    R    S     T    U    V    W     X    Y    Z
+          digit: one of
+                 0 1        2     3    4    5    6     7    8    9</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ An identifier is a sequence of nondigit characters (including the underscore _, the
+ lowercase and uppercase Latin letters, and other characters) and digits, which designates
+ one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
+ There is no specific limit on the maximum length of an identifier.
+<p><!--para 3-->
+ Each universal character name in an identifier shall designate a character whose encoding
+ in ISO/IEC 10646 falls into one of the ranges specified in <a href="#D">annex D</a>.<sup><a href="#note60"><b>60)</b></a></sup> The initial
+ character shall not be a universal character name designating a digit. An implementation
+ may allow multibyte characters that are not part of the basic source character set to
+ appear in identifiers; which characters and their correspondence to universal character
+ names is implementation-defined.
+<p><!--para 4-->
+ When preprocessing tokens are converted to tokens during translation phase 7, if a
+ preprocessing token could be converted to either a keyword or an identifier, it is converted
+ to a keyword.
+ 
+ 
+<!--page 64 indent 4-->
+ Implementation limits
+<p><!--para 5-->
+ As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
+ characters in an identifier; the limit for an external name (an identifier that has external
+ linkage) may be more restrictive than that for an internal name (a macro name or an
+ identifier that does not have external linkage). The number of significant characters in an
+ identifier is implementation-defined.
+<p><!--para 6-->
+ Any identifiers that differ in a significant character are different identifiers. If two
+ identifiers differ only in nonsignificant characters, the behavior is undefined.
+ Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note60">60)</a> On systems in which linkers cannot accept extended characters, an encoding of the universal character
+ name may be used in forming valid external identifiers. For example, some otherwise unused
+ character or sequence of characters may be used to encode the \u in a universal character name.
+ Extended characters may produce a long external identifier.
+
+
+<a name="6.4.2.2" href="#6.4.2.2"><h5>6.4.2.2 Predefined identifiers</h5></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ The identifier __func__ shall be implicitly declared by the translator as if,
+ immediately following the opening brace of each function definition, the declaration
+<pre>
+          static const char __func__[] = "function-name";</pre>
+ appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note61"><b>61)</b></a></sup>
+<p><!--para 2-->
+ This name is encoded as if the implicit declaration had been written in the source
+ character set and then translated into the execution character set as indicated in translation
+ phase 5.
+<p><!--para 3-->
+ EXAMPLE        Consider the code fragment:
+<pre>
+          #include &lt;stdio.h&gt;
+          void myfunc(void)
+          {
+                printf("%s\n", __func__);
+                /* ... */
+          }</pre>
+ Each time the function is called, it will print to the standard output stream:
+<pre>
+          myfunc</pre>
+ 
+ Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+ 
+ 
+ 
+ 
+<!--page 65 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note61">61)</a> Since the name __func__ is reserved for any use by the implementation (<a href="#7.1.3">7.1.3</a>), if any other
+ identifier is explicitly declared using the name __func__, the behavior is undefined.
+
+
+<a name="6.4.3" href="#6.4.3"><h4>6.4.3 Universal character names</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          universal-character-name:
+                 \u hex-quad
+                 \U hex-quad hex-quad
+          hex-quad:
+                 hexadecimal-digit hexadecimal-digit
+                              hexadecimal-digit hexadecimal-digit</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A universal character name shall not specify a character whose short identifier is less than
+ 00A0 other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through
+ DFFF inclusive.<sup><a href="#note62"><b>62)</b></a></sup>
+<h6>Description</h6>
+<p><!--para 3-->
+ Universal character names may be used in identifiers, character constants, and string
+ literals to designate characters that are not in the basic character set.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The universal character name \Unnnnnnnn designates the character whose eight-digit
+ short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note63"><b>63)</b></a></sup> Similarly, the universal
+ character name \unnnn designates the character whose four-digit short identifier is nnnn
+ (and whose eight-digit short identifier is 0000nnnn).
+ 
+ 
+ 
+ 
+<!--page 66 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note62">62)</a> The disallowed characters are the characters in the basic character set and the code positions reserved
+ by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
+ UTF-16).
+
+<p><a name="note63">63)</a> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
+
+
+<a name="6.4.4" href="#6.4.4"><h4>6.4.4 Constants</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          constant:
+                 integer-constant
+                 floating-constant
+                 enumeration-constant
+                 character-constant</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each constant shall have a type and the value of a constant shall be in the range of
+ representable values for its type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ Each constant has a type, determined by its form and value, as detailed later.
+
+<a name="6.4.4.1" href="#6.4.4.1"><h5>6.4.4.1 Integer constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 67 indent 4-->
+<pre>
+          integer-constant:
+                  decimal-constant integer-suffixopt
+                  octal-constant integer-suffixopt
+                  hexadecimal-constant integer-suffixopt
+          decimal-constant:
+                nonzero-digit
+                decimal-constant digit
+          octal-constant:
+                 0
+                 octal-constant octal-digit
+          hexadecimal-constant:
+                hexadecimal-prefix hexadecimal-digit
+                hexadecimal-constant hexadecimal-digit
+          hexadecimal-prefix: one of
+                0x 0X
+          nonzero-digit: one of
+                 1 2 3 4          5     6     7   8    9
+          octal-digit: one of
+                  0 1 2 3         4     5     6   7
+        hexadecimal-digit:   one of
+              0 1 2           3 4      5    6   7     8   9
+              a b c           d e      f
+              A B C           D E      F
+        integer-suffix:
+                unsigned-suffix long-suffixopt
+                unsigned-suffix long-long-suffix
+                long-suffix unsigned-suffixopt
+                long-long-suffix unsigned-suffixopt
+        unsigned-suffix: one of
+               u U
+        long-suffix: one of
+               l L
+        long-long-suffix: one of
+               ll LL</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ An integer constant begins with a digit, but has no period or exponent part. It may have a
+ prefix that specifies its base and a suffix that specifies its type.
+<p><!--para 3-->
+ A decimal constant begins with a nonzero digit and consists of a sequence of decimal
+ digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
+ digits 0 through 7 only. A hexadecimal constant consists of the prefix 0x or 0X followed
+ by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
+ 10 through 15 respectively.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The value of a decimal constant is computed base 10; that of an octal constant, base 8;
+ that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
+<p><!--para 5-->
+ The type of an integer constant is the first of the corresponding list in which its value can
+ be represented.
+<!--page 68 indent 4-->
+<pre>
+                                                                  Octal or Hexadecimal</pre>
+ Suffix                       Decimal Constant                           Constant
+ 
+ none                int                                    int
+<pre>
+                     long int                               unsigned int
+                     long long int                          long int
+                                                            unsigned long int
+                                                            long long int
+                                                            unsigned long long int</pre>
+ 
+ u or U              unsigned int                           unsigned int
+<pre>
+                     unsigned long int                      unsigned long int
+                     unsigned long long int                 unsigned long long int</pre>
+ 
+ l or L              long int                               long int
+<pre>
+                     long long int                          unsigned long int
+                                                            long long int
+                                                            unsigned long long int</pre>
+ 
+ Both u or U         unsigned long int                      unsigned long int
+ and l or L          unsigned long long int                 unsigned long long int
+ 
+ ll or LL            long long int                          long long int
+<pre>
+                                                            unsigned long long int</pre>
+ 
+ Both u or U         unsigned long long int                 unsigned long long int
+ and ll or LL
+<p><!--para 6-->
+ If an integer constant cannot be represented by any type in its list, it may have an
+ extended integer type, if the extended integer type can represent its value. If all of the
+ types in the list for the constant are signed, the extended integer type shall be signed. If
+ all of the types in the list for the constant are unsigned, the extended integer type shall be
+ unsigned. If the list contains both signed and unsigned types, the extended integer type
+ may be signed or unsigned. If an integer constant cannot be represented by any type in
+ its list and has no extended integer type, then the integer constant has no type.
+<!--page 69 indent 4-->
+
+<a name="6.4.4.2" href="#6.4.4.2"><h5>6.4.4.2 Floating constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 70 indent 4-->
+<pre>
+          floating-constant:
+                 decimal-floating-constant
+                 hexadecimal-floating-constant
+          decimal-floating-constant:
+                fractional-constant exponent-partopt floating-suffixopt
+                digit-sequence exponent-part floating-suffixopt
+          hexadecimal-floating-constant:
+                hexadecimal-prefix hexadecimal-fractional-constant
+                               binary-exponent-part floating-suffixopt
+                hexadecimal-prefix hexadecimal-digit-sequence
+                               binary-exponent-part floating-suffixopt
+          fractional-constant:
+                  digit-sequenceopt . digit-sequence
+                  digit-sequence .
+          exponent-part:
+                e signopt digit-sequence
+                E signopt digit-sequence
+          sign: one of
+                 + -
+          digit-sequence:
+                  digit
+                  digit-sequence digit
+          hexadecimal-fractional-constant:
+                hexadecimal-digit-sequenceopt .
+                               hexadecimal-digit-sequence
+                hexadecimal-digit-sequence .
+          binary-exponent-part:
+                 p signopt digit-sequence
+                 P signopt digit-sequence
+          hexadecimal-digit-sequence:
+                hexadecimal-digit
+                hexadecimal-digit-sequence hexadecimal-digit
+          floating-suffix: one of
+                 f l F L</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A floating constant has a significand part that may be followed by an exponent part and a
+ suffix that specifies its type. The components of the significand part may include a digit
+ sequence representing the whole-number part, followed by a period (.), followed by a
+ digit sequence representing the fraction part. The components of the exponent part are an
+ e, E, p, or P followed by an exponent consisting of an optionally signed digit sequence.
+ Either the whole-number part or the fraction part has to be present; for decimal floating
+ constants, either the period or the exponent part has to be present.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The significand part is interpreted as a (decimal or hexadecimal) rational number; the
+ digit sequence in the exponent part is interpreted as a decimal integer. For decimal
+ floating constants, the exponent indicates the power of 10 by which the significand part is
+ to be scaled. For hexadecimal floating constants, the exponent indicates the power of 2
+ by which the significand part is to be scaled. For decimal floating constants, and also for
+ hexadecimal floating constants when FLT_RADIX is not a power of 2, the result is either
+ the nearest representable value, or the larger or smaller representable value immediately
+ adjacent to the nearest representable value, chosen in an implementation-defined manner.
+ For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
+ correctly rounded.
+<p><!--para 4-->
+ An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
+ type float. If suffixed by the letter l or L, it has type long double.
+<p><!--para 5-->
+ Floating constants are converted to internal format as if at translation-time. The
+ conversion of a floating constant shall not raise an exceptional condition or a floating-
+ point exception at execution time.
+ Recommended practice
+<p><!--para 6-->
+ The implementation should produce a diagnostic message if a hexadecimal constant
+ cannot be represented exactly in its evaluation format; the implementation should then
+ proceed with the translation of the program.
+<p><!--para 7-->
+ The translation-time conversion of floating constants should match the execution-time
+ conversion of character strings by library functions, such as strtod, given matching
+ inputs suitable for both conversions, the same result format, and default execution-time
+ rounding.<sup><a href="#note64"><b>64)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 71 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note64">64)</a> The specification for the library functions recommends more accurate conversion than required for
+ floating constants (see <a href="#7.20.1.3">7.20.1.3</a>).
+
+
+<a name="6.4.4.3" href="#6.4.4.3"><h5>6.4.4.3 Enumeration constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          enumeration-constant:
+                identifier</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ An identifier declared as an enumeration constant has type int.
+ Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
+
+<a name="6.4.4.4" href="#6.4.4.4"><h5>6.4.4.4 Character constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 72 indent 4-->
+<pre>
+          character-constant:
+                 ' c-char-sequence '
+                 L' c-char-sequence '
+          c-char-sequence:
+                 c-char
+                 c-char-sequence c-char
+          c-char:
+                    any member of the source character set except
+                                 the single-quote ', backslash \, or new-line character
+                    escape-sequence
+          escape-sequence:
+                 simple-escape-sequence
+                 octal-escape-sequence
+                 hexadecimal-escape-sequence
+                 universal-character-name
+          simple-escape-sequence: one of
+                 \' \" \? \\
+                 \a \b \f \n \r                  \t    \v
+          octal-escape-sequence:
+                  \ octal-digit
+                  \ octal-digit octal-digit
+                  \ octal-digit octal-digit octal-digit
+          hexadecimal-escape-sequence:
+                \x hexadecimal-digit
+                hexadecimal-escape-sequence hexadecimal-digit</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ An integer character constant is a sequence of one or more multibyte characters enclosed
+ in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
+ letter L. With a few exceptions detailed later, the elements of the sequence are any
+ members of the source character set; they are mapped in an implementation-defined
+ manner to members of the execution character set.
+<p><!--para 3-->
+ The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
+ arbitrary integer values are representable according to the following table of escape
+ sequences:
+<p><!--para 4-->
+<pre>
+        single quote '                 \'
+        double quote "                 \"
+        question mark ?                \?
+        backslash \                    \\
+        octal character                \octal digits
+        hexadecimal character          \x hexadecimal digits</pre>
+ The double-quote " and question-mark ? are representable either by themselves or by the
+ escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
+ shall be represented, respectively, by the escape sequences \' and \\.
+<p><!--para 5-->
+ The octal digits that follow the backslash in an octal escape sequence are taken to be part
+ of the construction of a single character for an integer character constant or of a single
+ wide character for a wide character constant. The numerical value of the octal integer so
+ formed specifies the value of the desired character or wide character.
+<p><!--para 6-->
+ The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
+ sequence are taken to be part of the construction of a single character for an integer
+ character constant or of a single wide character for a wide character constant. The
+ numerical value of the hexadecimal integer so formed specifies the value of the desired
+ character or wide character.
+<p><!--para 7-->
+ Each octal or hexadecimal escape sequence is the longest sequence of characters that can
+ constitute the escape sequence.
+<p><!--para 8-->
+ In addition, characters not in the basic character set are representable by universal
+ character names and certain nongraphic characters are representable by escape sequences
+ consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
+ and \v.<sup><a href="#note65"><b>65)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 73 indent 5-->
+<h6>Constraints</h6>
+<p><!--para 9-->
+ The value of an octal or hexadecimal escape sequence shall be in the range of
+ representable values for the type unsigned char for an integer character constant, or
+ the unsigned type corresponding to wchar_t for a wide character constant.
+<h6>Semantics</h6>
+<p><!--para 10-->
+ An integer character constant has type int. The value of an integer character constant
+ containing a single character that maps to a single-byte execution character is the
+ numerical value of the representation of the mapped character interpreted as an integer.
+ The value of an integer character constant containing more than one character (e.g.,
+ 'ab'), or containing a character or escape sequence that does not map to a single-byte
+ execution character, is implementation-defined. If an integer character constant contains
+ a single character or escape sequence, its value is the one that results when an object with
+ type char whose value is that of the single character or escape sequence is converted to
+ type int.
+<p><!--para 11-->
+ A wide character constant has type wchar_t, an integer type defined in the
+ &lt;stddef.h&gt; header. The value of a wide character constant containing a single
+ multibyte character that maps to a member of the extended execution character set is the
+ wide character corresponding to that multibyte character, as defined by the mbtowc
+ function, with an implementation-defined current locale. The value of a wide character
+ constant containing more than one multibyte character, or containing a multibyte
+ character or escape sequence not represented in the extended execution character set, is
+ implementation-defined.
+<p><!--para 12-->
+ EXAMPLE 1      The construction '\0' is commonly used to represent the null character.
+ 
+<p><!--para 13-->
+ EXAMPLE 2 Consider implementations that use two's-complement representation for integers and eight
+ bits for objects that have type char. In an implementation in which type char has the same range of
+ values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
+ same range of values as unsigned char, the character constant '\xFF' has the value +255.
+ 
+<p><!--para 14-->
+ EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
+ specifies an integer character constant containing only one character, since a hexadecimal escape sequence
+ is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
+ two characters whose values are '\x12' and '3', the construction '\0223' may be used, since an octal
+ escape sequence is terminated after three octal digits. (The value of this two-character integer character
+ constant is implementation-defined.)
+ 
+<p><!--para 15-->
+ EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
+ L'\1234' specifies the implementation-defined value that results from the combination of the values
+ 0123 and '4'.
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.17">7.17</a>), the mbtowc function
+ (<a href="#7.20.7.2">7.20.7.2</a>).
+<!--page 74 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note65">65)</a> The semantics of these characters were discussed in <a href="#5.2.2">5.2.2</a>. If any other character follows a backslash,
+ the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
+
+
+<a name="6.4.5" href="#6.4.5"><h4>6.4.5 String literals</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          string-literal:
+                  " s-char-sequenceopt "
+                  L" s-char-sequenceopt "
+          s-char-sequence:
+                 s-char
+                 s-char-sequence s-char
+          s-char:
+                    any member of the source character set except
+                                 the double-quote ", backslash \, or new-line character
+                    escape-sequence</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A character string literal is a sequence of zero or more multibyte characters enclosed in
+ double-quotes, as in "xyz". A wide string literal is the same, except prefixed by the
+ letter L.
+<p><!--para 3-->
+ The same considerations apply to each element of the sequence in a character string
+ literal or a wide string literal as if it were in an integer character constant or a wide
+ character constant, except that the single-quote ' is representable either by itself or by the
+ escape sequence \', but the double-quote " shall be represented by the escape sequence
+ \".
+<h6>Semantics</h6>
+<p><!--para 4-->
+ In translation phase 6, the multibyte character sequences specified by any sequence of
+ adjacent character and wide string literal tokens are concatenated into a single multibyte
+ character sequence. If any of the tokens are wide string literal tokens, the resulting
+ multibyte character sequence is treated as a wide string literal; otherwise, it is treated as a
+ character string literal.
+<p><!--para 5-->
+ In translation phase 7, a byte or code of value zero is appended to each multibyte
+ character sequence that results from a string literal or literals.<sup><a href="#note66"><b>66)</b></a></sup> The multibyte character
+ sequence is then used to initialize an array of static storage duration and length just
+ sufficient to contain the sequence. For character string literals, the array elements have
+ type char, and are initialized with the individual bytes of the multibyte character
+ sequence; for wide string literals, the array elements have type wchar_t, and are
+ initialized with the sequence of wide characters corresponding to the multibyte character
+ 
+<!--page 75 indent 4-->
+ sequence, as defined by the mbstowcs function with an implementation-defined current
+ locale. The value of a string literal containing a multibyte character or escape sequence
+ not represented in the execution character set is implementation-defined.
+<p><!--para 6-->
+ It is unspecified whether these arrays are distinct provided their elements have the
+ appropriate values. If the program attempts to modify such an array, the behavior is
+ undefined.
+<p><!--para 7-->
+ EXAMPLE       This pair of adjacent character string literals
+<pre>
+          "\x12" "3"</pre>
+ produces a single character string literal containing the two characters whose values are '\x12' and '3',
+ because escape sequences are converted into single members of the execution character set just prior to
+ adjacent string literal concatenation.
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.17">7.17</a>), the mbstowcs
+ function (<a href="#7.20.8.1">7.20.8.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note66">66)</a> A character string literal need not be a string (see <a href="#7.1.1">7.1.1</a>), because a null character may be embedded in
+ it by a \0 escape sequence.
+
+
+<a name="6.4.6" href="#6.4.6"><h4>6.4.6 Punctuators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          punctuator: one of
+                 [ ] ( ) { } . -&gt;
+                 ++ -- &amp; * + - ~ !
+                 / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                               ==     !=     ^    |     &amp;&amp;     ||
+                 ? : ; ...
+                 = *= /= %= += -= &lt;&lt;=                              &gt;&gt;=      &amp;=       ^=   |=
+                 , # ##
+                 &lt;: :&gt; &lt;% %&gt; %: %:%:</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A punctuator is a symbol that has independent syntactic and semantic significance.
+ Depending on context, it may specify an operation to be performed (which in turn may
+ yield a value or a function designator, produce a side effect, or some combination thereof)
+ in which case it is known as an operator (other forms of operator also exist in some
+ contexts). An operand is an entity on which an operator acts.
+<!--page 76 indent 4-->
+<p><!--para 3-->
+ In all aspects of the language, the six tokens<sup><a href="#note67"><b>67)</b></a></sup>
+<pre>
+          &lt;:    :&gt;      &lt;%    %&gt;     %:     %:%:</pre>
+ behave, respectively, the same as the six tokens
+<pre>
+          [     ]       {     }      #      ##</pre>
+ except for their spelling.<sup><a href="#note68"><b>68)</b></a></sup>
+ Forward references: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
+ (<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note67">67)</a> These tokens are sometimes called ''digraphs''.
+
+<p><a name="note68">68)</a> Thus [ and &lt;: behave differently when ''stringized'' (see <a href="#6.10.3.2">6.10.3.2</a>), but can otherwise be freely
+ interchanged.
+
+
+<a name="6.4.7" href="#6.4.7"><h4>6.4.7 Header names</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          header-name:
+                 &lt; h-char-sequence &gt;
+                 " q-char-sequence "
+          h-char-sequence:
+                 h-char
+                 h-char-sequence h-char
+          h-char:
+                    any member of the source character set except
+                                 the new-line character and &gt;
+          q-char-sequence:
+                 q-char
+                 q-char-sequence q-char
+          q-char:
+                    any member of the source character set except
+                                 the new-line character and "</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The sequences in both forms of header names are mapped in an implementation-defined
+ manner to headers or external source file names as specified in <a href="#6.10.2">6.10.2</a>.
+<p><!--para 3-->
+ If the characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt; delimiters,
+ the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
+ 
+ 
+ 
+ 
+<!--page 77 indent 4-->
+ sequence between the " delimiters, the behavior is undefined.<sup><a href="#note69"><b>69)</b></a></sup> Header name
+ preprocessing tokens are recognized only within #include preprocessing directives and
+ in implementation-defined locations within #pragma directives.<sup><a href="#note70"><b>70)</b></a></sup>
+<p><!--para 4-->
+ EXAMPLE       The following sequence of characters:
+<pre>
+          0x3&lt;1/a.h&gt;1e2
+          #include &lt;1/a.h&gt;
+          #define const.member@$</pre>
+ forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
+ by a { on the left and a } on the right).
+<pre>
+          {0x3}{&lt;}{1}{/}{a}{.}{h}{&gt;}{1e2}
+          {#}{include} {&lt;1/a.h&gt;}
+          {#}{define} {const}{.}{member}{@}{$}</pre>
+ 
+ Forward references: source file inclusion (<a href="#6.10.2">6.10.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note69">69)</a> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
+
+<p><a name="note70">70)</a> For an example of a header name preprocessing token used in a #pragma directive, see <a href="#6.10.9">6.10.9</a>.
+
+
+<a name="6.4.8" href="#6.4.8"><h4>6.4.8 Preprocessing numbers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          pp-number:
+                digit
+                . digit
+                pp-number       digit
+                pp-number       identifier-nondigit
+                pp-number       e sign
+                pp-number       E sign
+                pp-number       p sign
+                pp-number       P sign
+                pp-number       .</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A preprocessing number begins with a digit optionally preceded by a period (.) and may
+ be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
+ p+, p-, P+, or P-.
+<p><!--para 3-->
+ Preprocessing number tokens lexically include all floating and integer constant tokens.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ A preprocessing number does not have type or a value; it acquires both after a successful
+ conversion (as part of translation phase 7) to a floating constant token or an integer
+ constant token.
+ 
+ 
+<!--page 78 indent 4-->
+
+<a name="6.4.9" href="#6.4.9"><h4>6.4.9 Comments</h4></a>
+<p><!--para 1-->
+ Except within a character constant, a string literal, or a comment, the characters /*
+ introduce a comment. The contents of such a comment are examined only to identify
+ multibyte characters and to find the characters */ that terminate it.<sup><a href="#note71"><b>71)</b></a></sup>
+<p><!--para 2-->
+ Except within a character constant, a string literal, or a comment, the characters //
+ introduce a comment that includes all multibyte characters up to, but not including, the
+ next new-line character. The contents of such a comment are examined only to identify
+ multibyte characters and to find the terminating new-line character.
+<p><!--para 3-->
+ EXAMPLE
+<pre>
+         "a//b"                              //   four-character string literal
+         #include "//e"                      //   undefined behavior
+         // */                               //   comment, not syntax error
+         f = g/**//h;                        //   equivalent to f = g / h;
+         //\
+         i();                                // part of a two-line comment
+         /\
+         / j();                              // part of a two-line comment
+         #define glue(x,y) x##y
+         glue(/,/) k();                      // syntax error, not comment
+         /*//*/ l();                         // equivalent to l();
+         m = n//**/o
+            + p;                             // equivalent to m = n + p;</pre>
+ 
+ 
+ 
+ 
+<!--page 79 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note71">71)</a> Thus, /* ... */ comments do not nest.
+
+
+<a name="6.5" href="#6.5"><h3>6.5 Expressions</h3></a>
+<p><!--para 1-->
+ An expression is a sequence of operators and operands that specifies computation of a
+ value, or that designates an object or a function, or that generates side effects, or that
+ performs a combination thereof.
+<p><!--para 2-->
+ Between the previous and next sequence point an object shall have its stored value
+ modified at most once by the evaluation of an expression.<sup><a href="#note72"><b>72)</b></a></sup> Furthermore, the prior value
+ shall be read only to determine the value to be stored.<sup><a href="#note73"><b>73)</b></a></sup>
+<p><!--para 3-->
+ The grouping of operators and operands is indicated by the syntax.<sup><a href="#note74"><b>74)</b></a></sup> Except as specified
+ later (for the function-call (), &amp;&amp;, ||, ?:, and comma operators), the order of evaluation
+ of subexpressions and the order in which side effects take place are both unspecified.
+<p><!--para 4-->
+ Some operators (the unary operator ~, and the binary operators &lt;&lt;, &gt;&gt;, &amp;, ^, and |,
+ collectively described as bitwise operators) are required to have operands that have
+ integer type. These operators yield values that depend on the internal representations of
+ integers, and have implementation-defined and undefined aspects for signed types.
+<p><!--para 5-->
+ If an exceptional condition occurs during the evaluation of an expression (that is, if the
+ result is not mathematically defined or not in the range of representable values for its
+ type), the behavior is undefined.
+<p><!--para 6-->
+ The effective type of an object for an access to its stored value is the declared type of the
+ object, if any.<sup><a href="#note75"><b>75)</b></a></sup> If a value is stored into an object having no declared type through an
+ lvalue having a type that is not a character type, then the type of the lvalue becomes the
+ 
+ 
+<!--page 80 indent 4-->
+ effective type of the object for that access and for subsequent accesses that do not modify
+ the stored value. If a value is copied into an object having no declared type using
+ memcpy or memmove, or is copied as an array of character type, then the effective type
+ of the modified object for that access and for subsequent accesses that do not modify the
+ value is the effective type of the object from which the value is copied, if it has one. For
+ all other accesses to an object having no declared type, the effective type of the object is
+ simply the type of the lvalue used for the access.
+<p><!--para 7-->
+ An object shall have its stored value accessed only by an lvalue expression that has one of
+ the following types:<sup><a href="#note76"><b>76)</b></a></sup>
+<ul>
+<li>  a type compatible with the effective type of the object,
+<li>  a qualified version of a type compatible with the effective type of the object,
+<li>  a type that is the signed or unsigned type corresponding to the effective type of the
+ object,
+<li>  a type that is the signed or unsigned type corresponding to a qualified version of the
+ effective type of the object,
+<li>  an aggregate or union type that includes one of the aforementioned types among its
+ members (including, recursively, a member of a subaggregate or contained union), or
+<li>  a character type.
+</ul>
+<p><!--para 8-->
+ A floating expression may be contracted, that is, evaluated as though it were an atomic
+ operation, thereby omitting rounding errors implied by the source code and the
+ expression evaluation method.<sup><a href="#note77"><b>77)</b></a></sup> The FP_CONTRACT pragma in &lt;math.h&gt; provides a
+ way to disallow contracted expressions. Otherwise, whether and how expressions are
+ contracted is implementation-defined.<sup><a href="#note78"><b>78)</b></a></sup>
+ Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.21.2">7.21.2</a>).
+ 
+ 
+ 
+ 
+<!--page 81 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note72">72)</a> A floating-point status flag is not an object and can be set more than once within an expression.
+
+<p><a name="note73">73)</a> This paragraph renders undefined statement expressions such as
+
+<pre>
+            i = ++i + 1;
+            a[i++] = i;
+    while allowing
+            i = i + 1;
+            a[i] = i;</pre>
+ 
+
+<p><a name="note74">74)</a> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
+ as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
+ expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
+ <a href="#6.5.1">6.5.1</a> through <a href="#6.5.6">6.5.6</a>. The exceptions are cast expressions (<a href="#6.5.4">6.5.4</a>) as operands of unary operators
+ (<a href="#6.5.3">6.5.3</a>), and an operand contained between any of the following pairs of operators: grouping
+ parentheses () (<a href="#6.5.1">6.5.1</a>), subscripting brackets [] (<a href="#6.5.2.1">6.5.2.1</a>), function-call parentheses () (<a href="#6.5.2.2">6.5.2.2</a>), and
+ the conditional operator ?: (<a href="#6.5.15">6.5.15</a>).
+
+<pre>
+    Within each major subclause, the operators have the same precedence. Left- or right-associativity is
+    indicated in each subclause by the syntax for the expressions discussed therein.</pre>
+
+<p><a name="note75">75)</a> Allocated objects have no declared type.
+
+<p><a name="note76">76)</a> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
+
+<p><a name="note77">77)</a> A contracted expression might also omit the raising of floating-point exceptions.
+
+<p><a name="note78">78)</a> This license is specifically intended to allow implementations to exploit fast machine instructions that
+ combine multiple C operators. As contractions potentially undermine predictability, and can even
+ decrease accuracy for containing expressions, their use needs to be well-defined and clearly
+ documented.
+
+
+<a name="6.5.1" href="#6.5.1"><h4>6.5.1 Primary expressions</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          primary-expression:
+                 identifier
+                 constant
+                 string-literal
+                 ( expression )</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ An identifier is a primary expression, provided it has been declared as designating an
+ object (in which case it is an lvalue) or a function (in which case it is a function
+ designator).<sup><a href="#note79"><b>79)</b></a></sup>
+<p><!--para 3-->
+ A constant is a primary expression. Its type depends on its form and value, as detailed in
+ <a href="#6.4.4">6.4.4</a>.
+<p><!--para 4-->
+ A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
+<p><!--para 5-->
+ A parenthesized expression is a primary expression. Its type and value are identical to
+ those of the unparenthesized expression. It is an lvalue, a function designator, or a void
+ expression if the unparenthesized expression is, respectively, an lvalue, a function
+ designator, or a void expression.
+ Forward references: declarations (<a href="#6.7">6.7</a>).
+
+<h6>footnotes</h6>
+<p><a name="note79">79)</a> Thus, an undeclared identifier is a violation of the syntax.
+
+
+<a name="6.5.2" href="#6.5.2"><h4>6.5.2 Postfix operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          postfix-expression:
+                 primary-expression
+                 postfix-expression [ expression ]
+                 postfix-expression ( argument-expression-listopt )
+                 postfix-expression . identifier
+                 postfix-expression -&gt; identifier
+                 postfix-expression ++
+                 postfix-expression --
+                 ( type-name ) { initializer-list }
+                 ( type-name ) { initializer-list , }</pre>
+ 
+ 
+ 
+ 
+<!--page 82 indent 4-->
+<pre>
+          argument-expression-list:
+                assignment-expression
+                argument-expression-list , assignment-expression</pre>
+
+<a name="6.5.2.1" href="#6.5.2.1"><h5>6.5.2.1 Array subscripting</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ One of the expressions shall have type ''pointer to object type'', the other expression shall
+ have integer type, and the result has type ''type''.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A postfix expression followed by an expression in square brackets [] is a subscripted
+ designation of an element of an array object. The definition of the subscript operator []
+ is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
+ apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
+ initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
+ element of E1 (counting from zero).
+<p><!--para 3-->
+ Successive subscript operators designate an element of a multidimensional array object.
+ If E is an n-dimensional array (n &gt;= 2) with dimensions i x j x . . . x k, then E (used as
+ other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
+ dimensions j x . . . x k. If the unary * operator is applied to this pointer explicitly, or
+ implicitly as a result of subscripting, the result is the pointed-to (n - 1)-dimensional array,
+ which itself is converted into a pointer if used as other than an lvalue. It follows from this
+ that arrays are stored in row-major order (last subscript varies fastest).
+<p><!--para 4-->
+ EXAMPLE        Consider the array object defined by the declaration
+<pre>
+          int x[3][5];</pre>
+ Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
+ array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
+ a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
+ entails multiplying i by the size of the object to which the pointer points, namely an array of five int
+ objects. The results are added and indirection is applied to yield an array of five ints. When used in the
+ expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
+ yields an int.
+ 
+ Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
+ (<a href="#6.5.3.2">6.5.3.2</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
+<!--page 83 indent 4-->
+
+<a name="6.5.2.2" href="#6.5.2.2"><h5>6.5.2.2 Function calls</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The expression that denotes the called function<sup><a href="#note80"><b>80)</b></a></sup> shall have type pointer to function
+ returning void or returning an object type other than an array type.
+<p><!--para 2-->
+ If the expression that denotes the called function has a type that includes a prototype, the
+ number of arguments shall agree with the number of parameters. Each argument shall
+ have a type such that its value may be assigned to an object with the unqualified version
+ of the type of its corresponding parameter.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A postfix expression followed by parentheses () containing a possibly empty, comma-
+ separated list of expressions is a function call. The postfix expression denotes the called
+ function. The list of expressions specifies the arguments to the function.
+<p><!--para 4-->
+ An argument may be an expression of any object type. In preparing for the call to a
+ function, the arguments are evaluated, and each parameter is assigned the value of the
+ corresponding argument.<sup><a href="#note81"><b>81)</b></a></sup>
+<p><!--para 5-->
+ If the expression that denotes the called function has type pointer to function returning an
+ object type, the function call expression has the same type as that object type, and has the
+ value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void. If
+ an attempt is made to modify the result of a function call or to access it after the next
+ sequence point, the behavior is undefined.
+<p><!--para 6-->
+ If the expression that denotes the called function has a type that does not include a
+ prototype, the integer promotions are performed on each argument, and arguments that
+ have type float are promoted to double. These are called the default argument
+ promotions. If the number of arguments does not equal the number of parameters, the
+ behavior is undefined. If the function is defined with a type that includes a prototype, and
+ either the prototype ends with an ellipsis (, ...) or the types of the arguments after
+ promotion are not compatible with the types of the parameters, the behavior is undefined.
+ If the function is defined with a type that does not include a prototype, and the types of
+ the arguments after promotion are not compatible with those of the parameters after
+ promotion, the behavior is undefined, except for the following cases:
+ 
+ 
+ 
+ 
+<!--page 84 indent 5-->
+<ul>
+<li>  one promoted type is a signed integer type, the other promoted type is the
+ corresponding unsigned integer type, and the value is representable in both types;
+<li>  both types are pointers to qualified or unqualified versions of a character type or
+ void.
+</ul>
+<p><!--para 7-->
+ If the expression that denotes the called function has a type that does include a prototype,
+ the arguments are implicitly converted, as if by assignment, to the types of the
+ corresponding parameters, taking the type of each parameter to be the unqualified version
+ of its declared type. The ellipsis notation in a function prototype declarator causes
+ argument type conversion to stop after the last declared parameter. The default argument
+ promotions are performed on trailing arguments.
+<p><!--para 8-->
+ No other conversions are performed implicitly; in particular, the number and types of
+ arguments are not compared with those of the parameters in a function definition that
+ does not include a function prototype declarator.
+<p><!--para 9-->
+ If the function is defined with a type that is not compatible with the type (of the
+ expression) pointed to by the expression that denotes the called function, the behavior is
+ undefined.
+<p><!--para 10-->
+ The order of evaluation of the function designator, the actual arguments, and
+ subexpressions within the actual arguments is unspecified, but there is a sequence point
+ before the actual call.
+<p><!--para 11-->
+ Recursive function calls shall be permitted, both directly and indirectly through any chain
+ of other functions.
+<p><!--para 12-->
+ EXAMPLE       In the function call
+<pre>
+         (*pf[f1()]) (f2(), f3() + f4())</pre>
+ the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
+ the function pointed to by pf[f1()] is called.
+ 
+ Forward references: function declarators (including prototypes) (<a href="#6.7.5.3">6.7.5.3</a>), function
+ definitions (<a href="#6.9.1">6.9.1</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note80">80)</a> Most often, this is the result of converting an identifier that is a function designator.
+
+<p><a name="note81">81)</a> A function may change the values of its parameters, but these changes cannot affect the values of the
+ arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
+ change the value of the object pointed to. A parameter declared to have array or function type is
+ adjusted to have a pointer type as described in <a href="#6.9.1">6.9.1</a>.
+
+
+<a name="6.5.2.3" href="#6.5.2.3"><h5>6.5.2.3 Structure and union members</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The first operand of the . operator shall have a qualified or unqualified structure or union
+ type, and the second operand shall name a member of that type.
+<p><!--para 2-->
+ The first operand of the -&gt; operator shall have type ''pointer to qualified or unqualified
+ structure'' or ''pointer to qualified or unqualified union'', and the second operand shall
+ name a member of the type pointed to.
+<!--page 85 indent 4-->
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A postfix expression followed by the . operator and an identifier designates a member of
+ a structure or union object. The value is that of the named member,<sup><a href="#note82"><b>82)</b></a></sup> and is an lvalue if
+ the first expression is an lvalue. If the first expression has qualified type, the result has
+ the so-qualified version of the type of the designated member.
+<p><!--para 4-->
+ A postfix expression followed by the -&gt; operator and an identifier designates a member
+ of a structure or union object. The value is that of the named member of the object to
+ which the first expression points, and is an lvalue.<sup><a href="#note83"><b>83)</b></a></sup> If the first expression is a pointer to
+ a qualified type, the result has the so-qualified version of the type of the designated
+ member.
+<p><!--para 5-->
+ One special guarantee is made in order to simplify the use of unions: if a union contains
+ several structures that share a common initial sequence (see below), and if the union
+ object currently contains one of these structures, it is permitted to inspect the common
+ initial part of any of them anywhere that a declaration of the complete type of the union is
+ visible. Two structures share a common initial sequence if corresponding members have
+ compatible types (and, for bit-fields, the same widths) for a sequence of one or more
+ initial members.
+<p><!--para 6-->
+ EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
+ union, f().x is a valid postfix expression but is not an lvalue.
+ 
+<p><!--para 7-->
+ EXAMPLE 2 In:
+<pre>
+          struct s { int i; const int ci; };
+          struct s s;
+          const struct s cs;
+          volatile struct s vs;</pre>
+ the various members have the types:
+<pre>
+          s.i        int
+          s.ci       const int
+          cs.i       const int
+          cs.ci      const int
+          vs.i       volatile int
+          vs.ci      volatile const int</pre>
+ 
+ 
+ 
+ 
+<!--page 86 indent 4-->
+<p><!--para 8-->
+ EXAMPLE 3       The following is a valid fragment:
+<pre>
+          union {
                   struct {
-                        int f1;
-                        struct s f2;
-                  } u1;
+                        int      alltypes;
+                  } n;
                   struct {
-                        struct s f3;
-                        int f4;
-                  } u2;
-            } g;
-            struct s f(void)
-            {
-                  return g.u1.f2;
-            }
-            /* ... */
-            g.u2.f3 = f();
-    there is no undefined behavior, although there would be if the assignment were done directly (without using
-    a function call to fetch the value).
-
-
-
-
-    <sup><a name="note139" href="#note139"><b>139)</b></a></sup> The return statement is not an assignment. The overlap restriction of subclause <a href="#6.5.16.1">6.5.16.1</a> does not
-         apply to the case of function return. The representation of floating-point values may have wider range
-         or precision and is determined by FLT_EVAL_METHOD. A cast may be used to remove this extra
-         range and precision.
-
-[<a name="p139" href="#p139">page 139</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.9" href="#6.9"><b>    6.9 External definitions</b></a>
-<b>    Syntax</b>
-1            translation-unit:
-                     external-declaration
-                     translation-unit external-declaration
-             external-declaration:
-                    function-definition
-                    declaration
-<b>    Constraints</b>
-2   The storage-class specifiers auto and register shall not appear in the declaration
-    specifiers in an external declaration.
-3   There shall be no more than one external definition for each identifier declared with
-    internal linkage in a translation unit. Moreover, if an identifier declared with internal
-    linkage is used in an expression (other than as a part of the operand of a sizeof
-    operator whose result is an integer constant), there shall be exactly one external definition
-    for the identifier in the translation unit.
-<b>    Semantics</b>
-4   As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
-    which consists of a sequence of external declarations. These are described as ''external''
-    because they appear outside any function (and hence have file scope). As discussed in
-    <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
-    by the identifier is a definition.
-5   An external definition is an external declaration that is also a definition of a function
-    (other than an inline definition) or an object. If an identifier declared with external
-    linkage is used in an expression (other than as part of the operand of a sizeof operator
-    whose result is an integer constant), somewhere in the entire program there shall be
-    exactly one external definition for the identifier; otherwise, there shall be no more than
-    one.<sup><a href="#note140"><b>140)</b></a></sup>
-
-
-
-
-    <sup><a name="note140" href="#note140"><b>140)</b></a></sup> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
-         external definition for it.
-
-[<a name="p140" href="#p140">page 140</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.9.1" href="#6.9.1"><b>    6.9.1 Function definitions</b></a>
-<b>    Syntax</b>
-1            function-definition:
-                    declaration-specifiers declarator declaration-listopt compound-statement
-             declaration-list:
-                    declaration
-                    declaration-list declaration
-<b>    Constraints</b>
-2   The identifier declared in a function definition (which is the name of the function) shall
-    have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note141"><b>141)</b></a></sup>
-3   The return type of a function shall be void or an object type other than array type.
-4   The storage-class specifier, if any, in the declaration specifiers shall be either extern or
-    static.
-5   If the declarator includes a parameter type list, the declaration of each parameter shall
-    include an identifier, except for the special case of a parameter list consisting of a single
-    parameter of type void, in which case there shall not be an identifier. No declaration list
-    shall follow.
-6   If the declarator includes an identifier list, each declaration in the declaration list shall
-    have at least one declarator, those declarators shall declare only identifiers from the
-    identifier list, and every identifier in the identifier list shall be declared. An identifier
-    declared as a typedef name shall not be redeclared as a parameter. The declarations in the
-    declaration list shall contain no storage-class specifier other than register and no
-    initializations.
-
-
-
-
-    <sup><a name="note141" href="#note141"><b>141)</b></a></sup> The intent is that the type category in a function definition cannot be inherited from a typedef:
-                  typedef int F(void);                          //   type F is ''function with no parameters
-                                                                //                  returning int''
-                  F f, g;                                       //   f and g both have type compatible with F
-                  F f { /* ... */ }                             //   WRONG: syntax/constraint error
-                  F g() { /* ... */ }                           //   WRONG: declares that g returns a function
-                  int f(void) { /* ... */ }                     //   RIGHT: f has type compatible with F
-                  int g() { /* ... */ }                         //   RIGHT: g has type compatible with F
-                  F *e(void) { /* ... */ }                      //   e returns a pointer to a function
-                  F *((e))(void) { /* ... */ }                  //   same: parentheses irrelevant
-                  int (*fp)(void);                              //   fp points to a function that has type F
-                  F *Fp;                                        //   Fp points to a function that has type F
-
-[<a name="p141" href="#p141">page 141</a>] (<a href="#Contents">Contents</a>)
-
-<b>     Semantics</b>
-7    The declarator in a function definition specifies the name of the function being defined
-     and the identifiers of its parameters. If the declarator includes a parameter type list, the
-     list also specifies the types of all the parameters; such a declarator also serves as a
-     function prototype for later calls to the same function in the same translation unit. If the
-     declarator includes an identifier list,<sup><a href="#note142"><b>142)</b></a></sup> the types of the parameters shall be declared in a
-     following declaration list. In either case, the type of each parameter is adjusted as
-     described in <a href="#6.7.5.3">6.7.5.3</a> for a parameter type list; the resulting type shall be an object type.
-8    If a function that accepts a variable number of arguments is defined without a parameter
-     type list that ends with the ellipsis notation, the behavior is undefined.
-9    Each parameter has automatic storage duration. Its identifier is an lvalue, which is in
-     effect declared at the head of the compound statement that constitutes the function body
-     (and therefore cannot be redeclared in the function body except in an enclosed block).
-     The layout of the storage for parameters is unspecified.
-10   On entry to the function, the size expressions of each variably modified parameter are
-     evaluated and the value of each argument expression is converted to the type of the
-     corresponding parameter as if by assignment. (Array expressions and function
-     designators as arguments were converted to pointers before the call.)
-11   After all parameters have been assigned, the compound statement that constitutes the
-     body of the function definition is executed.
-12   If the } that terminates a function is reached, and the value of the function call is used by
-     the caller, the behavior is undefined.
-13   EXAMPLE 1       In the following:
-              extern int max(int a, int b)
-              {
-                    return a &gt; b ? a : b;
-              }
-     extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
-     function declarator; and
-              { return a &gt; b ? a : b; }
-     is the function body. The following similar definition uses the identifier-list form for the parameter
-     declarations:
-
-
-
-
-     <sup><a name="note142" href="#note142"><b>142)</b></a></sup> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
-
-[<a name="p142" href="#p142">page 142</a>] (<a href="#Contents">Contents</a>)
-
-              extern int max(a, b)
-              int a, b;
-              {
-                    return a &gt; b ? a : b;
-              }
-     Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
-     that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
-     to the function, whereas the second form does not.
-
-14   EXAMPLE 2           To pass one function to another, one might say
-                          int f(void);
-                          /* ... */
-                          g(f);
-     Then the definition of g might read
-              void g(int (*funcp)(void))
-              {
-                    /* ... */
-                    (*funcp)(); /* or funcp(); ...                    */
-              }
-     or, equivalently,
-              void g(int func(void))
-              {
-                    /* ... */
-                    func(); /* or (*func)(); ...                   */
-              }
-
-<a name="6.9.2" href="#6.9.2"><b>     6.9.2 External object definitions</b></a>
-<b>     Semantics</b>
-1    If the declaration of an identifier for an object has file scope and an initializer, the
-     declaration is an external definition for the identifier.
-2    A declaration of an identifier for an object that has file scope without an initializer, and
-     without a storage-class specifier or with the storage-class specifier static, constitutes a
-     tentative definition. If a translation unit contains one or more tentative definitions for an
-     identifier, and the translation unit contains no external definition for that identifier, then
-     the behavior is exactly as if the translation unit contains a file scope declaration of that
-     identifier, with the composite type as of the end of the translation unit, with an initializer
-     equal to 0.
-3    If the declaration of an identifier for an object is a tentative definition and has internal
-     linkage, the declared type shall not be an incomplete type.
-
-[<a name="p143" href="#p143">page 143</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE 1
-             int i1 = 1;                    // definition, external linkage
-             static int i2 = 2;             // definition, internal linkage
-             extern int i3 = 3;             // definition, external linkage
-             int i4;                        // tentative definition, external linkage
-             static int i5;                 // tentative definition, internal linkage
-             int   i1;                      // valid tentative definition, refers to previous
-             int   i2;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
-             int   i3;                      // valid tentative definition, refers to previous
-             int   i4;                      // valid tentative definition, refers to previous
-             int   i5;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
-             extern    int   i1;            // refers to previous, whose linkage is external
-             extern    int   i2;            // refers to previous, whose linkage is internal
-             extern    int   i3;            // refers to previous, whose linkage is external
-             extern    int   i4;            // refers to previous, whose linkage is external
-             extern    int   i5;            // refers to previous, whose linkage is internal
-
-5   EXAMPLE 2       If at the end of the translation unit containing
-             int i[];
-    the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
-    zero on program startup.
-
-[<a name="p144" href="#p144">page 144</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10" href="#6.10"><b>    6.10 Preprocessing directives</b></a>
-<b>    Syntax</b>
-1            preprocessing-file:
-                    groupopt
-             group:
-                      group-part
-                      group group-part
-             group-part:
-                    if-section
-                    control-line
-                    text-line
-                    # non-directive
-             if-section:
-                      if-group elif-groupsopt else-groupopt endif-line
-             if-group:
-                     # if     constant-expression new-line groupopt
-                     # ifdef identifier new-line groupopt
-                     # ifndef identifier new-line groupopt
-             elif-groups:
-                     elif-group
-                     elif-groups elif-group
-             elif-group:
-                     # elif       constant-expression new-line groupopt
-             else-group:
-                     # else       new-line groupopt
-             endif-line:
-                     # endif      new-line
-
-[<a name="p145" href="#p145">page 145</a>] (<a href="#Contents">Contents</a>)
-
-             control-line:
-                    # include pp-tokens new-line
-                    # define identifier replacement-list new-line
-                    # define identifier lparen identifier-listopt )
-                                                    replacement-list new-line
-                    # define identifier lparen ... ) replacement-list new-line
-                    # define identifier lparen identifier-list , ... )
-                                                    replacement-list new-line
-                    # undef   identifier new-line
-                    # line    pp-tokens new-line
-                    # error   pp-tokensopt new-line
-                    # pragma pp-tokensopt new-line
-                    #         new-line
-             text-line:
-                     pp-tokensopt new-line
-             non-directive:
-                    pp-tokens new-line
-             lparen:
-                       a ( character not immediately preceded by white-space
-             replacement-list:
-                    pp-tokensopt
-             pp-tokens:
-                    preprocessing-token
-                    pp-tokens preprocessing-token
-             new-line:
-                    the new-line character
-<b>    Description</b>
-2   A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
-    following constraints: The first token in the sequence is a # preprocessing token that (at
-    the start of translation phase 4) is either the first character in the source file (optionally
-    after white space containing no new-line characters) or that follows white space
-    containing at least one new-line character. The last token in the sequence is the first new-
-    line character that follows the first token in the sequence.<sup><a href="#note143"><b>143)</b></a></sup> A new-line character ends
-    the preprocessing directive even if it occurs within what would otherwise be an
-
-    <sup><a name="note143" href="#note143"><b>143)</b></a></sup> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
-         significance, as all white space is equivalent except in certain situations during preprocessing (see the
-         # character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
-
-[<a name="p146" href="#p146">page 146</a>] (<a href="#Contents">Contents</a>)
-
-    invocation of a function-like macro.
-3   A text line shall not begin with a # preprocessing token. A non-directive shall not begin
-    with any of the directive names appearing in the syntax.
-4   When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
-    sequence of preprocessing tokens to occur between the directive name and the following
-    new-line character.
-<b>    Constraints</b>
-5   The only white-space characters that shall appear between preprocessing tokens within a
-    preprocessing directive (from just after the introducing # preprocessing token through
-    just before the terminating new-line character) are space and horizontal-tab (including
-    spaces that have replaced comments or possibly other white-space characters in
-    translation phase 3).
-<b>    Semantics</b>
-6   The implementation can process and skip sections of source files conditionally, include
-    other source files, and replace macros. These capabilities are called preprocessing,
-    because conceptually they occur before translation of the resulting translation unit.
-7   The preprocessing tokens within a preprocessing directive are not subject to macro
-    expansion unless otherwise stated.
-8   EXAMPLE        In:
-             #define EMPTY
-             EMPTY # include &lt;file.h&gt;
-    the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
-    begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
-    replaced.
-
-<a name="6.10.1" href="#6.10.1"><b>    6.10.1 Conditional inclusion</b></a>
-<b>    Constraints</b>
-1   The expression that controls conditional inclusion shall be an integer constant expression
-    except that: it shall not contain a cast; identifiers (including those lexically identical to
-    keywords) are interpreted as described below;<sup><a href="#note144"><b>144)</b></a></sup> and it may contain unary operator
-    expressions of the form
-
-
-
-
-    <sup><a name="note144" href="#note144"><b>144)</b></a></sup> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
-         either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
-
-[<a name="p147" href="#p147">page 147</a>] (<a href="#Contents">Contents</a>)
-
-         defined identifier
-    or
-         defined ( identifier )
-    which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
-    predefined or if it has been the subject of a #define preprocessing directive without an
-    intervening #undef directive with the same subject identifier), 0 if it is not.
-2   Each preprocessing token that remains (in the list of preprocessing tokens that will
-    become the controlling expression) after all macro replacements have occurred shall be in
-    the lexical form of a token (<a href="#6.4">6.4</a>).
-<b>    Semantics</b>
-3   Preprocessing directives of the forms
-         # if   constant-expression new-line groupopt
-         # elif constant-expression new-line groupopt
-    check whether the controlling constant expression evaluates to nonzero.
-4   Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
-    the controlling constant expression are replaced (except for those macro names modified
-    by the defined unary operator), just as in normal text. If the token defined is
-    generated as a result of this replacement process or use of the defined unary operator
-    does not match one of the two specified forms prior to macro replacement, the behavior is
-    undefined. After all replacements due to macro expansion and the defined unary
-    operator have been performed, all remaining identifiers (including those lexically
-    identical to keywords) are replaced with the pp-number 0, and then each preprocessing
-    token is converted into a token. The resulting tokens compose the controlling constant
-    expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
-    token conversion and evaluation, all signed integer types and all unsigned integer types
-    act as if they have the same representation as, respectively, the types intmax_t and
-    uintmax_t defined in the header <a href="#7.18">&lt;stdint.h&gt;</a>.<sup><a href="#note145"><b>145)</b></a></sup> This includes interpreting
-    character constants, which may involve converting escape sequences into execution
-    character set members. Whether the numeric value for these character constants matches
-    the value obtained when an identical character constant occurs in an expression (other
-    than within a #if or #elif directive) is implementation-defined.<sup><a href="#note146"><b>146)</b></a></sup> Also, whether a
-    single-character character constant may have a negative value is implementation-defined.
-5   Preprocessing directives of the forms
-
-
-
-    <sup><a name="note145" href="#note145"><b>145)</b></a></sup> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
-         0x8000 is signed and positive within a #if expression even though it would be unsigned in
-         translation phase 7.
-
-[<a name="p148" href="#p148">page 148</a>] (<a href="#Contents">Contents</a>)
-
-       # ifdef identifier new-line groupopt
-       # ifndef identifier new-line groupopt
-    check whether the identifier is or is not currently defined as a macro name. Their
-    conditions are equivalent to #if defined identifier and #if !defined identifier
-    respectively.
-6   Each directive's condition is checked in order. If it evaluates to false (zero), the group
-    that it controls is skipped: directives are processed only through the name that determines
-    the directive in order to keep track of the level of nested conditionals; the rest of the
-    directives' preprocessing tokens are ignored, as are the other preprocessing tokens in the
-    group. Only the first group whose control condition evaluates to true (nonzero) is
-    processed. If none of the conditions evaluates to true, and there is a #else directive, the
-    group controlled by the #else is processed; lacking a #else directive, all the groups
-    until the #endif are skipped.<sup><a href="#note147"><b>147)</b></a></sup>
-    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
-    integer types (<a href="#7.18.1.5">7.18.1.5</a>).
-<a name="6.10.2" href="#6.10.2"><b>    6.10.2 Source file inclusion</b></a>
-<b>    Constraints</b>
-1   A #include directive shall identify a header or source file that can be processed by the
-    implementation.
-<b>    Semantics</b>
-2   A preprocessing directive of the form
-       # include &lt;h-char-sequence&gt; new-line
-    searches a sequence of implementation-defined places for a header identified uniquely by
-    the specified sequence between the &lt; and &gt; delimiters, and causes the replacement of that
-    directive by the entire contents of the header. How the places are specified or the header
-    identified is implementation-defined.
-3   A preprocessing directive of the form
-
-
-
-    <sup><a name="note146" href="#note146"><b>146)</b></a></sup> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
-         evaluate to the same value in these two contexts.
-           #if 'z' - 'a' == 25
-           if ('z' - 'a' == 25)
-
-    <sup><a name="note147" href="#note147"><b>147)</b></a></sup> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
-         before the terminating new-line character. However, comments may appear anywhere in a source file,
-         including within a preprocessing directive.
-
-[<a name="p149" href="#p149">page 149</a>] (<a href="#Contents">Contents</a>)
-
-       # include "q-char-sequence" new-line
-    causes the replacement of that directive by the entire contents of the source file identified
-    by the specified sequence between the " delimiters. The named source file is searched
-    for in an implementation-defined manner. If this search is not supported, or if the search
-    fails, the directive is reprocessed as if it read
-       # include &lt;h-char-sequence&gt; new-line
-    with the identical contained sequence (including &gt; characters, if any) from the original
-    directive.
-4   A preprocessing directive of the form
-       # include pp-tokens new-line
-    (that does not match one of the two previous forms) is permitted. The preprocessing
-    tokens after include in the directive are processed just as in normal text. (Each
-    identifier currently defined as a macro name is replaced by its replacement list of
-    preprocessing tokens.) The directive resulting after all replacements shall match one of
-    the two previous forms.<sup><a href="#note148"><b>148)</b></a></sup> The method by which a sequence of preprocessing tokens
-    between a &lt; and a &gt; preprocessing token pair or a pair of " characters is combined into a
-    single header name preprocessing token is implementation-defined.
-5   The implementation shall provide unique mappings for sequences consisting of one or
-    more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
-    first character shall not be a digit. The implementation may ignore distinctions of
-    alphabetical case and restrict the mapping to eight significant characters before the
-    period.
-6   A #include preprocessing directive may appear in a source file that has been read
-    because of a #include directive in another file, up to an implementation-defined
-    nesting limit (see <a href="#5.2.4.1">5.2.4.1</a>).
-7   EXAMPLE 1       The most common uses of #include preprocessing directives are as in the following:
-             #include <a href="#7.19">&lt;stdio.h&gt;</a>
-             #include "myprog.h"
-
-8   EXAMPLE 2       This illustrates macro-replaced #include directives:
-
-
-
-
-    <sup><a name="note148" href="#note148"><b>148)</b></a></sup> Note that adjacent string literals are not concatenated into a single string literal (see the translation
-         phases in <a href="#5.1.1.2">5.1.1.2</a>); thus, an expansion that results in two string literals is an invalid directive.
-
-[<a name="p150" href="#p150">page 150</a>] (<a href="#Contents">Contents</a>)
-
-           #if VERSION == 1
-                 #define INCFILE        "vers1.h"
-           #elif VERSION == 2
-                 #define INCFILE        "vers2.h"      // and so on
-           #else
-                 #define INCFILE        "versN.h"
-           #endif
-           #include INCFILE
-
-    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>).
-<a name="6.10.3" href="#6.10.3"><b>    6.10.3 Macro replacement</b></a>
-<b>    Constraints</b>
-1   Two replacement lists are identical if and only if the preprocessing tokens in both have
-    the same number, ordering, spelling, and white-space separation, where all white-space
-    separations are considered identical.
-2   An identifier currently defined as an object-like macro shall not be redefined by another
-    #define preprocessing directive unless the second definition is an object-like macro
-    definition and the two replacement lists are identical. Likewise, an identifier currently
-    defined as a function-like macro shall not be redefined by another #define
-    preprocessing directive unless the second definition is a function-like macro definition
-    that has the same number and spelling of parameters, and the two replacement lists are
-    identical.
-3   There shall be white-space between the identifier and the replacement list in the definition
-    of an object-like macro.
-4   If the identifier-list in the macro definition does not end with an ellipsis, the number of
-    arguments (including those arguments consisting of no preprocessing tokens) in an
-    invocation of a function-like macro shall equal the number of parameters in the macro
-    definition. Otherwise, there shall be more arguments in the invocation than there are
-    parameters in the macro definition (excluding the ...). There shall exist a )
-    preprocessing token that terminates the invocation.
-5   The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
-    macro that uses the ellipsis notation in the parameters.
-6   A parameter identifier in a function-like macro shall be uniquely declared within its
-    scope.
-<b>    Semantics</b>
-7   The identifier immediately following the define is called the macro name. There is one
-    name space for macro names. Any white-space characters preceding or following the
-    replacement list of preprocessing tokens are not considered part of the replacement list
-    for either form of macro.
-
-[<a name="p151" href="#p151">page 151</a>] (<a href="#Contents">Contents</a>)
-
-8    If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
-     a preprocessing directive could begin, the identifier is not subject to macro replacement.
-9    A preprocessing directive of the form
-        # define identifier replacement-list new-line
-     defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note149"><b>149)</b></a></sup>
-     to be replaced by the replacement list of preprocessing tokens that constitute the
-     remainder of the directive. The replacement list is then rescanned for more macro names
-     as specified below.
-10   A preprocessing directive of the form
-        # define identifier lparen identifier-listopt ) replacement-list new-line
-        # define identifier lparen ... ) replacement-list new-line
-        # define identifier lparen identifier-list , ... ) replacement-list new-line
-     defines a function-like macro with parameters, whose use is similar syntactically to a
-     function call. The parameters are specified by the optional list of identifiers, whose scope
-     extends from their declaration in the identifier list until the new-line character that
-     terminates the #define preprocessing directive. Each subsequent instance of the
-     function-like macro name followed by a ( as the next preprocessing token introduces the
-     sequence of preprocessing tokens that is replaced by the replacement list in the definition
-     (an invocation of the macro). The replaced sequence of preprocessing tokens is
-     terminated by the matching ) preprocessing token, skipping intervening matched pairs of
-     left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
-     tokens making up an invocation of a function-like macro, new-line is considered a normal
-     white-space character.
-11   The sequence of preprocessing tokens bounded by the outside-most matching parentheses
-     forms the list of arguments for the function-like macro. The individual arguments within
-     the list are separated by comma preprocessing tokens, but comma preprocessing tokens
-     between matching inner parentheses do not separate arguments. If there are sequences of
-     preprocessing tokens within the list of arguments that would otherwise act as
-     preprocessing directives,<sup><a href="#note150"><b>150)</b></a></sup> the behavior is undefined.
-12   If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
-     including any separating comma preprocessing tokens, are merged to form a single item:
-     the variable arguments. The number of arguments so combined is such that, following
-
-
-     <sup><a name="note149" href="#note149"><b>149)</b></a></sup> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
-          not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
-          are never scanned for macro names or parameters.
-     <sup><a name="note150" href="#note150"><b>150)</b></a></sup> Despite the name, a non-directive is a preprocessing directive.
-
-[<a name="p152" href="#p152">page 152</a>] (<a href="#Contents">Contents</a>)
-
-    merger, the number of arguments is one more than the number of parameters in the macro
-    definition (excluding the ...).
-<a name="6.10.3.1" href="#6.10.3.1"><b>    6.10.3.1 Argument substitution</b></a>
-1   After the arguments for the invocation of a function-like macro have been identified,
-    argument substitution takes place. A parameter in the replacement list, unless preceded
-    by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
-    replaced by the corresponding argument after all macros contained therein have been
-    expanded. Before being substituted, each argument's preprocessing tokens are
-    completely macro replaced as if they formed the rest of the preprocessing file; no other
-    preprocessing tokens are available.
-2   An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
-    were a parameter, and the variable arguments shall form the preprocessing tokens used to
-    replace it.
-<a name="6.10.3.2" href="#6.10.3.2"><b>    6.10.3.2 The # operator</b></a>
-<b>    Constraints</b>
-1   Each # preprocessing token in the replacement list for a function-like macro shall be
-    followed by a parameter as the next preprocessing token in the replacement list.
-<b>    Semantics</b>
-2   If, in the replacement list, a parameter is immediately preceded by a # preprocessing
-    token, both are replaced by a single character string literal preprocessing token that
-    contains the spelling of the preprocessing token sequence for the corresponding
-    argument. Each occurrence of white space between the argument's preprocessing tokens
-    becomes a single space character in the character string literal. White space before the
-    first preprocessing token and after the last preprocessing token composing the argument
-    is deleted. Otherwise, the original spelling of each preprocessing token in the argument
-    is retained in the character string literal, except for special handling for producing the
-    spelling of string literals and character constants: a \ character is inserted before each "
-    and \ character of a character constant or string literal (including the delimiting "
-    characters), except that it is implementation-defined whether a \ character is inserted
-    before the \ character beginning a universal character name. If the replacement that
-    results is not a valid character string literal, the behavior is undefined. The character
-    string literal corresponding to an empty argument is "". The order of evaluation of # and
-    ## operators is unspecified.
-
-[<a name="p153" href="#p153">page 153</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.3.3" href="#6.10.3.3"><b>    6.10.3.3 The ## operator</b></a>
-<b>    Constraints</b>
-1   A ## preprocessing token shall not occur at the beginning or at the end of a replacement
-    list for either form of macro definition.
-<b>    Semantics</b>
-2   If, in the replacement list of a function-like macro, a parameter is immediately preceded
-    or followed by a ## preprocessing token, the parameter is replaced by the corresponding
-    argument's preprocessing token sequence; however, if an argument consists of no
-    preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
-    instead.<sup><a href="#note151"><b>151)</b></a></sup>
-3   For both object-like and function-like macro invocations, before the replacement list is
-    reexamined for more macro names to replace, each instance of a ## preprocessing token
-    in the replacement list (not from an argument) is deleted and the preceding preprocessing
-    token is concatenated with the following preprocessing token. Placemarker
-    preprocessing tokens are handled specially: concatenation of two placemarkers results in
-    a single placemarker preprocessing token, and concatenation of a placemarker with a
-    non-placemarker preprocessing token results in the non-placemarker preprocessing token.
-    If the result is not a valid preprocessing token, the behavior is undefined. The resulting
-    token is available for further macro replacement. The order of evaluation of ## operators
-    is unspecified.
-4   EXAMPLE       In the following fragment:
-            #define     hash_hash # ## #
-            #define     mkstr(a) # a
-            #define     in_between(a) mkstr(a)
-            #define     join(c, d) in_between(c hash_hash d)
-            char p[] = join(x, y); // equivalent to
-                                   // char p[] = "x ## y";
-    The expansion produces, at various stages:
-            join(x, y)
-            in_between(x hash_hash y)
-            in_between(x ## y)
-            mkstr(x ## y)
-            "x ## y"
-    In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
-    this new token is not the ## operator.
-
-
-    <sup><a name="note151" href="#note151"><b>151)</b></a></sup> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
-         exist only within translation phase 4.
-
-[<a name="p154" href="#p154">page 154</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.3.4" href="#6.10.3.4"><b>    6.10.3.4 Rescanning and further replacement</b></a>
-1   After all parameters in the replacement list have been substituted and # and ##
-    processing has taken place, all placemarker preprocessing tokens are removed. Then, the
-    resulting preprocessing token sequence is rescanned, along with all subsequent
-    preprocessing tokens of the source file, for more macro names to replace.
-2   If the name of the macro being replaced is found during this scan of the replacement list
-    (not including the rest of the source file's preprocessing tokens), it is not replaced.
-    Furthermore, if any nested replacements encounter the name of the macro being replaced,
-    it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
-    available for further replacement even if they are later (re)examined in contexts in which
-    that macro name preprocessing token would otherwise have been replaced.
-3   The resulting completely macro-replaced preprocessing token sequence is not processed
-    as a preprocessing directive even if it resembles one, but all pragma unary operator
-    expressions within it are then processed as specified in <a href="#6.10.9">6.10.9</a> below.
-<a name="6.10.3.5" href="#6.10.3.5"><b>    6.10.3.5 Scope of macro definitions</b></a>
-1   A macro definition lasts (independent of block structure) until a corresponding #undef
-    directive is encountered or (if none is encountered) until the end of the preprocessing
-    translation unit. Macro definitions have no significance after translation phase 4.
-2   A preprocessing directive of the form
-       # undef identifier new-line
-    causes the specified identifier no longer to be defined as a macro name. It is ignored if
-    the specified identifier is not currently defined as a macro name.
-3   EXAMPLE 1      The simplest use of this facility is to define a ''manifest constant'', as in
-            #define TABSIZE 100
-            int table[TABSIZE];
-
-4   EXAMPLE 2 The following defines a function-like macro whose value is the maximum of its arguments.
-    It has the advantages of working for any compatible types of the arguments and of generating in-line code
-    without the overhead of function calling. It has the disadvantages of evaluating one or the other of its
-    arguments a second time (including side effects) and generating more code than a function if invoked
-    several times. It also cannot have its address taken, as it has none.
-            #define max(a, b) ((a) &gt; (b) ? (a) : (b))
-    The parentheses ensure that the arguments and the resulting expression are bound properly.
-
-[<a name="p155" href="#p155">page 155</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE 3     To illustrate the rules for redefinition and reexamination, the sequence
-             #define   x         3
-             #define   f(a)      f(x * (a))
-             #undef    x
-             #define   x         2
-             #define   g         f
-             #define   z         z[0]
-             #define   h         g(~
-             #define   m(a)      a(w)
-             #define   w         0,1
-             #define   t(a)      a
-             #define   p()       int
-             #define   q(x)      x
-             #define   r(x,y)    x ## y
-             #define   str(x)    # x
-             f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);
-             g(x+(3,4)-w) | h 5) &amp; m
-                   (f)^m(m);
-             p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
-             char c[2][6] = { str(hello), str() };
-    results in
-             f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
-             f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) &amp; f(2 * (0,1))^m(0,1);
-             int i[] = { 1, 23, 4, 5, };
-             char c[2][6] = { "hello", "" };
-
-6   EXAMPLE 4     To illustrate the rules for creating character string literals and concatenating tokens, the
-    sequence
-             #define str(s)      # s
-             #define xstr(s)     str(s)
-             #define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
-                                     x ## s, x ## t)
-             #define INCFILE(n) vers ## n
-             #define glue(a, b) a ## b
-             #define xglue(a, b) glue(a, b)
-             #define HIGHLOW     "hello"
-             #define LOW         LOW ", world"
-             debug(1, 2);
-             fputs(str(strncmp("abc\0d", "abc", '\4') // this goes away
-                   == 0) str(: @\n), s);
-             #include xstr(INCFILE(2).h)
-             glue(HIGH, LOW);
-             xglue(HIGH, LOW)
-    results in
-
-[<a name="p156" href="#p156">page 156</a>] (<a href="#Contents">Contents</a>)
-
-             printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
-             fputs(
-               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0" ": @\n",
-               s);
-             #include "vers2.h"    (after macro replacement, before file access)
-             "hello";
-             "hello" ", world"
-    or, after concatenation of the character string literals,
-             printf("x1= %d, x2= %s", x1, x2);
-             fputs(
-               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: @\n",
-               s);
-             #include "vers2.h"    (after macro replacement, before file access)
-             "hello";
-             "hello, world"
-    Space around the # and ## tokens in the macro definition is optional.
-
-7   EXAMPLE 5        To illustrate the rules for placemarker preprocessing tokens, the sequence
-             #define t(x,y,z) x ## y ## z
-             int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
-                        t(10,,), t(,11,), t(,,12), t(,,) };
-    results in
-             int j[] = { 123, 45, 67, 89,
-                         10, 11, 12, };
-
-8   EXAMPLE 6        To demonstrate the redefinition rules, the following sequence is valid.
-             #define      OBJ_LIKE      (1-1)
-             #define      OBJ_LIKE      /* white space */ (1-1) /* other */
-             #define      FUNC_LIKE(a)   ( a )
-             #define      FUNC_LIKE( a )( /* note the white space */ \
-                                          a /* other stuff on this line
-                                              */ )
-    But the following redefinitions are invalid:
-             #define      OBJ_LIKE    (0)     // different token sequence
-             #define      OBJ_LIKE    (1 - 1) // different white space
-             #define      FUNC_LIKE(b) ( a ) // different parameter usage
-             #define      FUNC_LIKE(b) ( b ) // different parameter spelling
-
-9   EXAMPLE 7        Finally, to show the variable argument list macro facilities:
-             #define debug(...)       fprintf(stderr, __VA_ARGS__)
-             #define showlist(...)    puts(#__VA_ARGS__)
-             #define report(test, ...) ((test)?puts(#test):\
-                         printf(__VA_ARGS__))
-             debug("Flag");
-             debug("X = %d\n", x);
-             showlist(The first, second, and third items.);
-             report(x&gt;y, "x is %d but y is %d", x, y);
-
-[<a name="p157" href="#p157">page 157</a>] (<a href="#Contents">Contents</a>)
-
-    results in
-             fprintf(stderr, "Flag" );
-             fprintf(stderr, "X = %d\n", x );
-             puts( "The first, second, and third items." );
-             ((x&gt;y)?puts("x&gt;y"):
-                         printf("x is %d but y is %d", x, y));
-
-<a name="6.10.4" href="#6.10.4"><b>    6.10.4 Line control</b></a>
-<b>    Constraints</b>
-1   The string literal of a #line directive, if present, shall be a character string literal.
-<b>    Semantics</b>
-2   The line number of the current source line is one greater than the number of new-line
-    characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
-    file to the current token.
-3   A preprocessing directive of the form
-       # line digit-sequence new-line
-    causes the implementation to behave as if the following sequence of source lines begins
-    with a source line that has a line number as specified by the digit sequence (interpreted as
-    a decimal integer). The digit sequence shall not specify zero, nor a number greater than
-    2147483647.
-4   A preprocessing directive of the form
-       # line digit-sequence "s-char-sequenceopt" new-line
-    sets the presumed line number similarly and changes the presumed name of the source
-    file to be the contents of the character string literal.
-5   A preprocessing directive of the form
-       # line pp-tokens new-line
-    (that does not match one of the two previous forms) is permitted. The preprocessing
-    tokens after line on the directive are processed just as in normal text (each identifier
-    currently defined as a macro name is replaced by its replacement list of preprocessing
-    tokens). The directive resulting after all replacements shall match one of the two
-    previous forms and is then processed as appropriate.
-
-[<a name="p158" href="#p158">page 158</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.5" href="#6.10.5"><b>    6.10.5 Error directive</b></a>
-<b>    Semantics</b>
-1   A preprocessing directive of the form
-       # error pp-tokensopt new-line
-    causes the implementation to produce a diagnostic message that includes the specified
-    sequence of preprocessing tokens.
-<a name="6.10.6" href="#6.10.6"><b>    6.10.6 Pragma directive</b></a>
-<b>    Semantics</b>
-1   A preprocessing directive of the form
-       # pragma pp-tokensopt new-line
-    where the preprocessing token STDC does not immediately follow pragma in the
-    directive (prior to any macro replacement)<sup><a href="#note152"><b>152)</b></a></sup> causes the implementation to behave in an
-    implementation-defined manner. The behavior might cause translation to fail or cause the
-    translator or the resulting program to behave in a non-conforming manner. Any such
-    pragma that is not recognized by the implementation is ignored.
-2   If the preprocessing token STDC does immediately follow pragma in the directive (prior
-    to any macro replacement), then no macro replacement is performed on the directive, and
-    the directive shall have one of the following forms<sup><a href="#note153"><b>153)</b></a></sup> whose meanings are described
-    elsewhere:
-       #pragma STDC FP_CONTRACT on-off-switch
-       #pragma STDC FENV_ACCESS on-off-switch
-       #pragma STDC CX_LIMITED_RANGE on-off-switch
-       on-off-switch: one of
-                   ON     OFF           DEFAULT
-    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
-    (<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
-
-
-
-
-    <sup><a name="note152" href="#note152"><b>152)</b></a></sup> An implementation is not required to perform macro replacement in pragmas, but it is permitted
-         except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
-         replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
-         implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
-         but is not required to.
-    <sup><a name="note153" href="#note153"><b>153)</b></a></sup> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
-
-[<a name="p159" href="#p159">page 159</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.7" href="#6.10.7"><b>    6.10.7 Null directive</b></a>
-<b>    Semantics</b>
-1   A preprocessing directive of the form
-       # new-line
-    has no effect.
-<a name="6.10.8" href="#6.10.8"><b>    6.10.8 Predefined macro names</b></a>
-1   The following macro names<sup><a href="#note154"><b>154)</b></a></sup> shall be defined by the implementation:
-    __DATE__ The date of translation of the preprocessing translation unit: a character
-               string literal of the form "Mmm dd yyyy", where the names of the
-               months are the same as those generated by the asctime function, and the
-               first character of dd is a space character if the value is less than 10. If the
-               date of translation is not available, an implementation-defined valid date
-               shall be supplied.
-    __FILE__ The presumed name of the current source file (a character string literal).<sup><a href="#note155"><b>155)</b></a></sup>
-    __LINE__ The presumed line number (within the current source file) of the current
-               source line (an integer constant).155)
-    __STDC__ The integer constant 1, intended to indicate a conforming implementation.
-    __STDC_HOSTED__ The integer constant 1 if the implementation is a hosted
-              implementation or the integer constant 0 if it is not.
-    __STDC_MB_MIGHT_NEQ_WC__ The integer constant 1, intended to indicate that, in
-              the encoding for wchar_t, a member of the basic character set need not
-              have a code value equal to its value when used as the lone character in an
-              integer character constant.
-    __STDC_VERSION__ The integer constant 199901L.<sup><a href="#note156"><b>156)</b></a></sup>
-    __TIME__ The time of translation of the preprocessing translation unit: a character
-               string literal of the form "hh:mm:ss" as in the time generated by the
-               asctime function. If the time of translation is not available, an
-               implementation-defined valid time shall be supplied.
-
-
-
-    <sup><a name="note154" href="#note154"><b>154)</b></a></sup> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
-    <sup><a name="note155" href="#note155"><b>155)</b></a></sup> The presumed source file name and line number can be changed by the #line directive.
-    <sup><a name="note156" href="#note156"><b>156)</b></a></sup> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
-         ISO/IEC 9899/AMD1:1995. The intention is that this will remain an integer constant of type long
-         int that is increased with each revision of this International Standard.
-
-[<a name="p160" href="#p160">page 160</a>] (<a href="#Contents">Contents</a>)
-
-2   The following macro names are conditionally defined by the implementation:
-    __STDC_IEC_559__ The integer constant 1, intended to indicate conformance to the
-              specifications in <a href="#F">annex F</a> (IEC 60559 floating-point arithmetic).
-    __STDC_IEC_559_COMPLEX__ The integer constant 1, intended to indicate
-              adherence to the specifications in informative <a href="#G">annex G</a> (IEC 60559
-              compatible complex arithmetic).
-    __STDC_ISO_10646__ An integer constant of the form yyyymmL (for example,
-              199712L). If this symbol is defined, then every character in the Unicode
-              required set, when stored in an object of type wchar_t, has the same
-              value as the short identifier of that character. The Unicode required set
-              consists of all the characters that are defined by ISO/IEC 10646, along with
-              all amendments and technical corrigenda, as of the specified year and
-              month.
-3   The values of the predefined macros (except for __FILE__ and __LINE__) remain
-    constant throughout the translation unit.
-4   None of these macro names, nor the identifier defined, shall be the subject of a
-    #define or a #undef preprocessing directive. Any other predefined macro names
-    shall begin with a leading underscore followed by an uppercase letter or a second
-    underscore.
-5   The implementation shall not predefine the macro __cplusplus, nor shall it define it
-    in any standard header.
-    Forward references: the asctime function (<a href="#7.23.3.1">7.23.3.1</a>), standard headers (<a href="#7.1.2">7.1.2</a>).
-<a name="6.10.9" href="#6.10.9"><b>    6.10.9 Pragma operator</b></a>
-<b>    Semantics</b>
-1   A unary operator expression of the form:
-       _Pragma ( string-literal )
-    is processed as follows: The string literal is destringized by deleting the L prefix, if
-    present, deleting the leading and trailing double-quotes, replacing each escape sequence
-    \" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
-    resulting sequence of characters is processed through translation phase 3 to produce
-    preprocessing tokens that are executed as if they were the pp-tokens in a pragma
-    directive. The original four preprocessing tokens in the unary operator expression are
-    removed.
-2   EXAMPLE       A directive of the form:
-             #pragma listing on "..\listing.dir"
-    can also be expressed as:
-
-[<a name="p161" href="#p161">page 161</a>] (<a href="#Contents">Contents</a>)
-
-        _Pragma ( "listing on \"..\\listing.dir\"" )
-The latter form is processed in the same way whether it appears literally as shown, or results from macro
-replacement, as in:
-        #define LISTING(x) PRAGMA(listing on #x)
-        #define PRAGMA(x) _Pragma(#x)
-        LISTING ( ..\listing.dir )
-
-[<a name="p162" href="#p162">page 162</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.11" href="#6.11"><b>    6.11 Future language directions</b></a>
-<a name="6.11.1" href="#6.11.1"><b>    6.11.1 Floating types</b></a>
-1   Future standardization may include additional floating-point types, including those with
-    greater range, precision, or both than long double.
-<a name="6.11.2" href="#6.11.2"><b>    6.11.2 Linkages of identifiers</b></a>
-1   Declaring an identifier with internal linkage at file scope without the static storage-
-    class specifier is an obsolescent feature.
-<a name="6.11.3" href="#6.11.3"><b>    6.11.3 External names</b></a>
-1   Restriction of the significance of an external name to fewer than 255 characters
-    (considering each universal character name or extended source character as a single
-    character) is an obsolescent feature that is a concession to existing implementations.
-<a name="6.11.4" href="#6.11.4"><b>    6.11.4 Character escape sequences</b></a>
-1   Lowercase letters as escape sequences are reserved for future standardization. Other
-    characters may be used in extensions.
-<a name="6.11.5" href="#6.11.5"><b>    6.11.5 Storage-class specifiers</b></a>
-1   The placement of a storage-class specifier other than at the beginning of the declaration
-    specifiers in a declaration is an obsolescent feature.
-<a name="6.11.6" href="#6.11.6"><b>    6.11.6 Function declarators</b></a>
-1   The use of function declarators with empty parentheses (not prototype-format parameter
-    type declarators) is an obsolescent feature.
-<a name="6.11.7" href="#6.11.7"><b>    6.11.7 Function definitions</b></a>
-1   The use of function definitions with separate parameter identifier and declaration lists
-    (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
-<a name="6.11.8" href="#6.11.8"><b>    6.11.8 Pragma directives</b></a>
-1   Pragmas whose first preprocessing token is STDC are reserved for future standardization.
-<a name="6.11.9" href="#6.11.9"><b>    6.11.9 Predefined macro names</b></a>
-1   Macro names beginning with __STDC_ are reserved for future standardization.
-
-[<a name="p163" href="#p163">page 163</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="7" href="#7"><b>    7. Library</b></a>
-
-<a name="7.1" href="#7.1"><b>    7.1 Introduction</b></a>
-<a name="7.1.1" href="#7.1.1"><b>    7.1.1 Definitions of terms</b></a>
-1   A string is a contiguous sequence of characters terminated by and including the first null
-    character. The term multibyte string is sometimes used instead to emphasize special
-    processing given to multibyte characters contained in the string or to avoid confusion
-    with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
-    character. The length of a string is the number of bytes preceding the null character and
-    the value of a string is the sequence of the values of the contained characters, in order.
-2   The decimal-point character is the character used by functions that convert floating-point
-    numbers to or from character sequences to denote the beginning of the fractional part of
-    such character sequences.<sup><a href="#note157"><b>157)</b></a></sup> It is represented in the text and examples by a period, but
-    may be changed by the setlocale function.
-3   A null wide character is a wide character with code value zero.
-4   A wide string is a contiguous sequence of wide characters terminated by and including
-    the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
-    addressed) wide character. The length of a wide string is the number of wide characters
-    preceding the null wide character and the value of a wide string is the sequence of code
-    values of the contained wide characters, in order.
-5   A shift sequence is a contiguous sequence of bytes within a multibyte string that
-    (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
-    corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
-    character.<sup><a href="#note158"><b>158)</b></a></sup>
-    Forward references: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
-
-
-
-
-    <sup><a name="note157" href="#note157"><b>157)</b></a></sup> The functions that make use of the decimal-point character are the numeric conversion functions
-         (<a href="#7.20.1">7.20.1</a>, <a href="#7.24.4.1">7.24.4.1</a>) and the formatted input/output functions (<a href="#7.19.6">7.19.6</a>, <a href="#7.24.2">7.24.2</a>).
-    <sup><a name="note158" href="#note158"><b>158)</b></a></sup> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
-         enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
-         sequence of maximum length. Whether these counts provide for more than one shift sequence is the
-         implementation's choice.
-
-[<a name="p164" href="#p164">page 164</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.1.2" href="#7.1.2"><b>    7.1.2 Standard headers</b></a>
-1   Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note159"><b>159)</b></a></sup>
-    whose contents are made available by the #include preprocessing directive. The
-    header declares a set of related functions, plus any necessary types and additional macros
-    needed to facilitate their use. Declarations of types described in this clause shall not
-    include type qualifiers, unless explicitly stated otherwise.
-2   The standard headers are
-           <a href="#7.2">&lt;assert.h&gt;</a>             <a href="#7.8">&lt;inttypes.h&gt;</a>            <a href="#7.14">&lt;signal.h&gt;</a>              <a href="#7.20">&lt;stdlib.h&gt;</a>
-           <a href="#7.3">&lt;complex.h&gt;</a>            <a href="#7.9">&lt;iso646.h&gt;</a>              <a href="#7.15">&lt;stdarg.h&gt;</a>              <a href="#7.21">&lt;string.h&gt;</a>
-           <a href="#7.4">&lt;ctype.h&gt;</a>              <a href="#7.10">&lt;limits.h&gt;</a>              <a href="#7.16">&lt;stdbool.h&gt;</a>             <a href="#7.22">&lt;tgmath.h&gt;</a>
-           <a href="#7.5">&lt;errno.h&gt;</a>              <a href="#7.11">&lt;locale.h&gt;</a>              <a href="#7.17">&lt;stddef.h&gt;</a>              <a href="#7.23">&lt;time.h&gt;</a>
-           <a href="#7.6">&lt;fenv.h&gt;</a>               <a href="#7.12">&lt;math.h&gt;</a>                <a href="#7.18">&lt;stdint.h&gt;</a>              <a href="#7.24">&lt;wchar.h&gt;</a>
-           <a href="#7.7">&lt;float.h&gt;</a>              <a href="#7.13">&lt;setjmp.h&gt;</a>              <a href="#7.19">&lt;stdio.h&gt;</a>               <a href="#7.25">&lt;wctype.h&gt;</a>
-3   If a file with the same name as one of the above &lt; and &gt; delimited sequences, not
-    provided as part of the implementation, is placed in any of the standard places that are
-    searched for included source files, the behavior is undefined.
-4   Standard headers may be included in any order; each may be included more than once in
-    a given scope, with no effect different from being included only once, except that the
-    effect of including <a href="#7.2">&lt;assert.h&gt;</a> depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
-    used, a header shall be included outside of any external declaration or definition, and it
-    shall first be included before the first reference to any of the functions or objects it
-    declares, or to any of the types or macros it defines. However, if an identifier is declared
-    or defined in more than one header, the second and subsequent associated headers may be
-    included after the initial reference to the identifier. The program shall not have any
-    macros with names lexically identical to keywords currently defined prior to the
-    inclusion.
-5   Any definition of an object-like macro described in this clause shall expand to code that is
-    fully protected by parentheses where necessary, so that it groups in an arbitrary
-    expression as if it were a single identifier.
-6   Any declaration of a library function shall have external linkage.
-7   A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
-    Forward references: diagnostics (<a href="#7.2">7.2</a>).
-
-
-
-
-    <sup><a name="note159" href="#note159"><b>159)</b></a></sup> A header is not necessarily a source file, nor are the &lt; and &gt; delimited sequences in header names
-         necessarily valid source file names.
-
-[<a name="p165" href="#p165">page 165</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.1.3" href="#7.1.3"><b>    7.1.3 Reserved identifiers</b></a>
-1   Each header declares or defines all identifiers listed in its associated subclause, and
-    optionally declares or defines identifiers listed in its associated future library directions
-    subclause and identifiers which are always reserved either for any use or for use as file
-    scope identifiers.
-    -- All identifiers that begin with an underscore and either an uppercase letter or another
-      underscore are always reserved for any use.
-    -- All identifiers that begin with an underscore are always reserved for use as identifiers
-      with file scope in both the ordinary and tag name spaces.
-    -- Each macro name in any of the following subclauses (including the future library
-      directions) is reserved for use as specified if any of its associated headers is included;
-      unless explicitly stated otherwise (see <a href="#7.1.4">7.1.4</a>).
-    -- All identifiers with external linkage in any of the following subclauses (including the
-      future library directions) are always reserved for use as identifiers with external
-      linkage.<sup><a href="#note160"><b>160)</b></a></sup>
-    -- Each identifier with file scope listed in any of the following subclauses (including the
-      future library directions) is reserved for use as a macro name and as an identifier with
-      file scope in the same name space if any of its associated headers is included.
-2   No other identifiers are reserved. If the program declares or defines an identifier in a
-    context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
-    identifier as a macro name, the behavior is undefined.
-3   If the program removes (with #undef) any macro definition of an identifier in the first
-    group listed above, the behavior is undefined.
-<a name="7.1.4" href="#7.1.4"><b>    7.1.4 Use of library functions</b></a>
-1   Each of the following statements applies unless explicitly stated otherwise in the detailed
-    descriptions that follow: If an argument to a function has an invalid value (such as a value
-    outside the domain of the function, or a pointer outside the address space of the program,
-    or a null pointer, or a pointer to non-modifiable storage when the corresponding
-    parameter is not const-qualified) or a type (after promotion) not expected by a function
-    with variable number of arguments, the behavior is undefined. If a function argument is
-    described as being an array, the pointer actually passed to the function shall have a value
-    such that all address computations and accesses to objects (that would be valid if the
-    pointer did point to the first element of such an array) are in fact valid. Any function
-    declared in a header may be additionally implemented as a function-like macro defined in
-
-    <sup><a name="note160" href="#note160"><b>160)</b></a></sup> The list of reserved identifiers with external linkage includes errno, math_errhandling,
-         setjmp, and va_end.
-
-[<a name="p166" href="#p166">page 166</a>] (<a href="#Contents">Contents</a>)
-
-    the header, so if a library function is declared explicitly when its header is included, one
-    of the techniques shown below can be used to ensure the declaration is not affected by
-    such a macro. Any macro definition of a function can be suppressed locally by enclosing
-    the name of the function in parentheses, because the name is then not followed by the left
-    parenthesis that indicates expansion of a macro function name. For the same syntactic
-    reason, it is permitted to take the address of a library function even if it is also defined as
-    a macro.<sup><a href="#note161"><b>161)</b></a></sup> The use of #undef to remove any macro definition will also ensure that an
-    actual function is referred to. Any invocation of a library function that is implemented as
-    a macro shall expand to code that evaluates each of its arguments exactly once, fully
-    protected by parentheses where necessary, so it is generally safe to use arbitrary
-    expressions as arguments.<sup><a href="#note162"><b>162)</b></a></sup> Likewise, those function-like macros described in the
-    following subclauses may be invoked in an expression anywhere a function with a
-    compatible return type could be called.<sup><a href="#note163"><b>163)</b></a></sup> All object-like macros listed as expanding to
-    integer constant expressions shall additionally be suitable for use in #if preprocessing
-    directives.
-2   Provided that a library function can be declared without reference to any type defined in a
-    header, it is also permissible to declare the function and use it without including its
-    associated header.
-3   There is a sequence point immediately before a library function returns.
-4   The functions in the standard library are not guaranteed to be reentrant and may modify
-    objects with static storage duration.<sup><a href="#note164"><b>164)</b></a></sup>
-
-
-
-    <sup><a name="note161" href="#note161"><b>161)</b></a></sup> This means that an implementation shall provide an actual function for each library function, even if it
-         also provides a macro for that function.
-    <sup><a name="note162" href="#note162"><b>162)</b></a></sup> Such macros might not contain the sequence points that the corresponding function calls do.
-    <sup><a name="note163" href="#note163"><b>163)</b></a></sup> Because external identifiers and some macro names beginning with an underscore are reserved,
-         implementations may provide special semantics for such names. For example, the identifier
-         _BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
-         appropriate header could specify
-                  #define abs(x) _BUILTIN_abs(x)
-         for a compiler whose code generator will accept it.
-         In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
-         function may write
-                  #undef abs
-         whether the implementation's header provides a macro implementation of abs or a built-in
-         implementation. The prototype for the function, which precedes and is hidden by any macro
-         definition, is thereby revealed also.
-    <sup><a name="note164" href="#note164"><b>164)</b></a></sup> Thus, a signal handler cannot, in general, call standard library functions.
-
-[<a name="p167" href="#p167">page 167</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE       The function atoi may be used in any of several ways:
-    -- by use of its associated header (possibly generating a macro expansion)
-                #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-                const char *str;
-                /* ... */
-                i = atoi(str);
-    -- by use of its associated header (assuredly generating a true function reference)
-                #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-                #undef atoi
-                const char *str;
-                /* ... */
-                i = atoi(str);
-       or
-                #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-                const char *str;
-                /* ... */
-                i = (atoi)(str);
-    -- by explicit declaration
-                extern int atoi(const char *);
-                const char *str;
+                        int      type;
+                        int      intnode;
+                  } ni;
+                  struct {
+                        int      type;
+                        double doublenode;
+                  } nf;
+          } u;
+          u.nf.type = 1;
+          u.nf.doublenode = <a href="#3.14">3.14</a>;
+          /* ... */
+          if (u.n.alltypes == 1)
+                  if (sin(u.nf.doublenode) == 0.0)
+                        /* ... */</pre>
+ The following is not a valid fragment (because the union type is not visible within function f):
+<pre>
+          struct t1 { int m; };
+          struct t2 { int m; };
+          int f(struct t1 *p1, struct t2 *p2)
+          {
+                if (p1-&gt;m &lt; 0)
+                        p2-&gt;m = -p2-&gt;m;
+                return p1-&gt;m;
+          }
+          int g()
+          {
+                union {
+                        struct t1 s1;
+                        struct t2 s2;
+                } u;
                 /* ... */
-                i = atoi(str);
-
-[<a name="p168" href="#p168">page 168</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.2" href="#7.2"><b>    7.2 Diagnostics &lt;assert.h&gt;</b></a>
-1   The header <a href="#7.2">&lt;assert.h&gt;</a> defines the assert macro and refers to another macro,
-            NDEBUG
-    which is not defined by <a href="#7.2">&lt;assert.h&gt;</a>. If NDEBUG is defined as a macro name at the
-    point in the source file where <a href="#7.2">&lt;assert.h&gt;</a> is included, the assert macro is defined
-    simply as
-            #define assert(ignore) ((void)0)
-    The assert macro is redefined according to the current state of NDEBUG each time that
-    <a href="#7.2">&lt;assert.h&gt;</a> is included.
-2   The assert macro shall be implemented as a macro, not as an actual function. If the
-    macro definition is suppressed in order to access an actual function, the behavior is
-    undefined.
-<a name="7.2.1" href="#7.2.1"><b>    7.2.1 Program diagnostics</b></a>
-<a name="7.2.1.1" href="#7.2.1.1"><b>    7.2.1.1 The assert macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.2">&lt;assert.h&gt;</a>
-            void assert(scalar expression);
-<b>    Description</b>
-2   The assert macro puts diagnostic tests into programs; it expands to a void expression.
-    When it is executed, if expression (which shall have a scalar type) is false (that is,
-    compares equal to 0), the assert macro writes information about the particular call that
-    failed (including the text of the argument, the name of the source file, the source line
-    number, and the name of the enclosing function -- the latter are respectively the values of
-    the preprocessing macros __FILE__ and __LINE__ and of the identifier
-    __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note165"><b>165)</b></a></sup> It
-    then calls the abort function.
-<b>    Returns</b>
-3   The assert macro returns no value.
-    Forward references: the abort function (<a href="#7.20.4.1">7.20.4.1</a>).
-
-
-
-
-    <sup><a name="note165" href="#note165"><b>165)</b></a></sup> The message written might be of the form:
-         Assertion failed: expression, function abc, file xyz, line nnn.
-
-[<a name="p169" href="#p169">page 169</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3" href="#7.3"><b>    7.3 Complex arithmetic &lt;complex.h&gt;</b></a>
-<a name="7.3.1" href="#7.3.1"><b>    7.3.1 Introduction</b></a>
-1   The header <a href="#7.3">&lt;complex.h&gt;</a> defines macros and declares functions that support complex
-    arithmetic.<sup><a href="#note166"><b>166)</b></a></sup> Each synopsis specifies a family of functions consisting of a principal
-    function with one or more double complex parameters and a double complex or
-    double return value; and other functions with the same name but with f and l suffixes
-    which are corresponding functions with float and long double parameters and
-    return values.
-2   The macro
-             complex
-    expands to _Complex; the macro
-             _Complex_I
-    expands to a constant expression of type const float _Complex, with the value of
-    the imaginary unit.<sup><a href="#note167"><b>167)</b></a></sup>
-3   The macros
-             imaginary
-    and
-             _Imaginary_I
-    are defined if and only if the implementation supports imaginary types;<sup><a href="#note168"><b>168)</b></a></sup> if defined,
-    they expand to _Imaginary and a constant expression of type const float
-    _Imaginary with the value of the imaginary unit.
-4   The macro
-             I
-    expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
-    defined, I shall expand to _Complex_I.
-5   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
-    redefine the macros complex, imaginary, and I.
-    Forward references: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
-
-
-
-    <sup><a name="note166" href="#note166"><b>166)</b></a></sup> See ''future library directions'' (<a href="#7.26.1">7.26.1</a>).
-    <sup><a name="note167" href="#note167"><b>167)</b></a></sup> The imaginary unit is a number i such that i 2   = -1.
-    <sup><a name="note168" href="#note168"><b>168)</b></a></sup> A specification for imaginary types is in informative <a href="#G">annex G</a>.
-
-[<a name="p170" href="#p170">page 170</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.2" href="#7.3.2"><b>    7.3.2 Conventions</b></a>
-1   Values are interpreted as radians, not degrees. An implementation may set errno but is
-    not required to.
-<a name="7.3.3" href="#7.3.3"><b>    7.3.3 Branch cuts</b></a>
-1   Some of the functions below have branch cuts, across which the function is
-    discontinuous. For implementations with a signed zero (including all IEC 60559
-    implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
-    one side of a cut from another so the function is continuous (except for format
-    limitations) as the cut is approached from either side. For example, for the square root
-    function, which has a branch cut along the negative real axis, the top of the cut, with
-    imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
-    imaginary part -0, maps to the negative imaginary axis.
-2   Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
-    sides of branch cuts. These implementations shall map a cut so the function is continuous
-    as the cut is approached coming around the finite endpoint of the cut in a counter
-    clockwise direction. (Branch cuts for the functions specified here have just one finite
-    endpoint.) For example, for the square root function, coming counter clockwise around
-    the finite endpoint of the cut along the negative real axis approaches the cut from above,
-    so the cut maps to the positive imaginary axis.
-<a name="7.3.4" href="#7.3.4"><b>    7.3.4 The CX_LIMITED_RANGE pragma</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.3">&lt;complex.h&gt;</a>
-             #pragma STDC CX_LIMITED_RANGE on-off-switch
-<b>    Description</b>
-2   The usual mathematical formulas for complex multiply, divide, and absolute value are
-    problematic because of their treatment of infinities and because of undue overflow and
-    underflow. The CX_LIMITED_RANGE pragma can be used to inform the
-    implementation that (where the state is ''on'') the usual mathematical formulas are
-    acceptable.<sup><a href="#note169"><b>169)</b></a></sup> The pragma can occur either outside external declarations or preceding all
-    explicit declarations and statements inside a compound statement. When outside external
-
-    <sup><a name="note169" href="#note169"><b>169)</b></a></sup> The purpose of the pragma is to allow the implementation to use the formulas:
-             (x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
-             (x + iy) / (u + iv) = [(xu + yv) + i(yu - xv)]/(u2 + v 2 )
-             | x + iy | = (sqrt) x 2 + y 2
-                          ???????????????
-         where the programmer can determine they are safe.
-
-[<a name="p171" href="#p171">page 171</a>] (<a href="#Contents">Contents</a>)
-
-    declarations, the pragma takes effect from its occurrence until another
-    CX_LIMITED_RANGE pragma is encountered, or until the end of the translation unit.
-    When inside a compound statement, the pragma takes effect from its occurrence until
-    another CX_LIMITED_RANGE pragma is encountered (including within a nested
-    compound statement), or until the end of the compound statement; at the end of a
-    compound statement the state for the pragma is restored to its condition just before the
-    compound statement. If this pragma is used in any other context, the behavior is
-    undefined. The default state for the pragma is ''off''.
-<a name="7.3.5" href="#7.3.5"><b>    7.3.5 Trigonometric functions</b></a>
-<a name="7.3.5.1" href="#7.3.5.1"><b>    7.3.5.1 The cacos functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex cacos(double complex z);
-           float complex cacosf(float complex z);
-           long double complex cacosl(long double complex z);
-<b>    Description</b>
-2   The cacos functions compute the complex arc cosine of z, with branch cuts outside the
-    interval [-1, +1] along the real axis.
-<b>    Returns</b>
-3   The cacos functions return the complex arc cosine value, in the range of a strip
-    mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
-    real axis.
-<a name="7.3.5.2" href="#7.3.5.2"><b>    7.3.5.2 The casin functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex casin(double complex z);
-           float complex casinf(float complex z);
-           long double complex casinl(long double complex z);
-<b>    Description</b>
-2   The casin functions compute the complex arc sine of z, with branch cuts outside the
-    interval [-1, +1] along the real axis.
-<b>    Returns</b>
-3   The casin functions return the complex arc sine value, in the range of a strip
-    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
-    along the real axis.
-
-[<a name="p172" href="#p172">page 172</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.5.3" href="#7.3.5.3"><b>    7.3.5.3 The catan functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex catan(double complex z);
-           float complex catanf(float complex z);
-           long double complex catanl(long double complex z);
-<b>    Description</b>
-2   The catan functions compute the complex arc tangent of z, with branch cuts outside the
-    interval [-i, +i] along the imaginary axis.
-<b>    Returns</b>
-3   The catan functions return the complex arc tangent value, in the range of a strip
-    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
-    along the real axis.
-<a name="7.3.5.4" href="#7.3.5.4"><b>    7.3.5.4 The ccos functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex ccos(double complex z);
-           float complex ccosf(float complex z);
-           long double complex ccosl(long double complex z);
-<b>    Description</b>
-2   The ccos functions compute the complex cosine of z.
-<b>    Returns</b>
-3   The ccos functions return the complex cosine value.
-<a name="7.3.5.5" href="#7.3.5.5"><b>    7.3.5.5 The csin functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex csin(double complex z);
-           float complex csinf(float complex z);
-           long double complex csinl(long double complex z);
-<b>    Description</b>
-2   The csin functions compute the complex sine of z.
-<b>    Returns</b>
-3   The csin functions return the complex sine value.
-
-[<a name="p173" href="#p173">page 173</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.5.6" href="#7.3.5.6"><b>    7.3.5.6 The ctan functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex ctan(double complex z);
-           float complex ctanf(float complex z);
-           long double complex ctanl(long double complex z);
-<b>    Description</b>
-2   The ctan functions compute the complex tangent of z.
-<b>    Returns</b>
-3   The ctan functions return the complex tangent value.
-<a name="7.3.6" href="#7.3.6"><b>    7.3.6 Hyperbolic functions</b></a>
-<a name="7.3.6.1" href="#7.3.6.1"><b>    7.3.6.1 The cacosh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex cacosh(double complex z);
-           float complex cacoshf(float complex z);
-           long double complex cacoshl(long double complex z);
-<b>    Description</b>
-2   The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
-    cut at values less than 1 along the real axis.
-<b>    Returns</b>
-3   The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
-    half-strip of non-negative values along the real axis and in the interval [-ipi , +ipi ] along
-    the imaginary axis.
-<a name="7.3.6.2" href="#7.3.6.2"><b>    7.3.6.2 The casinh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex casinh(double complex z);
-           float complex casinhf(float complex z);
-           long double complex casinhl(long double complex z);
-<b>    Description</b>
-2   The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
-    outside the interval [-i, +i] along the imaginary axis.
-
-[<a name="p174" href="#p174">page 174</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The casinh functions return the complex arc hyperbolic sine value, in the range of a
-    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
-    along the imaginary axis.
-<a name="7.3.6.3" href="#7.3.6.3"><b>    7.3.6.3 The catanh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex catanh(double complex z);
-           float complex catanhf(float complex z);
-           long double complex catanhl(long double complex z);
-<b>    Description</b>
-2   The catanh functions compute the complex arc hyperbolic tangent of z, with branch
-    cuts outside the interval [-1, +1] along the real axis.
-<b>    Returns</b>
-3   The catanh functions return the complex arc hyperbolic tangent value, in the range of a
-    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
-    along the imaginary axis.
-<a name="7.3.6.4" href="#7.3.6.4"><b>    7.3.6.4 The ccosh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex ccosh(double complex z);
-           float complex ccoshf(float complex z);
-           long double complex ccoshl(long double complex z);
-<b>    Description</b>
-2   The ccosh functions compute the complex hyperbolic cosine of z.
-<b>    Returns</b>
-3   The ccosh functions return the complex hyperbolic cosine value.
-<a name="7.3.6.5" href="#7.3.6.5"><b>    7.3.6.5 The csinh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex csinh(double complex z);
-           float complex csinhf(float complex z);
-           long double complex csinhl(long double complex z);
-
-[<a name="p175" href="#p175">page 175</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The csinh functions compute the complex hyperbolic sine of z.
-<b>    Returns</b>
-3   The csinh functions return the complex hyperbolic sine value.
-<a name="7.3.6.6" href="#7.3.6.6"><b>    7.3.6.6 The ctanh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex ctanh(double complex z);
-           float complex ctanhf(float complex z);
-           long double complex ctanhl(long double complex z);
-<b>    Description</b>
-2   The ctanh functions compute the complex hyperbolic tangent of z.
-<b>    Returns</b>
-3   The ctanh functions return the complex hyperbolic tangent value.
-<a name="7.3.7" href="#7.3.7"><b>    7.3.7 Exponential and logarithmic functions</b></a>
-<a name="7.3.7.1" href="#7.3.7.1"><b>    7.3.7.1 The cexp functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex cexp(double complex z);
-           float complex cexpf(float complex z);
-           long double complex cexpl(long double complex z);
-<b>    Description</b>
-2   The cexp functions compute the complex base-e exponential of z.
-<b>    Returns</b>
-3   The cexp functions return the complex base-e exponential value.
-<a name="7.3.7.2" href="#7.3.7.2"><b>    7.3.7.2 The clog functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex clog(double complex z);
-           float complex clogf(float complex z);
-           long double complex clogl(long double complex z);
-
-[<a name="p176" href="#p176">page 176</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The clog functions compute the complex natural (base-e) logarithm of z, with a branch
-    cut along the negative real axis.
-<b>    Returns</b>
-3   The clog functions return the complex natural logarithm value, in the range of a strip
-    mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
-    imaginary axis.
-<a name="7.3.8" href="#7.3.8"><b>    7.3.8 Power and absolute-value functions</b></a>
-<a name="7.3.8.1" href="#7.3.8.1"><b>    7.3.8.1 The cabs functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double cabs(double complex z);
-           float cabsf(float complex z);
-           long double cabsl(long double complex z);
-<b>    Description</b>
-2   The cabs functions compute the complex absolute value (also called norm, modulus, or
-    magnitude) of z.
-<b>    Returns</b>
-3   The cabs functions return the complex absolute value.
-<a name="7.3.8.2" href="#7.3.8.2"><b>    7.3.8.2 The cpow functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex cpow(double complex x, double complex y);
-           float complex cpowf(float complex x, float complex y);
-           long double complex cpowl(long double complex x,
-                long double complex y);
-<b>    Description</b>
-2   The cpow functions compute the complex power function xy , with a branch cut for the
-    first parameter along the negative real axis.
-<b>    Returns</b>
-3   The cpow functions return the complex power function value.
-
-[<a name="p177" href="#p177">page 177</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.8.3" href="#7.3.8.3"><b>    7.3.8.3 The csqrt functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex csqrt(double complex z);
-           float complex csqrtf(float complex z);
-           long double complex csqrtl(long double complex z);
-<b>    Description</b>
-2   The csqrt functions compute the complex square root of z, with a branch cut along the
-    negative real axis.
-<b>    Returns</b>
-3   The csqrt functions return the complex square root value, in the range of the right half-
-    plane (including the imaginary axis).
-<a name="7.3.9" href="#7.3.9"><b>    7.3.9 Manipulation functions</b></a>
-<a name="7.3.9.1" href="#7.3.9.1"><b>    7.3.9.1 The carg functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double carg(double complex z);
-           float cargf(float complex z);
-           long double cargl(long double complex z);
-<b>    Description</b>
-2   The carg functions compute the argument (also called phase angle) of z, with a branch
-    cut along the negative real axis.
-<b>    Returns</b>
-3   The carg functions return the value of the argument in the interval [-pi , +pi ].
-<a name="7.3.9.2" href="#7.3.9.2"><b>    7.3.9.2 The cimag functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double cimag(double complex z);
-           float cimagf(float complex z);
-           long double cimagl(long double complex z);
-
-[<a name="p178" href="#p178">page 178</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The cimag functions compute the imaginary part of z.<sup><a href="#note170"><b>170)</b></a></sup>
-<b>    Returns</b>
-3   The cimag functions return the imaginary part value (as a real).
-<a name="7.3.9.3" href="#7.3.9.3"><b>    7.3.9.3 The conj functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex conj(double complex z);
-           float complex conjf(float complex z);
-           long double complex conjl(long double complex z);
-<b>    Description</b>
-2   The conj functions compute the complex conjugate of z, by reversing the sign of its
-    imaginary part.
-<b>    Returns</b>
-3   The conj functions return the complex conjugate value.
-<a name="7.3.9.4" href="#7.3.9.4"><b>    7.3.9.4 The cproj functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex cproj(double complex z);
-           float complex cprojf(float complex z);
-           long double complex cprojl(long double complex z);
-<b>    Description</b>
-2   The cproj functions compute a projection of z onto the Riemann sphere: z projects to
-    z except that all complex infinities (even those with one infinite part and one NaN part)
-    project to positive infinity on the real axis. If z has an infinite part, then cproj(z) is
-    equivalent to
-           INFINITY + I * copysign(0.0, cimag(z))
-<b>    Returns</b>
-3   The cproj functions return the value of the projection onto the Riemann sphere.
-
-
-
-
-    <sup><a name="note170" href="#note170"><b>170)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
-
-[<a name="p179" href="#p179">page 179</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.9.5" href="#7.3.9.5"><b>    7.3.9.5 The creal functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double creal(double complex z);
-           float crealf(float complex z);
-           long double creall(long double complex z);
-<b>    Description</b>
-2   The creal functions compute the real part of z.<sup><a href="#note171"><b>171)</b></a></sup>
-<b>    Returns</b>
-3   The creal functions return the real part value.
-
-
-
-
-    <sup><a name="note171" href="#note171"><b>171)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
-
-[<a name="p180" href="#p180">page 180</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.4" href="#7.4"><b>    7.4 Character handling &lt;ctype.h&gt;</b></a>
-1   The header <a href="#7.4">&lt;ctype.h&gt;</a> declares several functions useful for classifying and mapping
-    characters.<sup><a href="#note172"><b>172)</b></a></sup> In all cases the argument is an int, the value of which shall be
-    representable as an unsigned char or shall equal the value of the macro EOF. If the
-    argument has any other value, the behavior is undefined.
-2   The behavior of these functions is affected by the current locale. Those functions that
-    have locale-specific aspects only when not in the "C" locale are noted below.
-3   The term printing character refers to a member of a locale-specific set of characters, each
-    of which occupies one printing position on a display device; the term control character
-    refers to a member of a locale-specific set of characters that are not printing
-    characters.<sup><a href="#note173"><b>173)</b></a></sup> All letters and digits are printing characters.
-    Forward references: EOF (<a href="#7.19.1">7.19.1</a>), localization (<a href="#7.11">7.11</a>).
-<a name="7.4.1" href="#7.4.1"><b>    7.4.1 Character classification functions</b></a>
-1   The functions in this subclause return nonzero (true) if and only if the value of the
-    argument c conforms to that in the description of the function.
-<a name="7.4.1.1" href="#7.4.1.1"><b>    7.4.1.1 The isalnum function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
-             int isalnum(int c);
-<b>    Description</b>
-2   The isalnum function tests for any character for which isalpha or isdigit is true.
-<a name="7.4.1.2" href="#7.4.1.2"><b>    7.4.1.2 The isalpha function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
-             int isalpha(int c);
-<b>    Description</b>
-2   The isalpha function tests for any character for which isupper or islower is true,
-    or any character that is one of a locale-specific set of alphabetic characters for which
-
-
-
-    <sup><a name="note172" href="#note172"><b>172)</b></a></sup> See ''future library directions'' (<a href="#7.26.2">7.26.2</a>).
-    <sup><a name="note173" href="#note173"><b>173)</b></a></sup> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
-         whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
-         values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
-
-[<a name="p181" href="#p181">page 181</a>] (<a href="#Contents">Contents</a>)
-
-    none of iscntrl, isdigit, ispunct, or isspace is true.<sup><a href="#note174"><b>174)</b></a></sup> In the "C" locale,
-    isalpha returns true only for the characters for which isupper or islower is true.
-<a name="7.4.1.3" href="#7.4.1.3"><b>    7.4.1.3 The isblank function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isblank(int c);
-<b>    Description</b>
-2   The isblank function tests for any character that is a standard blank character or is one
-    of a locale-specific set of characters for which isspace is true and that is used to
-    separate words within a line of text. The standard blank characters are the following:
-    space (' '), and horizontal tab ('\t'). In the "C" locale, isblank returns true only
-    for the standard blank characters.
-<a name="7.4.1.4" href="#7.4.1.4"><b>    7.4.1.4 The iscntrl function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int iscntrl(int c);
-<b>    Description</b>
-2   The iscntrl function tests for any control character.
-<a name="7.4.1.5" href="#7.4.1.5"><b>    7.4.1.5 The isdigit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isdigit(int c);
-<b>    Description</b>
-2   The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.4.1.6" href="#7.4.1.6"><b>    7.4.1.6 The isgraph function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isgraph(int c);
-
-
-
-
-    <sup><a name="note174" href="#note174"><b>174)</b></a></sup> The functions islower and isupper test true or false separately for each of these additional
-         characters; all four combinations are possible.
-
-[<a name="p182" href="#p182">page 182</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The isgraph function tests for any printing character except space (' ').
-<a name="7.4.1.7" href="#7.4.1.7"><b>    7.4.1.7 The islower function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int islower(int c);
-<b>    Description</b>
-2   The islower function tests for any character that is a lowercase letter or is one of a
-    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
-    isspace is true. In the "C" locale, islower returns true only for the lowercase
-    letters (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.4.1.8" href="#7.4.1.8"><b>    7.4.1.8 The isprint function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int isprint(int c);
-<b>    Description</b>
-2   The isprint function tests for any printing character including space (' ').
-<a name="7.4.1.9" href="#7.4.1.9"><b>    7.4.1.9 The ispunct function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int ispunct(int c);
-<b>    Description</b>
-2   The ispunct function tests for any printing character that is one of a locale-specific set
-    of punctuation characters for which neither isspace nor isalnum is true. In the "C"
-    locale, ispunct returns true for every printing character for which neither isspace
-    nor isalnum is true.
-<a name="7.4.1.10" href="#7.4.1.10"><b>    7.4.1.10 The isspace function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int isspace(int c);
-<b>    Description</b>
-2   The isspace function tests for any character that is a standard white-space character or
-    is one of a locale-specific set of characters for which isalnum is false. The standard
-
-[<a name="p183" href="#p183">page 183</a>] (<a href="#Contents">Contents</a>)
-
-    white-space characters are the following: space (' '), form feed ('\f'), new-line
-    ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). In the
-    "C" locale, isspace returns true only for the standard white-space characters.
-<a name="7.4.1.11" href="#7.4.1.11"><b>    7.4.1.11 The isupper function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int isupper(int c);
-<b>    Description</b>
-2   The isupper function tests for any character that is an uppercase letter or is one of a
-    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
-    isspace is true. In the "C" locale, isupper returns true only for the uppercase
-    letters (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.4.1.12" href="#7.4.1.12"><b>    7.4.1.12 The isxdigit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int isxdigit(int c);
-<b>    Description</b>
-2   The isxdigit function tests for any hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
-<a name="7.4.2" href="#7.4.2"><b>    7.4.2 Character case mapping functions</b></a>
-<a name="7.4.2.1" href="#7.4.2.1"><b>    7.4.2.1 The tolower function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int tolower(int c);
-<b>    Description</b>
-2   The tolower function converts an uppercase letter to a corresponding lowercase letter.
-<b>    Returns</b>
-3   If the argument is a character for which isupper is true and there are one or more
-    corresponding characters, as specified by the current locale, for which islower is true,
-    the tolower function returns one of the corresponding characters (always the same one
-    for any given locale); otherwise, the argument is returned unchanged.
-
-[<a name="p184" href="#p184">page 184</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.4.2.2" href="#7.4.2.2"><b>    7.4.2.2 The toupper function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int toupper(int c);
-<b>    Description</b>
-2   The toupper function converts a lowercase letter to a corresponding uppercase letter.
-<b>    Returns</b>
-3   If the argument is a character for which islower is true and there are one or more
-    corresponding characters, as specified by the current locale, for which isupper is true,
-    the toupper function returns one of the corresponding characters (always the same one
-    for any given locale); otherwise, the argument is returned unchanged.
-
-[<a name="p185" href="#p185">page 185</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.5" href="#7.5"><b>    7.5 Errors &lt;errno.h&gt;</b></a>
-1   The header <a href="#7.5">&lt;errno.h&gt;</a> defines several macros, all relating to the reporting of error
-    conditions.
-2   The macros are
-             EDOM
-             EILSEQ
-             ERANGE
-    which expand to integer constant expressions with type int, distinct positive values, and
-    which are suitable for use in #if preprocessing directives; and
-             errno
-    which expands to a modifiable lvalue<sup><a href="#note175"><b>175)</b></a></sup> that has type int, the value of which is set to a
-    positive error number by several library functions. It is unspecified whether errno is a
-    macro or an identifier declared with external linkage. If a macro definition is suppressed
-    in order to access an actual object, or a program defines an identifier with the name
-    errno, the behavior is undefined.
-3   The value of errno is zero at program startup, but is never set to zero by any library
-    function.<sup><a href="#note176"><b>176)</b></a></sup> The value of errno may be set to nonzero by a library function call
-    whether or not there is an error, provided the use of errno is not documented in the
-    description of the function in this International Standard.
-4   Additional macro definitions, beginning with E and a digit or E and an uppercase
-    letter,<sup><a href="#note177"><b>177)</b></a></sup> may also be specified by the implementation.
-
-
-
-
-    <sup><a name="note175" href="#note175"><b>175)</b></a></sup> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
-         resulting from a function call (for example, *errno()).
-    <sup><a name="note176" href="#note176"><b>176)</b></a></sup> Thus, a program that uses errno for error checking should set it to zero before a library function call,
-         then inspect it before a subsequent library function call. Of course, a library function can save the
-         value of errno on entry and then set it to zero, as long as the original value is restored if errno's
-         value is still zero just before the return.
-    <sup><a name="note177" href="#note177"><b>177)</b></a></sup> See ''future library directions'' (<a href="#7.26.3">7.26.3</a>).
-
-[<a name="p186" href="#p186">page 186</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.6" href="#7.6"><b>    7.6 Floating-point environment &lt;fenv.h&gt;</b></a>
-1   The header <a href="#7.6">&lt;fenv.h&gt;</a> declares two types and several macros and functions to provide
-    access to the floating-point environment. The floating-point environment refers
-    collectively to any floating-point status flags and control modes supported by the
-    implementation.<sup><a href="#note178"><b>178)</b></a></sup> A floating-point status flag is a system variable whose value is set
-    (but never cleared) when a floating-point exception is raised, which occurs as a side effect
-    of exceptional floating-point arithmetic to provide auxiliary information.<sup><a href="#note179"><b>179)</b></a></sup> A floating-
-    point control mode is a system variable whose value may be set by the user to affect the
-    subsequent behavior of floating-point arithmetic.
-2   Certain programming conventions support the intended model of use for the floating-
-    point environment:<sup><a href="#note180"><b>180)</b></a></sup>
-    -- a function call does not alter its caller's floating-point control modes, clear its caller's
-      floating-point status flags, nor depend on the state of its caller's floating-point status
-      flags unless the function is so documented;
-    -- a function call is assumed to require default floating-point control modes, unless its
-      documentation promises otherwise;
-    -- a function call is assumed to have the potential for raising floating-point exceptions,
-      unless its documentation promises otherwise.
-3   The type
-            fenv_t
-    represents the entire floating-point environment.
-4   The type
-            fexcept_t
-    represents the floating-point status flags collectively, including any status the
-    implementation associates with the flags.
-
-
-
-
-    <sup><a name="note178" href="#note178"><b>178)</b></a></sup> This header is designed to support the floating-point exception status flags and directed-rounding
-         control modes required by IEC 60559, and other similar floating-point state information. Also it is
-         designed to facilitate code portability among all systems.
-    <sup><a name="note179" href="#note179"><b>179)</b></a></sup> A floating-point status flag is not an object and can be set more than once within an expression.
-    <sup><a name="note180" href="#note180"><b>180)</b></a></sup> With these conventions, a programmer can safely assume default floating-point control modes (or be
-         unaware of them). The responsibilities associated with accessing the floating-point environment fall
-         on the programmer or program that does so explicitly.
-
-[<a name="p187" href="#p187">page 187</a>] (<a href="#Contents">Contents</a>)
-
-5   Each of the macros
-            FE_DIVBYZERO
-            FE_INEXACT
-            FE_INVALID
-            FE_OVERFLOW
-            FE_UNDERFLOW
-    is defined if and only if the implementation supports the floating-point exception by
-    means of the functions in 7.6.2.<sup><a href="#note181"><b>181)</b></a></sup> Additional implementation-defined floating-point
-    exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
-    be specified by the implementation. The defined macros expand to integer constant
-    expressions with values such that bitwise ORs of all combinations of the macros result in
-    distinct values, and furthermore, bitwise ANDs of all combinations of the macros result in
-    zero.<sup><a href="#note182"><b>182)</b></a></sup>
-6   The macro
-            FE_ALL_EXCEPT
-    is simply the bitwise OR of all floating-point exception macros defined by the
-    implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
-7   Each of the macros
-            FE_DOWNWARD
-            FE_TONEAREST
-            FE_TOWARDZERO
-            FE_UPWARD
-    is defined if and only if the implementation supports getting and setting the represented
-    rounding direction by means of the fegetround and fesetround functions.
-    Additional implementation-defined rounding directions, with macro definitions beginning
-    with FE_ and an uppercase letter, may also be specified by the implementation. The
-    defined macros expand to integer constant expressions whose values are distinct
-    nonnegative values.<sup><a href="#note183"><b>183)</b></a></sup>
-8   The macro
-
-
-
-    <sup><a name="note181" href="#note181"><b>181)</b></a></sup> The implementation supports an exception if there are circumstances where a call to at least one of the
-         functions in <a href="#7.6.2">7.6.2</a>, using the macro as the appropriate argument, will succeed. It is not necessary for
-         all the functions to succeed all the time.
-    <sup><a name="note182" href="#note182"><b>182)</b></a></sup> The macros should be distinct powers of two.
-    <sup><a name="note183" href="#note183"><b>183)</b></a></sup> Even though the rounding direction macros may expand to constants corresponding to the values of
-         FLT_ROUNDS, they are not required to do so.
-
-[<a name="p188" href="#p188">page 188</a>] (<a href="#Contents">Contents</a>)
-
-             FE_DFL_ENV
-    represents the default floating-point environment -- the one installed at program startup
-    -- and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
-    <a href="#7.6">&lt;fenv.h&gt;</a> functions that manage the floating-point environment.
-9   Additional implementation-defined environments, with macro definitions beginning with
-    FE_ and an uppercase letter, and having type ''pointer to const-qualified fenv_t'', may
-    also be specified by the implementation.
-<a name="7.6.1" href="#7.6.1"><b>    7.6.1 The FENV_ACCESS pragma</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             #pragma STDC FENV_ACCESS on-off-switch
-<b>    Description</b>
-2   The FENV_ACCESS pragma provides a means to inform the implementation when a
-    program might access the floating-point environment to test floating-point status flags or
-    run under non-default floating-point control modes.<sup><a href="#note184"><b>184)</b></a></sup> The pragma shall occur either
-    outside external declarations or preceding all explicit declarations and statements inside a
-    compound statement. When outside external declarations, the pragma takes effect from
-    its occurrence until another FENV_ACCESS pragma is encountered, or until the end of
-    the translation unit. When inside a compound statement, the pragma takes effect from its
-    occurrence until another FENV_ACCESS pragma is encountered (including within a
-    nested compound statement), or until the end of the compound statement; at the end of a
-    compound statement the state for the pragma is restored to its condition just before the
-    compound statement. If this pragma is used in any other context, the behavior is
-    undefined. If part of a program tests floating-point status flags, sets floating-point control
-    modes, or runs under non-default mode settings, but was translated with the state for the
-    FENV_ACCESS pragma ''off'', the behavior is undefined. The default state (''on'' or
-    ''off'') for the pragma is implementation-defined. (When execution passes from a part of
-    the program translated with FENV_ACCESS ''off'' to a part translated with
-    FENV_ACCESS ''on'', the state of the floating-point status flags is unspecified and the
-    floating-point control modes have their default settings.)
-
-
-
-
-    <sup><a name="note184" href="#note184"><b>184)</b></a></sup> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
-         tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
-         folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
-         modes are in effect and the flags are not tested.
-
-[<a name="p189" href="#p189">page 189</a>] (<a href="#Contents">Contents</a>)
-
-3   EXAMPLE
-            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            void f(double x)
-            {
-                  #pragma STDC FENV_ACCESS ON
-                  void g(double);
-                  void h(double);
-                  /* ... */
-                  g(x + 1);
-                  h(x + 1);
-                  /* ... */
-            }
-4   If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
-    x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
-    contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note185"><b>185)</b></a></sup>
-
-<a name="7.6.2" href="#7.6.2"><b>    7.6.2 Floating-point exceptions</b></a>
-1   The following functions provide access to the floating-point status flags.<sup><a href="#note186"><b>186)</b></a></sup> The int
-    input argument for the functions represents a subset of floating-point exceptions, and can
-    be zero or the bitwise OR of one or more floating-point exception macros, for example
-    FE_OVERFLOW | FE_INEXACT. For other argument values the behavior of these
-    functions is undefined.
-<a name="7.6.2.1" href="#7.6.2.1"><b>    7.6.2.1 The feclearexcept function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int feclearexcept(int excepts);
-<b>    Description</b>
-2   The feclearexcept function attempts to clear the supported floating-point exceptions
-    represented by its argument.
-<b>    Returns</b>
-3   The feclearexcept function returns zero if the excepts argument is zero or if all
-    the specified exceptions were successfully cleared. Otherwise, it returns a nonzero value.
-
-
-    <sup><a name="note185" href="#note185"><b>185)</b></a></sup> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
-         hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
-         ''off'', just one evaluation of x + 1 would suffice.
-    <sup><a name="note186" href="#note186"><b>186)</b></a></sup> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
-         abstraction of flags that are either set or clear. An implementation may endow floating-point status
-         flags with more information -- for example, the address of the code which first raised the floating-
-         point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
-         content of flags.
-
-[<a name="p190" href="#p190">page 190</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.6.2.2" href="#7.6.2.2"><b>    7.6.2.2 The fegetexceptflag function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             int fegetexceptflag(fexcept_t *flagp,
-                  int excepts);
-<b>    Description</b>
-2   The fegetexceptflag function attempts to store an implementation-defined
-    representation of the states of the floating-point status flags indicated by the argument
-    excepts in the object pointed to by the argument flagp.
-<b>    Returns</b>
-3   The fegetexceptflag function returns zero if the representation was successfully
-    stored. Otherwise, it returns a nonzero value.
-<a name="7.6.2.3" href="#7.6.2.3"><b>    7.6.2.3 The feraiseexcept function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             int feraiseexcept(int excepts);
-<b>    Description</b>
-2   The feraiseexcept function attempts to raise the supported floating-point exceptions
-    represented by its argument.<sup><a href="#note187"><b>187)</b></a></sup> The order in which these floating-point exceptions are
-    raised is unspecified, except as stated in <a href="#F.7.6">F.7.6</a>. Whether the feraiseexcept function
-    additionally raises the ''inexact'' floating-point exception whenever it raises the
-    ''overflow'' or ''underflow'' floating-point exception is implementation-defined.
-<b>    Returns</b>
-3   The feraiseexcept function returns zero if the excepts argument is zero or if all
-    the specified exceptions were successfully raised. Otherwise, it returns a nonzero value.
-
-
-
-
-    <sup><a name="note187" href="#note187"><b>187)</b></a></sup> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
-         Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
-         in <a href="#F.7.6">F.7.6</a> is in the same spirit.
-
-[<a name="p191" href="#p191">page 191</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.6.2.4" href="#7.6.2.4"><b>    7.6.2.4 The fesetexceptflag function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fesetexceptflag(const fexcept_t *flagp,
-                 int excepts);
-<b>    Description</b>
-2   The fesetexceptflag function attempts to set the floating-point status flags
-    indicated by the argument excepts to the states stored in the object pointed to by
-    flagp. The value of *flagp shall have been set by a previous call to
-    fegetexceptflag whose second argument represented at least those floating-point
-    exceptions represented by the argument excepts. This function does not raise floating-
-    point exceptions, but only sets the state of the flags.
-<b>    Returns</b>
-3   The fesetexceptflag function returns zero if the excepts argument is zero or if
-    all the specified flags were successfully set to the appropriate state. Otherwise, it returns
-    a nonzero value.
-<a name="7.6.2.5" href="#7.6.2.5"><b>    7.6.2.5 The fetestexcept function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fetestexcept(int excepts);
-<b>    Description</b>
-2   The fetestexcept function determines which of a specified subset of the floating-
-    point exception flags are currently set. The excepts argument specifies the floating-
-    point status flags to be queried.<sup><a href="#note188"><b>188)</b></a></sup>
-<b>    Returns</b>
-3   The fetestexcept function returns the value of the bitwise OR of the floating-point
-    exception macros corresponding to the currently set floating-point exceptions included in
-    excepts.
-4   EXAMPLE       Call f if ''invalid'' is set, then g if ''overflow'' is set:
-
-
-
-
-    <sup><a name="note188" href="#note188"><b>188)</b></a></sup> This mechanism allows testing several floating-point exceptions with just one function call.
-
-[<a name="p192" href="#p192">page 192</a>] (<a href="#Contents">Contents</a>)
-
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           /* ... */
+                return f(&amp;u.s1, &amp;u.s2);
+          }</pre>
+ 
+ Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
+ specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
+<!--page 87 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note82">82)</a> If the member used to access the contents of a union object is not the same as the member last used to
+ store a value in the object, the appropriate part of the object representation of the value is reinterpreted
+ as an object representation in the new type as described in <a href="#6.2.6">6.2.6</a> (a process sometimes called "type
+ punning"). This might be a trap representation.
+
+<p><a name="note83">83)</a> If &amp;E is a valid pointer expression (where &amp; is the ''address-of '' operator, which generates a pointer to
+ its operand), the expression (&amp;E)-&gt;MOS is the same as E.MOS.
+
+
+<a name="6.5.2.4" href="#6.5.2.4"><h5>6.5.2.4 Postfix increment and decrement operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the postfix increment or decrement operator shall have qualified or
+ unqualified real or pointer type and shall be a modifiable lvalue.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The result of the postfix ++ operator is the value of the operand. After the result is
+ obtained, the value of the operand is incremented. (That is, the value 1 of the appropriate
+ type is added to it.) See the discussions of additive operators and compound assignment
+ for information on constraints, types, and conversions and the effects of operations on
+ pointers. The side effect of updating the stored value of the operand shall occur between
+ the previous and the next sequence point.
+<p><!--para 3-->
+ The postfix -- operator is analogous to the postfix ++ operator, except that the value of
+ the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
+ it).
+ Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+
+<a name="6.5.2.5" href="#6.5.2.5"><h5>6.5.2.5 Compound literals</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The type name shall specify an object type or an array of unknown size, but not a variable
+ length array type.
+<p><!--para 2-->
+ No initializer shall attempt to provide a value for an object not contained within the entire
+ unnamed object specified by the compound literal.
+<p><!--para 3-->
+ If the compound literal occurs outside the body of a function, the initializer list shall
+ consist of constant expressions.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ A postfix expression that consists of a parenthesized type name followed by a brace-
+ enclosed list of initializers is a compound literal. It provides an unnamed object whose
+ value is given by the initializer list.<sup><a href="#note84"><b>84)</b></a></sup>
+<p><!--para 5-->
+ If the type name specifies an array of unknown size, the size is determined by the
+ initializer list as specified in <a href="#6.7.8">6.7.8</a>, and the type of the compound literal is that of the
+ completed array type. Otherwise (when the type name specifies an object type), the type
+ of the compound literal is that specified by the type name. In either case, the result is an
+ lvalue.
+ 
+ 
+<!--page 88 indent 5-->
+<p><!--para 6-->
+ The value of the compound literal is that of an unnamed object initialized by the
+ initializer list. If the compound literal occurs outside the body of a function, the object
+ has static storage duration; otherwise, it has automatic storage duration associated with
+ the enclosing block.
+<p><!--para 7-->
+ All the semantic rules and constraints for initializer lists in <a href="#6.7.8">6.7.8</a> are applicable to
+ compound literals.<sup><a href="#note85"><b>85)</b></a></sup>
+<p><!--para 8-->
+ String literals, and compound literals with const-qualified types, need not designate
+ distinct objects.<sup><a href="#note86"><b>86)</b></a></sup>
+<p><!--para 9-->
+ EXAMPLE 1       The file scope definition
+<pre>
+          int *p = (int []){2, 4};</pre>
+ initializes p to point to the first element of an array of two ints, the first having the value two and the
+ second, four. The expressions in this compound literal are required to be constant. The unnamed object
+ has static storage duration.
+ 
+<p><!--para 10-->
+ EXAMPLE 2       In contrast, in
+<pre>
+          void f(void)
+          {
+                int *p;
+                /*...*/
+                p = (int [2]){*p};
+                /*...*/
+          }</pre>
+ p is assigned the address of the first element of an array of two ints, the first having the value previously
+ pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
+ unnamed object has automatic storage duration.
+ 
+<p><!--para 11-->
+ EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
+ created using compound literals can be passed to functions without depending on member order:
+<pre>
+          drawline((struct point){.x=1, .y=1},
+                (struct point){.x=3, .y=4});</pre>
+ Or, if drawline instead expected pointers to struct point:
+<pre>
+          drawline(&amp;(struct point){.x=1, .y=1},
+                &amp;(struct point){.x=3, .y=4});</pre>
+ 
+<p><!--para 12-->
+ EXAMPLE 4       A read-only compound literal can be specified through constructions like:
+<pre>
+          (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}</pre>
+ 
+ 
+ 
+ 
+<!--page 89 indent 5-->
+<p><!--para 13-->
+ EXAMPLE 5        The following three expressions have different meanings:
+<pre>
+          "/tmp/fileXXXXXX"
+          (char []){"/tmp/fileXXXXXX"}
+          (const char []){"/tmp/fileXXXXXX"}</pre>
+ The first always has static storage duration and has type array of char, but need not be modifiable; the last
+ two have automatic storage duration when they occur within the body of a function, and the first of these
+ two is modifiable.
+ 
+<p><!--para 14-->
+ EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
+ and can even be shared. For example,
+<pre>
+          (const char []){"abc"} == "abc"</pre>
+ might yield 1 if the literals' storage is shared.
+ 
+<p><!--para 15-->
+ EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
+ linked object. For example, there is no way to write a self-referential compound literal that could be used
+ as the function argument in place of the named object endless_zeros below:
+<pre>
+          struct int_list { int car; struct int_list *cdr; };
+          struct int_list endless_zeros = {0, &amp;endless_zeros};
+          eval(endless_zeros);</pre>
+ 
+<p><!--para 16-->
+ EXAMPLE 8        Each compound literal creates only a single object in a given scope:
+<pre>
+          struct s { int i; };
+          int f (void)
+          {
+                struct s *p = 0, *q;
+                int j = 0;
+          again:
+                q = p, p = &amp;((struct s){ j++ });
+                if (j &lt; 2) goto again;
+                    return p == q &amp;&amp; q-&gt;i == 1;
+          }</pre>
+ The function f() always returns the value 1.
+<p><!--para 17-->
+ Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
+ lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
+ have an indeterminate value, which would result in undefined behavior.
+ 
+ Forward references: type names (<a href="#6.7.6">6.7.6</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+<!--page 90 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note84">84)</a> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
+ or void only, and the result of a cast expression is not an lvalue.
+
+<p><a name="note85">85)</a> For example, subobjects without explicit initializers are initialized to zero.
+
+<p><a name="note86">86)</a> This allows implementations to share storage for string literals and constant compound literals with
+ the same or overlapping representations.
+
+
+<a name="6.5.3" href="#6.5.3"><h4>6.5.3 Unary operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          unary-expression:
+                 postfix-expression
+                 ++ unary-expression
+                 -- unary-expression
+                 unary-operator cast-expression
+                 sizeof unary-expression
+                 sizeof ( type-name )
+          unary-operator: one of
+                 &amp; * + - ~             !</pre>
+
+<a name="6.5.3.1" href="#6.5.3.1"><h5>6.5.3.1 Prefix increment and decrement operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the prefix increment or decrement operator shall have qualified or
+ unqualified real or pointer type and shall be a modifiable lvalue.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The value of the operand of the prefix ++ operator is incremented. The result is the new
+ value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
+ See the discussions of additive operators and compound assignment for information on
+ constraints, types, side effects, and conversions and the effects of operations on pointers.
+<p><!--para 3-->
+ The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
+ operand is decremented.
+ Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+
+<a name="6.5.3.2" href="#6.5.3.2"><h5>6.5.3.2 Address and indirection operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the unary &amp; operator shall be either a function designator, the result of a
+ [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
+ not declared with the register storage-class specifier.
+<p><!--para 2-->
+ The operand of the unary * operator shall have pointer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The unary &amp; operator yields the address of its operand. If the operand has type ''type'',
+ the result has type ''pointer to type''. If the operand is the result of a unary * operator,
+ neither that operator nor the &amp; operator is evaluated and the result is as if both were
+ omitted, except that the constraints on the operators still apply and the result is not an
+ lvalue. Similarly, if the operand is the result of a [] operator, neither the &amp; operator nor
+<!--page 91 indent 4-->
+ the unary * that is implied by the [] is evaluated and the result is as if the &amp; operator
+ were removed and the [] operator were changed to a + operator. Otherwise, the result is
+ a pointer to the object or function designated by its operand.
+<p><!--para 4-->
+ The unary * operator denotes indirection. If the operand points to a function, the result is
+ a function designator; if it points to an object, the result is an lvalue designating the
+ object. If the operand has type ''pointer to type'', the result has type ''type''. If an
+ invalid value has been assigned to the pointer, the behavior of the unary * operator is
+ undefined.<sup><a href="#note87"><b>87)</b></a></sup>
+ Forward references: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note87">87)</a> Thus, &amp;*E is equivalent to E (even if E is a null pointer), and &amp;(E1[E2]) to ((E1)+(E2)). It is
+ always true that if E is a function designator or an lvalue that is a valid operand of the unary &amp;
+ operator, *&amp;E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
+ an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
+  Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
+  address inappropriately aligned for the type of object pointed to, and the address of an object after the
+  end of its lifetime.
+
+
+<a name="6.5.3.3" href="#6.5.3.3"><h5>6.5.3.3 Unary arithmetic operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
+ integer type; of the ! operator, scalar type.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The result of the unary + operator is the value of its (promoted) operand. The integer
+ promotions are performed on the operand, and the result has the promoted type.
+<p><!--para 3-->
+ The result of the unary - operator is the negative of its (promoted) operand. The integer
+ promotions are performed on the operand, and the result has the promoted type.
+<p><!--para 4-->
+ The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
+ each bit in the result is set if and only if the corresponding bit in the converted operand is
+ not set). The integer promotions are performed on the operand, and the result has the
+ promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
+ to the maximum value representable in that type minus E.
+<p><!--para 5-->
+ The result of the logical negation operator ! is 0 if the value of its operand compares
+ unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int.
+ The expression !E is equivalent to (0==E).
+ 
+ 
+ 
+ 
+<!--page 92 indent 4-->
+
+<a name="6.5.3.4" href="#6.5.3.4"><h5>6.5.3.4 The sizeof operator</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The sizeof operator shall not be applied to an expression that has function type or an
+ incomplete type, to the parenthesized name of such a type, or to an expression that
+ designates a bit-field member.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The sizeof operator yields the size (in bytes) of its operand, which may be an
+ expression or the parenthesized name of a type. The size is determined from the type of
+ the operand. The result is an integer. If the type of the operand is a variable length array
+ type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
+ integer constant.
+<p><!--para 3-->
+ When applied to an operand that has type char, unsigned char, or signed char,
+ (or a qualified version thereof) the result is 1. When applied to an operand that has array
+ type, the result is the total number of bytes in the array.<sup><a href="#note88"><b>88)</b></a></sup> When applied to an operand
+ that has structure or union type, the result is the total number of bytes in such an object,
+ including internal and trailing padding.
+<p><!--para 4-->
+ The value of the result is implementation-defined, and its type (an unsigned integer type)
+ is size_t, defined in &lt;stddef.h&gt; (and other headers).
+<p><!--para 5-->
+ EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
+ allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
+ allocate and return a pointer to void. For example:
+<pre>
+         extern void *alloc(size_t);
+         double *dp = alloc(sizeof *dp);</pre>
+ The implementation of the alloc function should ensure that its return value is aligned suitably for
+ conversion to a pointer to double.
+ 
+<p><!--para 6-->
+ EXAMPLE 2      Another use of the sizeof operator is to compute the number of elements in an array:
+<pre>
+         sizeof array / sizeof array[0]</pre>
+ 
+<p><!--para 7-->
+ EXAMPLE 3      In this example, the size of a variable length array is computed and returned from a
+ function:
+<pre>
+         #include &lt;stddef.h&gt;
+         size_t fsize3(int n)
+         {
+               char b[n+3];                  // variable length array
+               return sizeof b;              // execution time sizeof
+         }</pre>
+ 
+ 
+ 
+<!--page 93 indent 4-->
+<pre>
+          int main()
+          {
+                size_t size;
+                size = fsize3(10); // fsize3 returns 13
+                return 0;
+          }</pre>
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.17">7.17</a>), declarations (<a href="#6.7">6.7</a>),
+ structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.6">6.7.6</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note88">88)</a> When applied to a parameter declared to have array or function type, the sizeof operator yields the
+ size of the adjusted (pointer) type (see <a href="#6.9.1">6.9.1</a>).
+
+
+<a name="6.5.4" href="#6.5.4"><h4>6.5.4 Cast operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          cast-expression:
+                 unary-expression
+                 ( type-name ) cast-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Unless the type name specifies a void type, the type name shall specify qualified or
+ unqualified scalar type and the operand shall have scalar type.
+<p><!--para 3-->
+ Conversions that involve pointers, other than where permitted by the constraints of
+ <a href="#6.5.16.1">6.5.16.1</a>, shall be specified by means of an explicit cast.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ Preceding an expression by a parenthesized type name converts the value of the
+ expression to the named type. This construction is called a cast.<sup><a href="#note89"><b>89)</b></a></sup> A cast that specifies
+ no conversion has no effect on the type or value of an expression.
+<p><!--para 5-->
+ If the value of the expression is represented with greater precision or range than required
+ by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
+ type of the expression is the same as the named type.
+ Forward references: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
+ prototypes) (<a href="#6.7.5.3">6.7.5.3</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>), type names (<a href="#6.7.6">6.7.6</a>).
+ 
+ 
+ 
+ 
+<!--page 94 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note89">89)</a> A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the
+ unqualified version of the type.
+
+
+<a name="6.5.5" href="#6.5.5"><h4>6.5.5 Multiplicative operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          multiplicative-expression:
+                  cast-expression
+                  multiplicative-expression * cast-expression
+                  multiplicative-expression / cast-expression
+                  multiplicative-expression % cast-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have arithmetic type. The operands of the % operator shall
+ have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the binary * operator is the product of the operands.
+<p><!--para 5-->
+ The result of the / operator is the quotient from the division of the first operand by the
+ second; the result of the % operator is the remainder. In both operations, if the value of
+ the second operand is zero, the behavior is undefined.
+<p><!--para 6-->
+ When integers are divided, the result of the / operator is the algebraic quotient with any
+ fractional part discarded.<sup><a href="#note90"><b>90)</b></a></sup> If the quotient a/b is representable, the expression
+ (a/b)*b + a%b shall equal a.
+
+<h6>footnotes</h6>
+<p><a name="note90">90)</a> This is often called ''truncation toward zero''.
+
+
+<a name="6.5.6" href="#6.5.6"><h4>6.5.6 Additive operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          additive-expression:
+                  multiplicative-expression
+                  additive-expression + multiplicative-expression
+                  additive-expression - multiplicative-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ For addition, either both operands shall have arithmetic type, or one operand shall be a
+ pointer to an object type and the other shall have integer type. (Incrementing is
+ equivalent to adding 1.)
+<p><!--para 3-->
+ For subtraction, one of the following shall hold:
+<ul>
+<li>  both operands have arithmetic type;
+ 
+ 
+ 
+<!--page 95 indent 4-->
+<li>  both operands are pointers to qualified or unqualified versions of compatible object
+ types; or
+<li>  the left operand is a pointer to an object type and the right operand has integer type.
+</ul>
+ (Decrementing is equivalent to subtracting 1.)
+<h6>Semantics</h6>
+<p><!--para 4-->
+ If both operands have arithmetic type, the usual arithmetic conversions are performed on
+ them.
+<p><!--para 5-->
+ The result of the binary + operator is the sum of the operands.
+<p><!--para 6-->
+ The result of the binary - operator is the difference resulting from the subtraction of the
+ second operand from the first.
+<p><!--para 7-->
+ For the purposes of these operators, a pointer to an object that is not an element of an
+ array behaves the same as a pointer to the first element of an array of length one with the
+ type of the object as its element type.
+<p><!--para 8-->
+ When an expression that has integer type is added to or subtracted from a pointer, the
+ result has the type of the pointer operand. If the pointer operand points to an element of
+ an array object, and the array is large enough, the result points to an element offset from
+ the original element such that the difference of the subscripts of the resulting and original
+ array elements equals the integer expression. In other words, if the expression P points to
+ the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and
+ (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of
+ the array object, provided they exist. Moreover, if the expression P points to the last
+ element of an array object, the expression (P)+1 points one past the last element of the
+ array object, and if the expression Q points one past the last element of an array object,
+ the expression (Q)-1 points to the last element of the array object. If both the pointer
+ operand and the result point to elements of the same array object, or one past the last
+ element of the array object, the evaluation shall not produce an overflow; otherwise, the
+ behavior is undefined. If the result points one past the last element of the array object, it
+ shall not be used as the operand of a unary * operator that is evaluated.
+<p><!--para 9-->
+ When two pointers are subtracted, both shall point to elements of the same array object,
+ or one past the last element of the array object; the result is the difference of the
+ subscripts of the two array elements. The size of the result is implementation-defined,
+ and its type (a signed integer type) is ptrdiff_t defined in the &lt;stddef.h&gt; header.
+ If the result is not representable in an object of that type, the behavior is undefined. In
+ other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
+ an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
+ object of type ptrdiff_t. Moreover, if the expression P points either to an element of
+ an array object or one past the last element of an array object, and the expression Q points
+ to the last element of the same array object, the expression ((Q)+1)-(P) has the same
+<!--page 96 indent 5-->
+ value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the
+ expression P points one past the last element of the array object, even though the
+ expression (Q)+1 does not point to an element of the array object.<sup><a href="#note91"><b>91)</b></a></sup>
+<p><!--para 10-->
+ EXAMPLE        Pointer arithmetic is well defined with pointers to variable length array types.
+<p><!--para 11-->
+<pre>
+          {
+                   int n = 4, m = 3;
+                   int a[n][m];
+                   int (*p)[m] = a;            //   p == &amp;a[0]
+                   p += 1;                     //   p == &amp;a[1]
+                   (*p)[2] = 99;               //   a[1][2] == 99
+                   n = p - a;                  //   n == 1
+          }</pre>
+ If array a in the above example were declared to be an array of known constant size, and pointer p were
+ declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
+ the same.
+ 
+ Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), common definitions &lt;stddef.h&gt;
+ (<a href="#7.17">7.17</a>).
+
+<h6>footnotes</h6>
+<p><a name="note91">91)</a> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
+ this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
+ by the size of the object originally pointed to, and the resulting pointer is converted back to the
+ original type. For pointer subtraction, the result of the difference between the character pointers is
+ similarly divided by the size of the object originally pointed to.
+  When viewed in this way, an implementation need only provide one extra byte (which may overlap
+  another object in the program) just after the end of the object in order to satisfy the ''one past the last
+  element'' requirements.
+
+
+<a name="6.5.7" href="#6.5.7"><h4>6.5.7 Bitwise shift operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          shift-expression:
+                  additive-expression
+                  shift-expression &lt;&lt; additive-expression
+                  shift-expression &gt;&gt; additive-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The integer promotions are performed on each of the operands. The type of the result is
+ that of the promoted left operand. If the value of the right operand is negative or is
+ greater than or equal to the width of the promoted left operand, the behavior is undefined.
+ 
+ 
+ 
+ 
+<!--page 97 indent 4-->
+<p><!--para 4-->
+ The result of E1 &lt;&lt; E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
+ zeros. If E1 has an unsigned type, the value of the result is E1 x 2E2 , reduced modulo
+ one more than the maximum value representable in the result type. If E1 has a signed
+ type and nonnegative value, and E1 x 2E2 is representable in the result type, then that is
+ the resulting value; otherwise, the behavior is undefined.
+<p><!--para 5-->
+ The result of E1 &gt;&gt; E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
+ or if E1 has a signed type and a nonnegative value, the value of the result is the integral
+ part of the quotient of E1 / 2E2 . If E1 has a signed type and a negative value, the
+ resulting value is implementation-defined.
+
+<a name="6.5.8" href="#6.5.8"><h4>6.5.8 Relational operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          relational-expression:
+                  shift-expression
+                  relational-expression   &lt;    shift-expression
+                  relational-expression   &gt;    shift-expression
+                  relational-expression   &lt;=   shift-expression
+                  relational-expression   &gt;=   shift-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ One of the following shall hold:
+<ul>
+<li>  both operands have real type;
+<li>  both operands are pointers to qualified or unqualified versions of compatible object
+ types; or
+<li>  both operands are pointers to qualified or unqualified versions of compatible
+ incomplete types.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 3-->
+ If both of the operands have arithmetic type, the usual arithmetic conversions are
+ performed.
+<p><!--para 4-->
+ For the purposes of these operators, a pointer to an object that is not an element of an
+ array behaves the same as a pointer to the first element of an array of length one with the
+ type of the object as its element type.
+<p><!--para 5-->
+ When two pointers are compared, the result depends on the relative locations in the
+ address space of the objects pointed to. If two pointers to object or incomplete types both
+ point to the same object, or both point one past the last element of the same array object,
+ they compare equal. If the objects pointed to are members of the same aggregate object,
+ pointers to structure members declared later compare greater than pointers to members
+ declared earlier in the structure, and pointers to array elements with larger subscript
+<!--page 98 indent 4-->
+ values compare greater than pointers to elements of the same array with lower subscript
+ values. All pointers to members of the same union object compare equal. If the
+ expression P points to an element of an array object and the expression Q points to the
+ last element of the same array object, the pointer expression Q+1 compares greater than
+ P. In all other cases, the behavior is undefined.
+<p><!--para 6-->
+ Each of the operators &lt; (less than), &gt; (greater than), &lt;= (less than or equal to), and &gt;=
+ (greater than or equal to) shall yield 1 if the specified relation is true and 0 if it is false.<sup><a href="#note92"><b>92)</b></a></sup>
+ The result has type int.
+
+<h6>footnotes</h6>
+<p><a name="note92">92)</a> The expression a&lt;b&lt;c is not interpreted as in ordinary mathematics. As the syntax indicates, it
+ means (a&lt;b)&lt;c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
+
+
+<a name="6.5.9" href="#6.5.9"><h4>6.5.9 Equality operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          equality-expression:
+                  relational-expression
+                 equality-expression == relational-expression
+                 equality-expression != relational-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ One of the following shall hold:
+<ul>
+<li>  both operands have arithmetic type;
+<li>  both operands are pointers to qualified or unqualified versions of compatible types;
+<li>  one operand is a pointer to an object or incomplete type and the other is a pointer to a
+ qualified or unqualified version of void; or
+<li>  one operand is a pointer and the other is a null pointer constant.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The == (equal to) and != (not equal to) operators are analogous to the relational
+ operators except for their lower precedence.<sup><a href="#note93"><b>93)</b></a></sup> Each of the operators yields 1 if the
+ specified relation is true and 0 if it is false. The result has type int. For any pair of
+ operands, exactly one of the relations is true.
+<p><!--para 4-->
+ If both of the operands have arithmetic type, the usual arithmetic conversions are
+ performed. Values of complex types are equal if and only if both their real parts are equal
+ and also their imaginary parts are equal. Any two values of arithmetic types from
+ different type domains are equal if and only if the results of their conversions to the
+ (complex) result type determined by the usual arithmetic conversions are equal.
+ 
+ 
+<!--page 99 indent 4-->
+<p><!--para 5-->
+ Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
+ null pointer constant, the null pointer constant is converted to the type of the pointer. If
+ one operand is a pointer to an object or incomplete type and the other is a pointer to a
+ qualified or unqualified version of void, the former is converted to the type of the latter.
+<p><!--para 6-->
+ Two pointers compare equal if and only if both are null pointers, both are pointers to the
+ same object (including a pointer to an object and a subobject at its beginning) or function,
+ both are pointers to one past the last element of the same array object, or one is a pointer
+ to one past the end of one array object and the other is a pointer to the start of a different
+ array object that happens to immediately follow the first array object in the address
+ space.<sup><a href="#note94"><b>94)</b></a></sup>
+<p><!--para 7-->
+ For the purposes of these operators, a pointer to an object that is not an element of an
+ array behaves the same as a pointer to the first element of an array of length one with the
+ type of the object as its element type.
+
+<h6>footnotes</h6>
+<p><a name="note93">93)</a> Because of the precedences, a&lt;b == c&lt;d is 1 whenever a&lt;b and c&lt;d have the same truth-value.
+
+<p><a name="note94">94)</a> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
+ adjacent members of a structure with no padding between them, or because the implementation chose
+ to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
+ outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
+ behavior.
+
+
+<a name="6.5.10" href="#6.5.10"><h4>6.5.10 Bitwise AND operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          AND-expression:
+                equality-expression
+                AND-expression &amp; equality-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the binary &amp; operator is the bitwise AND of the operands (that is, each bit in
+ the result is set if and only if each of the corresponding bits in the converted operands is
+ set).
+ 
+ 
+ 
+ 
+<!--page 100 indent 4-->
+
+<a name="6.5.11" href="#6.5.11"><h4>6.5.11 Bitwise exclusive OR operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          exclusive-OR-expression:
+                  AND-expression
+                  exclusive-OR-expression ^ AND-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
+ in the result is set if and only if exactly one of the corresponding bits in the converted
+ operands is set).
+
+<a name="6.5.12" href="#6.5.12"><h4>6.5.12 Bitwise inclusive OR operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          inclusive-OR-expression:
+                  exclusive-OR-expression
+                  inclusive-OR-expression | exclusive-OR-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
+ the result is set if and only if at least one of the corresponding bits in the converted
+ operands is set).
+<!--page 101 indent 4-->
+
+<a name="6.5.13" href="#6.5.13"><h4>6.5.13 Logical AND operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+           logical-AND-expression:
+                   inclusive-OR-expression
+                   logical-AND-expression &amp;&amp; inclusive-OR-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have scalar type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The &amp;&amp; operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
+ yields 0. The result has type int.
+<p><!--para 4-->
+ Unlike the bitwise binary &amp; operator, the &amp;&amp; operator guarantees left-to-right evaluation;
+ there is a sequence point after the evaluation of the first operand. If the first operand
+ compares equal to 0, the second operand is not evaluated.
+
+<a name="6.5.14" href="#6.5.14"><h4>6.5.14 Logical OR operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+           logical-OR-expression:
+                   logical-AND-expression
+                   logical-OR-expression || logical-AND-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have scalar type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
+ yields 0. The result has type int.
+<p><!--para 4-->
+ Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; there is
+ a sequence point after the evaluation of the first operand. If the first operand compares
+ unequal to 0, the second operand is not evaluated.
+<!--page 102 indent 4-->
+
+<a name="6.5.15" href="#6.5.15"><h4>6.5.15 Conditional operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          conditional-expression:
+                 logical-OR-expression
+                 logical-OR-expression ? expression : conditional-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The first operand shall have scalar type.
+<p><!--para 3-->
+ One of the following shall hold for the second and third operands:
+<ul>
+<li>  both operands have arithmetic type;
+<li>  both operands have the same structure or union type;
+<li>  both operands have void type;
+<li>  both operands are pointers to qualified or unqualified versions of compatible types;
+<li>  one operand is a pointer and the other is a null pointer constant; or
+<li>  one operand is a pointer to an object or incomplete type and the other is a pointer to a
+ qualified or unqualified version of void.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The first operand is evaluated; there is a sequence point after its evaluation. The second
+ operand is evaluated only if the first compares unequal to 0; the third operand is evaluated
+ only if the first compares equal to 0; the result is the value of the second or third operand
+ (whichever is evaluated), converted to the type described below.<sup><a href="#note95"><b>95)</b></a></sup> If an attempt is made
+ to modify the result of a conditional operator or to access it after the next sequence point,
+ the behavior is undefined.
+<p><!--para 5-->
+ If both the second and third operands have arithmetic type, the result type that would be
+ determined by the usual arithmetic conversions, were they applied to those two operands,
+ is the type of the result. If both the operands have structure or union type, the result has
+ that type. If both operands have void type, the result has void type.
+<p><!--para 6-->
+ If both the second and third operands are pointers or one is a null pointer constant and the
+ other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
+ of the types pointed-to by both operands. Furthermore, if both operands are pointers to
+ compatible types or to differently qualified versions of compatible types, the result type is
+ a pointer to an appropriately qualified version of the composite type; if one operand is a
+ null pointer constant, the result has the type of the other operand; otherwise, one operand
+ is a pointer to void or a qualified version of void, in which case the result type is a
+ 
+<!--page 103 indent 4-->
+ pointer to an appropriately qualified version of void.
+<p><!--para 7-->
+ EXAMPLE The common type that results when the second and third operands are pointers is determined
+ in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
+ pointers have compatible types.
+<p><!--para 8-->
+ Given the declarations
+<pre>
+          const void *c_vp;
+          void *vp;
+          const int *c_ip;
+          volatile int *v_ip;
+          int *ip;
+          const char *c_cp;</pre>
+ the third column in the following table is the common type that is the result of a conditional expression in
+ which the first two columns are the second and third operands (in either order):
+<pre>
+          c_vp     c_ip      const void *
+          v_ip     0         volatile int *
+          c_ip     v_ip      const volatile int *
+          vp       c_cp      const void *
+          ip       c_ip      const int *
+          vp       ip        void *</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note95">95)</a> A conditional expression does not yield an lvalue.
+
+
+<a name="6.5.16" href="#6.5.16"><h4>6.5.16 Assignment operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          assignment-expression:
+                 conditional-expression
+                 unary-expression assignment-operator assignment-expression
+          assignment-operator: one of
+                 = *= /= %= +=                       -=     &lt;&lt;=      &gt;&gt;=      &amp;=     ^=     |=</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ An assignment operator shall have a modifiable lvalue as its left operand.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ An assignment operator stores a value in the object designated by the left operand. An
+ assignment expression has the value of the left operand after the assignment, but is not an
+ lvalue. The type of an assignment expression is the type of the left operand unless the
+ left operand has qualified type, in which case it is the unqualified version of the type of
+ the left operand. The side effect of updating the stored value of the left operand shall
+ occur between the previous and the next sequence point.
+<p><!--para 4-->
+ The order of evaluation of the operands is unspecified. If an attempt is made to modify
+ the result of an assignment operator or to access it after the next sequence point, the
+ behavior is undefined.
+<!--page 104 indent 4-->
+
+<a name="6.5.16.1" href="#6.5.16.1"><h5>6.5.16.1 Simple assignment</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ One of the following shall hold:<sup><a href="#note96"><b>96)</b></a></sup>
+<ul>
+<li>  the left operand has qualified or unqualified arithmetic type and the right has
+ arithmetic type;
+<li>  the left operand has a qualified or unqualified version of a structure or union type
+ compatible with the type of the right;
+<li>  both operands are pointers to qualified or unqualified versions of compatible types,
+ and the type pointed to by the left has all the qualifiers of the type pointed to by the
+ right;
+<li>  one operand is a pointer to an object or incomplete type and the other is a pointer to a
+ qualified or unqualified version of void, and the type pointed to by the left has all
+ the qualifiers of the type pointed to by the right;
+<li>  the left operand is a pointer and the right is a null pointer constant; or
+<li>  the left operand has type _Bool and the right is a pointer.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ In simple assignment (=), the value of the right operand is converted to the type of the
+ assignment expression and replaces the value stored in the object designated by the left
+ operand.
+<p><!--para 3-->
+ If the value being stored in an object is read from another object that overlaps in any way
+ the storage of the first object, then the overlap shall be exact and the two objects shall
+ have qualified or unqualified versions of a compatible type; otherwise, the behavior is
+ undefined.
+<p><!--para 4-->
+ EXAMPLE 1       In the program fragment
+<pre>
+         int f(void);
+         char c;
+         /* ... */
+         if ((c = f()) == -1)
+                 /* ... */</pre>
+ the int value returned by the function may be truncated when stored in the char, and then converted back
+ to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
+ values as unsigned char (and char is narrower than int), the result of the conversion cannot be
+ 
+ 
+ 
+<!--page 105 indent 4-->
+ negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
+ variable c should be declared as int.
+ 
+<p><!--para 5-->
+ EXAMPLE 2       In the fragment:
+<pre>
+         char c;
+         int i;
+         long l;
+         l = (c = i);</pre>
+ the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
+ of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
+ that is, long int type.
+ 
+<p><!--para 6-->
+ EXAMPLE 3       Consider the fragment:
+<pre>
+         const char **cpp;
+         char *p;
+         const char c = 'A';
+         cpp = &amp;p;                  // constraint violation
+         *cpp = &amp;c;                 // valid
+         *p = 0;                    // valid</pre>
+ The first assignment is unsafe because it would allow the following valid code to attempt to change the
+ value of the const object c.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note96">96)</a> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
+ (specified in <a href="#6.3.2.1">6.3.2.1</a>) that changes lvalues to ''the value of the expression'' and thus removes any type
+ qualifiers that were applied to the type category of the expression (for example, it removes const but
+ not volatile from the type int volatile * const).
+
+
+<a name="6.5.16.2" href="#6.5.16.2"><h5>6.5.16.2 Compound assignment</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ For the operators += and -= only, either the left operand shall be a pointer to an object
+ type and the right shall have integer type, or the left operand shall have qualified or
+ unqualified arithmetic type and the right shall have arithmetic type.
+<p><!--para 2-->
+ For the other operators, each operand shall have arithmetic type consistent with those
+ allowed by the corresponding binary operator.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A compound assignment of the form E1 op = E2 differs from the simple assignment
+ expression E1 = E1 op (E2) only in that the lvalue E1 is evaluated only once.
+<!--page 106 indent 4-->
+
+<a name="6.5.17" href="#6.5.17"><h4>6.5.17 Comma operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          expression:
+                 assignment-expression
+                 expression , assignment-expression</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The left operand of a comma operator is evaluated as a void expression; there is a
+ sequence point after its evaluation. Then the right operand is evaluated; the result has its
+ type and value.<sup><a href="#note97"><b>97)</b></a></sup> If an attempt is made to modify the result of a comma operator or to
+ access it after the next sequence point, the behavior is undefined.
+<p><!--para 3-->
+ EXAMPLE As indicated by the syntax, the comma operator (as described in this subclause) cannot
+ appear in contexts where a comma is used to separate items in a list (such as arguments to functions or lists
+ of initializers). On the other hand, it can be used within a parenthesized expression or within the second
+ expression of a conditional operator in such contexts. In the function call
+<pre>
+          f(a, (t=3, t+2), c)</pre>
+ the function has three arguments, the second of which has the value 5.
+ 
+ Forward references: initialization (<a href="#6.7.8">6.7.8</a>).
+ 
+ 
+ 
+ 
+<!--page 107 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note97">97)</a> A comma operator does not yield an lvalue.
+
+
+<a name="6.6" href="#6.6"><h3>6.6 Constant expressions</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          constant-expression:
+                 conditional-expression</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A constant expression can be evaluated during translation rather than runtime, and
+ accordingly may be used in any place that a constant may be.
+<h6>Constraints</h6>
+<p><!--para 3-->
+ Constant expressions shall not contain assignment, increment, decrement, function-call,
+ or comma operators, except when they are contained within a subexpression that is not
+ evaluated.<sup><a href="#note98"><b>98)</b></a></sup>
+<p><!--para 4-->
+ Each constant expression shall evaluate to a constant that is in the range of representable
+ values for its type.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ An expression that evaluates to a constant is required in several contexts. If a floating
+ expression is evaluated in the translation environment, the arithmetic precision and range
+ shall be at least as great as if the expression were being evaluated in the execution
+ environment.
+<p><!--para 6-->
+ An integer constant expression<sup><a href="#note99"><b>99)</b></a></sup> shall have integer type and shall only have operands
+ that are integer constants, enumeration constants, character constants, sizeof
+ expressions whose results are integer constants, and floating constants that are the
+ immediate operands of casts. Cast operators in an integer constant expression shall only
+ convert arithmetic types to integer types, except as part of an operand to the sizeof
+ operator.
+<p><!--para 7-->
+ More latitude is permitted for constant expressions in initializers. Such a constant
+ expression shall be, or evaluate to, one of the following:
+<ul>
+<li>  an arithmetic constant expression,
+<li>  a null pointer constant,
+ 
+ 
+ 
+ 
+<!--page 108 indent 5-->
+<li>  an address constant, or
+<li>  an address constant for an object type plus or minus an integer constant expression.
+</ul>
+<p><!--para 8-->
+ An arithmetic constant expression shall have arithmetic type and shall only have
+ operands that are integer constants, floating constants, enumeration constants, character
+ constants, and sizeof expressions. Cast operators in an arithmetic constant expression
+ shall only convert arithmetic types to arithmetic types, except as part of an operand to a
+ sizeof operator whose result is an integer constant.
+<p><!--para 9-->
+ An address constant is a null pointer, a pointer to an lvalue designating an object of static
+ storage duration, or a pointer to a function designator; it shall be created explicitly using
+ the unary &amp; operator or an integer constant cast to pointer type, or implicitly by the use of
+ an expression of array or function type. The array-subscript [] and member-access .
+ and -&gt; operators, the address &amp; and indirection * unary operators, and pointer casts may
+ be used in the creation of an address constant, but the value of an object shall not be
+ accessed by use of these operators.
+<p><!--para 10-->
+ An implementation may accept other forms of constant expressions.
+<p><!--para 11-->
+ The semantic rules for the evaluation of a constant expression are the same as for
+ nonconstant expressions.<sup><a href="#note100"><b>100)</b></a></sup>
+ Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+ 
+ 
+ 
+ 
+<!--page 109 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note98">98)</a> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
+
+<p><a name="note99">99)</a> An integer constant expression is used to specify the size of a bit-field member of a structure, the
+ value of an enumeration constant, the size of an array, or the value of a case constant. Further
+ constraints that apply to the integer constant expressions used in conditional-inclusion preprocessing
+ directives are discussed in <a href="#6.10.1">6.10.1</a>.
+
+<p><a name="note100">100)</a> Thus, in the following initialization,
+
+<pre>
+          static int i = 2 || 1 / 0;</pre>
+ the expression is a valid integer constant expression with value one.
+
+
+<a name="6.7" href="#6.7"><h3>6.7 Declarations</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          declaration:
+                 declaration-specifiers init-declarator-listopt ;
+          declaration-specifiers:
+                 storage-class-specifier declaration-specifiersopt
+                 type-specifier declaration-specifiersopt
+                 type-qualifier declaration-specifiersopt
+                 function-specifier declaration-specifiersopt
+          init-declarator-list:
+                  init-declarator
+                  init-declarator-list , init-declarator
+          init-declarator:
+                  declarator
+                  declarator = initializer</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A declaration shall declare at least a declarator (other than the parameters of a function or
+ the members of a structure or union), a tag, or the members of an enumeration.
+<p><!--para 3-->
+ If an identifier has no linkage, there shall be no more than one declaration of the identifier
+ (in a declarator or type specifier) with the same scope and in the same name space, except
+ for tags as specified in <a href="#6.7.2.3">6.7.2.3</a>.
+<p><!--para 4-->
+ All declarations in the same scope that refer to the same object or function shall specify
+ compatible types.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ A declaration specifies the interpretation and attributes of a set of identifiers. A definition
+ of an identifier is a declaration for that identifier that:
+<ul>
+<li>  for an object, causes storage to be reserved for that object;
+<li>  for a function, includes the function body;<sup><a href="#note101"><b>101)</b></a></sup>
+<li>  for an enumeration constant or typedef name, is the (only) declaration of the
+ identifier.
+</ul>
+<p><!--para 6-->
+ The declaration specifiers consist of a sequence of specifiers that indicate the linkage,
+ storage duration, and part of the type of the entities that the declarators denote. The init-
+ declarator-list is a comma-separated sequence of declarators, each of which may have
+ 
+<!--page 110 indent 4-->
+ additional type information, or an initializer, or both. The declarators contain the
+ identifiers (if any) being declared.
+<p><!--para 7-->
+ If an identifier for an object is declared with no linkage, the type for the object shall be
+ complete by the end of its declarator, or by the end of its init-declarator if it has an
+ initializer; in the case of function parameters (including in prototypes), it is the adjusted
+ type (see <a href="#6.7.5.3">6.7.5.3</a>) that is required to be complete.
+ Forward references: declarators (<a href="#6.7.5">6.7.5</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
+ (<a href="#6.7.8">6.7.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note101">101)</a> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
+
+
+<a name="6.7.1" href="#6.7.1"><h4>6.7.1 Storage-class specifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          storage-class-specifier:
+                 typedef
+                 extern
+                 static
+                 auto
+                 register</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ At most, one storage-class specifier may be given in the declaration specifiers in a
+ declaration.<sup><a href="#note102"><b>102)</b></a></sup>
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
+ only; it is discussed in <a href="#6.7.7">6.7.7</a>. The meanings of the various linkages and storage durations
+ were discussed in <a href="#6.2.2">6.2.2</a> and <a href="#6.2.4">6.2.4</a>.
+<p><!--para 4-->
+ A declaration of an identifier for an object with storage-class specifier register
+ suggests that access to the object be as fast as possible. The extent to which such
+ suggestions are effective is implementation-defined.<sup><a href="#note103"><b>103)</b></a></sup>
+<p><!--para 5-->
+ The declaration of an identifier for a function that has block scope shall have no explicit
+ storage-class specifier other than extern.
+ 
+ 
+ 
+<!--page 111 indent 4-->
+<p><!--para 6-->
+ If an aggregate or union object is declared with a storage-class specifier other than
+ typedef, the properties resulting from the storage-class specifier, except with respect to
+ linkage, also apply to the members of the object, and so on recursively for any aggregate
+ or union member objects.
+ Forward references: type definitions (<a href="#6.7.7">6.7.7</a>).
+
+<h6>footnotes</h6>
+<p><a name="note102">102)</a> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
+
+<p><a name="note103">103)</a> The implementation may treat any register declaration simply as an auto declaration. However,
+ whether or not addressable storage is actually used, the address of any part of an object declared with
+ storage-class specifier register cannot be computed, either explicitly (by use of the unary &amp;
+ operator as discussed in <a href="#6.5.3.2">6.5.3.2</a>) or implicitly (by converting an array name to a pointer as discussed in
+ <a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operator that can be applied to an array declared with storage-class specifier
+ register is sizeof.
+
+
+<a name="6.7.2" href="#6.7.2"><h4>6.7.2 Type specifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          type-specifier:
+                 void
+                 char
+                 short
+                 int
+                 long
+                 float
+                 double
+                 signed
+                 unsigned
+                 _Bool
+                 _Complex
+                 struct-or-union-specifier                                                      *
+                 enum-specifier
+                 typedef-name</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ At least one type specifier shall be given in the declaration specifiers in each declaration,
+ and in the specifier-qualifier list in each struct declaration and type name. Each list of
+ type specifiers shall be one of the following sets (delimited by commas, when there is
+ more than one set on a line); the type specifiers may occur in any order, possibly
+ intermixed with the other declaration specifiers.
+<ul>
+<li>  void
+<li>  char
+<li>  signed char
+<li>  unsigned char
+<li>  short, signed short, short int, or signed short int
+<li>  unsigned short, or unsigned short int
+<li>  int, signed, or signed int
+<!--page 112 indent 4-->
+<li>  unsigned, or unsigned int
+<li>  long, signed long, long int, or signed long int
+<li>  unsigned long, or unsigned long int
+<li>  long long, signed long long, long long int, or
+ signed long long int
+<li>  unsigned long long, or unsigned long long int
+<li>  float
+<li>  double
+<li>  long double
+<li>  _Bool
+<li>  float _Complex
+<li>  double _Complex
+<li>  long double _Complex
+<li>  struct or union specifier                                                                    *
+<li>  enum specifier
+<li>  typedef name
+</ul>
+<p><!--para 3-->
+ The type specifier _Complex shall not be used if the implementation does not provide
+ complex types.<sup><a href="#note104"><b>104)</b></a></sup>
+<h6>Semantics</h6>
+<p><!--para 4-->
+ Specifiers for structures, unions, and enumerations are discussed in <a href="#6.7.2.1">6.7.2.1</a> through
+ <a href="#6.7.2.3">6.7.2.3</a>. Declarations of typedef names are discussed in <a href="#6.7.7">6.7.7</a>. The characteristics of the
+ other types are discussed in <a href="#6.2.5">6.2.5</a>.
+<p><!--para 5-->
+ Each of the comma-separated sets designates the same type, except that for bit-fields, it is
+ implementation-defined whether the specifier int designates the same type as signed
+ int or the same type as unsigned int.
+ Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
+ (<a href="#6.7.2.1">6.7.2.1</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>), type definitions (<a href="#6.7.7">6.7.7</a>).
+ 
+ 
+ 
+ 
+<!--page 113 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note104">104)</a> Freestanding implementations are not required to provide complex types.                  *
+
+
+<a name="6.7.2.1" href="#6.7.2.1"><h5>6.7.2.1 Structure and union specifiers</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          struct-or-union-specifier:
+                  struct-or-union identifieropt { struct-declaration-list }
+                  struct-or-union identifier
+          struct-or-union:
+                  struct
+                  union
+          struct-declaration-list:
+                  struct-declaration
+                  struct-declaration-list struct-declaration
+          struct-declaration:
+                  specifier-qualifier-list struct-declarator-list ;
+          specifier-qualifier-list:
+                 type-specifier specifier-qualifier-listopt
+                 type-qualifier specifier-qualifier-listopt
+          struct-declarator-list:
+                  struct-declarator
+                  struct-declarator-list , struct-declarator
+          struct-declarator:
+                  declarator
+                  declaratoropt : constant-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A structure or union shall not contain a member with incomplete or function type (hence,
+ a structure shall not contain an instance of itself, but may contain a pointer to an instance
+ of itself), except that the last member of a structure with more than one named member
+ may have incomplete array type; such a structure (and any union containing, possibly
+ recursively, a member that is such a structure) shall not be a member of a structure or an
+ element of an array.
+<p><!--para 3-->
+ The expression that specifies the width of a bit-field shall be an integer constant
+ expression with a nonnegative value that does not exceed the width of an object of the
+ type that would be specified were the colon and expression omitted. If the value is zero,
+ the declaration shall have no declarator.
+<p><!--para 4-->
+ A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
+ int, unsigned int, or some other implementation-defined type.
+<!--page 114 indent 5-->
+<h6>Semantics</h6>
+<p><!--para 5-->
+ As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
+ storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
+ of members whose storage overlap.
+<p><!--para 6-->
+ Structure and union specifiers have the same form. The keywords struct and union
+ indicate that the type being specified is, respectively, a structure type or a union type.
+<p><!--para 7-->
+ The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
+ within a translation unit. The struct-declaration-list is a sequence of declarations for the
+ members of the structure or union. If the struct-declaration-list contains no named
+ members, the behavior is undefined. The type is incomplete until after the } that
+ terminates the list.
+<p><!--para 8-->
+ A member of a structure or union may have any object type other than a variably
+ modified type.<sup><a href="#note105"><b>105)</b></a></sup> In addition, a member may be declared to consist of a specified
+ number of bits (including a sign bit, if any). Such a member is called a bit-field;<sup><a href="#note106"><b>106)</b></a></sup> its
+ width is preceded by a colon.
+<p><!--para 9-->
+ A bit-field is interpreted as a signed or unsigned integer type consisting of the specified
+ number of bits.<sup><a href="#note107"><b>107)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of type
+ _Bool, the value of the bit-field shall compare equal to the value stored.
+<p><!--para 10-->
+ An implementation may allocate any addressable storage unit large enough to hold a bit-
+ field. If enough space remains, a bit-field that immediately follows another bit-field in a
+ structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
+ whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is
+ implementation-defined. The order of allocation of bit-fields within a unit (high-order to
+ low-order or low-order to high-order) is implementation-defined. The alignment of the
+ addressable storage unit is unspecified.
+<p><!--para 11-->
+ A bit-field declaration with no declarator, but only a colon and a width, indicates an
+ unnamed bit-field.<sup><a href="#note108"><b>108)</b></a></sup> As a special case, a bit-field structure member with a width of 0
+ indicates that no further bit-field is to be packed into the unit in which the previous bit-
+ field, if any, was placed.
+ 
+ 
+<!--page 115 indent 5-->
+<p><!--para 12-->
+ Each non-bit-field member of a structure or union object is aligned in an implementation-
+ defined manner appropriate to its type.
+<p><!--para 13-->
+ Within a structure object, the non-bit-field members and the units in which bit-fields
+ reside have addresses that increase in the order in which they are declared. A pointer to a
+ structure object, suitably converted, points to its initial member (or if that member is a
+ bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
+ padding within a structure object, but not at its beginning.
+<p><!--para 14-->
+ The size of a union is sufficient to contain the largest of its members. The value of at
+ most one of the members can be stored in a union object at any time. A pointer to a
+ union object, suitably converted, points to each of its members (or if a member is a bit-
+ field, then to the unit in which it resides), and vice versa.
+<p><!--para 15-->
+ There may be unnamed padding at the end of a structure or union.
+<p><!--para 16-->
+ As a special case, the last element of a structure with more than one named member may
+ have an incomplete array type; this is called a flexible array member. In most situations,
+ the flexible array member is ignored. In particular, the size of the structure is as if the
+ flexible array member were omitted except that it may have more trailing padding than
+ the omission would imply. However, when a . (or -&gt;) operator has a left operand that is
+ (a pointer to) a structure with a flexible array member and the right operand names that
+ member, it behaves as if that member were replaced with the longest array (with the same
+ element type) that would not make the structure larger than the object being accessed; the
+ offset of the array shall remain that of the flexible array member, even if this would differ
+ from that of the replacement array. If this array would have no elements, it behaves as if
+ it had one element but the behavior is undefined if any attempt is made to access that
+ element or to generate a pointer one past it.
+<p><!--para 17-->
+ EXAMPLE       After the declaration:
+<pre>
+         struct s { int n; double d[]; };</pre>
+ the structure struct s has a flexible array member d. A typical way to use this is:
+<pre>
+         int m = /* some value */;
+         struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));</pre>
+ and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
+ p had been declared as:
+<pre>
+         struct { int n; double d[m]; } *p;</pre>
+ (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
+ not be the same).
+<p><!--para 18-->
+ Following the above declaration:
+<!--page 116 indent 5-->
+<pre>
+          struct s t1 = { 0 };                        //   valid
+          struct s t2 = { 1, { <a href="#4.2">4.2</a> }};                //   invalid
+          t1.n = 4;                                   //   valid
+          t1.d[0] = <a href="#4.2">4.2</a>;                              //   might be undefined behavior</pre>
+ The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
+ contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
+<pre>
+          sizeof (struct s) &gt;= offsetof(struct s, d) + sizeof (double)</pre>
+ in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
+ code.
+<p><!--para 19-->
+ After the further declaration:
+<pre>
+          struct ss { int n; };</pre>
+ the expressions:
+<pre>
+          sizeof (struct s) &gt;= sizeof (struct ss)
+          sizeof (struct s) &gt;= offsetof(struct s, d)</pre>
+ are always equal to 1.
+<p><!--para 20-->
+ If sizeof (double) is 8, then after the following code is executed:
+<pre>
+          struct s *s1;
+          struct s *s2;
+          s1 = malloc(sizeof (struct s) + 64);
+          s2 = malloc(sizeof (struct s) + 46);</pre>
+ and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
+ purposes, as if the identifiers had been declared as:
+<p><!--para 21-->
+<pre>
+          struct { int n; double d[8]; } *s1;
+          struct { int n; double d[5]; } *s2;</pre>
+ Following the further successful assignments:
+<pre>
+          s1 = malloc(sizeof (struct s) + 10);
+          s2 = malloc(sizeof (struct s) + 6);</pre>
+ they then behave as if the declarations were:
+<pre>
+          struct { int n; double d[1]; } *s1, *s2;</pre>
+ and:
+<p><!--para 22-->
+<pre>
+          double *dp;
+          dp = &amp;(s1-&gt;d[0]);           //   valid
+          *dp = 42;                   //   valid
+          dp = &amp;(s2-&gt;d[0]);           //   valid
+          *dp = 42;                   //   undefined behavior</pre>
+ The assignment:
+<pre>
+          *s1 = *s2;</pre>
+ only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
+ of the structure, they might be copied or simply overwritten with indeterminate values.
+ 
+ Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
+<!--page 117 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note105">105)</a> A structure or union can not contain a member with a variably modified type because member names
+ are not ordinary identifiers as defined in <a href="#6.2.3">6.2.3</a>.
+
+<p><a name="note106">106)</a> The unary &amp; (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
+ or arrays of bit-field objects.
+
+<p><a name="note107">107)</a> As specified in <a href="#6.7.2">6.7.2</a> above, if the actual type specifier used is int or a typedef-name defined as int,
+ then it is implementation-defined whether the bit-field is signed or unsigned.
+
+<p><a name="note108">108)</a> An unnamed bit-field structure member is useful for padding to conform to externally imposed
+ layouts.
+
+
+<a name="6.7.2.2" href="#6.7.2.2"><h5>6.7.2.2 Enumeration specifiers</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          enum-specifier:
+                enum identifieropt { enumerator-list }
+                enum identifieropt { enumerator-list , }
+                enum identifier
+          enumerator-list:
+                enumerator
+                enumerator-list , enumerator
+          enumerator:
+                enumeration-constant
+                enumeration-constant = constant-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The expression that defines the value of an enumeration constant shall be an integer
+ constant expression that has a value representable as an int.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The identifiers in an enumerator list are declared as constants that have type int and
+ may appear wherever such are permitted.<sup><a href="#note109"><b>109)</b></a></sup> An enumerator with = defines its
+ enumeration constant as the value of the constant expression. If the first enumerator has
+ no =, the value of its enumeration constant is 0. Each subsequent enumerator with no =
+ defines its enumeration constant as the value of the constant expression obtained by
+ adding 1 to the value of the previous enumeration constant. (The use of enumerators with
+ = may produce enumeration constants with values that duplicate other values in the same
+ enumeration.) The enumerators of an enumeration are also known as its members.
+<p><!--para 4-->
+ Each enumerated type shall be compatible with char, a signed integer type, or an
+ unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note110"><b>110)</b></a></sup> but shall be
+ capable of representing the values of all the members of the enumeration. The
+ enumerated type is incomplete until after the } that terminates the list of enumerator
+ declarations.
+ 
+ 
+ 
+ 
+<!--page 118 indent 4-->
+<p><!--para 5-->
+ EXAMPLE       The following fragment:
+<pre>
+         enum hue { chartreuse, burgundy, claret=20, winedark };
+         enum hue col, *cp;
+         col = claret;
+         cp = &amp;col;
+         if (*cp != burgundy)
+               /* ... */</pre>
+ makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
+ pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
+ 
+ Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note109">109)</a> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
+ each other and from other identifiers declared in ordinary declarators.
+
+<p><a name="note110">110)</a> An implementation may delay the choice of which integer type until all enumeration constants have
+ been seen.
+
+
+<a name="6.7.2.3" href="#6.7.2.3"><h5>6.7.2.3 Tags</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A specific type shall have its content defined at most once.
+<p><!--para 2-->
+ Where two declarations that use the same tag declare the same type, they shall both use
+ the same choice of struct, union, or enum.
+<p><!--para 3-->
+ A type specifier of the form
+<pre>
+         enum identifier</pre>
+ without an enumerator list shall only appear after the type it specifies is complete.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ All declarations of structure, union, or enumerated types that have the same scope and
+ use the same tag declare the same type. The type is incomplete<sup><a href="#note111"><b>111)</b></a></sup> until the closing brace
+ of the list defining the content, and complete thereafter.
+<p><!--para 5-->
+ Two declarations of structure, union, or enumerated types which are in different scopes or
+ use different tags declare distinct types. Each declaration of a structure, union, or
+ enumerated type which does not include a tag declares a distinct type.
+<p><!--para 6-->
+ A type specifier of the form
+<pre>
+         struct-or-union identifieropt { struct-declaration-list }</pre>
+ or
+<pre>
+         enum identifier { enumerator-list }</pre>
+ or
+<pre>
+         enum identifier { enumerator-list , }</pre>
+ declares a structure, union, or enumerated type. The list defines the structure content,
+ 
+<!--page 119 indent 5-->
+ union content, or enumeration content. If an identifier is provided,<sup><a href="#note112"><b>112)</b></a></sup> the type specifier
+ also declares the identifier to be the tag of that type.
+<p><!--para 7-->
+ A declaration of the form
+<pre>
+          struct-or-union identifier ;</pre>
+ specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note113"><b>113)</b></a></sup>
+<p><!--para 8-->
+ If a type specifier of the form
+<pre>
+          struct-or-union identifier</pre>
+ occurs other than as part of one of the above forms, and no other declaration of the
+ identifier as a tag is visible, then it declares an incomplete structure or union type, and
+ declares the identifier as the tag of that type.113)
+<p><!--para 9-->
+ If a type specifier of the form
+<pre>
+          struct-or-union identifier</pre>
+ or
+<pre>
+          enum identifier</pre>
+ occurs other than as part of one of the above forms, and a declaration of the identifier as a
+ tag is visible, then it specifies the same type as that other declaration, and does not
+ redeclare the tag.
+<p><!--para 10-->
+ EXAMPLE 1       This mechanism allows declaration of a self-referential structure.
+<pre>
+          struct tnode {
+                int count;
+                struct tnode *left, *right;
+          };</pre>
+ specifies a structure that contains an integer and two pointers to objects of the same type. Once this
+ declaration has been given, the declaration
+<pre>
+          struct tnode s, *sp;</pre>
+ declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
+ these declarations, the expression sp-&gt;left refers to the left struct tnode pointer of the object to
+ which sp points; the expression s.right-&gt;count designates the count member of the right struct
+ tnode pointed to from s.
+<p><!--para 11-->
+ The following alternative formulation uses the typedef mechanism:
+ 
+ 
+ 
+ 
+<!--page 120 indent 5-->
+<pre>
+          typedef struct tnode TNODE;
+          struct tnode {
+                int count;
+                TNODE *left, *right;
+          };
+          TNODE s, *sp;</pre>
+ 
+<p><!--para 12-->
+ EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
+ structures, the declarations
+<pre>
+          struct s1 { struct s2 *s2p; /* ... */ }; // D1
+          struct s2 { struct s1 *s1p; /* ... */ }; // D2</pre>
+ specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
+ declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
+ D2. To eliminate this context sensitivity, the declaration
+<pre>
+          struct s2;</pre>
+ may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
+ completes the specification of the new type.
+ 
+ Forward references: declarators (<a href="#6.7.5">6.7.5</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>), type definitions
+ (<a href="#6.7.7">6.7.7</a>).
+
+<h6>footnotes</h6>
+<p><a name="note111">111)</a> An incomplete type may only by used when the size of an object of that type is not needed. It is not
+ needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
+ when a pointer to or a function returning a structure or union is being declared. (See incomplete types
+ in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
+
+<p><a name="note112">112)</a> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
+ of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
+ can make use of that typedef name to declare objects having the specified structure, union, or
+ enumerated type.
+
+<p><a name="note113">113)</a> A similar construction with enum does not exist.
+
+
+<a name="6.7.3" href="#6.7.3"><h4>6.7.3 Type qualifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          type-qualifier:
+                 const
+                 restrict
+                 volatile</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Types other than pointer types derived from object or incomplete types shall not be
+ restrict-qualified.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The properties associated with qualified types are meaningful only for expressions that
+ are lvalues.<sup><a href="#note114"><b>114)</b></a></sup>
+<p><!--para 4-->
+ If the same qualifier appears more than once in the same specifier-qualifier-list, either
+ directly or via one or more typedefs, the behavior is the same as if it appeared only
+ once.
+ 
+ 
+ 
+ 
+<!--page 121 indent 5-->
+<p><!--para 5-->
+ If an attempt is made to modify an object defined with a const-qualified type through use
+ of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
+ made to refer to an object defined with a volatile-qualified type through use of an lvalue
+ with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note115"><b>115)</b></a></sup>
+<p><!--para 6-->
+ An object that has volatile-qualified type may be modified in ways unknown to the
+ implementation or have other unknown side effects. Therefore any expression referring
+ to such an object shall be evaluated strictly according to the rules of the abstract machine,
+ as described in <a href="#5.1.2.3">5.1.2.3</a>. Furthermore, at every sequence point the value last stored in the
+ object shall agree with that prescribed by the abstract machine, except as modified by the
+ unknown factors mentioned previously.<sup><a href="#note116"><b>116)</b></a></sup> What constitutes an access to an object that
+ has volatile-qualified type is implementation-defined.
+<p><!--para 7-->
+ An object that is accessed through a restrict-qualified pointer has a special association
+ with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
+ that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note117"><b>117)</b></a></sup> The intended
+ use of the restrict qualifier (like the register storage class) is to promote
+ optimization, and deleting all instances of the qualifier from all preprocessing translation
+ units composing a conforming program does not change its meaning (i.e., observable
+ behavior).
+<p><!--para 8-->
+ If the specification of an array type includes any type qualifiers, the element type is so-
+ qualified, not the array type. If the specification of a function type includes any type
+ qualifiers, the behavior is undefined.<sup><a href="#note118"><b>118)</b></a></sup>
+<p><!--para 9-->
+ For two qualified types to be compatible, both shall have the identically qualified version
+ of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
+ does not affect the specified type.
+<p><!--para 10-->
+ EXAMPLE 1       An object declared
+<pre>
+          extern const volatile int real_time_clock;</pre>
+ may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
+ 
+ 
+ 
+ 
+<!--page 122 indent 5-->
+<p><!--para 11-->
+ EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
+ modify an aggregate type:
+<pre>
+         const struct s { int mem; } cs = { 1 };
+         struct s ncs; // the object ncs is modifiable
+         typedef int A[2][3];
+         const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
+         int *pi;
+         const int *pci;
+         ncs = cs;             //   valid
+         cs = ncs;             //   violates modifiable lvalue constraint for =
+         pi = &amp;ncs.mem;        //   valid
+         pi = &amp;cs.mem;         //   violates type constraints for =
+         pci = &amp;cs.mem;        //   valid
+         pi = a[0];            //   invalid: a[0] has type ''const int *''</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note114">114)</a> The implementation may place a const object that is not volatile in a read-only region of
+ storage. Moreover, the implementation need not allocate storage for such an object if its address is
+ never used.
+
+<p><a name="note115">115)</a> This applies to those objects that behave as if they were defined with qualified types, even if they are
+ never actually defined as objects in the program (such as an object at a memory-mapped input/output
+ address).
+
+<p><a name="note116">116)</a> A volatile declaration may be used to describe an object corresponding to a memory-mapped
+ input/output port or an object accessed by an asynchronously interrupting function. Actions on
+ objects so declared shall not be ''optimized out'' by an implementation or reordered except as
+ permitted by the rules for evaluating expressions.
+
+<p><a name="note117">117)</a> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
+ association between the allocated object and the pointer.
+
+<p><a name="note118">118)</a> Both of these can occur through the use of typedefs.
+
+
+<a name="6.7.3.1" href="#6.7.3.1"><h5>6.7.3.1 Formal definition of restrict</h5></a>
+<p><!--para 1-->
+ Let D be a declaration of an ordinary identifier that provides a means of designating an
+ object P as a restrict-qualified pointer to type T.
+<p><!--para 2-->
+ If D appears inside a block and does not have storage class extern, let B denote the
+ block. If D appears in the list of parameter declarations of a function definition, let B
+ denote the associated block. Otherwise, let B denote the block of main (or the block of
+ whatever function is called at program startup in a freestanding environment).
+<p><!--para 3-->
+ In what follows, a pointer expression E is said to be based on object P if (at some
+ sequence point in the execution of B prior to the evaluation of E) modifying P to point to
+ a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note119"><b>119)</b></a></sup>
+ Note that ''based'' is defined only for expressions with pointer types.
+<p><!--para 4-->
+ During each execution of B, let L be any lvalue that has &amp;L based on P. If L is used to
+ access the value of the object X that it designates, and X is also modified (by any means),
+ then the following requirements apply: T shall not be const-qualified. Every other lvalue
+ used to access the value of X shall also have its address based on P. Every access that
+ modifies X shall be considered also to modify P, for the purposes of this subclause. If P
+ is assigned the value of a pointer expression E that is based on another restricted pointer
+ object P2, associated with block B2, then either the execution of B2 shall begin before
+ the execution of B, or the execution of B2 shall end prior to the assignment. If these
+ requirements are not met, then the behavior is undefined.
+<p><!--para 5-->
+ Here an execution of B means that portion of the execution of the program that would
+ correspond to the lifetime of an object with scalar type and automatic storage duration
+ 
+<!--page 123 indent 5-->
+ associated with B.
+<p><!--para 6-->
+ A translator is free to ignore any or all aliasing implications of uses of restrict.
+<p><!--para 7-->
+ EXAMPLE 1       The file scope declarations
+<pre>
+          int * restrict a;
+          int * restrict b;
+          extern int c[];</pre>
+ assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
+ program, then it is never accessed using either of the other two.
+ 
+<p><!--para 8-->
+ EXAMPLE 2 The function parameter declarations in the following example
+<pre>
+         void f(int n, int * restrict p, int * restrict q)
+         {
+               while (n-- &gt; 0)
+                     *p++ = *q++;
+         }</pre>
+ assert that, during each execution of the function, if an object is accessed through one of the pointer
+ parameters, then it is not also accessed through the other.
+<p><!--para 9-->
+ The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
+ analysis of function f without examining any of the calls of f in the program. The cost is that the
+ programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
+ second call of f in g has undefined behavior because each of d[1] through d[49] is accessed through
+ both p and q.
+<pre>
+         void g(void)
+         {
+               extern int d[100];
+               f(50, d + 50, d); // valid
+               f(50, d + 1, d); // undefined behavior
+         }</pre>
+ 
+<p><!--para 10-->
+ EXAMPLE 3       The function parameter declarations
+<pre>
+         void h(int n, int * restrict p, int * restrict q, int * restrict r)
+         {
+               int i;
+               for (i = 0; i &lt; n; i++)
+                      p[i] = q[i] + r[i];
+         }</pre>
+ illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
+ are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
+ modified within function h.
+ 
+<p><!--para 11-->
+ EXAMPLE 4 The rule limiting assignments between restricted pointers does not distinguish between a
+ function call and an equivalent nested block. With one exception, only ''outer-to-inner'' assignments
+ between restricted pointers declared in nested blocks have defined behavior.
+<!--page 124 indent 5-->
+<p><!--para 12-->
+<pre>
+          {
+                   int * restrict p1;
+                   int * restrict q1;
+                   p1 = q1; // undefined behavior
+                   {
+                         int * restrict p2 = p1; // valid
+                         int * restrict q2 = q1; // valid
+                         p1 = q2;                // undefined behavior
+                         p2 = q2;                // undefined behavior
+                   }
+          }</pre>
+ The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
+ precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
+ example, this permits new_vector to return a vector.
+<pre>
+          typedef struct { int n; float * restrict v; } vector;
+          vector new_vector(int n)
+          {
+                vector t;
+                t.n = n;
+                t.v = malloc(n * sizeof (float));
+                return t;
+          }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note119">119)</a> In other words, E depends on the value of P itself rather than on the value of an object referenced
+ indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
+ expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
+ expressions *p and p[1] are not.
+
+
+<a name="6.7.4" href="#6.7.4"><h4>6.7.4 Function specifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          function-specifier:
+                 inline</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Function specifiers shall be used only in the declaration of an identifier for a function.
+<p><!--para 3-->
+ An inline definition of a function with external linkage shall not contain a definition of a
+ modifiable object with static storage duration, and shall not contain a reference to an
+ identifier with internal linkage.
+<p><!--para 4-->
+ In a hosted environment, the inline function specifier shall not appear in a declaration
+ of main.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ A function declared with an inline function specifier is an inline function. The
+ function specifier may appear more than once; the behavior is the same as if it appeared
+ only once. Making a function an inline function suggests that calls to the function be as
+ fast as possible.<sup><a href="#note120"><b>120)</b></a></sup> The extent to which such suggestions are effective is
+ implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
+<p><!--para 6-->
+ Any function with internal linkage can be an inline function. For a function with external
+ linkage, the following restrictions apply: If a function is declared with an inline
+<!--page 125 indent 4-->
+ function specifier, then it shall also be defined in the same translation unit. If all of the
+ file scope declarations for a function in a translation unit include the inline function
+ specifier without extern, then the definition in that translation unit is an inline
+ definition. An inline definition does not provide an external definition for the function,
+ and does not forbid an external definition in another translation unit. An inline definition
+ provides an alternative to an external definition, which a translator may use to implement
+ any call to the function in the same translation unit. It is unspecified whether a call to the
+ function uses the inline definition or the external definition.<sup><a href="#note122"><b>122)</b></a></sup>
+<p><!--para 7-->
+ EXAMPLE The declaration of an inline function with external linkage can result in either an external
+ definition, or a definition available for use only within the translation unit. A file scope declaration with
+ extern creates an external definition. The following example shows an entire translation unit.
+<p><!--para 8-->
+<pre>
+          inline double fahr(double t)
+          {
+                return (9.0 * t) / 5.0 + 32.0;
+          }
+          inline double cels(double t)
+          {
+                return (5.0 * (t - 32.0)) / 9.0;
+          }
+          extern double fahr(double);                  // creates an external definition
+          double convert(int is_fahr, double temp)
+          {
+                /* A translator may perform inline substitutions */
+                return is_fahr ? cels(temp) : fahr(temp);
+          }</pre>
+ Note that the definition of fahr is an external definition because fahr is also declared with extern, but
+ the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
+ external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
+ definition are distinct and either may be used for the call.
+ 
+ Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+ 
+ 
+<!--page 126 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note120">120)</a> By using, for example, an alternative to the usual function call mechanism, such as ''inline
+ substitution''. Inline substitution is not textual substitution, nor does it create a new function.
+ Therefore, for example, the expansion of a macro used within the body of the function uses the
+ definition it had at the point the function body appears, and not where the function is called; and
+ identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
+ single address, regardless of the number of inline definitions that occur in addition to the external
+ definition.
+
+<p><a name="note121">121)</a> For example, an implementation might never perform inline substitution, or might only perform inline
+ substitutions to calls in the scope of an inline declaration.
+
+<p><a name="note122">122)</a> Since an inline definition is distinct from the corresponding external definition and from any other
+ corresponding inline definitions in other translation units, all corresponding objects with static storage
+ duration are also distinct in each of the definitions.
+
+
+<a name="6.7.5" href="#6.7.5"><h4>6.7.5 Declarators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          declarator:
+                 pointeropt direct-declarator
+          direct-declarator:
+                  identifier
+                  ( declarator )
+                  direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+                  direct-declarator [ static type-qualifier-listopt assignment-expression ]
+                  direct-declarator [ type-qualifier-list static assignment-expression ]
+                  direct-declarator [ type-qualifier-listopt * ]
+                  direct-declarator ( parameter-type-list )
+                  direct-declarator ( identifier-listopt )
+          pointer:
+                 * type-qualifier-listopt
+                 * type-qualifier-listopt pointer
+          type-qualifier-list:
+                 type-qualifier
+                 type-qualifier-list type-qualifier
+          parameter-type-list:
+                parameter-list
+                parameter-list , ...
+          parameter-list:
+                parameter-declaration
+                parameter-list , parameter-declaration
+          parameter-declaration:
+                declaration-specifiers declarator
+                declaration-specifiers abstract-declaratoropt
+          identifier-list:
+                  identifier
+                  identifier-list , identifier</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ Each declarator declares one identifier, and asserts that when an operand of the same
+ form as the declarator appears in an expression, it designates a function or object with the
+ scope, storage duration, and type indicated by the declaration specifiers.
+<p><!--para 3-->
+ A full declarator is a declarator that is not part of another declarator. The end of a full
+ declarator is a sequence point. If, in the nested sequence of declarators in a full
+<!--page 127 indent 4-->
+ declarator, there is a declarator specifying a variable length array type, the type specified
+ by the full declarator is said to be variably modified. Furthermore, any type derived by
+ declarator type derivation from a variably modified type is itself variably modified.
+<p><!--para 4-->
+ In the following subclauses, consider a declaration
+<pre>
+         T D1</pre>
+ where T contains the declaration specifiers that specify a type T (such as int) and D1 is
+ a declarator that contains an identifier ident. The type specified for the identifier ident in
+ the various forms of declarator is described inductively using this notation.
+<p><!--para 5-->
+ If, in the declaration ''T D1'', D1 has the form
+<pre>
+         identifier</pre>
+ then the type specified for ident is T .
+<p><!--para 6-->
+ If, in the declaration ''T D1'', D1 has the form
+<pre>
+         ( D )</pre>
+ then ident has the type specified by the declaration ''T D''. Thus, a declarator in
+ parentheses is identical to the unparenthesized declarator, but the binding of complicated
+ declarators may be altered by parentheses.
+ Implementation limits
+<p><!--para 7-->
+ As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
+ function declarators that modify an arithmetic, structure, union, or incomplete type, either
+ directly or via one or more typedefs.
+ Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), type definitions (<a href="#6.7.7">6.7.7</a>).
+
+<a name="6.7.5.1" href="#6.7.5.1"><h5>6.7.5.1 Pointer declarators</h5></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If, in the declaration ''T D1'', D1 has the form
+<pre>
+         * type-qualifier-listopt D</pre>
+ and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+ T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
+ pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
+<p><!--para 2-->
+ For two pointer types to be compatible, both shall be identically qualified and both shall
+ be pointers to compatible types.
+<p><!--para 3-->
+ EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
+ to a constant value'' and a ''constant pointer to a variable value''.
+<!--page 128 indent 4-->
+<pre>
+          const int *ptr_to_constant;
+          int *const constant_ptr;</pre>
+ The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
+ but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
+ int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
+ same location.
+<p><!--para 4-->
+ The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
+ type ''pointer to int''.
+<pre>
+          typedef int *int_ptr;
+          const int_ptr constant_ptr;</pre>
+ declares constant_ptr as an object that has type ''const-qualified pointer to int''.
+ 
+
+<a name="6.7.5.2" href="#6.7.5.2"><h5>6.7.5.2 Array declarators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
+ an expression or *. If they delimit an expression (which specifies the size of an array), the
+ expression shall have an integer type. If the expression is a constant expression, it shall
+ have a value greater than zero. The element type shall not be an incomplete or function
+ type. The optional type qualifiers and the keyword static shall appear only in a
+ declaration of a function parameter with an array type, and then only in the outermost
+ array type derivation.
+<p><!--para 2-->
+ An ordinary identifier (as defined in <a href="#6.2.3">6.2.3</a>) that has a variably modified type shall have
+ either block scope and no linkage or function prototype scope. If an identifier is declared
+ to be an object with static storage duration, it shall not have a variable length array type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ If, in the declaration ''T D1'', D1 has one of the forms:
+<pre>
+          D[ type-qualifier-listopt assignment-expressionopt ]
+          D[ static type-qualifier-listopt assignment-expression ]
+          D[ type-qualifier-list static assignment-expression ]
+          D[ type-qualifier-listopt * ]</pre>
+ and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+ T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note123"><b>123)</b></a></sup>
+ (See <a href="#6.7.5.3">6.7.5.3</a> for the meaning of the optional type qualifiers and the keyword static.)
+<p><!--para 4-->
+ If the size is not present, the array type is an incomplete type. If the size is * instead of
+ being an expression, the array type is a variable length array type of unspecified size,
+ which can only be used in declarations with function prototype scope;<sup><a href="#note124"><b>124)</b></a></sup> such arrays are
+ nonetheless complete types. If the size is an integer constant expression and the element
+ 
+<!--page 129 indent 4-->
+ type has a known constant size, the array type is not a variable length array type;
+ otherwise, the array type is a variable length array type.
+<p><!--para 5-->
+ If the size is an expression that is not an integer constant expression: if it occurs in a
+ declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
+ each time it is evaluated it shall have a value greater than zero. The size of each instance
+ of a variable length array type does not change during its lifetime. Where a size
+ expression is part of the operand of a sizeof operator and changing the value of the
+ size expression would not affect the result of the operator, it is unspecified whether or not
+ the size expression is evaluated.
+<p><!--para 6-->
+ For two array types to be compatible, both shall have compatible element types, and if
+ both size specifiers are present, and are integer constant expressions, then both size
+ specifiers shall have the same constant value. If the two array types are used in a context
+ which requires them to be compatible, it is undefined behavior if the two size specifiers
+ evaluate to unequal values.
+<p><!--para 7-->
+ EXAMPLE 1
+<pre>
+          float fa[11], *afp[17];</pre>
+ declares an array of float numbers and an array of pointers to float numbers.
+ 
+<p><!--para 8-->
+ EXAMPLE 2       Note the distinction between the declarations
+<pre>
+          extern int *x;
+          extern int y[];</pre>
+ The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
+ (an incomplete type), the storage for which is defined elsewhere.
+ 
+<p><!--para 9-->
+ EXAMPLE 3       The following declarations demonstrate the compatibility rules for variably modified types.
+<pre>
+          extern int n;
+          extern int m;
+          void fcompat(void)
+          {
+                int a[n][6][m];
+                int (*p)[4][n+1];
+                int c[n][n][6][m];
+                int (*r)[n][n][n+1];
+                p = a;      // invalid: not compatible because 4 != 6
+                r = c;      // compatible, but defined behavior only if
+                            // n == 6 and m == n+1
+          }</pre>
+ 
+ 
+ 
+ 
+<!--page 130 indent 5-->
+<p><!--para 10-->
+ EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
+ function prototype scope. Array objects declared with the static or extern storage-class specifier
+ cannot have a variable length array (VLA) type. However, an object declared with the static storage-
+ class specifier can have a VM type (that is, a pointer to a VLA type). Finally, all identifiers declared with a
+ VM type have to be ordinary identifiers and cannot, therefore, be members of structures or unions.
+<pre>
+          extern int n;
+          int A[n];                                             // invalid: file scope VLA
+          extern int (*p2)[n];                                  // invalid: file scope VM
+          int B[100];                                           // valid: file scope but not VM
+          void fvla(int m, int C[m][m]);                        // valid: VLA with prototype scope
+          void fvla(int m, int C[m][m])                         // valid: adjusted to auto pointer to VLA
+          {
+                typedef int VLA[m][m];                          // valid: block scope typedef VLA
+                   struct tag {
+                         int (*y)[n];                           // invalid: y not ordinary identifier
+                         int z[n];                              // invalid: z not ordinary identifier
+                   };
+                   int D[m];                                    //   valid: auto VLA
+                   static int E[m];                             //   invalid: static block scope VLA
+                   extern int F[m];                             //   invalid: F has linkage and is VLA
+                   int (*s)[m];                                 //   valid: auto pointer to VLA
+                   extern int (*r)[m];                          //   invalid: r has linkage and points to VLA
+                   static int (*q)[m] = &amp;B;                     //   valid: q is a static block pointer to VLA
+          }</pre>
+ 
+ Forward references:            function declarators (<a href="#6.7.5.3">6.7.5.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
+ initialization (<a href="#6.7.8">6.7.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note123">123)</a> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
+
+<p><a name="note124">124)</a> Thus, * can be used only in function declarations that are not definitions (see <a href="#6.7.5.3">6.7.5.3</a>).
+
+
+<a name="6.7.5.3" href="#6.7.5.3"><h5>6.7.5.3 Function declarators (including prototypes)</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A function declarator shall not specify a return type that is a function type or an array
+ type.
+<p><!--para 2-->
+ The only storage-class specifier that shall occur in a parameter declaration is register.
+<p><!--para 3-->
+ An identifier list in a function declarator that is not part of a definition of that function
+ shall be empty.
+<p><!--para 4-->
+ After adjustment, the parameters in a parameter type list in a function declarator that is
+ part of a definition of that function shall not have incomplete type.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ If, in the declaration ''T D1'', D1 has the form
+<pre>
+          D( parameter-type-list )</pre>
+ or
+<!--page 131 indent 5-->
+<pre>
+          D( identifier-listopt )</pre>
+ and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+ T '', then the type specified for ident is ''derived-declarator-type-list function returning
+ T ''.
+<p><!--para 6-->
+ A parameter type list specifies the types of, and may declare identifiers for, the
+ parameters of the function.
+<p><!--para 7-->
+ A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
+ type'', where the type qualifiers (if any) are those specified within the [ and ] of the
+ array type derivation. If the keyword static also appears within the [ and ] of the
+ array type derivation, then for each call to the function, the value of the corresponding
+ actual argument shall provide access to the first element of an array with at least as many
+ elements as specified by the size expression.
+<p><!--para 8-->
+ A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
+ function returning type'', as in <a href="#6.3.2.1">6.3.2.1</a>.
+<p><!--para 9-->
+ If the list terminates with an ellipsis (, ...), no information about the number or types
+ of the parameters after the comma is supplied.<sup><a href="#note125"><b>125)</b></a></sup>
+<p><!--para 10-->
+ The special case of an unnamed parameter of type void as the only item in the list
+ specifies that the function has no parameters.
+<p><!--para 11-->
+ If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
+ parameter name, it shall be taken as a typedef name.
+<p><!--para 12-->
+ If the function declarator is not part of a definition of that function, parameters may have
+ incomplete type and may use the [*] notation in their sequences of declarator specifiers
+ to specify variable length array types.
+<p><!--para 13-->
+ The storage-class specifier in the declaration specifiers for a parameter declaration, if
+ present, is ignored unless the declared parameter is one of the members of the parameter
+ type list for a function definition.
+<p><!--para 14-->
+ An identifier list declares only the identifiers of the parameters of the function. An empty
+ list in a function declarator that is part of a definition of that function specifies that the
+ function has no parameters. The empty list in a function declarator that is not part of a
+ definition of that function specifies that no information about the number or types of the
+ parameters is supplied.<sup><a href="#note126"><b>126)</b></a></sup>
+<p><!--para 15-->
+ For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note127"><b>127)</b></a></sup>
+ 
+ 
+<!--page 132 indent 5-->
+ Moreover, the parameter type lists, if both are present, shall agree in the number of
+ parameters and in use of the ellipsis terminator; corresponding parameters shall have
+ compatible types. If one type has a parameter type list and the other type is specified by a
+ function declarator that is not part of a function definition and that contains an empty
+ identifier list, the parameter list shall not have an ellipsis terminator and the type of each
+ parameter shall be compatible with the type that results from the application of the
+ default argument promotions. If one type has a parameter type list and the other type is
+ specified by a function definition that contains a (possibly empty) identifier list, both shall
+ agree in the number of parameters, and the type of each prototype parameter shall be
+ compatible with the type that results from the application of the default argument
+ promotions to the type of the corresponding identifier. (In the determination of type
+ compatibility and of a composite type, each parameter declared with function or array
+ type is taken as having the adjusted type and each parameter declared with qualified type
+ is taken as having the unqualified version of its declared type.)
+<p><!--para 16-->
+ EXAMPLE 1       The declaration
+<pre>
+          int f(void), *fip(), (*pfi)();</pre>
+ declares a function f with no parameters returning an int, a function fip with no parameter specification
+ returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
+ int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
+ declaration suggests, and the same construction in an expression requires, the calling of a function fip,
+ and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
+ extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
+ designator, which is then used to call the function; it returns an int.
+<p><!--para 17-->
+ If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
+ declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
+ internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
+ the identifier of the pointer pfi has block scope and no linkage.
+ 
+<p><!--para 18-->
+ EXAMPLE 2       The declaration
+<pre>
+          int (*apfi[3])(int *x, int *y);</pre>
+ declares an array apfi of three pointers to functions returning int. Each of these functions has two
+ parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
+ go out of scope at the end of the declaration of apfi.
+ 
+<p><!--para 19-->
+ EXAMPLE 3       The declaration
+<pre>
+          int (*fpfi(int (*)(long), int))(int, ...);</pre>
+ declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
+ parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
+ The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
+ additional arguments of any type.
+<!--page 133 indent 5-->
+<p><!--para 20-->
+ EXAMPLE 4        The following prototype has a variably modified parameter.
+<pre>
+           void addscalar(int n, int m,
+                 double a[n][n*m+300], double x);
+           int main()
            {
-                   #pragma STDC FENV_ACCESS ON
-                   int set_excepts;
-                   feclearexcept(FE_INVALID | FE_OVERFLOW);
-                   // maybe raise exceptions
-                   set_excepts = fetestexcept(FE_INVALID | FE_OVERFLOW);
-                   if (set_excepts &amp; FE_INVALID) f();
-                   if (set_excepts &amp; FE_OVERFLOW) g();
-                   /* ... */
+                 double b[4][308];
+                 addscalar(4, 2, b, <a href="#2.17">2.17</a>);
+                 return 0;
            }
-
-<a name="7.6.3" href="#7.6.3"><b>    7.6.3 Rounding</b></a>
-1   The fegetround and fesetround functions provide control of rounding direction
-    modes.
-<a name="7.6.3.1" href="#7.6.3.1"><b>    7.6.3.1 The fegetround function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           int fegetround(void);
-<b>    Description</b>
-2   The fegetround function gets the current rounding direction.
-<b>    Returns</b>
-3   The fegetround function returns the value of the rounding direction macro
-    representing the current rounding direction or a negative value if there is no such
-    rounding direction macro or the current rounding direction is not determinable.
-<a name="7.6.3.2" href="#7.6.3.2"><b>    7.6.3.2 The fesetround function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           int fesetround(int round);
-<b>    Description</b>
-2   The fesetround function establishes the rounding direction represented by its
-    argument round. If the argument is not equal to the value of a rounding direction macro,
-    the rounding direction is not changed.
-<b>    Returns</b>
-3   The fesetround function returns zero if and only if the requested rounding direction
-    was established.
-
-[<a name="p193" href="#p193">page 193</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
-    rounding direction fails.
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           #include <a href="#7.2">&lt;assert.h&gt;</a>
-           void f(int round_dir)
+           void addscalar(int n, int m,
+                 double a[n][n*m+300], double x)
            {
-                 #pragma STDC FENV_ACCESS ON
-                 int save_round;
-                 int setround_ok;
-                 save_round = fegetround();
-                 setround_ok = fesetround(round_dir);
-                 assert(setround_ok == 0);
-                 /* ... */
-                 fesetround(save_round);
-                 /* ... */
-           }
-
-<a name="7.6.4" href="#7.6.4"><b>    7.6.4 Environment</b></a>
-1   The functions in this section manage the floating-point environment -- status flags and
-    control modes -- as one entity.
-<a name="7.6.4.1" href="#7.6.4.1"><b>    7.6.4.1 The fegetenv function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           int fegetenv(fenv_t *envp);
-<b>    Description</b>
-2   The fegetenv function attempts to store the current floating-point environment in the
-    object pointed to by envp.
-<b>    Returns</b>
-3   The fegetenv function returns zero if the environment was successfully stored.
-    Otherwise, it returns a nonzero value.
-<a name="7.6.4.2" href="#7.6.4.2"><b>    7.6.4.2 The feholdexcept function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           int feholdexcept(fenv_t *envp);
-<b>    Description</b>
-2   The feholdexcept function saves the current floating-point environment in the object
-    pointed to by envp, clears the floating-point status flags, and then installs a non-stop
-    (continue on floating-point exceptions) mode, if available, for all floating-point
-    exceptions.<sup><a href="#note189"><b>189)</b></a></sup>
-
-[<a name="p194" href="#p194">page 194</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The feholdexcept function returns zero if and only if non-stop floating-point
-    exception handling was successfully installed.
-<a name="7.6.4.3" href="#7.6.4.3"><b>    7.6.4.3 The fesetenv function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fesetenv(const fenv_t *envp);
-<b>    Description</b>
-2   The fesetenv function attempts to establish the floating-point environment represented
-    by the object pointed to by envp. The argument envp shall point to an object set by a
-    call to fegetenv or feholdexcept, or equal a floating-point environment macro.
-    Note that fesetenv merely installs the state of the floating-point status flags
-    represented through its argument, and does not raise these floating-point exceptions.
-<b>    Returns</b>
-3   The fesetenv function returns zero if the environment was successfully established.
-    Otherwise, it returns a nonzero value.
-<a name="7.6.4.4" href="#7.6.4.4"><b>    7.6.4.4 The feupdateenv function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int feupdateenv(const fenv_t *envp);
-<b>    Description</b>
-2   The feupdateenv function attempts to save the currently raised floating-point
-    exceptions in its automatic storage, install the floating-point environment represented by
-    the object pointed to by envp, and then raise the saved floating-point exceptions. The
-    argument envp shall point to an object set by a call to feholdexcept or fegetenv,
-    or equal a floating-point environment macro.
-<b>    Returns</b>
-3   The feupdateenv function returns zero if all the actions were successfully carried out.
-    Otherwise, it returns a nonzero value.
-
-
-
-
-    <sup><a name="note189" href="#note189"><b>189)</b></a></sup> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
-         handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
-         such systems, the feholdexcept function can be used in conjunction with the feupdateenv
-         function to write routines that hide spurious floating-point exceptions from their callers.
-
-[<a name="p195" href="#p195">page 195</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE   Hide spurious underflow floating-point exceptions:
-          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-          double f(double x)
+                 for (int i = 0; i &lt; n; i++)
+                       for (int j = 0, k = n*m+300; j &lt; k; j++)
+                             // a is a pointer to a VLA with n*m+300 elements
+                             a[i][j] += x;
+           }</pre>
+ 
+<p><!--para 21-->
+ EXAMPLE 5        The following are all compatible function prototype declarators.
+<pre>
+           double    maximum(int       n,   int   m,   double   a[n][m]);
+           double    maximum(int       n,   int   m,   double   a[*][*]);
+           double    maximum(int       n,   int   m,   double   a[ ][*]);
+           double    maximum(int       n,   int   m,   double   a[ ][m]);</pre>
+ as are:
+<pre>
+           void   f(double     (* restrict a)[5]);
+           void   f(double     a[restrict][5]);
+           void   f(double     a[restrict 3][5]);
+           void   f(double     a[restrict static 3][5]);</pre>
+ (Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
+ non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
+ 
+ Forward references: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.6">6.7.6</a>).
+<!--page 134 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note125">125)</a> The macros defined in the &lt;stdarg.h&gt; header (<a href="#7.15">7.15</a>) may be used to access arguments that
+ correspond to the ellipsis.
+
+<p><a name="note126">126)</a> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
+
+<p><a name="note127">127)</a> If both function types are ''old style'', parameter types are not compared.
+
+
+<a name="6.7.6" href="#6.7.6"><h4>6.7.6 Type names</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          type-name:
+                 specifier-qualifier-list abstract-declaratoropt
+          abstract-declarator:
+                 pointer
+                 pointeropt direct-abstract-declarator
+          direct-abstract-declarator:
+                  ( abstract-declarator )
+                  direct-abstract-declaratoropt [ type-qualifier-listopt
+                                 assignment-expressionopt ]
+                  direct-abstract-declaratoropt [ static type-qualifier-listopt
+                                 assignment-expression ]
+                  direct-abstract-declaratoropt [ type-qualifier-list static
+                                 assignment-expression ]
+                  direct-abstract-declaratoropt [ * ]
+                  direct-abstract-declaratoropt ( parameter-type-listopt )</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ In several contexts, it is necessary to specify a type. This is accomplished using a type
+ name, which is syntactically a declaration for a function or an object of that type that
+ omits the identifier.<sup><a href="#note128"><b>128)</b></a></sup>
+<p><!--para 3-->
+ EXAMPLE        The constructions
+<pre>
+          (a)      int
+          (b)      int   *
+          (c)      int   *[3]
+          (d)      int   (*)[3]
+          (e)      int   (*)[*]
+          (f)      int   *()
+          (g)      int   (*)(void)
+          (h)      int   (*const [])(unsigned int, ...)</pre>
+ name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
+ array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
+ with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
+ returning an int, and (h) array of an unspecified number of constant pointers to functions, each with one
+ parameter that has type unsigned int and an unspecified number of other parameters, returning an
+ int.
+ 
+ 
+ 
+ 
+<!--page 135 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note128">128)</a> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
+ parameter specification'', rather than redundant parentheses around the omitted identifier.
+
+
+<a name="6.7.7" href="#6.7.7"><h4>6.7.7 Type definitions</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          typedef-name:
+                 identifier</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ If a typedef name specifies a variably modified type then it shall have block scope.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ In a declaration whose storage-class specifier is typedef, each declarator defines an
+ identifier to be a typedef name that denotes the type specified for the identifier in the way
+ described in <a href="#6.7.5">6.7.5</a>. Any array size expressions associated with variable length array
+ declarators are evaluated each time the declaration of the typedef name is reached in the
+ order of execution. A typedef declaration does not introduce a new type, only a
+ synonym for the type so specified. That is, in the following declarations:
+<pre>
+          typedef T type_ident;
+          type_ident D;</pre>
+ type_ident is defined as a typedef name with the type specified by the declaration
+ specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
+ type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
+ typedef name shares the same name space as other identifiers declared in ordinary
+ declarators.
+<p><!--para 4-->
+ EXAMPLE 1       After
+<pre>
+          typedef int MILES, KLICKSP();
+          typedef struct { double hi, lo; } range;</pre>
+ the constructions
+<pre>
+          MILES distance;
+          extern KLICKSP *metricp;
+          range x;
+          range z, *zp;</pre>
+ are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
+ parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
+ such a structure. The object distance has a type compatible with any other int object.
+ 
+<p><!--para 5-->
+ EXAMPLE 2       After the declarations
+<pre>
+          typedef struct s1 { int x; } t1, *tp1;
+          typedef struct s2 { int x; } t2, *tp2;</pre>
+ type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
+ s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
+<!--page 136 indent 4-->
+<p><!--para 6-->
+ EXAMPLE 3       The following obscure constructions
+<pre>
+         typedef signed int t;
+         typedef int plain;
+         struct tag {
+               unsigned t:4;
+               const t:5;
+               plain r:5;
+         };</pre>
+ declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
+ with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
+ qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
+ [-16, +15], and one named r that contains values in one of the ranges [0, 31], [-15, +15], or [-16, +15].
+ (The choice of range is implementation-defined.) The first two bit-field declarations differ in that
+ unsigned is a type specifier (which forces t to be the name of a structure member), while const is a
+ type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed
+ in an inner scope by
+<pre>
+         t f(t (t));
+         long t;</pre>
+ then a function f is declared with type ''function returning signed int with one unnamed parameter
+ with type pointer to function returning signed int with one unnamed parameter with type signed
+ int'', and an identifier t with type long int.
+ 
+<p><!--para 7-->
+ EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
+ following declarations of the signal function specify exactly the same type, the first without making use
+ of any typedef names.
+<pre>
+         typedef void fv(int), (*pfv)(int);
+         void (*signal(int, void (*)(int)))(int);
+         fv *signal(int, fv *);
+         pfv signal(int, pfv);</pre>
+ 
+<p><!--para 8-->
+ EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
+ time the typedef name is defined, not each time it is used:
+<!--page 137 indent 4-->
+<pre>
+         void copyt(int n)
+         {
+               typedef int B[n];    //               B is n ints, n evaluated now
+               n += 1;
+               B a;                //                a is n ints, n without += 1
+               int b[n];           //                a and b are different sizes
+               for (int i = 1; i &lt; n;                i++)
+                     a[i-1] = b[i];
+         }</pre>
+
+<a name="6.7.8" href="#6.7.8"><h4>6.7.8 Initialization</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          initializer:
+                   assignment-expression
+                   { initializer-list }
+                   { initializer-list , }
+          initializer-list:
+                   designationopt initializer
+                   initializer-list , designationopt initializer
+          designation:
+                 designator-list =
+          designator-list:
+                 designator
+                 designator-list designator
+          designator:
+                 [ constant-expression ]
+                 . identifier</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ No initializer shall attempt to provide a value for an object not contained within the entity
+ being initialized.
+<p><!--para 3-->
+ The type of the entity to be initialized shall be an array of unknown size or an object type
+ that is not a variable length array type.
+<p><!--para 4-->
+ All the expressions in an initializer for an object that has static storage duration shall be
+ constant expressions or string literals.
+<p><!--para 5-->
+ If the declaration of an identifier has block scope, and the identifier has external or
+ internal linkage, the declaration shall have no initializer for the identifier.
+<p><!--para 6-->
+ If a designator has the form
+<pre>
+          [ constant-expression ]</pre>
+ then the current object (defined below) shall have array type and the expression shall be
+ an integer constant expression. If the array is of unknown size, any nonnegative value is
+ valid.
+<p><!--para 7-->
+ If a designator has the form
+<pre>
+          . identifier</pre>
+ then the current object (defined below) shall have structure or union type and the
+ identifier shall be the name of a member of that type.
+<!--page 138 indent 5-->
+<h6>Semantics</h6>
+<p><!--para 8-->
+ An initializer specifies the initial value stored in an object.
+<p><!--para 9-->
+ Except where explicitly stated otherwise, for the purposes of this subclause unnamed
+ members of objects of structure and union type do not participate in initialization.
+ Unnamed members of structure objects have indeterminate value even after initialization.
+<p><!--para 10-->
+ If an object that has automatic storage duration is not initialized explicitly, its value is
+ indeterminate. If an object that has static storage duration is not initialized explicitly,
+ then:
+<ul>
+<li>  if it has pointer type, it is initialized to a null pointer;
+<li>  if it has arithmetic type, it is initialized to (positive or unsigned) zero;
+<li>  if it is an aggregate, every member is initialized (recursively) according to these rules;
+<li>  if it is a union, the first named member is initialized (recursively) according to these
+ rules.
+</ul>
+<p><!--para 11-->
+ The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
+ initial value of the object is that of the expression (after conversion); the same type
+ constraints and conversions as for simple assignment apply, taking the type of the scalar
+ to be the unqualified version of its declared type.
+<p><!--para 12-->
+ The rest of this subclause deals with initializers for objects that have aggregate or union
+ type.
+<p><!--para 13-->
+ The initializer for a structure or union object that has automatic storage duration shall be
+ either an initializer list as described below, or a single expression that has compatible
+ structure or union type. In the latter case, the initial value of the object, including
+ unnamed members, is that of the expression.
+<p><!--para 14-->
+ An array of character type may be initialized by a character string literal, optionally
+ enclosed in braces. Successive characters of the character string literal (including the
+ terminating null character if there is room or if the array is of unknown size) initialize the
+ elements of the array.
+<p><!--para 15-->
+ An array with element type compatible with wchar_t may be initialized by a wide
+ string literal, optionally enclosed in braces. Successive wide characters of the wide string
+ literal (including the terminating null wide character if there is room or if the array is of
+ unknown size) initialize the elements of the array.
+<p><!--para 16-->
+ Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
+ enclosed list of initializers for the elements or named members.
+<p><!--para 17-->
+ Each brace-enclosed initializer list has an associated current object. When no
+ designations are present, subobjects of the current object are initialized in order according
+ to the type of the current object: array elements in increasing subscript order, structure
+<!--page 139 indent 5-->
+ members in declaration order, and the first named member of a union.<sup><a href="#note129"><b>129)</b></a></sup> In contrast, a
+ designation causes the following initializer to begin initialization of the subobject
+ described by the designator. Initialization then continues forward in order, beginning
+ with the next subobject after that described by the designator.<sup><a href="#note130"><b>130)</b></a></sup>
+<p><!--para 18-->
+ Each designator list begins its description with the current object associated with the
+ closest surrounding brace pair. Each item in the designator list (in order) specifies a
+ particular member of its current object and changes the current object for the next
+ designator (if any) to be that member.<sup><a href="#note131"><b>131)</b></a></sup> The current object that results at the end of the
+ designator list is the subobject to be initialized by the following initializer.
+<p><!--para 19-->
+ The initialization shall occur in initializer list order, each initializer provided for a
+ particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note132"><b>132)</b></a></sup>
+ all subobjects that are not initialized explicitly shall be initialized implicitly the same as
+ objects that have static storage duration.
+<p><!--para 20-->
+ If the aggregate or union contains elements or members that are aggregates or unions,
+ these rules apply recursively to the subaggregates or contained unions. If the initializer of
+ a subaggregate or contained union begins with a left brace, the initializers enclosed by
+ that brace and its matching right brace initialize the elements or members of the
+ subaggregate or the contained union. Otherwise, only enough initializers from the list are
+ taken to account for the elements or members of the subaggregate or the first member of
+ the contained union; any remaining initializers are left to initialize the next element or
+ member of the aggregate of which the current subaggregate or contained union is a part.
+<p><!--para 21-->
+ If there are fewer initializers in a brace-enclosed list than there are elements or members
+ of an aggregate, or fewer characters in a string literal used to initialize an array of known
+ size than there are elements in the array, the remainder of the aggregate shall be
+ initialized implicitly the same as objects that have static storage duration.
+<p><!--para 22-->
+ If an array of unknown size is initialized, its size is determined by the largest indexed
+ element with an explicit initializer. At the end of its initializer list, the array no longer
+ has incomplete type.
+ 
+ 
+ 
+<!--page 140 indent 5-->
+<p><!--para 23-->
+ The order in which any side effects occur among the initialization list expressions is
+ unspecified.<sup><a href="#note133"><b>133)</b></a></sup>
+<p><!--para 24-->
+ EXAMPLE 1       Provided that &lt;complex.h&gt; has been #included, the declarations
+<pre>
+          int i = <a href="#3.5">3.5</a>;
+          double complex c = 5 + 3 * I;</pre>
+ define and initialize i with the value 3 and c with the value 5.0 + i3.0.
+ 
+<p><!--para 25-->
+ EXAMPLE 2 The declaration
+<pre>
+          int x[] = { 1, 3, 5 };</pre>
+ defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
+ and there are three initializers.
+ 
+<p><!--para 26-->
+ EXAMPLE 3       The declaration
+<pre>
+          int y[4][3] =         {
+                { 1, 3,         5 },
+                { 2, 4,         6 },
+                { 3, 5,         7 },
+          };</pre>
+ is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
+ y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
+ y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
+ been achieved by
+<pre>
+          int y[4][3] = {
+                1, 3, 5, 2, 4, 6, 3, 5, 7
+          };</pre>
+ The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
+ next three are taken successively for y[1] and y[2].
+ 
+<p><!--para 27-->
+ EXAMPLE 4       The declaration
+<pre>
+          int z[4][3] = {
+                { 1 }, { 2 }, { 3 }, { 4 }
+          };</pre>
+ initializes the first column of z as specified and initializes the rest with zeros.
+ 
+<p><!--para 28-->
+ EXAMPLE 5       The declaration
+<pre>
+          struct { int a[3], b; } w[] = { { 1 }, 2 };</pre>
+ is a definition with an inconsistently bracketed initialization. It defines an array with two element
+ structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
+ 
+ 
+ 
+ 
+<!--page 141 indent 5-->
+<p><!--para 29-->
+ EXAMPLE 6         The declaration
+<pre>
+           short q[4][3][2] = {
+                 { 1 },
+                 { 2, 3 },
+                 { 4, 5, 6 }
+           };</pre>
+ contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
+ object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
+ q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
+ q[0][0] does not begin with a left brace, so up to six items from the current list may be used. There is
+ only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers
+ for q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their
+ respective two-dimensional subaggregates. If there had been more than six items in any of the lists, a
+ diagnostic message would have been issued. The same initialization result could have been achieved by:
+<pre>
+           short q[4][3][2] = {
+                 1, 0, 0, 0, 0, 0,
+                 2, 3, 0, 0, 0, 0,
+                 4, 5, 6
+           };</pre>
+ or by:
+<pre>
+           short q[4][3][2] = {
+                 {
+                       { 1 },
+                 },
+                 {
+                       { 2, 3 },
+                 },
+                 {
+                       { 4, 5 },
+                       { 6 },
+                 }
+           };</pre>
+ in a fully bracketed form.
+<p><!--para 30-->
+ Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
+ cause confusion.
+ 
+<p><!--para 31-->
+ EXAMPLE 7         One form of initialization that completes array types involves typedef names. Given the
+ declaration
+<pre>
+           typedef int A[];          // OK - declared with block scope</pre>
+ the declaration
+<pre>
+           A a = { 1, 2 }, b = { 3, 4, 5 };</pre>
+ is identical to
+<pre>
+           int a[] = { 1, 2 }, b[] = { 3, 4, 5 };</pre>
+ due to the rules for incomplete types.
+<!--page 142 indent 5-->
+<p><!--para 32-->
+ EXAMPLE 8       The declaration
+<pre>
+          char s[] = "abc", t[3] = "abc";</pre>
+ defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
+ This declaration is identical to
+<pre>
+          char s[] = { 'a', 'b', 'c', '\0' },
+               t[] = { 'a', 'b', 'c' };</pre>
+ The contents of the arrays are modifiable. On the other hand, the declaration
+<pre>
+          char *p = "abc";</pre>
+ defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
+ with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
+ modify the contents of the array, the behavior is undefined.
+ 
+<p><!--para 33-->
+ EXAMPLE 9       Arrays can be initialized to correspond to the elements of an enumeration by using
+ designators:
+<pre>
+          enum { member_one,           member_two };
+          const char *nm[] =           {
+                [member_two]           = "member two",
+                [member_one]           = "member one",
+          };</pre>
+ 
+<p><!--para 34-->
+ EXAMPLE 10       Structure members can be initialized to nonzero values without depending on their order:
+<pre>
+          div_t answer = { .quot = 2, .rem = -1 };</pre>
+ 
+<p><!--para 35-->
+ EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
+ might be misunderstood:
+<pre>
+          struct { int a[3], b; } w[] =
+                { [0].a = {1}, [1].a[0] = 2 };</pre>
+ 
+<p><!--para 36-->
+ EXAMPLE 12       Space can be ''allocated'' from both ends of an array by using a single designator:
+<p><!--para 37-->
+<pre>
+          int a[MAX] = {
+                1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
+          };</pre>
+ In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
+ than ten, some of the values provided by the first five initializers will be overridden by the second five.
+ 
+<p><!--para 38-->
+ EXAMPLE 13       Any member of a union can be initialized:
+<pre>
+          union { /* ... */ } u = { .any_member = 42 };</pre>
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.17">7.17</a>).
+<!--page 143 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note129">129)</a> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
+ subobjects are initialized as usual, but the subaggregate or contained union does not become the
+ current object: current objects are associated only with brace-enclosed initializer lists.
+
+<p><a name="note130">130)</a> After a union member is initialized, the next object is not the next member of the union; instead, it is
+ the next subobject of an object containing the union.
+
+<p><a name="note131">131)</a> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
+ the surrounding brace pair. Note, too, that each separate designator list is independent.
+
+<p><a name="note132">132)</a> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
+ not be evaluated at all.
+
+<p><a name="note133">133)</a> In particular, the evaluation order need not be the same as the order of subobject initialization.
+
+
+<a name="6.8" href="#6.8"><h3>6.8 Statements and blocks</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          statement:
+                 labeled-statement
+                 compound-statement
+                 expression-statement
+                 selection-statement
+                 iteration-statement
+                 jump-statement</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A statement specifies an action to be performed. Except as indicated, statements are
+ executed in sequence.
+<p><!--para 3-->
+ A block allows a set of declarations and statements to be grouped into one syntactic unit.
+ The initializers of objects that have automatic storage duration, and the variable length
+ array declarators of ordinary identifiers with block scope, are evaluated and the values are
+ stored in the objects (including storing an indeterminate value in objects without an
+ initializer) each time the declaration is reached in the order of execution, as if it were a
+ statement, and within each declaration in the order that declarators appear.
+<p><!--para 4-->
+ A full expression is an expression that is not part of another expression or of a declarator.
+ Each of the following is a full expression: an initializer; the expression in an expression
+ statement; the controlling expression of a selection statement (if or switch); the
+ controlling expression of a while or do statement; each of the (optional) expressions of
+ a for statement; the (optional) expression in a return statement. The end of a full
+ expression is a sequence point.
+ Forward references: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
+ (<a href="#6.8.4">6.8.4</a>), iteration statements (<a href="#6.8.5">6.8.5</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>).
+
+<a name="6.8.1" href="#6.8.1"><h4>6.8.1 Labeled statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          labeled-statement:
+                 identifier : statement
+                 case constant-expression : statement
+                 default : statement</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A case or default label shall appear only in a switch statement. Further
+ constraints on such labels are discussed under the switch statement.
+<!--page 144 indent 4-->
+<p><!--para 3-->
+ Label names shall be unique within a function.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ Any statement may be preceded by a prefix that declares an identifier as a label name.
+ Labels in themselves do not alter the flow of control, which continues unimpeded across
+ them.
+ Forward references: the goto statement (<a href="#6.8.6.1">6.8.6.1</a>), the switch statement (<a href="#6.8.4.2">6.8.4.2</a>).
+
+<a name="6.8.2" href="#6.8.2"><h4>6.8.2 Compound statement</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          compound-statement:
+                { block-item-listopt }
+          block-item-list:
+                  block-item
+                  block-item-list block-item
+          block-item:
+                  declaration
+                  statement</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A compound statement is a block.
+
+<a name="6.8.3" href="#6.8.3"><h4>6.8.3 Expression and null statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          expression-statement:
+                 expressionopt ;</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The expression in an expression statement is evaluated as a void expression for its side
+ effects.<sup><a href="#note134"><b>134)</b></a></sup>
+<p><!--para 3-->
+ A null statement (consisting of just a semicolon) performs no operations.
+<p><!--para 4-->
+ EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
+ discarding of its value may be made explicit by converting the expression to a void expression by means of
+ a cast:
+<pre>
+          int p(int);
+          /* ... */
+          (void)p(0);</pre>
+ 
+ 
+ 
+<!--page 145 indent 4-->
+<p><!--para 5-->
+ EXAMPLE 2       In the program fragment
+<pre>
+          char *s;
+          /* ... */
+          while (*s++ != '\0')
+                  ;</pre>
+ a null statement is used to supply an empty loop body to the iteration statement.
+ 
+<p><!--para 6-->
+ EXAMPLE 3       A null statement may also be used to carry a label just before the closing } of a compound
+ statement.
+<pre>
+          while (loop1) {
+                /* ... */
+                while (loop2) {
+                        /* ... */
+                        if (want_out)
+                                goto end_loop1;
+                        /* ... */
+                }
+                /* ... */
+          end_loop1: ;
+          }</pre>
+ 
+ Forward references: iteration statements (<a href="#6.8.5">6.8.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note134">134)</a> Such as assignments, and function calls which have side effects.
+
+
+<a name="6.8.4" href="#6.8.4"><h4>6.8.4 Selection statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          selection-statement:
+                  if ( expression ) statement
+                  if ( expression ) statement else statement
+                  switch ( expression ) statement</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A selection statement selects among a set of statements depending on the value of a
+ controlling expression.
+<p><!--para 3-->
+ A selection statement is a block whose scope is a strict subset of the scope of its
+ enclosing block. Each associated substatement is also a block whose scope is a strict
+ subset of the scope of the selection statement.
+
+<a name="6.8.4.1" href="#6.8.4.1"><h5>6.8.4.1 The if statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The controlling expression of an if statement shall have scalar type.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ In both forms, the first substatement is executed if the expression compares unequal to 0.
+ In the else form, the second substatement is executed if the expression compares equal
+<!--page 146 indent 4-->
+ to 0. If the first substatement is reached via a label, the second substatement is not
+ executed.
+<p><!--para 3-->
+ An else is associated with the lexically nearest preceding if that is allowed by the
+ syntax.
+
+<a name="6.8.4.2" href="#6.8.4.2"><h5>6.8.4.2 The switch statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The controlling expression of a switch statement shall have integer type.
+<p><!--para 2-->
+ If a switch statement has an associated case or default label within the scope of an
+ identifier with a variably modified type, the entire switch statement shall be within the
+ scope of that identifier.<sup><a href="#note135"><b>135)</b></a></sup>
+<p><!--para 3-->
+ The expression of each case label shall be an integer constant expression and no two of
+ the case constant expressions in the same switch statement shall have the same value
+ after conversion. There may be at most one default label in a switch statement.
+ (Any enclosed switch statement may have a default label or case constant
+ expressions with values that duplicate case constant expressions in the enclosing
+ switch statement.)
+<h6>Semantics</h6>
+<p><!--para 4-->
+ A switch statement causes control to jump to, into, or past the statement that is the
+ switch body, depending on the value of a controlling expression, and on the presence of a
+ default label and the values of any case labels on or in the switch body. A case or
+ default label is accessible only within the closest enclosing switch statement.
+<p><!--para 5-->
+ The integer promotions are performed on the controlling expression. The constant
+ expression in each case label is converted to the promoted type of the controlling
+ expression. If a converted value matches that of the promoted controlling expression,
+ control jumps to the statement following the matched case label. Otherwise, if there is
+ a default label, control jumps to the labeled statement. If no converted case constant
+ expression matches and there is no default label, no part of the switch body is
+ executed.
+ Implementation limits
+<p><!--para 6-->
+ As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
+ switch statement.
+ 
+ 
+ 
+ 
+<!--page 147 indent 4-->
+<p><!--para 7-->
+ EXAMPLE        In the artificial program fragment
+<pre>
+          switch (expr)
           {
-                #pragma STDC FENV_ACCESS ON
-                double result;
-                fenv_t save_env;
-                if (feholdexcept(&amp;save_env))
-                      return /* indication of an environmental problem */;
-                // compute result
-                if (/* test spurious underflow */)
-                      if (feclearexcept(FE_UNDERFLOW))
-                               return /* indication of an environmental problem */;
-                if (feupdateenv(&amp;save_env))
-                      return /* indication of an environmental problem */;
-                return result;
+                int i = 4;
+                f(i);
+          case 0:
+                i = 17;
+                /* falls through into default code */
+          default:
+                printf("%d\n", i);
+          }</pre>
+ the object whose identifier is i exists with automatic storage duration (within the block) but is never
+ initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
+ access an indeterminate value. Similarly, the call to the function f cannot be reached.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note135">135)</a> That is, the declaration either precedes the switch statement, or it follows the last case or
+ default label associated with the switch that is in the block containing the declaration.
+
+
+<a name="6.8.5" href="#6.8.5"><h4>6.8.5 Iteration statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          iteration-statement:
+                  while ( expression ) statement
+                  do statement while ( expression ) ;
+                  for ( expressionopt ; expressionopt ; expressionopt ) statement
+                  for ( declaration expressionopt ; expressionopt ) statement</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The controlling expression of an iteration statement shall have scalar type.
+<p><!--para 3-->
+ The declaration part of a for statement shall only declare identifiers for objects having
+ storage class auto or register.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ An iteration statement causes a statement called the loop body to be executed repeatedly
+ until the controlling expression compares equal to 0. The repetition occurs regardless of
+ whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note136"><b>136)</b></a></sup>
+<p><!--para 5-->
+ An iteration statement is a block whose scope is a strict subset of the scope of its
+ enclosing block. The loop body is also a block whose scope is a strict subset of the scope
+ of the iteration statement.
+ 
+ 
+ 
+ 
+<!--page 148 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note136">136)</a> Code jumped over is not executed. In particular, the controlling expression of a for or while
+ statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
+
+
+<a name="6.8.5.1" href="#6.8.5.1"><h5>6.8.5.1 The while statement</h5></a>
+<p><!--para 1-->
+ The evaluation of the controlling expression takes place before each execution of the loop
+ body.
+
+<a name="6.8.5.2" href="#6.8.5.2"><h5>6.8.5.2 The do statement</h5></a>
+<p><!--para 1-->
+ The evaluation of the controlling expression takes place after each execution of the loop
+ body.
+
+<a name="6.8.5.3" href="#6.8.5.3"><h5>6.8.5.3 The for statement</h5></a>
+<p><!--para 1-->
+ The statement
+<pre>
+          for ( clause-1 ; expression-2 ; expression-3 ) statement</pre>
+ behaves as follows: The expression expression-2 is the controlling expression that is
+ evaluated before each execution of the loop body. The expression expression-3 is
+ evaluated as a void expression after each execution of the loop body. If clause-1 is a
+ declaration, the scope of any identifiers it declares is the remainder of the declaration and
+ the entire loop, including the other two expressions; it is reached in the order of execution
+ before the first evaluation of the controlling expression. If clause-1 is an expression, it is
+ evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note137"><b>137)</b></a></sup>
+<p><!--para 2-->
+ Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a
+ nonzero constant.
+
+<h6>footnotes</h6>
+<p><a name="note137">137)</a> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
+ the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
+ such that execution of the loop continues until the expression compares equal to 0; and expression-3
+ specifies an operation (such as incrementing) that is performed after each iteration.
+
+
+<a name="6.8.6" href="#6.8.6"><h4>6.8.6 Jump statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          jump-statement:
+                 goto identifier ;
+                 continue ;
+                 break ;
+                 return expressionopt ;</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A jump statement causes an unconditional jump to another place.
+ 
+ 
+ 
+ 
+<!--page 149 indent 4-->
+
+<a name="6.8.6.1" href="#6.8.6.1"><h5>6.8.6.1 The goto statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The identifier in a goto statement shall name a label located somewhere in the enclosing
+ function. A goto statement shall not jump from outside the scope of an identifier having
+ a variably modified type to inside the scope of that identifier.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A goto statement causes an unconditional jump to the statement prefixed by the named
+ label in the enclosing function.
+<p><!--para 3-->
+ EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
+ following outline presents one possible approach to a problem based on these three assumptions:
+<ol>
+<li>  The general initialization code accesses objects only visible to the current function.
+<li>  The general initialization code is too large to warrant duplication.
+<li>  The code to determine the next operation is at the head of the loop. (To allow it to be reached by
+ continue statements, for example.)
+  /* ... */
+  goto first_time;
+  for (;;) {
+<pre>
+          // determine next operation
+          /* ... */
+          if (need to reinitialize) {
+                  // reinitialize-only code
+                  /* ... */
+          first_time:
+                  // general initialization code
+                  /* ... */
+                  continue;
           }
-
-[<a name="p196" href="#p196">page 196</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.7" href="#7.7"><b>    7.7 Characteristics of floating types &lt;float.h&gt;</b></a>
-1   The header <a href="#7.7">&lt;float.h&gt;</a> defines several macros that expand to various limits and
-    parameters of the standard floating-point types.
-2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
-    in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
-
-[<a name="p197" href="#p197">page 197</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.8" href="#7.8"><b>    7.8 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
-1   The header <a href="#7.8">&lt;inttypes.h&gt;</a> includes the header <a href="#7.18">&lt;stdint.h&gt;</a> and extends it with
-    additional facilities provided by hosted implementations.
-2   It declares functions for manipulating greatest-width integers and converting numeric
-    character strings to greatest-width integers, and it declares the type
-             imaxdiv_t
-    which is a structure type that is the type of the value returned by the imaxdiv function.
-    For each type declared in <a href="#7.18">&lt;stdint.h&gt;</a>, it defines corresponding macros for conversion
-    specifiers for use with the formatted input/output functions.<sup><a href="#note190"><b>190)</b></a></sup>
-    Forward references: integer types <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#7.18">7.18</a>), formatted input/output
-    functions (<a href="#7.19.6">7.19.6</a>), formatted wide character input/output functions (<a href="#7.24.2">7.24.2</a>).
-<a name="7.8.1" href="#7.8.1"><b>    7.8.1 Macros for format specifiers</b></a>
-1   Each of the following object-like macros<sup><a href="#note191"><b>191)</b></a></sup> expands to a character string literal
-    containing a conversion specifier, possibly modified by a length modifier, suitable for use
-    within the format argument of a formatted input/output function when converting the
-    corresponding integer type. These macro names have the general form of PRI (character
-    string literals for the fprintf and fwprintf family) or SCN (character string literals
-    for the fscanf and fwscanf family),<sup><a href="#note192"><b>192)</b></a></sup> followed by the conversion specifier,
-    followed by a name corresponding to a similar type name in <a href="#7.18.1">7.18.1</a>. In these names, N
-    represents the width of the type as described in <a href="#7.18.1">7.18.1</a>. For example, PRIdFAST32 can
-    be used in a format string to print the value of an integer of type int_fast32_t.
-2   The fprintf macros for signed integers are:
-           PRIdN             PRIdLEASTN                PRIdFASTN          PRIdMAX             PRIdPTR
-           PRIiN             PRIiLEASTN                PRIiFASTN          PRIiMAX             PRIiPTR
-
-
-
-
-    <sup><a name="note190" href="#note190"><b>190)</b></a></sup> See ''future library directions'' (<a href="#7.26.4">7.26.4</a>).
-    <sup><a name="note191" href="#note191"><b>191)</b></a></sup> C++ implementations should define these macros only when __STDC_FORMAT_MACROS is defined
-         before <a href="#7.8">&lt;inttypes.h&gt;</a> is included.
-    <sup><a name="note192" href="#note192"><b>192)</b></a></sup> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
-         different format specifiers may be required for fprintf and fscanf, even when the type is the
-         same.
-
-[<a name="p198" href="#p198">page 198</a>] (<a href="#Contents">Contents</a>)
-
-3   The fprintf macros for unsigned integers are:
-           PRIoN           PRIoLEASTN               PRIoFASTN              PRIoMAX             PRIoPTR
-           PRIuN           PRIuLEASTN               PRIuFASTN              PRIuMAX             PRIuPTR
-           PRIxN           PRIxLEASTN               PRIxFASTN              PRIxMAX             PRIxPTR
-           PRIXN           PRIXLEASTN               PRIXFASTN              PRIXMAX             PRIXPTR
-4   The fscanf macros for signed integers are:
-           SCNdN           SCNdLEASTN               SCNdFASTN              SCNdMAX             SCNdPTR
-           SCNiN           SCNiLEASTN               SCNiFASTN              SCNiMAX             SCNiPTR
-5   The fscanf macros for unsigned integers are:
-           SCNoN           SCNoLEASTN               SCNoFASTN              SCNoMAX             SCNoPTR
-           SCNuN           SCNuLEASTN               SCNuFASTN              SCNuMAX             SCNuPTR
-           SCNxN           SCNxLEASTN               SCNxFASTN              SCNxMAX             SCNxPTR
-6   For each type that the implementation provides in <a href="#7.18">&lt;stdint.h&gt;</a>, the corresponding
-    fprintf macros shall be defined and the corresponding fscanf macros shall be
-    defined unless the implementation does not have a suitable fscanf length modifier for
-    the type.
-7   EXAMPLE
-            #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            int main(void)
-            {
-                  uintmax_t i = UINTMAX_MAX;    // this type always exists
-                  wprintf(L"The largest integer value is %020"
-                        PRIxMAX "\n", i);
-                  return 0;
-            }
-
-<a name="7.8.2" href="#7.8.2"><b>    7.8.2 Functions for greatest-width integer types</b></a>
-<a name="7.8.2.1" href="#7.8.2.1"><b>    7.8.2.1 The imaxabs function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-            intmax_t imaxabs(intmax_t j);
-<b>    Description</b>
-2   The imaxabs function computes the absolute value of an integer j. If the result cannot
-    be represented, the behavior is undefined.<sup><a href="#note193"><b>193)</b></a></sup>
-
-
-
-    <sup><a name="note193" href="#note193"><b>193)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
-
-[<a name="p199" href="#p199">page 199</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The imaxabs function returns the absolute value.
-<a name="7.8.2.2" href="#7.8.2.2"><b>    7.8.2.2 The imaxdiv function</b></a>
-<b>    Synopsis</b>
-1              #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-               imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
-<b>    Description</b>
-2   The imaxdiv function computes numer / denom and numer % denom in a single
-    operation.
-<b>    Returns</b>
-3   The imaxdiv function returns a structure of type imaxdiv_t comprising both the
-    quotient and the remainder. The structure shall contain (in either order) the members
-    quot (the quotient) and rem (the remainder), each of which has type intmax_t. If
-    either part of the result cannot be represented, the behavior is undefined.
-<a name="7.8.2.3" href="#7.8.2.3"><b>    7.8.2.3 The strtoimax and strtoumax functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-           intmax_t strtoimax(const char * restrict nptr,
-                char ** restrict endptr, int base);
-           uintmax_t strtoumax(const char * restrict nptr,
-                char ** restrict endptr, int base);
-<b>    Description</b>
-2   The strtoimax and strtoumax functions are equivalent to the strtol, strtoll,
-    strtoul, and strtoull functions, except that the initial portion of the string is
-    converted to intmax_t and uintmax_t representation, respectively.
-<b>    Returns</b>
-3   The strtoimax and strtoumax functions return the converted value, if any. If no
-    conversion could be performed, zero is returned. If the correct value is outside the range
-    of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
-    (according to the return type and sign of the value, if any), and the value of the macro
-    ERANGE is stored in errno.
-    Forward references: the strtol, strtoll, strtoul, and strtoull functions
-    (<a href="#7.20.1.4">7.20.1.4</a>).
-
-[<a name="p200" href="#p200">page 200</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.8.2.4" href="#7.8.2.4"><b>    7.8.2.4 The wcstoimax and wcstoumax functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.17">&lt;stddef.h&gt;</a>           // for wchar_t
-           #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-           intmax_t wcstoimax(const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr, int base);
-           uintmax_t wcstoumax(const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr, int base);
-<b>    Description</b>
-2   The wcstoimax and wcstoumax functions are equivalent to the wcstol, wcstoll,
-    wcstoul, and wcstoull functions except that the initial portion of the wide string is
-    converted to intmax_t and uintmax_t representation, respectively.
-<b>    Returns</b>
-3   The wcstoimax function returns the converted value, if any. If no conversion could be
-    performed, zero is returned. If the correct value is outside the range of representable
-    values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
-    return type and sign of the value, if any), and the value of the macro ERANGE is stored in
-    errno.
-    Forward references: the wcstol, wcstoll, wcstoul, and wcstoull functions
-    (<a href="#7.24.4.1.2">7.24.4.1.2</a>).
-
-[<a name="p201" href="#p201">page 201</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.9" href="#7.9"><b>    7.9 Alternative spellings &lt;iso646.h&gt;</b></a>
-1   The header <a href="#7.9">&lt;iso646.h&gt;</a> defines the following eleven macros (on the left) that expand
-    to the corresponding tokens (on the right):
-          and          &amp;&amp;
-          and_eq       &amp;=
-          bitand       &amp;
-          bitor        |
-          compl        ~
-          not          !
-          not_eq       !=
-          or           ||
-          or_eq        |=
-          xor          ^
-          xor_eq       ^=
-
-[<a name="p202" href="#p202">page 202</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.10" href="#7.10"><b>    7.10 Sizes of integer types &lt;limits.h&gt;</b></a>
-1   The header <a href="#7.10">&lt;limits.h&gt;</a> defines several macros that expand to various limits and
-    parameters of the standard integer types.
-2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
-    in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
-
-[<a name="p203" href="#p203">page 203</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.11" href="#7.11"><b>    7.11 Localization &lt;locale.h&gt;</b></a>
-1   The header <a href="#7.11">&lt;locale.h&gt;</a> declares two functions, one type, and defines several macros.
-2   The type is
-           struct lconv
-    which contains members related to the formatting of numeric values. The structure shall
-    contain at least the following members, in any order. The semantics of the members and
-    their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
-    the values specified in the comments.
-           char   *decimal_point;                 //   "."
-           char   *thousands_sep;                 //   ""
-           char   *grouping;                      //   ""
-           char   *mon_decimal_point;             //   ""
-           char   *mon_thousands_sep;             //   ""
-           char   *mon_grouping;                  //   ""
-           char   *positive_sign;                 //   ""
-           char   *negative_sign;                 //   ""
-           char   *currency_symbol;               //   ""
-           char   frac_digits;                    //   CHAR_MAX
-           char   p_cs_precedes;                  //   CHAR_MAX
-           char   n_cs_precedes;                  //   CHAR_MAX
-           char   p_sep_by_space;                 //   CHAR_MAX
-           char   n_sep_by_space;                 //   CHAR_MAX
-           char   p_sign_posn;                    //   CHAR_MAX
-           char   n_sign_posn;                    //   CHAR_MAX
-           char   *int_curr_symbol;               //   ""
-           char   int_frac_digits;                //   CHAR_MAX
-           char   int_p_cs_precedes;              //   CHAR_MAX
-           char   int_n_cs_precedes;              //   CHAR_MAX
-           char   int_p_sep_by_space;             //   CHAR_MAX
-           char   int_n_sep_by_space;             //   CHAR_MAX
-           char   int_p_sign_posn;                //   CHAR_MAX
-           char   int_n_sign_posn;                //   CHAR_MAX
-
-[<a name="p204" href="#p204">page 204</a>] (<a href="#Contents">Contents</a>)
-
-3   The macros defined are NULL (described in <a href="#7.17">7.17</a>); and
-             LC_ALL
-             LC_COLLATE
-             LC_CTYPE
-             LC_MONETARY
-             LC_NUMERIC
-             LC_TIME
-    which expand to integer constant expressions with distinct values, suitable for use as the
-    first argument to the setlocale function.<sup><a href="#note194"><b>194)</b></a></sup> Additional macro definitions, beginning
-    with the characters LC_ and an uppercase letter,<sup><a href="#note195"><b>195)</b></a></sup> may also be specified by the
-    implementation.
-<a name="7.11.1" href="#7.11.1"><b>    7.11.1 Locale control</b></a>
-<a name="7.11.1.1" href="#7.11.1.1"><b>    7.11.1.1 The setlocale function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.11">&lt;locale.h&gt;</a>
-             char *setlocale(int category, const char *locale);
-<b>    Description</b>
-2   The setlocale function selects the appropriate portion of the program's locale as
-    specified by the category and locale arguments. The setlocale function may be
-    used to change or query the program's entire current locale or portions thereof. The value
-    LC_ALL for category names the program's entire locale; the other values for
-    category name only a portion of the program's locale. LC_COLLATE affects the
-    behavior of the strcoll and strxfrm functions. LC_CTYPE affects the behavior of
-    the character handling functions<sup><a href="#note196"><b>196)</b></a></sup> and the multibyte and wide character functions.
-    LC_MONETARY affects the monetary formatting information returned by the
-    localeconv function. LC_NUMERIC affects the decimal-point character for the
-    formatted input/output functions and the string conversion functions, as well as the
-    nonmonetary formatting information returned by the localeconv function. LC_TIME
-    affects the behavior of the strftime and wcsftime functions.
-3   A value of "C" for locale specifies the minimal environment for C translation; a value
-    of "" for locale specifies the locale-specific native environment. Other
-    implementation-defined strings may be passed as the second argument to setlocale.
-
-    <sup><a name="note194" href="#note194"><b>194)</b></a></sup> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
-    <sup><a name="note195" href="#note195"><b>195)</b></a></sup> See ''future library directions'' (<a href="#7.26.5">7.26.5</a>).
-    <sup><a name="note196" href="#note196"><b>196)</b></a></sup> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
-         isxdigit.
-
-[<a name="p205" href="#p205">page 205</a>] (<a href="#Contents">Contents</a>)
-
-4   At program startup, the equivalent of
-            setlocale(LC_ALL, "C");
-    is executed.
-5   The implementation shall behave as if no library function calls the setlocale function.
-<b>    Returns</b>
-6   If a pointer to a string is given for locale and the selection can be honored, the
-    setlocale function returns a pointer to the string associated with the specified
-    category for the new locale. If the selection cannot be honored, the setlocale
-    function returns a null pointer and the program's locale is not changed.
-7   A null pointer for locale causes the setlocale function to return a pointer to the
-    string associated with the category for the program's current locale; the program's
-    locale is not changed.<sup><a href="#note197"><b>197)</b></a></sup>
-8   The pointer to string returned by the setlocale function is such that a subsequent call
-    with that string value and its associated category will restore that part of the program's
-    locale. The string pointed to shall not be modified by the program, but may be
-    overwritten by a subsequent call to the setlocale function.
-    Forward references: formatted input/output functions (<a href="#7.19.6">7.19.6</a>), multibyte/wide
-    character conversion functions (<a href="#7.20.7">7.20.7</a>), multibyte/wide string conversion functions
-    (<a href="#7.20.8">7.20.8</a>), numeric conversion functions (<a href="#7.20.1">7.20.1</a>), the strcoll function (<a href="#7.21.4.3">7.21.4.3</a>), the
-    strftime function (<a href="#7.23.3.5">7.23.3.5</a>), the strxfrm function (<a href="#7.21.4.5">7.21.4.5</a>).
-<a name="7.11.2" href="#7.11.2"><b>    7.11.2 Numeric formatting convention inquiry</b></a>
-<a name="7.11.2.1" href="#7.11.2.1"><b>    7.11.2.1 The localeconv function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.11">&lt;locale.h&gt;</a>
-            struct lconv *localeconv(void);
-<b>    Description</b>
-2   The localeconv function sets the components of an object with type struct lconv
-    with values appropriate for the formatting of numeric quantities (monetary and otherwise)
-    according to the rules of the current locale.
-3   The members of the structure with type char * are pointers to strings, any of which
-    (except decimal_point) can point to "", to indicate that the value is not available in
-    the current locale or is of zero length. Apart from grouping and mon_grouping, the
-
-    <sup><a name="note197" href="#note197"><b>197)</b></a></sup> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
-         locale when category has the value LC_ALL.
-
-[<a name="p206" href="#p206">page 206</a>] (<a href="#Contents">Contents</a>)
-
-strings shall start and end in the initial shift state. The members with type char are
-nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not
-available in the current locale. The members include the following:
-char *decimal_point
-          The decimal-point character used to format nonmonetary quantities.
-char *thousands_sep
-          The character used to separate groups of digits before the decimal-point
-          character in formatted nonmonetary quantities.
-char *grouping
-          A string whose elements indicate the size of each group of digits in
-          formatted nonmonetary quantities.
-char *mon_decimal_point
-          The decimal-point used to format monetary quantities.
-char *mon_thousands_sep
-          The separator for groups of digits before the decimal-point in formatted
-          monetary quantities.
-char *mon_grouping
-          A string whose elements indicate the size of each group of digits in
-          formatted monetary quantities.
-char *positive_sign
-          The string used to indicate a nonnegative-valued formatted monetary
-          quantity.
-char *negative_sign
-          The string used to indicate a negative-valued formatted monetary quantity.
-char *currency_symbol
-          The local currency symbol applicable to the current locale.
-char frac_digits
-          The number of fractional digits (those after the decimal-point) to be
-          displayed in a locally formatted monetary quantity.
-char p_cs_precedes
-          Set to 1 or 0 if the currency_symbol respectively precedes or
-          succeeds the value for a nonnegative locally formatted monetary quantity.
-char n_cs_precedes
-          Set to 1 or 0 if the currency_symbol respectively precedes or
-          succeeds the value for a negative locally formatted monetary quantity.
-
-[<a name="p207" href="#p207">page 207</a>] (<a href="#Contents">Contents</a>)
-
-char p_sep_by_space
-          Set to a value indicating the separation of the currency_symbol, the
-          sign string, and the value for a nonnegative locally formatted monetary
-          quantity.
-char n_sep_by_space
-          Set to a value indicating the separation of the currency_symbol, the
-          sign string, and the value for a negative locally formatted monetary
-          quantity.
-char p_sign_posn
-          Set to a value indicating the positioning of the positive_sign for a
-          nonnegative locally formatted monetary quantity.
-char n_sign_posn
-          Set to a value indicating the positioning of the negative_sign for a
-          negative locally formatted monetary quantity.
-char *int_curr_symbol
-          The international currency symbol applicable to the current locale. The
-          first three characters contain the alphabetic international currency symbol
-          in accordance with those specified in ISO 4217. The fourth character
-          (immediately preceding the null character) is the character used to separate
-          the international currency symbol from the monetary quantity.
-char int_frac_digits
-          The number of fractional digits (those after the decimal-point) to be
-          displayed in an internationally formatted monetary quantity.
-char int_p_cs_precedes
-          Set to 1 or 0 if the int_curr_symbol respectively precedes or
-          succeeds the value for a nonnegative internationally formatted monetary
-          quantity.
-char int_n_cs_precedes
-          Set to 1 or 0 if the int_curr_symbol respectively precedes or
-          succeeds the value for a negative internationally formatted monetary
-          quantity.
-char int_p_sep_by_space
-          Set to a value indicating the separation of the int_curr_symbol, the
-          sign string, and the value for a nonnegative internationally formatted
-          monetary quantity.
-
-[<a name="p208" href="#p208">page 208</a>] (<a href="#Contents">Contents</a>)
-
-    char int_n_sep_by_space
-              Set to a value indicating the separation of the int_curr_symbol, the
-              sign string, and the value for a negative internationally formatted monetary
-              quantity.
-    char int_p_sign_posn
-              Set to a value indicating the positioning of the positive_sign for a
-              nonnegative internationally formatted monetary quantity.
-    char int_n_sign_posn
-              Set to a value indicating the positioning of the negative_sign for a
-              negative internationally formatted monetary quantity.
-4   The elements of grouping and mon_grouping are interpreted according to the
-    following:
-    CHAR_MAX      No further grouping is to be performed.
-    0             The previous element is to be repeatedly used for the remainder of the
-                  digits.
-    other         The integer value is the number of digits that compose the current group.
-                  The next element is examined to determine the size of the next group of
-                  digits before the current group.
-5   The values of p_sep_by_space, n_sep_by_space, int_p_sep_by_space,
-    and int_n_sep_by_space are interpreted according to the following:
-    0   No space separates the currency symbol and value.
-    1   If the currency symbol and sign string are adjacent, a space separates them from the
-        value; otherwise, a space separates the currency symbol from the value.
-    2   If the currency symbol and sign string are adjacent, a space separates them;
-        otherwise, a space separates the sign string from the value.
-    For int_p_sep_by_space and int_n_sep_by_space, the fourth character of
-    int_curr_symbol is used instead of a space.
-6   The values of p_sign_posn, n_sign_posn, int_p_sign_posn,                            and
-    int_n_sign_posn are interpreted according to the following:
-    0   Parentheses surround the quantity and currency symbol.
-    1   The sign string precedes the quantity and currency symbol.
-    2   The sign string succeeds the quantity and currency symbol.
-    3   The sign string immediately precedes the currency symbol.
-    4   The sign string immediately succeeds the currency symbol.
-
-[<a name="p209" href="#p209">page 209</a>] (<a href="#Contents">Contents</a>)
-
-7    The implementation shall behave as if no library function calls the localeconv
-     function.
-<b>     Returns</b>
-8    The localeconv function returns a pointer to the filled-in object. The structure
-     pointed to by the return value shall not be modified by the program, but may be
-     overwritten by a subsequent call to the localeconv function. In addition, calls to the
-     setlocale function with categories LC_ALL, LC_MONETARY, or LC_NUMERIC may
-     overwrite the contents of the structure.
-9    EXAMPLE 1 The following table illustrates rules which may well be used by four countries to format
-     monetary quantities.
-                                   Local format                                     International format
-
-     Country            Positive                  Negative                    Positive               Negative
-
-     Country1     1.234,56 mk             -1.234,56 mk                  FIM   1.234,56         FIM -1.234,56
-     Country2     L.1.234                 -L.1.234                      ITL   1.234            -ITL 1.234
-     Country3     fl. 1.234,56              fl. -1.234,56                   NLG   1.234,56         NLG -1.234,56
-     Country4     SFrs.1,234.56           SFrs.1,234.56C                CHF   1,234.56         CHF 1,234.56C
-10   For these four countries, the respective values for the monetary members of the structure returned by
-     localeconv could be:
-                                       Country1              Country2              Country3            Country4
-
-     mon_decimal_point                 ","                   ""                   ","                 "."
-     mon_thousands_sep                 "."                   "."                  "."                 ","
-     mon_grouping                      "\3"                  "\3"                 "\3"                "\3"
-     positive_sign                     ""                    ""                   ""                  ""
-     negative_sign                     "-"                   "-"                  "-"                 "C"
-     currency_symbol                   "mk"                  "L."                 "\u0192"            "SFrs."
-     frac_digits                       2                     0                    2                   2
-     p_cs_precedes                     0                     1                    1                   1
-     n_cs_precedes                     0                     1                    1                   1
-     p_sep_by_space                    1                     0                    1                   0
-     n_sep_by_space                    1                     0                    2                   0
-     p_sign_posn                       1                     1                    1                   1
-     n_sign_posn                       1                     1                    4                   2
-     int_curr_symbol                   "FIM "                "ITL "               "NLG "              "CHF "
-     int_frac_digits                   2                     0                    2                   2
-     int_p_cs_precedes                 1                     1                    1                   1
-     int_n_cs_precedes                 1                     1                    1                   1
-     int_p_sep_by_space                1                     1                    1                   1
-     int_n_sep_by_space                2                     1                    2                   1
-     int_p_sign_posn                   1                     1                    1                   1
-     int_n_sign_posn                   4                     1                    4                   2
-
-[<a name="p210" href="#p210">page 210</a>] (<a href="#Contents">Contents</a>)
-
-11   EXAMPLE 2 The following table illustrates how the cs_precedes, sep_by_space, and sign_posn members
-     affect the formatted value.
-                                                                   p_sep_by_space
-
-     p_cs_precedes           p_sign_posn                0                   1                  2
-
-                     0                    0         (<a href="#1.25">1.25</a>$)            (<a href="#1.25">1.25</a> $)            (<a href="#1.25">1.25</a>$)
-                                          1         +1.25$             +1.25 $             + <a href="#1.25">1.25</a>$
-                                          2         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
-                                          3         <a href="#1.25">1.25</a>+$             <a href="#1.25">1.25</a> +$             <a href="#1.25">1.25</a>+ $
-                                          4         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
-
-                     1                    0         ($1.25)            ($ <a href="#1.25">1.25</a>)            ($1.25)
-                                          1         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
-                                          2         $1.25+             $ <a href="#1.25">1.25</a>+             $1.25 +
-                                          3         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
-                                          4         $+1.25             $+ <a href="#1.25">1.25</a>             $ +1.25
-
-[<a name="p211" href="#p211">page 211</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12" href="#7.12"><b>    7.12 Mathematics &lt;math.h&gt;</b></a>
-1   The header <a href="#7.12">&lt;math.h&gt;</a> declares two types and many mathematical functions and defines
-    several macros. Most synopses specify a family of functions consisting of a principal
-    function with one or more double parameters, a double return value, or both; and
-    other functions with the same name but with f and l suffixes, which are corresponding
-    functions with float and long double parameters, return values, or both.<sup><a href="#note198"><b>198)</b></a></sup>
-    Integer arithmetic functions and conversion functions are discussed later.
-2   The types
-            float_t
-            double_t
-    are floating types at least as wide as float and double, respectively, and such that
-    double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
-    float_t and double_t are float and double, respectively; if
-    FLT_EVAL_METHOD equals 1, they are both double; if FLT_EVAL_METHOD equals
-    2, they are both long double; and for other values of FLT_EVAL_METHOD, they are
-    otherwise implementation-defined.<sup><a href="#note199"><b>199)</b></a></sup>
-3   The macro
-            HUGE_VAL
-    expands to a positive double constant expression, not necessarily representable as a
-    float. The macros
-            HUGE_VALF
-            HUGE_VALL
-    are respectively float and long double analogs of HUGE_VAL.<sup><a href="#note200"><b>200)</b></a></sup>
-4   The macro
-            INFINITY
-    expands to a constant expression of type float representing positive or unsigned
-    infinity, if available; else to a positive constant of type float that overflows at
-
-
-
-    <sup><a name="note198" href="#note198"><b>198)</b></a></sup> Particularly on systems with wide expression evaluation, a <a href="#7.12">&lt;math.h&gt;</a> function might pass arguments
-         and return values in wider format than the synopsis prototype indicates.
-    <sup><a name="note199" href="#note199"><b>199)</b></a></sup> The types float_t and double_t are intended to be the implementation's most efficient types at
-         least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
-         type float_t is the narrowest type used by the implementation to evaluate floating expressions.
-    <sup><a name="note200" href="#note200"><b>200)</b></a></sup> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
-         supports infinities.
-
-[<a name="p212" href="#p212">page 212</a>] (<a href="#Contents">Contents</a>)
-
-    translation time.<sup><a href="#note201"><b>201)</b></a></sup>
-5   The macro
-             NAN
-    is defined if and only if the implementation supports quiet NaNs for the float type. It
-    expands to a constant expression of type float representing a quiet NaN.
-6   The number classification macros
-             FP_INFINITE
-             FP_NAN
-             FP_NORMAL
-             FP_SUBNORMAL
-             FP_ZERO
-    represent the mutually exclusive kinds of floating-point values. They expand to integer
-    constant expressions with distinct values. Additional implementation-defined floating-
-    point classifications, with macro definitions beginning with FP_ and an uppercase letter,
-    may also be specified by the implementation.
-7   The macro
-             FP_FAST_FMA
-    is optionally defined. If defined, it indicates that the fma function generally executes
-    about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note202"><b>202)</b></a></sup> The
-    macros
-             FP_FAST_FMAF
-             FP_FAST_FMAL
-    are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
-    these macros expand to the integer constant 1.
-8   The macros
-             FP_ILOGB0
-             FP_ILOGBNAN
-    expand to integer constant expressions whose values are returned by ilogb(x) if x is
-    zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
-    -INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
-
-
-    <sup><a name="note201" href="#note201"><b>201)</b></a></sup> In this case, using INFINITY will violate the constraint in <a href="#6.4.4">6.4.4</a> and thus require a diagnostic.
-    <sup><a name="note202" href="#note202"><b>202)</b></a></sup> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
-         directly with a hardware multiply-add instruction. Software implementations are expected to be
-         substantially slower.
-
-[<a name="p213" href="#p213">page 213</a>] (<a href="#Contents">Contents</a>)
-
-9   The macros
-            MATH_ERRNO
-            MATH_ERREXCEPT
-    expand to the integer constants 1 and 2, respectively; the macro
-            math_errhandling
-    expands to an expression that has type int and the value MATH_ERRNO,
-    MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
-    constant for the duration of the program. It is unspecified whether
-    math_errhandling is a macro or an identifier with external linkage. If a macro
-    definition is suppressed or a program defines an identifier with the name
-    math_errhandling, the behavior is undefined.               If the expression
-    math_errhandling &amp; MATH_ERREXCEPT can be nonzero, the implementation
-    shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
-    <a href="#7.6">&lt;fenv.h&gt;</a>.
-<a name="7.12.1" href="#7.12.1"><b>    7.12.1 Treatment of error conditions</b></a>
-1   The behavior of each of the functions in <a href="#7.12">&lt;math.h&gt;</a> is specified for all representable
-    values of its input arguments, except where stated otherwise. Each function shall execute
-    as if it were a single operation without generating any externally visible exceptional
-    conditions.
-2   For all functions, a domain error occurs if an input argument is outside the domain over
-    which the mathematical function is defined. The description of each function lists any
-    required domain errors; an implementation may define additional domain errors, provided
-    that such errors are consistent with the mathematical definition of the function.<sup><a href="#note203"><b>203)</b></a></sup> On a
-    domain error, the function returns an implementation-defined value; if the integer
-    expression math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression
-    errno acquires the value EDOM; if the integer expression math_errhandling &amp;
-    MATH_ERREXCEPT is nonzero, the ''invalid'' floating-point exception is raised.
-3   Similarly, a range error occurs if the mathematical result of the function cannot be
-    represented in an object of the specified type, due to extreme magnitude.
-4   A floating result overflows if the magnitude of the mathematical result is finite but so
-    large that the mathematical result cannot be represented without extraordinary roundoff
-    error in an object of the specified type. If a floating result overflows and default rounding
-    is in effect, or if the mathematical result is an exact infinity from finite arguments (for
-    example log(0.0)), then the function returns the value of the macro HUGE_VAL,
-
-
-    <sup><a name="note203" href="#note203"><b>203)</b></a></sup> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
-         error if the mathematical domain of the function does not include the infinity.
-
-[<a name="p214" href="#p214">page 214</a>] (<a href="#Contents">Contents</a>)
-
-    HUGE_VALF, or HUGE_VALL according to the return type, with the same sign as the
-    correct value of the function; if the integer expression math_errhandling &amp;
-    MATH_ERRNO is nonzero, the integer expression errno acquires the value ERANGE; if
-    the integer expression math_errhandling &amp; MATH_ERREXCEPT is nonzero, the
-    ''divide-by-zero'' floating-point exception is raised if the mathematical result is an exact
-    infinity and the ''overflow'' floating-point exception is raised otherwise.
-5   The result underflows if the magnitude of the mathematical result is so small that the
-    mathematical result cannot be represented, without extraordinary roundoff error, in an
-    object of the specified type.<sup><a href="#note204"><b>204)</b></a></sup> If the result underflows, the function returns an
-    implementation-defined value whose magnitude is no greater than the smallest
-    normalized positive number in the specified type; if the integer expression
-    math_errhandling &amp; MATH_ERRNO is nonzero, whether errno acquires the
-    value    ERANGE       is    implementation-defined;     if   the  integer   expression
-    math_errhandling &amp; MATH_ERREXCEPT is nonzero, whether the ''underflow''
-    floating-point exception is raised is implementation-defined.
-<a name="7.12.2" href="#7.12.2"><b>    7.12.2 The FP_CONTRACT pragma</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            #pragma STDC FP_CONTRACT on-off-switch
-<b>    Description</b>
-2   The FP_CONTRACT pragma can be used to allow (if the state is ''on'') or disallow (if the
-    state is ''off'') the implementation to contract expressions (<a href="#6.5">6.5</a>). Each pragma can occur
-    either outside external declarations or preceding all explicit declarations and statements
-    inside a compound statement. When outside external declarations, the pragma takes
-    effect from its occurrence until another FP_CONTRACT pragma is encountered, or until
-    the end of the translation unit. When inside a compound statement, the pragma takes
-    effect from its occurrence until another FP_CONTRACT pragma is encountered
-    (including within a nested compound statement), or until the end of the compound
-    statement; at the end of a compound statement the state for the pragma is restored to its
-    condition just before the compound statement. If this pragma is used in any other
-    context, the behavior is undefined. The default state (''on'' or ''off'') for the pragma is
-    implementation-defined.
-
-
-
-
-    <sup><a name="note204" href="#note204"><b>204)</b></a></sup> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
-         also ''flush-to-zero'' underflow.
-
-[<a name="p215" href="#p215">page 215</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.3" href="#7.12.3"><b>    7.12.3 Classification macros</b></a>
-1   In the synopses in this subclause, real-floating indicates that the argument shall be an
-    expression of real floating type.
-<a name="7.12.3.1" href="#7.12.3.1"><b>    7.12.3.1 The fpclassify macro</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             int fpclassify(real-floating x);
-<b>    Description</b>
-2   The fpclassify macro classifies its argument value as NaN, infinite, normal,
-    subnormal, zero, or into another implementation-defined category. First, an argument
-    represented in a format wider than its semantic type is converted to its semantic type.
-    Then classification is based on the type of the argument.<sup><a href="#note205"><b>205)</b></a></sup>
-<b>    Returns</b>
-3   The fpclassify macro returns the value of the number classification macro
-    appropriate to the value of its argument.
-4   EXAMPLE        The fpclassify macro might be implemented in terms of ordinary functions as
-             #define fpclassify(x) \
-                   ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) : \
-                    (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) : \
-                                                      __fpclassifyl(x))
-
-<a name="7.12.3.2" href="#7.12.3.2"><b>    7.12.3.2 The isfinite macro</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             int isfinite(real-floating x);
-<b>    Description</b>
-2   The isfinite macro determines whether its argument has a finite value (zero,
-    subnormal, or normal, and not infinite or NaN). First, an argument represented in a
-    format wider than its semantic type is converted to its semantic type. Then determination
-    is based on the type of the argument.
-
-
-
-
-    <sup><a name="note205" href="#note205"><b>205)</b></a></sup> Since an expression can be evaluated with more range and precision than its type has, it is important to
-         know the type that classification is based on. For example, a normal long double value might
-         become subnormal when converted to double, and zero when converted to float.
-
-[<a name="p216" href="#p216">page 216</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The isfinite macro returns a nonzero value if and only if its argument has a finite
-    value.
-<a name="7.12.3.3" href="#7.12.3.3"><b>    7.12.3.3 The isinf macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isinf(real-floating x);
-<b>    Description</b>
-2   The isinf macro determines whether its argument value is an infinity (positive or
-    negative). First, an argument represented in a format wider than its semantic type is
-    converted to its semantic type. Then determination is based on the type of the argument.
-<b>    Returns</b>
-3   The isinf macro returns a nonzero value if and only if its argument has an infinite
-    value.
-<a name="7.12.3.4" href="#7.12.3.4"><b>    7.12.3.4 The isnan macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isnan(real-floating x);
-<b>    Description</b>
-2   The isnan macro determines whether its argument value is a NaN. First, an argument
-    represented in a format wider than its semantic type is converted to its semantic type.
-    Then determination is based on the type of the argument.<sup><a href="#note206"><b>206)</b></a></sup>
-<b>    Returns</b>
-3   The isnan macro returns a nonzero value if and only if its argument has a NaN value.
-<a name="7.12.3.5" href="#7.12.3.5"><b>    7.12.3.5 The isnormal macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isnormal(real-floating x);
-
-
-
-
-    <sup><a name="note206" href="#note206"><b>206)</b></a></sup> For the isnan macro, the type for determination does not matter unless the implementation supports
-         NaNs in the evaluation type but not in the semantic type.
-
-[<a name="p217" href="#p217">page 217</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The isnormal macro determines whether its argument value is normal (neither zero,
-    subnormal, infinite, nor NaN). First, an argument represented in a format wider than its
-    semantic type is converted to its semantic type. Then determination is based on the type
-    of the argument.
-<b>    Returns</b>
-3   The isnormal macro returns a nonzero value if and only if its argument has a normal
-    value.
-<a name="7.12.3.6" href="#7.12.3.6"><b>    7.12.3.6 The signbit macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int signbit(real-floating x);
-<b>    Description</b>
-2   The signbit macro determines whether the sign of its argument value is negative.<sup><a href="#note207"><b>207)</b></a></sup>
-<b>    Returns</b>
-3   The signbit macro returns a nonzero value if and only if the sign of its argument value
-    is negative.
-<a name="7.12.4" href="#7.12.4"><b>    7.12.4 Trigonometric functions</b></a>
-<a name="7.12.4.1" href="#7.12.4.1"><b>    7.12.4.1 The acos functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double acos(double x);
-            float acosf(float x);
-            long double acosl(long double x);
-<b>    Description</b>
-2   The acos functions compute the principal value of the arc cosine of x. A domain error
-    occurs for arguments not in the interval [-1, +1].
-<b>    Returns</b>
-3   The acos functions return arccos x in the interval [0, pi ] radians.
-
-
-
-
-    <sup><a name="note207" href="#note207"><b>207)</b></a></sup> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
-         unsigned, it is treated as positive.
-
-[<a name="p218" href="#p218">page 218</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.4.2" href="#7.12.4.2"><b>    7.12.4.2 The asin functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double asin(double x);
-           float asinf(float x);
-           long double asinl(long double x);
-<b>    Description</b>
-2   The asin functions compute the principal value of the arc sine of x. A domain error
-    occurs for arguments not in the interval [-1, +1].
-<b>    Returns</b>
-3   The asin functions return arcsin x in the interval [-pi /2, +pi /2] radians.
-<a name="7.12.4.3" href="#7.12.4.3"><b>    7.12.4.3 The atan functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double atan(double x);
-           float atanf(float x);
-           long double atanl(long double x);
-<b>    Description</b>
-2   The atan functions compute the principal value of the arc tangent of x.
-<b>    Returns</b>
-3   The atan functions return arctan x in the interval [-pi /2, +pi /2] radians.
-<a name="7.12.4.4" href="#7.12.4.4"><b>    7.12.4.4 The atan2 functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double atan2(double y, double x);
-           float atan2f(float y, float x);
-           long double atan2l(long double y, long double x);
-<b>    Description</b>
-2   The atan2 functions compute the value of the arc tangent of y/x, using the signs of both
-    arguments to determine the quadrant of the return value. A domain error may occur if
-    both arguments are zero.
-<b>    Returns</b>
-3   The atan2 functions return arctan y/x in the interval [-pi , +pi ] radians.
-
-[<a name="p219" href="#p219">page 219</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.4.5" href="#7.12.4.5"><b>    7.12.4.5 The cos functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double cos(double x);
-           float cosf(float x);
-           long double cosl(long double x);
-<b>    Description</b>
-2   The cos functions compute the cosine of x (measured in radians).
-<b>    Returns</b>
-3   The cos functions return cos x.
-<a name="7.12.4.6" href="#7.12.4.6"><b>    7.12.4.6 The sin functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double sin(double x);
-           float sinf(float x);
-           long double sinl(long double x);
-<b>    Description</b>
-2   The sin functions compute the sine of x (measured in radians).
-<b>    Returns</b>
-3   The sin functions return sin x.
-<a name="7.12.4.7" href="#7.12.4.7"><b>    7.12.4.7 The tan functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double tan(double x);
-           float tanf(float x);
-           long double tanl(long double x);
-<b>    Description</b>
-2   The tan functions return the tangent of x (measured in radians).
-<b>    Returns</b>
-3   The tan functions return tan x.
-
-[<a name="p220" href="#p220">page 220</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.5" href="#7.12.5"><b>    7.12.5 Hyperbolic functions</b></a>
-<a name="7.12.5.1" href="#7.12.5.1"><b>    7.12.5.1 The acosh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double acosh(double x);
-           float acoshf(float x);
-           long double acoshl(long double x);
-<b>    Description</b>
-2   The acosh functions compute the (nonnegative) arc hyperbolic cosine of x. A domain
-    error occurs for arguments less than 1.
-<b>    Returns</b>
-3   The acosh functions return arcosh x in the interval [0, +(inf)].
-<a name="7.12.5.2" href="#7.12.5.2"><b>    7.12.5.2 The asinh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double asinh(double x);
-           float asinhf(float x);
-           long double asinhl(long double x);
-<b>    Description</b>
-2   The asinh functions compute the arc hyperbolic sine of x.
-<b>    Returns</b>
-3   The asinh functions return arsinh x.
-<a name="7.12.5.3" href="#7.12.5.3"><b>    7.12.5.3 The atanh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double atanh(double x);
-           float atanhf(float x);
-           long double atanhl(long double x);
-<b>    Description</b>
-2   The atanh functions compute the arc hyperbolic tangent of x. A domain error occurs
-    for arguments not in the interval [-1, +1]. A range error may occur if the argument
-    equals -1 or +1.
-
-[<a name="p221" href="#p221">page 221</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The atanh functions return artanh x.
-<a name="7.12.5.4" href="#7.12.5.4"><b>    7.12.5.4 The cosh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double cosh(double x);
-           float coshf(float x);
-           long double coshl(long double x);
-<b>    Description</b>
-2   The cosh functions compute the hyperbolic cosine of x. A range error occurs if the
-    magnitude of x is too large.
-<b>    Returns</b>
-3   The cosh functions return cosh x.
-<a name="7.12.5.5" href="#7.12.5.5"><b>    7.12.5.5 The sinh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double sinh(double x);
-           float sinhf(float x);
-           long double sinhl(long double x);
-<b>    Description</b>
-2   The sinh functions compute the hyperbolic sine of x. A range error occurs if the
-    magnitude of x is too large.
-<b>    Returns</b>
-3   The sinh functions return sinh x.
-<a name="7.12.5.6" href="#7.12.5.6"><b>    7.12.5.6 The tanh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double tanh(double x);
-           float tanhf(float x);
-           long double tanhl(long double x);
-<b>    Description</b>
-2   The tanh functions compute the hyperbolic tangent of x.
-
-[<a name="p222" href="#p222">page 222</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The tanh functions return tanh x.
-<a name="7.12.6" href="#7.12.6"><b>    7.12.6 Exponential and logarithmic functions</b></a>
-<a name="7.12.6.1" href="#7.12.6.1"><b>    7.12.6.1 The exp functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double exp(double x);
-           float expf(float x);
-           long double expl(long double x);
-<b>    Description</b>
-2   The exp functions compute the base-e exponential of x. A range error occurs if the
-    magnitude of x is too large.
-<b>    Returns</b>
-3   The exp functions return ex .
-<a name="7.12.6.2" href="#7.12.6.2"><b>    7.12.6.2 The exp2 functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double exp2(double x);
-           float exp2f(float x);
-           long double exp2l(long double x);
-<b>    Description</b>
-2   The exp2 functions compute the base-2 exponential of x. A range error occurs if the
-    magnitude of x is too large.
-<b>    Returns</b>
-3   The exp2 functions return 2x .
-<a name="7.12.6.3" href="#7.12.6.3"><b>    7.12.6.3 The expm1 functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double expm1(double x);
-           float expm1f(float x);
-           long double expm1l(long double x);
-
-[<a name="p223" href="#p223">page 223</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The expm1 functions compute the base-e exponential of the argument, minus 1. A range
-    error occurs if x is too large.<sup><a href="#note208"><b>208)</b></a></sup>
-<b>    Returns</b>
-3   The expm1 functions return ex - 1.
-<a name="7.12.6.4" href="#7.12.6.4"><b>    7.12.6.4 The frexp functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double frexp(double value, int *exp);
-            float frexpf(float value, int *exp);
-            long double frexpl(long double value, int *exp);
-<b>    Description</b>
-2   The frexp functions break a floating-point number into a normalized fraction and an
-    integral power of 2. They store the integer in the int object pointed to by exp.
-<b>    Returns</b>
-3   If value is not a floating-point number, the results are unspecified. Otherwise, the
-    frexp functions return the value x, such that x has a magnitude in the interval [1/2, 1) or
-    zero, and value equals x x 2*exp . If value is zero, both parts of the result are zero.
-<a name="7.12.6.5" href="#7.12.6.5"><b>    7.12.6.5 The ilogb functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int ilogb(double x);
-            int ilogbf(float x);
-            int ilogbl(long double x);
-<b>    Description</b>
-2   The ilogb functions extract the exponent of x as a signed int value. If x is zero they
-    compute the value FP_ILOGB0; if x is infinite they compute the value INT_MAX; if x is
-    a NaN they compute the value FP_ILOGBNAN; otherwise, they are equivalent to calling
-    the corresponding logb function and casting the returned value to type int. A domain
-    error or range error may occur if x is zero, infinite, or NaN. If the correct value is outside
-    the range of the return type, the numeric result is unspecified.
-
-
-
-
-    <sup><a name="note208" href="#note208"><b>208)</b></a></sup> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
-
-[<a name="p224" href="#p224">page 224</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The ilogb functions return the exponent of x as a signed int value.
-    Forward references: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
-<a name="7.12.6.6" href="#7.12.6.6"><b>    7.12.6.6 The ldexp functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double ldexp(double x, int exp);
-           float ldexpf(float x, int exp);
-           long double ldexpl(long double x, int exp);
-<b>    Description</b>
-2   The ldexp functions multiply a floating-point number by an integral power of 2. A
-    range error may occur.
-<b>    Returns</b>
-3   The ldexp functions return x x 2exp .
-<a name="7.12.6.7" href="#7.12.6.7"><b>    7.12.6.7 The log functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double log(double x);
-           float logf(float x);
-           long double logl(long double x);
-<b>    Description</b>
-2   The log functions compute the base-e (natural) logarithm of x. A domain error occurs if
-    the argument is negative. A range error may occur if the argument is zero.
-<b>    Returns</b>
-3   The log functions return loge x.
-<a name="7.12.6.8" href="#7.12.6.8"><b>    7.12.6.8 The log10 functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double log10(double x);
-           float log10f(float x);
-           long double log10l(long double x);
-
-[<a name="p225" href="#p225">page 225</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The log10 functions compute the base-10 (common) logarithm of x. A domain error
-    occurs if the argument is negative. A range error may occur if the argument is zero.
-<b>    Returns</b>
-3   The log10 functions return log10 x.
-<a name="7.12.6.9" href="#7.12.6.9"><b>    7.12.6.9 The log1p functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double log1p(double x);
-            float log1pf(float x);
-            long double log1pl(long double x);
-<b>    Description</b>
-2   The log1p functions compute the base-e (natural) logarithm of 1 plus the argument.<sup><a href="#note209"><b>209)</b></a></sup>
-    A domain error occurs if the argument is less than -1. A range error may occur if the
-    argument equals -1.
-<b>    Returns</b>
-3   The log1p functions return loge (1 + x).
-<a name="7.12.6.10" href="#7.12.6.10"><b>    7.12.6.10 The log2 functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double log2(double x);
-            float log2f(float x);
-            long double log2l(long double x);
-<b>    Description</b>
-2   The log2 functions compute the base-2 logarithm of x. A domain error occurs if the
-    argument is less than zero. A range error may occur if the argument is zero.
-<b>    Returns</b>
-3   The log2 functions return log2 x.
-
-
-
-
-    <sup><a name="note209" href="#note209"><b>209)</b></a></sup> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
-
-[<a name="p226" href="#p226">page 226</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.6.11" href="#7.12.6.11"><b>    7.12.6.11 The logb functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double logb(double x);
-           float logbf(float x);
-           long double logbl(long double x);
-<b>    Description</b>
-2   The logb functions extract the exponent of x, as a signed integer value in floating-point
-    format. If x is subnormal it is treated as though it were normalized; thus, for positive
-    finite x,
-          1 &lt;= x x FLT_RADIX-logb(x) &lt; FLT_RADIX
-    A domain error or range error may occur if the argument is zero.
-<b>    Returns</b>
-3   The logb functions return the signed exponent of x.
-<a name="7.12.6.12" href="#7.12.6.12"><b>    7.12.6.12 The modf functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double modf(double value, double *iptr);
-           float modff(float value, float *iptr);
-           long double modfl(long double value, long double *iptr);
-<b>    Description</b>
-2   The modf functions break the argument value into integral and fractional parts, each of
-    which has the same type and sign as the argument. They store the integral part (in
-    floating-point format) in the object pointed to by iptr.
-<b>    Returns</b>
-3   The modf functions return the signed fractional part of value.
-
-[<a name="p227" href="#p227">page 227</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.6.13" href="#7.12.6.13"><b>    7.12.6.13 The scalbn and scalbln functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double scalbn(double x, int n);
-           float scalbnf(float x, int n);
-           long double scalbnl(long double x, int n);
-           double scalbln(double x, long int n);
-           float scalblnf(float x, long int n);
-           long double scalblnl(long double x, long int n);
-<b>    Description</b>
-2   The scalbn and scalbln functions compute x x FLT_RADIXn efficiently, not
-    normally by computing FLT_RADIXn explicitly. A range error may occur.
-<b>    Returns</b>
-3   The scalbn and scalbln functions return x x FLT_RADIXn .
-<a name="7.12.7" href="#7.12.7"><b>    7.12.7 Power and absolute-value functions</b></a>
-<a name="7.12.7.1" href="#7.12.7.1"><b>    7.12.7.1 The cbrt functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double cbrt(double x);
-           float cbrtf(float x);
-           long double cbrtl(long double x);
-<b>    Description</b>
-2   The cbrt functions compute the real cube root of x.
-<b>    Returns</b>
-3   The cbrt functions return x1/3 .
-<a name="7.12.7.2" href="#7.12.7.2"><b>    7.12.7.2 The fabs functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double fabs(double x);
-           float fabsf(float x);
-           long double fabsl(long double x);
-<b>    Description</b>
-2   The fabs functions compute the absolute value of a floating-point number x.
-
-[<a name="p228" href="#p228">page 228</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The fabs functions return | x |.
-<a name="7.12.7.3" href="#7.12.7.3"><b>    7.12.7.3 The hypot functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double hypot(double x, double y);
-           float hypotf(float x, float y);
-           long double hypotl(long double x, long double y);
-<b>    Description</b>
-2   The hypot functions compute the square root of the sum of the squares of x and y,
-    without undue overflow or underflow. A range error may occur.
-3   Returns
-4   The hypot functions return (sqrt)x2 + y2 .
-                               ???
-                               ???????????????
-<a name="7.12.7.4" href="#7.12.7.4"><b>    7.12.7.4 The pow functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double pow(double x, double y);
-           float powf(float x, float y);
-           long double powl(long double x, long double y);
-<b>    Description</b>
-2   The pow functions compute x raised to the power y. A domain error occurs if x is finite
-    and negative and y is finite and not an integer value. A range error may occur. A domain
-    error may occur if x is zero and y is zero. A domain error or range error may occur if x
-    is zero and y is less than zero.
-<b>    Returns</b>
-3   The pow functions return xy .
-<a name="7.12.7.5" href="#7.12.7.5"><b>    7.12.7.5 The sqrt functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double sqrt(double x);
-           float sqrtf(float x);
-           long double sqrtl(long double x);
-
-[<a name="p229" href="#p229">page 229</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The sqrt functions compute the nonnegative square root of x. A domain error occurs if
-    the argument is less than zero.
-<b>    Returns</b>
-3   The sqrt functions return (sqrt)x.
-                              ???
-                              ???
-<a name="7.12.8" href="#7.12.8"><b>    7.12.8 Error and gamma functions</b></a>
-<a name="7.12.8.1" href="#7.12.8.1"><b>    7.12.8.1 The erf functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double erf(double x);
-           float erff(float x);
-           long double erfl(long double x);
-<b>    Description</b>
-2   The erf functions compute the error function of x.
-<b>    Returns</b>
-                                       2        x
-                                            (integral)
-3
-    The erf functions return erf x =                e-t dt.
-                                                      2
-
-
-                                       (sqrt)pi
-                                       ???
-                                       ???    0
-
-<a name="7.12.8.2" href="#7.12.8.2"><b>    7.12.8.2 The erfc functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double erfc(double x);
-           float erfcf(float x);
-           long double erfcl(long double x);
-<b>    Description</b>
-2   The erfc functions compute the complementary error function of x. A range error
-    occurs if x is too large.
-<b>    Returns</b>
-                                                              2        (inf)
-                                                                   (integral)
-3
-    The erfc functions return erfc x = 1 - erf x =                         e-t dt.
-                                                                             2
-
-
-                                                              (sqrt)pi
-                                                              ???
-                                                              ???    x
-
-[<a name="p230" href="#p230">page 230</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.8.3" href="#7.12.8.3"><b>    7.12.8.3 The lgamma functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double lgamma(double x);
-           float lgammaf(float x);
-           long double lgammal(long double x);
-<b>    Description</b>
-2   The lgamma functions compute the natural logarithm of the absolute value of gamma of
-    x. A range error occurs if x is too large. A range error may occur if x is a negative
-    integer or zero.
-<b>    Returns</b>
-3   The lgamma functions return loge | (Gamma)(x) |.
-<a name="7.12.8.4" href="#7.12.8.4"><b>    7.12.8.4 The tgamma functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double tgamma(double x);
-           float tgammaf(float x);
-           long double tgammal(long double x);
-<b>    Description</b>
-2   The tgamma functions compute the gamma function of x. A domain error or range error
-    may occur if x is a negative integer or zero. A range error may occur if the magnitude of
-    x is too large or too small.
-<b>    Returns</b>
-3   The tgamma functions return (Gamma)(x).
-<a name="7.12.9" href="#7.12.9"><b>    7.12.9 Nearest integer functions</b></a>
-<a name="7.12.9.1" href="#7.12.9.1"><b>    7.12.9.1 The ceil functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double ceil(double x);
-           float ceilf(float x);
-           long double ceill(long double x);
-<b>    Description</b>
-2   The ceil functions compute the smallest integer value not less than x.
-
-[<a name="p231" href="#p231">page 231</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The ceil functions return ???x???, expressed as a floating-point number.
-<a name="7.12.9.2" href="#7.12.9.2"><b>    7.12.9.2 The floor functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double floor(double x);
-           float floorf(float x);
-           long double floorl(long double x);
-<b>    Description</b>
-2   The floor functions compute the largest integer value not greater than x.
-<b>    Returns</b>
-3   The floor functions return ???x???, expressed as a floating-point number.
-<a name="7.12.9.3" href="#7.12.9.3"><b>    7.12.9.3 The nearbyint functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double nearbyint(double x);
-           float nearbyintf(float x);
-           long double nearbyintl(long double x);
-<b>    Description</b>
-2   The nearbyint functions round their argument to an integer value in floating-point
-    format, using the current rounding direction and without raising the ''inexact'' floating-
-    point exception.
-<b>    Returns</b>
-3   The nearbyint functions return the rounded integer value.
-<a name="7.12.9.4" href="#7.12.9.4"><b>    7.12.9.4 The rint functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double rint(double x);
-           float rintf(float x);
-           long double rintl(long double x);
-<b>    Description</b>
-2   The rint functions differ from the nearbyint functions (<a href="#7.12.9.3">7.12.9.3</a>) only in that the
-    rint functions may raise the ''inexact'' floating-point exception if the result differs in
-    value from the argument.
-
-[<a name="p232" href="#p232">page 232</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The rint functions return the rounded integer value.
-<a name="7.12.9.5" href="#7.12.9.5"><b>    7.12.9.5 The lrint and llrint functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           long int lrint(double x);
-           long int lrintf(float x);
-           long int lrintl(long double x);
-           long long int llrint(double x);
-           long long int llrintf(float x);
-           long long int llrintl(long double x);
-<b>    Description</b>
-2   The lrint and llrint functions round their argument to the nearest integer value,
-    rounding according to the current rounding direction. If the rounded value is outside the
-    range of the return type, the numeric result is unspecified and a domain error or range
-    error may occur.                                                                          *
-<b>    Returns</b>
-3   The lrint and llrint functions return the rounded integer value.
-<a name="7.12.9.6" href="#7.12.9.6"><b>    7.12.9.6 The round functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double round(double x);
-           float roundf(float x);
-           long double roundl(long double x);
-<b>    Description</b>
-2   The round functions round their argument to the nearest integer value in floating-point
-    format, rounding halfway cases away from zero, regardless of the current rounding
-    direction.
-<b>    Returns</b>
-3   The round functions return the rounded integer value.
-
-[<a name="p233" href="#p233">page 233</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.9.7" href="#7.12.9.7"><b>    7.12.9.7 The lround and llround functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           long int lround(double x);
-           long int lroundf(float x);
-           long int lroundl(long double x);
-           long long int llround(double x);
-           long long int llroundf(float x);
-           long long int llroundl(long double x);
-<b>    Description</b>
-2   The lround and llround functions round their argument to the nearest integer value,
-    rounding halfway cases away from zero, regardless of the current rounding direction. If
-    the rounded value is outside the range of the return type, the numeric result is unspecified
-    and a domain error or range error may occur.
-<b>    Returns</b>
-3   The lround and llround functions return the rounded integer value.
-<a name="7.12.9.8" href="#7.12.9.8"><b>    7.12.9.8 The trunc functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double trunc(double x);
-           float truncf(float x);
-           long double truncl(long double x);
-<b>    Description</b>
-2   The trunc functions round their argument to the integer value, in floating format,
-    nearest to but no larger in magnitude than the argument.
-<b>    Returns</b>
-3   The trunc functions return the truncated integer value.
-
-[<a name="p234" href="#p234">page 234</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.10" href="#7.12.10"><b>    7.12.10 Remainder functions</b></a>
-<a name="7.12.10.1" href="#7.12.10.1"><b>    7.12.10.1 The fmod functions</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             double fmod(double x, double y);
-             float fmodf(float x, float y);
-             long double fmodl(long double x, long double y);
-<b>    Description</b>
-2   The fmod functions compute the floating-point remainder of x/y.
-<b>    Returns</b>
-3   The fmod functions return the value x - ny, for some integer n such that, if y is nonzero,
-    the result has the same sign as x and magnitude less than the magnitude of y. If y is zero,
-    whether a domain error occurs or the fmod functions return zero is implementation-
-    defined.
-<a name="7.12.10.2" href="#7.12.10.2"><b>    7.12.10.2 The remainder functions</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             double remainder(double x, double y);
-             float remainderf(float x, float y);
-             long double remainderl(long double x, long double y);
-<b>    Description</b>
-2   The remainder functions compute the remainder x REM y required by IEC 60559.<sup><a href="#note210"><b>210)</b></a></sup>
-<b>    Returns</b>
-3   The remainder functions return x REM y. If y is zero, whether a domain error occurs
-    or the functions return zero is implementation defined.
-
-
-
-
-    <sup><a name="note210" href="#note210"><b>210)</b></a></sup> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
-         mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
-         | n - x/y | = 1/2, then n is even. Thus, the remainder is always exact. If r = 0, its sign shall be that of
-         x.'' This definition is applicable for all implementations.
-
-[<a name="p235" href="#p235">page 235</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.10.3" href="#7.12.10.3"><b>    7.12.10.3 The remquo functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double remquo(double x, double y, int *quo);
-           float remquof(float x, float y, int *quo);
-           long double remquol(long double x, long double y,
-                int *quo);
-<b>    Description</b>
-2   The remquo functions compute the same remainder as the remainder functions. In
-    the object pointed to by quo they store a value whose sign is the sign of x/y and whose
-    magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where
-    n is an implementation-defined integer greater than or equal to 3.
-<b>    Returns</b>
-3   The remquo functions return x REM y. If y is zero, the value stored in the object
-    pointed to by quo is unspecified and whether a domain error occurs or the functions
-    return zero is implementation defined.
-<a name="7.12.11" href="#7.12.11"><b>    7.12.11 Manipulation functions</b></a>
-<a name="7.12.11.1" href="#7.12.11.1"><b>    7.12.11.1 The copysign functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double copysign(double x, double y);
-           float copysignf(float x, float y);
-           long double copysignl(long double x, long double y);
-<b>    Description</b>
-2   The copysign functions produce a value with the magnitude of x and the sign of y.
-    They produce a NaN (with the sign of y) if x is a NaN. On implementations that
-    represent a signed zero but do not treat negative zero consistently in arithmetic
-    operations, the copysign functions regard the sign of zero as positive.
-<b>    Returns</b>
-3   The copysign functions return a value with the magnitude of x and the sign of y.
-
-[<a name="p236" href="#p236">page 236</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.11.2" href="#7.12.11.2"><b>    7.12.11.2 The nan functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double nan(const char *tagp);
-            float nanf(const char *tagp);
-            long double nanl(const char *tagp);
-<b>    Description</b>
-2   The call nan("n-char-sequence") is equivalent to strtod("NAN(n-char-
-    sequence)",     (char**)       NULL); the call nan("") is equivalent to
-    strtod("NAN()", (char**) NULL). If tagp does not point to an n-char
-    sequence or an empty string, the call is equivalent to strtod("NAN", (char**)
-    NULL). Calls to nanf and nanl are equivalent to the corresponding calls to strtof
-    and strtold.
-<b>    Returns</b>
-3   The nan functions return a quiet NaN, if available, with content indicated through tagp.
-    If the implementation does not support quiet NaNs, the functions return zero.
-    Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>).
-<a name="7.12.11.3" href="#7.12.11.3"><b>    7.12.11.3 The nextafter functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double nextafter(double x, double y);
-            float nextafterf(float x, float y);
-            long double nextafterl(long double x, long double y);
-<b>    Description</b>
-2   The nextafter functions determine the next representable value, in the type of the
-    function, after x in the direction of y, where x and y are first converted to the type of the
-    function.<sup><a href="#note211"><b>211)</b></a></sup> The nextafter functions return y if x equals y. A range error may occur
-    if the magnitude of x is the largest finite value representable in the type and the result is
-    infinite or not representable in the type.
-<b>    Returns</b>
-3   The nextafter functions return the next representable value in the specified format
-    after x in the direction of y.
-
-
-    <sup><a name="note211" href="#note211"><b>211)</b></a></sup> The argument values are converted to the type of the function, even by a macro implementation of the
-         function.
-
-[<a name="p237" href="#p237">page 237</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.11.4" href="#7.12.11.4"><b>    7.12.11.4 The nexttoward functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double nexttoward(double x, long double y);
-            float nexttowardf(float x, long double y);
-            long double nexttowardl(long double x, long double y);
-<b>    Description</b>
-2   The nexttoward functions are equivalent to the nextafter functions except that the
-    second parameter has type long double and the functions return y converted to the
-    type of the function if x equals y.<sup><a href="#note212"><b>212)</b></a></sup>
-<a name="7.12.12" href="#7.12.12"><b>    7.12.12 Maximum, minimum, and positive difference functions</b></a>
-<a name="7.12.12.1" href="#7.12.12.1"><b>    7.12.12.1 The fdim functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fdim(double x, double y);
-            float fdimf(float x, float y);
-            long double fdiml(long double x, long double y);
-<b>    Description</b>
-2   The fdim functions determine the positive difference between their arguments:
-          ???x - y if x &gt; y
-          ???
-          ???+0     if x &lt;= y
-    A range error may occur.
-<b>    Returns</b>
-3   The fdim functions return the positive difference value.
-<a name="7.12.12.2" href="#7.12.12.2"><b>    7.12.12.2 The fmax functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fmax(double x, double y);
-            float fmaxf(float x, float y);
-            long double fmaxl(long double x, long double y);
-
-
-
-    <sup><a name="note212" href="#note212"><b>212)</b></a></sup> The result of the nexttoward functions is determined in the type of the function, without loss of
-         range or precision in a floating second argument.
-
-[<a name="p238" href="#p238">page 238</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The fmax functions determine the maximum numeric value of their arguments.<sup><a href="#note213"><b>213)</b></a></sup>
-<b>    Returns</b>
-3   The fmax functions return the maximum numeric value of their arguments.
-<a name="7.12.12.3" href="#7.12.12.3"><b>    7.12.12.3 The fmin functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fmin(double x, double y);
-            float fminf(float x, float y);
-            long double fminl(long double x, long double y);
-<b>    Description</b>
-2   The fmin functions determine the minimum numeric value of their arguments.<sup><a href="#note214"><b>214)</b></a></sup>
-<b>    Returns</b>
-3   The fmin functions return the minimum numeric value of their arguments.
-<a name="7.12.13" href="#7.12.13"><b>    7.12.13 Floating multiply-add</b></a>
-<a name="7.12.13.1" href="#7.12.13.1"><b>    7.12.13.1 The fma functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fma(double x, double y, double z);
-            float fmaf(float x, float y, float z);
-            long double fmal(long double x, long double y,
-                 long double z);
-<b>    Description</b>
-2   The fma functions compute (x x y) + z, rounded as one ternary operation: they compute
-    the value (as if) to infinite precision and round once to the result format, according to the
-    current rounding mode. A range error may occur.
-<b>    Returns</b>
-3   The fma functions return (x x y) + z, rounded as one ternary operation.
-
-
-
-
-    <sup><a name="note213" href="#note213"><b>213)</b></a></sup> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
-         fmax functions choose the numeric value. See <a href="#F.9.9.2">F.9.9.2</a>.
-    <sup><a name="note214" href="#note214"><b>214)</b></a></sup> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
-
-[<a name="p239" href="#p239">page 239</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.14" href="#7.12.14"><b>    7.12.14 Comparison macros</b></a>
-1   The relational and equality operators support the usual mathematical relationships
-    between numeric values. For any ordered pair of numeric values exactly one of the
-    relationships -- less, greater, and equal -- is true. Relational operators may raise the
-    ''invalid'' floating-point exception when argument values are NaNs. For a NaN and a
-    numeric value, or for two NaNs, just the unordered relationship is true.<sup><a href="#note215"><b>215)</b></a></sup> The following
-    subclauses provide macros that are quiet (non floating-point exception raising) versions
-    of the relational operators, and other comparison macros that facilitate writing efficient
-    code that accounts for NaNs without suffering the ''invalid'' floating-point exception. In
-    the synopses in this subclause, real-floating indicates that the argument shall be an
-    expression of real floating type.
-<a name="7.12.14.1" href="#7.12.14.1"><b>    7.12.14.1 The isgreater macro</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             int isgreater(real-floating x, real-floating y);
-<b>    Description</b>
-2   The isgreater macro determines whether its first argument is greater than its second
-    argument. The value of isgreater(x, y) is always equal to (x) &gt; (y); however,
-    unlike (x) &gt; (y), isgreater(x, y) does not raise the ''invalid'' floating-point
-    exception when x and y are unordered.
-<b>    Returns</b>
-3   The isgreater macro returns the value of (x) &gt; (y).
-<a name="7.12.14.2" href="#7.12.14.2"><b>    7.12.14.2 The isgreaterequal macro</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             int isgreaterequal(real-floating x, real-floating y);
-<b>    Description</b>
-2   The isgreaterequal macro determines whether its first argument is greater than or
-    equal to its second argument. The value of isgreaterequal(x, y) is always equal
-    to (x) &gt;= (y); however, unlike (x) &gt;= (y), isgreaterequal(x, y) does
-    not raise the ''invalid'' floating-point exception when x and y are unordered.
-
-
-
-    <sup><a name="note215" href="#note215"><b>215)</b></a></sup> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
-         the operands compare unordered, as an error indicator for programs written without consideration of
-         NaNs; the result in these cases is false.
-
-[<a name="p240" href="#p240">page 240</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The isgreaterequal macro returns the value of (x) &gt;= (y).
-<a name="7.12.14.3" href="#7.12.14.3"><b>    7.12.14.3 The isless macro</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           int isless(real-floating x, real-floating y);
-<b>    Description</b>
-2   The isless macro determines whether its first argument is less than its second
-    argument. The value of isless(x, y) is always equal to (x) &lt; (y); however,
-    unlike (x) &lt; (y), isless(x, y) does not raise the ''invalid'' floating-point
-    exception when x and y are unordered.
-<b>    Returns</b>
-3   The isless macro returns the value of (x) &lt; (y).
-<a name="7.12.14.4" href="#7.12.14.4"><b>    7.12.14.4 The islessequal macro</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           int islessequal(real-floating x, real-floating y);
-<b>    Description</b>
-2   The islessequal macro determines whether its first argument is less than or equal to
-    its second argument. The value of islessequal(x, y) is always equal to
-    (x) &lt;= (y); however, unlike (x) &lt;= (y), islessequal(x, y) does not raise
-    the ''invalid'' floating-point exception when x and y are unordered.
-<b>    Returns</b>
-3   The islessequal macro returns the value of (x) &lt;= (y).
-<a name="7.12.14.5" href="#7.12.14.5"><b>    7.12.14.5 The islessgreater macro</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           int islessgreater(real-floating x, real-floating y);
-<b>    Description</b>
-2   The islessgreater macro determines whether its first argument is less than or
-    greater than its second argument. The islessgreater(x, y) macro is similar to
-    (x) &lt; (y) || (x) &gt; (y); however, islessgreater(x, y) does not raise
-    the ''invalid'' floating-point exception when x and y are unordered (nor does it evaluate x
-    and y twice).
-
-[<a name="p241" href="#p241">page 241</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The islessgreater macro returns the value of (x) &lt; (y) || (x) &gt; (y).
-<a name="7.12.14.6" href="#7.12.14.6"><b>    7.12.14.6 The isunordered macro</b></a>
-<b>    Synopsis</b>
-1         #include <a href="#7.12">&lt;math.h&gt;</a>
-          int isunordered(real-floating x, real-floating y);
-<b>    Description</b>
-2   The isunordered macro determines whether its arguments are unordered.
-<b>    Returns</b>
-3   The isunordered macro returns 1 if its arguments are unordered and 0 otherwise.
-
-[<a name="p242" href="#p242">page 242</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.13" href="#7.13"><b>    7.13 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
-1   The header <a href="#7.13">&lt;setjmp.h&gt;</a> defines the macro setjmp, and declares one function and
-    one type, for bypassing the normal function call and return discipline.<sup><a href="#note216"><b>216)</b></a></sup>
-2   The type declared is
-            jmp_buf
-    which is an array type suitable for holding the information needed to restore a calling
-    environment. The environment of a call to the setjmp macro consists of information
-    sufficient for a call to the longjmp function to return execution to the correct block and
-    invocation of that block, were it called recursively. It does not include the state of the
-    floating-point status flags, of open files, or of any other component of the abstract
-    machine.
-3   It is unspecified whether setjmp is a macro or an identifier declared with external
-    linkage. If a macro definition is suppressed in order to access an actual function, or a
-    program defines an external identifier with the name setjmp, the behavior is undefined.
-<a name="7.13.1" href="#7.13.1"><b>    7.13.1 Save calling environment</b></a>
-<a name="7.13.1.1" href="#7.13.1.1"><b>    7.13.1.1 The setjmp macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.13">&lt;setjmp.h&gt;</a>
-            int setjmp(jmp_buf env);
-<b>    Description</b>
-2   The setjmp macro saves its calling environment in its jmp_buf argument for later use
-    by the longjmp function.
-<b>    Returns</b>
-3   If the return is from a direct invocation, the setjmp macro returns the value zero. If the
-    return is from a call to the longjmp function, the setjmp macro returns a nonzero
-    value.
-    Environmental limits
-4   An invocation of the setjmp macro shall appear only in one of the following contexts:
-    -- the entire controlling expression of a selection or iteration statement;
-    -- one operand of a relational or equality operator with the other operand an integer
-      constant expression, with the resulting expression being the entire controlling
-
-
-    <sup><a name="note216" href="#note216"><b>216)</b></a></sup> These functions are useful for dealing with unusual conditions encountered in a low-level function of
-         a program.
-
-[<a name="p243" href="#p243">page 243</a>] (<a href="#Contents">Contents</a>)
-
-        expression of a selection or iteration statement;
-    -- the operand of a unary ! operator with the resulting expression being the entire
-      controlling expression of a selection or iteration statement; or
-    -- the entire expression of an expression statement (possibly cast to void).
-5   If the invocation appears in any other context, the behavior is undefined.
-<a name="7.13.2" href="#7.13.2"><b>    7.13.2 Restore calling environment</b></a>
-<a name="7.13.2.1" href="#7.13.2.1"><b>    7.13.2.1 The longjmp function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.13">&lt;setjmp.h&gt;</a>
-             void longjmp(jmp_buf env, int val);
-<b>    Description</b>
-2   The longjmp function restores the environment saved by the most recent invocation of
-    the setjmp macro in the same invocation of the program with the corresponding
-    jmp_buf argument. If there has been no such invocation, or if the function containing
-    the invocation of the setjmp macro has terminated execution<sup><a href="#note217"><b>217)</b></a></sup> in the interim, or if the
-    invocation of the setjmp macro was within the scope of an identifier with variably
-    modified type and execution has left that scope in the interim, the behavior is undefined.
-3   All accessible objects have values, and all other components of the abstract machine<sup><a href="#note218"><b>218)</b></a></sup>
-    have state, as of the time the longjmp function was called, except that the values of
-    objects of automatic storage duration that are local to the function containing the
-    invocation of the corresponding setjmp macro that do not have volatile-qualified type
-    and have been changed between the setjmp invocation and longjmp call are
-    indeterminate.
-<b>    Returns</b>
-4   After longjmp is completed, program execution continues as if the corresponding
-    invocation of the setjmp macro had just returned the value specified by val. The
-    longjmp function cannot cause the setjmp macro to return the value 0; if val is 0,
-    the setjmp macro returns the value 1.
-5   EXAMPLE The longjmp function that returns control back to the point of the setjmp invocation
-    might cause memory associated with a variable length array object to be squandered.
-
-
-
-
-    <sup><a name="note217" href="#note217"><b>217)</b></a></sup> For example, by executing a return statement or because another longjmp call has caused a
-         transfer to a setjmp invocation in a function earlier in the set of nested calls.
-    <sup><a name="note218" href="#note218"><b>218)</b></a></sup> This includes, but is not limited to, the floating-point status flags and the state of open files.
-
-[<a name="p244" href="#p244">page 244</a>] (<a href="#Contents">Contents</a>)
-
-       #include <a href="#7.13">&lt;setjmp.h&gt;</a>
-       jmp_buf buf;
-       void g(int n);
-       void h(int n);
-       int n = 6;
-       void f(void)
-       {
-             int x[n];          // valid: f is not terminated
-             setjmp(buf);
-             g(n);
-       }
-       void g(int n)
-       {
-             int a[n];          // a may remain allocated
-             h(n);
-       }
-       void h(int n)
-       {
-             int b[n];          // b may remain allocated
-             longjmp(buf, 2);   // might cause memory loss
-       }
-
-[<a name="p245" href="#p245">page 245</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.14" href="#7.14"><b>    7.14 Signal handling &lt;signal.h&gt;</b></a>
-1   The header <a href="#7.14">&lt;signal.h&gt;</a> declares a type and two functions and defines several macros,
-    for handling various signals (conditions that may be reported during program execution).
-2   The type defined is
-            sig_atomic_t
-    which is the (possibly volatile-qualified) integer type of an object that can be accessed as
-    an atomic entity, even in the presence of asynchronous interrupts.
-3   The macros defined are
-            SIG_DFL
-            SIG_ERR
-            SIG_IGN
-    which expand to constant expressions with distinct values that have type compatible with
-    the second argument to, and the return value of, the signal function, and whose values
-    compare unequal to the address of any declarable function; and the following, which
-    expand to positive integer constant expressions with type int and distinct values that are
-    the signal numbers, each corresponding to the specified condition:
-            SIGABRT abnormal termination, such as is initiated by the abort function
-            SIGFPE         an erroneous arithmetic operation, such as zero divide or an operation
-                           resulting in overflow
-            SIGILL         detection of an invalid function image, such as an invalid instruction
-            SIGINT         receipt of an interactive attention signal
-            SIGSEGV an invalid access to storage
-            SIGTERM a termination request sent to the program
-4   An implementation need not generate any of these signals, except as a result of explicit
-    calls to the raise function. Additional signals and pointers to undeclarable functions,
-    with macro definitions beginning, respectively, with the letters SIG and an uppercase
-    letter or with SIG_ and an uppercase letter,<sup><a href="#note219"><b>219)</b></a></sup> may also be specified by the
-    implementation. The complete set of signals, their semantics, and their default handling
-    is implementation-defined; all signal numbers shall be positive.
-
-
-
-
-    <sup><a name="note219" href="#note219"><b>219)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>). The names of the signal numbers reflect the following terms
-         (respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
-         and termination.
-
-[<a name="p246" href="#p246">page 246</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.14.1" href="#7.14.1"><b>    7.14.1 Specify signal handling</b></a>
-<a name="7.14.1.1" href="#7.14.1.1"><b>    7.14.1.1 The signal function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.14">&lt;signal.h&gt;</a>
-            void (*signal(int sig, void (*func)(int)))(int);
-<b>    Description</b>
-2   The signal function chooses one of three ways in which receipt of the signal number
-    sig is to be subsequently handled. If the value of func is SIG_DFL, default handling
-    for that signal will occur. If the value of func is SIG_IGN, the signal will be ignored.
-    Otherwise, func shall point to a function to be called when that signal occurs. An
-    invocation of such a function because of a signal, or (recursively) of any further functions
-    called by that invocation (other than functions in the standard library), is called a signal
-    handler.
-3   When a signal occurs and func points to a function, it is implementation-defined
-    whether the equivalent of signal(sig, SIG_DFL); is executed or the
-    implementation prevents some implementation-defined set of signals (at least including
-    sig) from occurring until the current signal handling has completed; in the case of
-    SIGILL, the implementation may alternatively define that no action is taken. Then the
-    equivalent of (*func)(sig); is executed. If and when the function returns, if the
-    value of sig is SIGFPE, SIGILL, SIGSEGV, or any other implementation-defined
-    value corresponding to a computational exception, the behavior is undefined; otherwise
-    the program will resume execution at the point it was interrupted.
-4   If the signal occurs as the result of calling the abort or raise function, the signal
-    handler shall not call the raise function.
-5   If the signal occurs other than as the result of calling the abort or raise function, the
-    behavior is undefined if the signal handler refers to any object with static storage duration
-    other than by assigning a value to an object declared as volatile sig_atomic_t, or
-    the signal handler calls any function in the standard library other than the abort
-    function, the _Exit function, or the signal function with the first argument equal to
-    the signal number corresponding to the signal that caused the invocation of the handler.
-    Furthermore, if such a call to the signal function results in a SIG_ERR return, the
-    value of errno is indeterminate.<sup><a href="#note220"><b>220)</b></a></sup>
-6   At program startup, the equivalent of
-            signal(sig, SIG_IGN);
-
-
-    <sup><a name="note220" href="#note220"><b>220)</b></a></sup> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
-
-[<a name="p247" href="#p247">page 247</a>] (<a href="#Contents">Contents</a>)
-
-    may be executed for some signals selected in an implementation-defined manner; the
-    equivalent of
-           signal(sig, SIG_DFL);
-    is executed for all other signals defined by the implementation.
-7   The implementation shall behave as if no library function calls the signal function.
-<b>    Returns</b>
-8   If the request can be honored, the signal function returns the value of func for the
-    most recent successful call to signal for the specified signal sig. Otherwise, a value of
-    SIG_ERR is returned and a positive value is stored in errno.
-    Forward references: the abort function (<a href="#7.20.4.1">7.20.4.1</a>), the exit function (<a href="#7.20.4.3">7.20.4.3</a>), the
-    _Exit function (<a href="#7.20.4.4">7.20.4.4</a>).
-<a name="7.14.2" href="#7.14.2"><b>    7.14.2 Send signal</b></a>
-<a name="7.14.2.1" href="#7.14.2.1"><b>    7.14.2.1 The raise function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.14">&lt;signal.h&gt;</a>
-           int raise(int sig);
-<b>    Description</b>
-2   The raise function carries out the actions described in <a href="#7.14.1.1">7.14.1.1</a> for the signal sig. If a
-    signal handler is called, the raise function shall not return until after the signal handler
-    does.
-<b>    Returns</b>
-3   The raise function returns zero if successful, nonzero if unsuccessful.
-
-[<a name="p248" href="#p248">page 248</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.15" href="#7.15"><b>    7.15 Variable arguments &lt;stdarg.h&gt;</b></a>
-1   The header <a href="#7.15">&lt;stdarg.h&gt;</a> declares a type and defines four macros, for advancing
-    through a list of arguments whose number and types are not known to the called function
-    when it is translated.
-2   A function may be called with a variable number of arguments of varying types. As
-    described in <a href="#6.9.1">6.9.1</a>, its parameter list contains one or more parameters. The rightmost
-    parameter plays a special role in the access mechanism, and will be designated parmN in
-    this description.
-3   The type declared is
-            va_list
-    which is an object type suitable for holding information needed by the macros
-    va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
-    desired, the called function shall declare an object (generally referred to as ap in this
-    subclause) having type va_list. The object ap may be passed as an argument to
-    another function; if that function invokes the va_arg macro with parameter ap, the
-    value of ap in the calling function is indeterminate and shall be passed to the va_end
-    macro prior to any further reference to ap.<sup><a href="#note221"><b>221)</b></a></sup>
-<a name="7.15.1" href="#7.15.1"><b>    7.15.1 Variable argument list access macros</b></a>
-1   The va_start and va_arg macros described in this subclause shall be implemented
-    as macros, not functions. It is unspecified whether va_copy and va_end are macros or
-    identifiers declared with external linkage. If a macro definition is suppressed in order to
-    access an actual function, or a program defines an external identifier with the same name,
-    the behavior is undefined. Each invocation of the va_start and va_copy macros
-    shall be matched by a corresponding invocation of the va_end macro in the same
-    function.
-<a name="7.15.1.1" href="#7.15.1.1"><b>    7.15.1.1 The va_arg macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-            type va_arg(va_list ap, type);
-<b>    Description</b>
-2   The va_arg macro expands to an expression that has the specified type and the value of
-    the next argument in the call. The parameter ap shall have been initialized by the
-    va_start or va_copy macro (without an intervening invocation of the va_end
-
-    <sup><a name="note221" href="#note221"><b>221)</b></a></sup> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
-         case the original function may make further use of the original list after the other function returns.
-
-[<a name="p249" href="#p249">page 249</a>] (<a href="#Contents">Contents</a>)
-
-    macro for the same ap). Each invocation of the va_arg macro modifies ap so that the
-    values of successive arguments are returned in turn. The parameter type shall be a type
-    name specified such that the type of a pointer to an object that has the specified type can
-    be obtained simply by postfixing a * to type. If there is no actual next argument, or if
-    type is not compatible with the type of the actual next argument (as promoted according
-    to the default argument promotions), the behavior is undefined, except for the following
-    cases:
-    -- one type is a signed integer type, the other type is the corresponding unsigned integer
-      type, and the value is representable in both types;
-    -- one type is pointer to void and the other is a pointer to a character type.
-<b>    Returns</b>
-3   The first invocation of the va_arg macro after that of the va_start macro returns the
-    value of the argument after that specified by parmN . Successive invocations return the
-    values of the remaining arguments in succession.
-<a name="7.15.1.2" href="#7.15.1.2"><b>    7.15.1.2 The va_copy macro</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           void va_copy(va_list dest, va_list src);
-<b>    Description</b>
-2   The va_copy macro initializes dest as a copy of src, as if the va_start macro had
-    been applied to dest followed by the same sequence of uses of the va_arg macro as
-    had previously been used to reach the present state of src. Neither the va_copy nor
-    va_start macro shall be invoked to reinitialize dest without an intervening
-    invocation of the va_end macro for the same dest.
-<b>    Returns</b>
-3   The va_copy macro returns no value.
-<a name="7.15.1.3" href="#7.15.1.3"><b>    7.15.1.3 The va_end macro</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           void va_end(va_list ap);
-<b>    Description</b>
-2   The va_end macro facilitates a normal return from the function whose variable
-    argument list was referred to by the expansion of the va_start macro, or the function
-    containing the expansion of the va_copy macro, that initialized the va_list ap. The
-    va_end macro may modify ap so that it is no longer usable (without being reinitialized
-
-[<a name="p250" href="#p250">page 250</a>] (<a href="#Contents">Contents</a>)
-
-    by the va_start or va_copy macro). If there is no corresponding invocation of the
-    va_start or va_copy macro, or if the va_end macro is not invoked before the
-    return, the behavior is undefined.
-<b>    Returns</b>
-3   The va_end macro returns no value.
-<a name="7.15.1.4" href="#7.15.1.4"><b>    7.15.1.4 The va_start macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-            void va_start(va_list ap, parmN);
-<b>    Description</b>
-2   The va_start macro shall be invoked before any access to the unnamed arguments.
-3   The va_start macro initializes ap for subsequent use by the va_arg and va_end
-    macros. Neither the va_start nor va_copy macro shall be invoked to reinitialize ap
-    without an intervening invocation of the va_end macro for the same ap.
-4   The parameter parmN is the identifier of the rightmost parameter in the variable
-    parameter list in the function definition (the one just before the , ...). If the parameter
-    parmN is declared with the register storage class, with a function or array type, or
-    with a type that is not compatible with the type that results after application of the default
-    argument promotions, the behavior is undefined.
-<b>    Returns</b>
-5   The va_start macro returns no value.
-6   EXAMPLE 1 The function f1 gathers into an array a list of arguments that are pointers to strings (but not
-    more than MAXARGS arguments), then passes the array as a single argument to function f2. The number of
-    pointers is specified by the first argument to f1.
-            #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-            #define MAXARGS   31
-            void f1(int n_ptrs, ...)
-            {
-                  va_list ap;
-                  char *array[MAXARGS];
-                  int ptr_no = 0;
-
-[<a name="p251" href="#p251">page 251</a>] (<a href="#Contents">Contents</a>)
-
-                      if (n_ptrs &gt; MAXARGS)
-                            n_ptrs = MAXARGS;
-                      va_start(ap, n_ptrs);
-                      while (ptr_no &lt; n_ptrs)
-                            array[ptr_no++] = va_arg(ap, char *);
-                      va_end(ap);
-                      f2(n_ptrs, array);
-             }
-    Each call to f1 is required to have visible the definition of the function or a declaration such as
-             void f1(int, ...);
-
-7   EXAMPLE 2 The function f3 is similar, but saves the status of the variable argument list after the
-    indicated number of arguments; after f2 has been called once with the whole list, the trailing part of the list
-    is gathered again and passed to function f4.
-             #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-             #define MAXARGS 31
-             void f3(int n_ptrs, int f4_after, ...)
-             {
-                   va_list ap, ap_save;
-                   char *array[MAXARGS];
-                   int ptr_no = 0;
-                   if (n_ptrs &gt; MAXARGS)
-                         n_ptrs = MAXARGS;
-                   va_start(ap, f4_after);
-                   while (ptr_no &lt; n_ptrs) {
-                         array[ptr_no++] = va_arg(ap, char *);
-                         if (ptr_no == f4_after)
-                               va_copy(ap_save, ap);
-                   }
-                   va_end(ap);
-                   f2(n_ptrs, array);
-                      // Now process the saved copy.
-                      n_ptrs -= f4_after;
-                      ptr_no = 0;
-                      while (ptr_no &lt; n_ptrs)
-                            array[ptr_no++] = va_arg(ap_save, char *);
-                      va_end(ap_save);
-                      f4(n_ptrs, array);
-             }
-
-[<a name="p252" href="#p252">page 252</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.16" href="#7.16"><b>    7.16 Boolean type and values &lt;stdbool.h&gt;</b></a>
-1   The header <a href="#7.16">&lt;stdbool.h&gt;</a> defines four macros.
-2   The macro
-             bool
-    expands to _Bool.
-3   The remaining three macros are suitable for use in #if preprocessing directives. They
-    are
-             true
-    which expands to the integer constant 1,
-             false
-    which expands to the integer constant 0, and
-             __bool_true_false_are_defined
-    which expands to the integer constant 1.
-4   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
-    redefine the macros bool, true, and false.<sup><a href="#note222"><b>222)</b></a></sup>
-
-
-
-
-    <sup><a name="note222" href="#note222"><b>222)</b></a></sup> See ''future library directions'' (<a href="#7.26.7">7.26.7</a>).
-
-[<a name="p253" href="#p253">page 253</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.17" href="#7.17"><b>    7.17 Common definitions &lt;stddef.h&gt;</b></a>
-1   The following types and macros are defined in the standard header <a href="#7.17">&lt;stddef.h&gt;</a>. Some
-    are also defined in other headers, as noted in their respective subclauses.
-2   The types are
-           ptrdiff_t
-    which is the signed integer type of the result of subtracting two pointers;
-           size_t
-    which is the unsigned integer type of the result of the sizeof operator; and
-           wchar_t
-    which is an integer type whose range of values can represent distinct codes for all
-    members of the largest extended character set specified among the supported locales; the
-    null character shall have the code value zero. Each member of the basic character set
-    shall have a code value equal to its value when used as the lone character in an integer
-    character      constant     if     an      implementation      does      not      define
-    __STDC_MB_MIGHT_NEQ_WC__.
-3   The macros are
-           NULL
-    which expands to an implementation-defined null pointer constant; and
-           offsetof(type, member-designator)
-    which expands to an integer constant expression that has type size_t, the value of
-    which is the offset in bytes, to the structure member (designated by member-designator),
-    from the beginning of its structure (designated by type). The type and member designator
-    shall be such that given
-           static type t;
-    then the expression &amp;(t.member-designator) evaluates to an address constant. (If the
-    specified member is a bit-field, the behavior is undefined.)
-    Recommended practice
-4   The types used for size_t and ptrdiff_t should not have an integer conversion rank
-    greater than that of signed long int unless the implementation supports objects
-    large enough to make this necessary.
-    Forward references: localization (<a href="#7.11">7.11</a>).
-
-[<a name="p254" href="#p254">page 254</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.18" href="#7.18"><b>    7.18 Integer types &lt;stdint.h&gt;</b></a>
-1   The header <a href="#7.18">&lt;stdint.h&gt;</a> declares sets of integer types having specified widths, and
-    defines corresponding sets of macros.<sup><a href="#note223"><b>223)</b></a></sup> It also defines macros that specify limits of
-    integer types corresponding to types defined in other standard headers.
-2   Types are defined in the following categories:
-    -- integer types having certain exact widths;
-    -- integer types having at least certain specified widths;
-    -- fastest integer types having at least certain specified widths;
-    -- integer types wide enough to hold pointers to objects;
-    -- integer types having greatest width.
-    (Some of these types may denote the same type.)
-3   Corresponding macros specify limits of the declared types and construct suitable
-    constants.
-4   For each type described herein that the implementation provides,<sup><a href="#note224"><b>224)</b></a></sup> <a href="#7.18">&lt;stdint.h&gt;</a> shall
-    declare that typedef name and define the associated macros. Conversely, for each type
-    described herein that the implementation does not provide, <a href="#7.18">&lt;stdint.h&gt;</a> shall not
-    declare that typedef name nor shall it define the associated macros. An implementation
-    shall provide those types described as ''required'', but need not provide any of the others
-    (described as ''optional'').
-<a name="7.18.1" href="#7.18.1"><b>    7.18.1 Integer types</b></a>
-1   When typedef names differing only in the absence or presence of the initial u are defined,
-    they shall denote corresponding signed and unsigned types as described in <a href="#6.2.5">6.2.5</a>; an
-    implementation providing one of these corresponding types shall also provide the other.
-2   In the following descriptions, the symbol N represents an unsigned decimal integer with
-    no leading zeros (e.g., 8 or 24, but not 04 or 048).
-
-
-
-
-    <sup><a name="note223" href="#note223"><b>223)</b></a></sup> See ''future library directions'' (<a href="#7.26.8">7.26.8</a>).
-    <sup><a name="note224" href="#note224"><b>224)</b></a></sup> Some of these types may denote implementation-defined extended integer types.
-
-[<a name="p255" href="#p255">page 255</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.18.1.1" href="#7.18.1.1"><b>    7.18.1.1 Exact-width integer types</b></a>
-1   The typedef name intN_t designates a signed integer type with width N , no padding
-    bits, and a two's complement representation. Thus, int8_t denotes a signed integer
-    type with a width of exactly 8 bits.
-2   The typedef name uintN_t designates an unsigned integer type with width N . Thus,
-    uint24_t denotes an unsigned integer type with a width of exactly 24 bits.
-3   These types are optional. However, if an implementation provides integer types with
-    widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a
-    two's complement representation, it shall define the corresponding typedef names.
-<a name="7.18.1.2" href="#7.18.1.2"><b>    7.18.1.2 Minimum-width integer types</b></a>
-1   The typedef name int_leastN_t designates a signed integer type with a width of at
-    least N , such that no signed integer type with lesser size has at least the specified width.
-    Thus, int_least32_t denotes a signed integer type with a width of at least 32 bits.
-2   The typedef name uint_leastN_t designates an unsigned integer type with a width
-    of at least N , such that no unsigned integer type with lesser size has at least the specified
-    width. Thus, uint_least16_t denotes an unsigned integer type with a width of at
-    least 16 bits.
-3   The following types are required:
-             int_least8_t                                      uint_least8_t
-             int_least16_t                                     uint_least16_t
-             int_least32_t                                     uint_least32_t
-             int_least64_t                                     uint_least64_t
-    All other types of this form are optional.
-<a name="7.18.1.3" href="#7.18.1.3"><b>    7.18.1.3 Fastest minimum-width integer types</b></a>
-1   Each of the following types designates an integer type that is usually fastest<sup><a href="#note225"><b>225)</b></a></sup> to operate
-    with among all integer types that have at least the specified width.
-2   The typedef name int_fastN_t designates the fastest signed integer type with a width
-    of at least N . The typedef name uint_fastN_t designates the fastest unsigned integer
-    type with a width of at least N .
-
-
-
-
-    <sup><a name="note225" href="#note225"><b>225)</b></a></sup> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
-         grounds for choosing one type over another, it will simply pick some integer type satisfying the
-         signedness and width requirements.
-
-[<a name="p256" href="#p256">page 256</a>] (<a href="#Contents">Contents</a>)
-
-3   The following types are required:
-           int_fast8_t                                 uint_fast8_t
-           int_fast16_t                                uint_fast16_t
-           int_fast32_t                                uint_fast32_t
-           int_fast64_t                                uint_fast64_t
-    All other types of this form are optional.
-<a name="7.18.1.4" href="#7.18.1.4"><b>    7.18.1.4 Integer types capable of holding object pointers</b></a>
-1   The following type designates a signed integer type with the property that any valid
-    pointer to void can be converted to this type, then converted back to pointer to void,
-    and the result will compare equal to the original pointer:
-           intptr_t
-    The following type designates an unsigned integer type with the property that any valid
-    pointer to void can be converted to this type, then converted back to pointer to void,
-    and the result will compare equal to the original pointer:
-           uintptr_t
-    These types are optional.
-<a name="7.18.1.5" href="#7.18.1.5"><b>    7.18.1.5 Greatest-width integer types</b></a>
-1   The following type designates a signed integer type capable of representing any value of
-    any signed integer type:
-           intmax_t
-    The following type designates an unsigned integer type capable of representing any value
-    of any unsigned integer type:
-           uintmax_t
-    These types are required.
-<a name="7.18.2" href="#7.18.2"><b>    7.18.2 Limits of specified-width integer types</b></a>
-1   The following object-like macros<sup><a href="#note226"><b>226)</b></a></sup> specify the minimum and maximum limits of the
-    types declared in <a href="#7.18">&lt;stdint.h&gt;</a>. Each macro name corresponds to a similar type name in
-    <a href="#7.18.1">7.18.1</a>.
-2   Each instance of any defined macro shall be replaced by a constant expression suitable
-    for use in #if preprocessing directives, and this expression shall have the same type as
-    would an expression that is an object of the corresponding type converted according to
-
-    <sup><a name="note226" href="#note226"><b>226)</b></a></sup> C++ implementations should define these macros only when __STDC_LIMIT_MACROS is defined
-         before <a href="#7.18">&lt;stdint.h&gt;</a> is included.
-
-[<a name="p257" href="#p257">page 257</a>] (<a href="#Contents">Contents</a>)
-
-    the integer promotions. Its implementation-defined value shall be equal to or greater in
-    magnitude (absolute value) than the corresponding value given below, with the same sign,
-    except where stated to be exactly the given value.
-<a name="7.18.2.1" href="#7.18.2.1"><b>    7.18.2.1 Limits of exact-width integer types</b></a>
-1   -- minimum values of exact-width signed integer types
-       INTN_MIN                                    exactly -(2 N -1 )
-    -- maximum values of exact-width signed integer types
-       INTN_MAX                                    exactly 2 N -1 - 1
-    -- maximum values of exact-width unsigned integer types
-       UINTN_MAX                                   exactly 2 N - 1
-<a name="7.18.2.2" href="#7.18.2.2"><b>    7.18.2.2 Limits of minimum-width integer types</b></a>
-1   -- minimum values of minimum-width signed integer types
-       INT_LEASTN_MIN                                      -(2 N -1 - 1)
-    -- maximum values of minimum-width signed integer types
-       INT_LEASTN_MAX                                      2 N -1 - 1
-    -- maximum values of minimum-width unsigned integer types
-       UINT_LEASTN_MAX                                     2N - 1
-<a name="7.18.2.3" href="#7.18.2.3"><b>    7.18.2.3 Limits of fastest minimum-width integer types</b></a>
-1   -- minimum values of fastest minimum-width signed integer types
-       INT_FASTN_MIN                                       -(2 N -1 - 1)
-    -- maximum values of fastest minimum-width signed integer types
-       INT_FASTN_MAX                                       2 N -1 - 1
-    -- maximum values of fastest minimum-width unsigned integer types
-       UINT_FASTN_MAX                                      2N - 1
-<a name="7.18.2.4" href="#7.18.2.4"><b>    7.18.2.4 Limits of integer types capable of holding object pointers</b></a>
-1   -- minimum value of pointer-holding signed integer type
-          INTPTR_MIN                                       -(215 - 1)
-    -- maximum value of pointer-holding signed integer type
-          INTPTR_MAX                                       215 - 1
-
-[<a name="p258" href="#p258">page 258</a>] (<a href="#Contents">Contents</a>)
-
-    -- maximum value of pointer-holding unsigned integer type
-        UINTPTR_MAX                                                   216 - 1
-<a name="7.18.2.5" href="#7.18.2.5"><b>    7.18.2.5 Limits of greatest-width integer types</b></a>
-1   -- minimum value of greatest-width signed integer type
-        INTMAX_MIN                                                    -(263 - 1)
-    -- maximum value of greatest-width signed integer type
-        INTMAX_MAX                                                    263 - 1
-    -- maximum value of greatest-width unsigned integer type
-        UINTMAX_MAX                                                   264 - 1
-<a name="7.18.3" href="#7.18.3"><b>    7.18.3 Limits of other integer types</b></a>
-1   The following object-like macros<sup><a href="#note227"><b>227)</b></a></sup> specify the minimum and maximum limits of
-    integer types corresponding to types defined in other standard headers.
-2   Each instance of these macros shall be replaced by a constant expression suitable for use
-    in #if preprocessing directives, and this expression shall have the same type as would an
-    expression that is an object of the corresponding type converted according to the integer
-    promotions. Its implementation-defined value shall be equal to or greater in magnitude
-    (absolute value) than the corresponding value given below, with the same sign. An
-    implementation shall define only the macros corresponding to those typedef names it
-    actually provides.<sup><a href="#note228"><b>228)</b></a></sup>
-    -- limits of ptrdiff_t
-        PTRDIFF_MIN                                                 -65535
-        PTRDIFF_MAX                                                 +65535
-    -- limits of sig_atomic_t
-        SIG_ATOMIC_MIN                                              see below
-        SIG_ATOMIC_MAX                                              see below
-    -- limit of size_t
-        SIZE_MAX                                                      65535
-    -- limits of wchar_t
-
-
-
-    <sup><a name="note227" href="#note227"><b>227)</b></a></sup> C++ implementations should define these macros only when __STDC_LIMIT_MACROS is defined
-         before <a href="#7.18">&lt;stdint.h&gt;</a> is included.
-    <sup><a name="note228" href="#note228"><b>228)</b></a></sup> A freestanding implementation need not provide all of these types.
-
-[<a name="p259" href="#p259">page 259</a>] (<a href="#Contents">Contents</a>)
-
-       WCHAR_MIN                                              see below
-       WCHAR_MAX                                              see below
-    -- limits of wint_t
-       WINT_MIN                                               see below
-       WINT_MAX                                               see below
-3   If sig_atomic_t (see <a href="#7.14">7.14</a>) is defined as a signed integer type, the value of
-    SIG_ATOMIC_MIN shall be no greater than -127 and the value of SIG_ATOMIC_MAX
-    shall be no less than 127; otherwise, sig_atomic_t is defined as an unsigned integer
-    type, and the value of SIG_ATOMIC_MIN shall be 0 and the value of
-    SIG_ATOMIC_MAX shall be no less than 255.
-4   If wchar_t (see <a href="#7.17">7.17</a>) is defined as a signed integer type, the value of WCHAR_MIN
-    shall be no greater than -127 and the value of WCHAR_MAX shall be no less than 127;
-    otherwise, wchar_t is defined as an unsigned integer type, and the value of
-    WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.<sup><a href="#note229"><b>229)</b></a></sup>
-5   If wint_t (see <a href="#7.24">7.24</a>) is defined as a signed integer type, the value of WINT_MIN shall
-    be no greater than -32767 and the value of WINT_MAX shall be no less than 32767;
-    otherwise, wint_t is defined as an unsigned integer type, and the value of WINT_MIN
-    shall be 0 and the value of WINT_MAX shall be no less than 65535.
-<a name="7.18.4" href="#7.18.4"><b>    7.18.4 Macros for integer constants</b></a>
-1   The following function-like macros<sup><a href="#note230"><b>230)</b></a></sup> expand to integer constants suitable for
-    initializing objects that have integer types corresponding to types defined in
-    <a href="#7.18">&lt;stdint.h&gt;</a>. Each macro name corresponds to a similar type name in <a href="#7.18.1.2">7.18.1.2</a> or
-    <a href="#7.18.1.5">7.18.1.5</a>.
-2   The argument in any instance of these macros shall be an unsuffixed integer constant (as
-    defined in <a href="#6.4.4.1">6.4.4.1</a>) with a value that does not exceed the limits for the corresponding type.
-3   Each invocation of one of these macros shall expand to an integer constant expression
-    suitable for use in #if preprocessing directives. The type of the expression shall have
-    the same type as would an expression of the corresponding type converted according to
-    the integer promotions. The value of the expression shall be that of the argument.
-
-
-
-
-    <sup><a name="note229" href="#note229"><b>229)</b></a></sup> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
-         character set.
-    <sup><a name="note230" href="#note230"><b>230)</b></a></sup> C++ implementations should define these macros only when __STDC_CONSTANT_MACROS is
-         defined before <a href="#7.18">&lt;stdint.h&gt;</a> is included.
-
-[<a name="p260" href="#p260">page 260</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.18.4.1" href="#7.18.4.1"><b>    7.18.4.1 Macros for minimum-width integer constants</b></a>
-1   The macro INTN_C(value) shall expand to an integer constant expression
-    corresponding to the type int_leastN_t. The macro UINTN_C(value) shall expand
-    to an integer constant expression corresponding to the type uint_leastN_t. For
-    example, if uint_least64_t is a name for the type unsigned long long int,
-    then UINT64_C(0x123) might expand to the integer constant 0x123ULL.
-<a name="7.18.4.2" href="#7.18.4.2"><b>    7.18.4.2 Macros for greatest-width integer constants</b></a>
-1   The following macro expands to an integer constant expression having the value specified
-    by its argument and the type intmax_t:
-           INTMAX_C(value)
-    The following macro expands to an integer constant expression having the value specified
-    by its argument and the type uintmax_t:
-           UINTMAX_C(value)
-
-[<a name="p261" href="#p261">page 261</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19" href="#7.19"><b>    7.19 Input/output &lt;stdio.h&gt;</b></a>
-<a name="7.19.1" href="#7.19.1"><b>    7.19.1 Introduction</b></a>
-1   The header <a href="#7.19">&lt;stdio.h&gt;</a> declares three types, several macros, and many functions for
-    performing input and output.
-2   The types declared are size_t (described in <a href="#7.17">7.17</a>);
-           FILE
-    which is an object type capable of recording all the information needed to control a
-    stream, including its file position indicator, a pointer to its associated buffer (if any), an
-    error indicator that records whether a read/write error has occurred, and an end-of-file
-    indicator that records whether the end of the file has been reached; and
-           fpos_t
-    which is an object type other than an array type capable of recording all the information
-    needed to specify uniquely every position within a file.
-3   The macros are NULL (described in <a href="#7.17">7.17</a>);
-           _IOFBF
-           _IOLBF
-           _IONBF
-    which expand to integer constant expressions with distinct values, suitable for use as the
-    third argument to the setvbuf function;
-           BUFSIZ
-    which expands to an integer constant expression that is the size of the buffer used by the
-    setbuf function;
-           EOF
-    which expands to an integer constant expression, with type int and a negative value, that
-    is returned by several functions to indicate end-of-file, that is, no more input from a
-    stream;
-           FOPEN_MAX
-    which expands to an integer constant expression that is the minimum number of files that
-    the implementation guarantees can be open simultaneously;
-           FILENAME_MAX
-    which expands to an integer constant expression that is the size needed for an array of
-    char large enough to hold the longest file name string that the implementation
-
-[<a name="p262" href="#p262">page 262</a>] (<a href="#Contents">Contents</a>)
-
-    guarantees can be opened;<sup><a href="#note231"><b>231)</b></a></sup>
-            L_tmpnam
-    which expands to an integer constant expression that is the size needed for an array of
-    char large enough to hold a temporary file name string generated by the tmpnam
-    function;
-            SEEK_CUR
-            SEEK_END
-            SEEK_SET
-    which expand to integer constant expressions with distinct values, suitable for use as the
-    third argument to the fseek function;
-            TMP_MAX
-    which expands to an integer constant expression that is the maximum number of unique
-    file names that can be generated by the tmpnam function;
-            stderr
-            stdin
-            stdout
-    which are expressions of type ''pointer to FILE'' that point to the FILE objects
-    associated, respectively, with the standard error, input, and output streams.
-4   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares a number of functions useful for wide character input
-    and output. The wide character input/output functions described in that subclause
-    provide operations analogous to most of those described here, except that the
-    fundamental units internal to the program are wide characters. The external
-    representation (in the file) is a sequence of ''generalized'' multibyte characters, as
-    described further in <a href="#7.19.3">7.19.3</a>.
-5   The input/output functions are given the following collective terms:
-    -- The wide character input functions -- those functions described in <a href="#7.24">7.24</a> that perform
-      input into wide characters and wide strings: fgetwc, fgetws, getwc, getwchar,
-      fwscanf, wscanf, vfwscanf, and vwscanf.
-    -- The wide character output functions -- those functions described in <a href="#7.24">7.24</a> that perform
-      output from wide characters and wide strings: fputwc, fputws, putwc,
-      putwchar, fwprintf, wprintf, vfwprintf, and vwprintf.
-
-
-    <sup><a name="note231" href="#note231"><b>231)</b></a></sup> If the implementation imposes no practical limit on the length of file name strings, the value of
-         FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
-         string. Of course, file name string contents are subject to other system-specific constraints; therefore
-         all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
-
-[<a name="p263" href="#p263">page 263</a>] (<a href="#Contents">Contents</a>)
-
-    -- The wide character input/output functions -- the union of the ungetwc function, the
-      wide character input functions, and the wide character output functions.
-    -- The byte input/output functions -- those functions described in this subclause that
-      perform input/output: fgetc, fgets, fprintf, fputc, fputs, fread,
-      fscanf, fwrite, getc, getchar, gets, printf, putc, putchar, puts,
-      scanf, ungetc, vfprintf, vfscanf, vprintf, and vscanf.
-    Forward references: files (<a href="#7.19.3">7.19.3</a>), the fseek function (<a href="#7.19.9.2">7.19.9.2</a>), streams (<a href="#7.19.2">7.19.2</a>), the
-    tmpnam function (<a href="#7.19.4.4">7.19.4.4</a>), <a href="#7.24">&lt;wchar.h&gt;</a> (<a href="#7.24">7.24</a>).
-<a name="7.19.2" href="#7.19.2"><b>    7.19.2 Streams</b></a>
-1   Input and output, whether to or from physical devices such as terminals and tape drives,
-    or whether to or from files supported on structured storage devices, are mapped into
-    logical data streams, whose properties are more uniform than their various inputs and
-    outputs. Two forms of mapping are supported, for text streams and for binary
-    streams.<sup><a href="#note232"><b>232)</b></a></sup>
-2   A text stream is an ordered sequence of characters composed into lines, each line
-    consisting of zero or more characters plus a terminating new-line character. Whether the
-    last line requires a terminating new-line character is implementation-defined. Characters
-    may have to be added, altered, or deleted on input and output to conform to differing
-    conventions for representing text in the host environment. Thus, there need not be a one-
-    to-one correspondence between the characters in a stream and those in the external
-    representation. Data read in from a text stream will necessarily compare equal to the data
-    that were earlier written out to that stream only if: the data consist only of printing
-    characters and the control characters horizontal tab and new-line; no new-line character is
-    immediately preceded by space characters; and the last character is a new-line character.
-    Whether space characters that are written out immediately before a new-line character
-    appear when read in is implementation-defined.
-3   A binary stream is an ordered sequence of characters that can transparently record
-    internal data. Data read in from a binary stream shall compare equal to the data that were
-    earlier written out to that stream, under the same implementation. Such a stream may,
-    however, have an implementation-defined number of null characters appended to the end
-    of the stream.
-4   Each stream has an orientation. After a stream is associated with an external file, but
-    before any operations are performed on it, the stream is without orientation. Once a wide
-    character input/output function has been applied to a stream without orientation, the
-
-
-    <sup><a name="note232" href="#note232"><b>232)</b></a></sup> An implementation need not distinguish between text streams and binary streams. In such an
-         implementation, there need be no new-line characters in a text stream nor any limit to the length of a
-         line.
-
-[<a name="p264" href="#p264">page 264</a>] (<a href="#Contents">Contents</a>)
-
-    stream becomes a wide-oriented stream. Similarly, once a byte input/output function has
-    been applied to a stream without orientation, the stream becomes a byte-oriented stream.
-    Only a call to the freopen function or the fwide function can otherwise alter the
-    orientation of a stream. (A successful call to freopen removes any orientation.)<sup><a href="#note233"><b>233)</b></a></sup>
-5   Byte input/output functions shall not be applied to a wide-oriented stream and wide
-    character input/output functions shall not be applied to a byte-oriented stream. The
-    remaining stream operations do not affect, and are not affected by, a stream's orientation,
-    except for the following additional restrictions:
-    -- Binary wide-oriented streams have the file-positioning restrictions ascribed to both
-      text and binary streams.
-    -- For wide-oriented streams, after a successful call to a file-positioning function that
-      leaves the file position indicator prior to the end-of-file, a wide character output
-      function can overwrite a partial multibyte character; any file contents beyond the
-      byte(s) written are henceforth indeterminate.
-6   Each wide-oriented stream has an associated mbstate_t object that stores the current
-    parse state of the stream. A successful call to fgetpos stores a representation of the
-    value of this mbstate_t object as part of the value of the fpos_t object. A later
-    successful call to fsetpos using the same stored fpos_t value restores the value of
-    the associated mbstate_t object as well as the position within the controlled stream.
-    Environmental limits
-7   An implementation shall support text files with lines containing at least 254 characters,
-    including the terminating new-line character. The value of the macro BUFSIZ shall be at
-    least 256.
-    Forward references: the freopen function (<a href="#7.19.5.4">7.19.5.4</a>), the fwide function (<a href="#7.24.3.5">7.24.3.5</a>),
-    mbstate_t (<a href="#7.25.1">7.25.1</a>), the fgetpos function (<a href="#7.19.9.1">7.19.9.1</a>), the fsetpos function
-    (<a href="#7.19.9.3">7.19.9.3</a>).
-
-
-
-
-    <sup><a name="note233" href="#note233"><b>233)</b></a></sup> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
-
-[<a name="p265" href="#p265">page 265</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.3" href="#7.19.3"><b>    7.19.3 Files</b></a>
-1   A stream is associated with an external file (which may be a physical device) by opening
-    a file, which may involve creating a new file. Creating an existing file causes its former
-    contents to be discarded, if necessary. If a file can support positioning requests (such as a
-    disk file, as opposed to a terminal), then a file position indicator associated with the
-    stream is positioned at the start (character number zero) of the file, unless the file is
-    opened with append mode in which case it is implementation-defined whether the file
-    position indicator is initially positioned at the beginning or the end of the file. The file
-    position indicator is maintained by subsequent reads, writes, and positioning requests, to
-    facilitate an orderly progression through the file.
-2   Binary files are not truncated, except as defined in <a href="#7.19.5.3">7.19.5.3</a>. Whether a write on a text
-    stream causes the associated file to be truncated beyond that point is implementation-
-    defined.
-3   When a stream is unbuffered, characters are intended to appear from the source or at the
-    destination as soon as possible. Otherwise characters may be accumulated and
-    transmitted to or from the host environment as a block. When a stream is fully buffered,
-    characters are intended to be transmitted to or from the host environment as a block when
-    a buffer is filled. When a stream is line buffered, characters are intended to be
-    transmitted to or from the host environment as a block when a new-line character is
-    encountered. Furthermore, characters are intended to be transmitted as a block to the host
-    environment when a buffer is filled, when input is requested on an unbuffered stream, or
-    when input is requested on a line buffered stream that requires the transmission of
-    characters from the host environment. Support for these characteristics is
-    implementation-defined, and may be affected via the setbuf and setvbuf functions.
-4   A file may be disassociated from a controlling stream by closing the file. Output streams
-    are flushed (any unwritten buffer contents are transmitted to the host environment) before
-    the stream is disassociated from the file. The value of a pointer to a FILE object is
-    indeterminate after the associated file is closed (including the standard text streams).
-    Whether a file of zero length (on which no characters have been written by an output
-    stream) actually exists is implementation-defined.
-5   The file may be subsequently reopened, by the same or another program execution, and
-    its contents reclaimed or modified (if it can be repositioned at its start). If the main
-    function returns to its original caller, or if the exit function is called, all open files are
-    closed (hence all output streams are flushed) before program termination. Other paths to
-    program termination, such as calling the abort function, need not close all files
-    properly.
-6   The address of the FILE object used to control a stream may be significant; a copy of a
-    FILE object need not serve in place of the original.
-
-[<a name="p266" href="#p266">page 266</a>] (<a href="#Contents">Contents</a>)
-
-7    At program startup, three text streams are predefined and need not be opened explicitly
-     -- standard input (for reading conventional input), standard output (for writing
-     conventional output), and standard error (for writing diagnostic output). As initially
-     opened, the standard error stream is not fully buffered; the standard input and standard
-     output streams are fully buffered if and only if the stream can be determined not to refer
-     to an interactive device.
-8    Functions that open additional (nontemporary) files require a file name, which is a string.
-     The rules for composing valid file names are implementation-defined. Whether the same
-     file can be simultaneously open multiple times is also implementation-defined.
-9    Although both text and binary wide-oriented streams are conceptually sequences of wide
-     characters, the external file associated with a wide-oriented stream is a sequence of
-     multibyte characters, generalized as follows:
-     -- Multibyte encodings within files may contain embedded null bytes (unlike multibyte
-       encodings valid for use internal to the program).
-     -- A file need not begin nor end in the initial shift state.<sup><a href="#note234"><b>234)</b></a></sup>
-10   Moreover, the encodings used for multibyte characters may differ among files. Both the
-     nature and choice of such encodings are implementation-defined.
-11   The wide character input functions read multibyte characters from the stream and convert
-     them to wide characters as if they were read by successive calls to the fgetwc function.
-     Each conversion occurs as if by a call to the mbrtowc function, with the conversion state
-     described by the stream's own mbstate_t object. The byte input functions read
-     characters from the stream as if by successive calls to the fgetc function.
-12   The wide character output functions convert wide characters to multibyte characters and
-     write them to the stream as if they were written by successive calls to the fputwc
-     function. Each conversion occurs as if by a call to the wcrtomb function, with the
-     conversion state described by the stream's own mbstate_t object. The byte output
-     functions write characters to the stream as if by successive calls to the fputc function.
-13   In some cases, some of the byte input/output functions also perform conversions between
-     multibyte characters and wide characters. These conversions also occur as if by calls to
-     the mbrtowc and wcrtomb functions.
-14   An encoding error occurs if the character sequence presented to the underlying
-     mbrtowc function does not form a valid (generalized) multibyte character, or if the code
-     value passed to the underlying wcrtomb does not correspond to a valid (generalized)
-
-
-     <sup><a name="note234" href="#note234"><b>234)</b></a></sup> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
-          undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
-          with state-dependent encoding that does not assuredly end in the initial shift state.
-
-[<a name="p267" href="#p267">page 267</a>] (<a href="#Contents">Contents</a>)
-
-     multibyte character. The wide character input/output functions and the byte input/output
-     functions store the value of the macro EILSEQ in errno if and only if an encoding error
-     occurs.
-     Environmental limits
-15   The value of FOPEN_MAX shall be at least eight, including the three standard text
-     streams.
-     Forward references: the exit function (<a href="#7.20.4.3">7.20.4.3</a>), the fgetc function (<a href="#7.19.7.1">7.19.7.1</a>), the
-     fopen function (<a href="#7.19.5.3">7.19.5.3</a>), the fputc function (<a href="#7.19.7.3">7.19.7.3</a>), the setbuf function
-     (<a href="#7.19.5.5">7.19.5.5</a>), the setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>), the fgetwc function (<a href="#7.24.3.1">7.24.3.1</a>), the
-     fputwc function (<a href="#7.24.3.3">7.24.3.3</a>), conversion state (<a href="#7.24.6">7.24.6</a>), the mbrtowc function
-     (<a href="#7.24.6.3.2">7.24.6.3.2</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
-<a name="7.19.4" href="#7.19.4"><b>     7.19.4 Operations on files</b></a>
-<a name="7.19.4.1" href="#7.19.4.1"><b>     7.19.4.1 The remove function</b></a>
-<b>     Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            int remove(const char *filename);
-<b>     Description</b>
-2    The remove function causes the file whose name is the string pointed to by filename
-     to be no longer accessible by that name. A subsequent attempt to open that file using that
-     name will fail, unless it is created anew. If the file is open, the behavior of the remove
-     function is implementation-defined.
-<b>     Returns</b>
-3    The remove function returns zero if the operation succeeds, nonzero if it fails.
-<a name="7.19.4.2" href="#7.19.4.2"><b>     7.19.4.2 The rename function</b></a>
-<b>     Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            int rename(const char *old, const char *new);
-<b>     Description</b>
-2    The rename function causes the file whose name is the string pointed to by old to be
-     henceforth known by the name given by the string pointed to by new. The file named
-     old is no longer accessible by that name. If a file named by the string pointed to by new
-     exists prior to the call to the rename function, the behavior is implementation-defined.
-
-[<a name="p268" href="#p268">page 268</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The rename function returns zero if the operation succeeds, nonzero if it fails,<sup><a href="#note235"><b>235)</b></a></sup> in
-    which case if the file existed previously it is still known by its original name.
-<a name="7.19.4.3" href="#7.19.4.3"><b>    7.19.4.3 The tmpfile function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            FILE *tmpfile(void);
-<b>    Description</b>
-2   The tmpfile function creates a temporary binary file that is different from any other
-    existing file and that will automatically be removed when it is closed or at program
-    termination. If the program terminates abnormally, whether an open temporary file is
-    removed is implementation-defined. The file is opened for update with "wb+" mode.
-    Recommended practice
-3   It should be possible to open at least TMP_MAX temporary files during the lifetime of the
-    program (this limit may be shared with tmpnam) and there should be no limit on the
-    number simultaneously open other than this limit and any limit on the number of open
-    files (FOPEN_MAX).
-<b>    Returns</b>
-4   The tmpfile function returns a pointer to the stream of the file that it created. If the file
-    cannot be created, the tmpfile function returns a null pointer.
-    Forward references: the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
-<a name="7.19.4.4" href="#7.19.4.4"><b>    7.19.4.4 The tmpnam function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            char *tmpnam(char *s);
-<b>    Description</b>
-2   The tmpnam function generates a string that is a valid file name and that is not the same
-    as the name of an existing file.<sup><a href="#note236"><b>236)</b></a></sup> The function is potentially capable of generating
-
-
-    <sup><a name="note235" href="#note235"><b>235)</b></a></sup> Among the reasons the implementation may cause the rename function to fail are that the file is open
-         or that it is necessary to copy its contents to effectuate its renaming.
-    <sup><a name="note236" href="#note236"><b>236)</b></a></sup> Files created using strings generated by the tmpnam function are temporary only in the sense that
-         their names should not collide with those generated by conventional naming rules for the
-         implementation. It is still necessary to use the remove function to remove such files when their use
-         is ended, and before program termination.
-
-[<a name="p269" href="#p269">page 269</a>] (<a href="#Contents">Contents</a>)
-
-    TMP_MAX different strings, but any or all of them may already be in use by existing files
-    and thus not be suitable return values.
-3   The tmpnam function generates a different string each time it is called.
-4   The implementation shall behave as if no library function calls the tmpnam function.
-<b>    Returns</b>
-5   If no suitable string can be generated, the tmpnam function returns a null pointer.
-    Otherwise, if the argument is a null pointer, the tmpnam function leaves its result in an
-    internal static object and returns a pointer to that object (subsequent calls to the tmpnam
-    function may modify the same object). If the argument is not a null pointer, it is assumed
-    to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
-    in that array and returns the argument as its value.
-    Environmental limits
-6   The value of the macro TMP_MAX shall be at least 25.
-<a name="7.19.5" href="#7.19.5"><b>    7.19.5 File access functions</b></a>
-<a name="7.19.5.1" href="#7.19.5.1"><b>    7.19.5.1 The fclose function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int fclose(FILE *stream);
-<b>    Description</b>
-2   A successful call to the fclose function causes the stream pointed to by stream to be
-    flushed and the associated file to be closed. Any unwritten buffered data for the stream
-    are delivered to the host environment to be written to the file; any unread buffered data
-    are discarded. Whether or not the call succeeds, the stream is disassociated from the file
-    and any buffer set by the setbuf or setvbuf function is disassociated from the stream
-    (and deallocated if it was automatically allocated).
-<b>    Returns</b>
-3   The fclose function returns zero if the stream was successfully closed, or EOF if any
-    errors were detected.
-<a name="7.19.5.2" href="#7.19.5.2"><b>    7.19.5.2 The fflush function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int fflush(FILE *stream);
-
-[<a name="p270" href="#p270">page 270</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   If stream points to an output stream or an update stream in which the most recent
-    operation was not input, the fflush function causes any unwritten data for that stream
-    to be delivered to the host environment to be written to the file; otherwise, the behavior is
-    undefined.
-3   If stream is a null pointer, the fflush function performs this flushing action on all
-    streams for which the behavior is defined above.
-<b>    Returns</b>
-4   The fflush function sets the error indicator for the stream and returns EOF if a write
-    error occurs, otherwise it returns zero.
-    Forward references: the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
-<a name="7.19.5.3" href="#7.19.5.3"><b>    7.19.5.3 The fopen function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            FILE *fopen(const char * restrict filename,
-                 const char * restrict mode);
-<b>    Description</b>
-2   The fopen function opens the file whose name is the string pointed to by filename,
-    and associates a stream with it.
-3   The argument mode points to a string. If the string is one of the following, the file is
-    open in the indicated mode. Otherwise, the behavior is undefined.<sup><a href="#note237"><b>237)</b></a></sup>
-    r                open text file for reading
-    w                truncate to zero length or create text file for writing
-    a                append; open or create text file for writing at end-of-file
-    rb               open binary file for reading
-    wb               truncate to zero length or create binary file for writing
-    ab               append; open or create binary file for writing at end-of-file
-    r+               open text file for update (reading and writing)
-    w+               truncate to zero length or create text file for update
-    a+               append; open or create text file for update, writing at end-of-file
-
-
-
-
-    <sup><a name="note237" href="#note237"><b>237)</b></a></sup> If the string begins with one of the above sequences, the implementation might choose to ignore the
-         remaining characters, or it might use them to select different kinds of a file (some of which might not
-         conform to the properties in <a href="#7.19.2">7.19.2</a>).
-
-[<a name="p271" href="#p271">page 271</a>] (<a href="#Contents">Contents</a>)
-
-    r+b or rb+ open binary file for update (reading and writing)
-    w+b or wb+ truncate to zero length or create binary file for update
-    a+b or ab+ append; open or create binary file for update, writing at end-of-file
-4   Opening a file with read mode ('r' as the first character in the mode argument) fails if
-    the file does not exist or cannot be read.
-5   Opening a file with append mode ('a' as the first character in the mode argument)
-    causes all subsequent writes to the file to be forced to the then current end-of-file,
-    regardless of intervening calls to the fseek function. In some implementations, opening
-    a binary file with append mode ('b' as the second or third character in the above list of
-    mode argument values) may initially position the file position indicator for the stream
-    beyond the last data written, because of null character padding.
-6   When a file is opened with update mode ('+' as the second or third character in the
-    above list of mode argument values), both input and output may be performed on the
-    associated stream. However, output shall not be directly followed by input without an
-    intervening call to the fflush function or to a file positioning function (fseek,
-    fsetpos, or rewind), and input shall not be directly followed by output without an
-    intervening call to a file positioning function, unless the input operation encounters end-
-    of-file. Opening (or creating) a text file with update mode may instead open (or create) a
-    binary stream in some implementations.
-7   When opened, a stream is fully buffered if and only if it can be determined not to refer to
-    an interactive device. The error and end-of-file indicators for the stream are cleared.
-<b>    Returns</b>
-8   The fopen function returns a pointer to the object controlling the stream. If the open
-    operation fails, fopen returns a null pointer.
-    Forward references: file positioning functions (<a href="#7.19.9">7.19.9</a>).
-<a name="7.19.5.4" href="#7.19.5.4"><b>    7.19.5.4 The freopen function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           FILE *freopen(const char * restrict filename,
-                const char * restrict mode,
-                FILE * restrict stream);
-<b>    Description</b>
-2   The freopen function opens the file whose name is the string pointed to by filename
-    and associates the stream pointed to by stream with it. The mode argument is used just
-
-[<a name="p272" href="#p272">page 272</a>] (<a href="#Contents">Contents</a>)
-
-    as in the fopen function.<sup><a href="#note238"><b>238)</b></a></sup>
-3   If filename is a null pointer, the freopen function attempts to change the mode of
-    the stream to that specified by mode, as if the name of the file currently associated with
-    the stream had been used. It is implementation-defined which changes of mode are
-    permitted (if any), and under what circumstances.
-4   The freopen function first attempts to close any file that is associated with the specified
-    stream. Failure to close the file is ignored. The error and end-of-file indicators for the
-    stream are cleared.
-<b>    Returns</b>
-5   The freopen function returns a null pointer if the open operation fails. Otherwise,
-    freopen returns the value of stream.
-<a name="7.19.5.5" href="#7.19.5.5"><b>    7.19.5.5 The setbuf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            void setbuf(FILE * restrict stream,
-                 char * restrict buf);
-<b>    Description</b>
-2   Except that it returns no value, the setbuf function is equivalent to the setvbuf
-    function invoked with the values _IOFBF for mode and BUFSIZ for size, or (if buf
-    is a null pointer), with the value _IONBF for mode.
-<b>    Returns</b>
-3   The setbuf function returns no value.
-    Forward references: the setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>).
-<a name="7.19.5.6" href="#7.19.5.6"><b>    7.19.5.6 The setvbuf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            int setvbuf(FILE * restrict stream,
-                 char * restrict buf,
-                 int mode, size_t size);
-
-
-
-
-    <sup><a name="note238" href="#note238"><b>238)</b></a></sup> The primary use of the freopen function is to change the file associated with a standard text stream
-         (stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
-         returned by the fopen function may be assigned.
-
-[<a name="p273" href="#p273">page 273</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The setvbuf function may be used only after the stream pointed to by stream has
-    been associated with an open file and before any other operation (other than an
-    unsuccessful call to setvbuf) is performed on the stream. The argument mode
-    determines how stream will be buffered, as follows: _IOFBF causes input/output to be
-    fully buffered; _IOLBF causes input/output to be line buffered; _IONBF causes
-    input/output to be unbuffered. If buf is not a null pointer, the array it points to may be
-    used instead of a buffer allocated by the setvbuf function<sup><a href="#note239"><b>239)</b></a></sup> and the argument size
-    specifies the size of the array; otherwise, size may determine the size of a buffer
-    allocated by the setvbuf function. The contents of the array at any time are
-    indeterminate.
-<b>    Returns</b>
-3   The setvbuf function returns zero on success, or nonzero if an invalid value is given
-    for mode or if the request cannot be honored.
-<a name="7.19.6" href="#7.19.6"><b>    7.19.6 Formatted input/output functions</b></a>
-1   The formatted input/output functions shall behave as if there is a sequence point after the
-    actions associated with each specifier.<sup><a href="#note240"><b>240)</b></a></sup>
-<a name="7.19.6.1" href="#7.19.6.1"><b>    7.19.6.1 The fprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            int fprintf(FILE * restrict stream,
-                 const char * restrict format, ...);
-<b>    Description</b>
-2   The fprintf function writes output to the stream pointed to by stream, under control
-    of the string pointed to by format that specifies how subsequent arguments are
-    converted for output. If there are insufficient arguments for the format, the behavior is
-    undefined. If the format is exhausted while arguments remain, the excess arguments are
-    evaluated (as always) but are otherwise ignored. The fprintf function returns when
-    the end of the format string is encountered.
-3   The format shall be a multibyte character sequence, beginning and ending in its initial
-    shift state. The format is composed of zero or more directives: ordinary multibyte
-    characters (not %), which are copied unchanged to the output stream; and conversion
-
-
-    <sup><a name="note239" href="#note239"><b>239)</b></a></sup> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
-         before a buffer that has automatic storage duration is deallocated upon block exit.
-    <sup><a name="note240" href="#note240"><b>240)</b></a></sup> The fprintf functions perform writes to memory for the %n specifier.
-
-[<a name="p274" href="#p274">page 274</a>] (<a href="#Contents">Contents</a>)
-
-    specifications, each of which results in fetching zero or more subsequent arguments,
-    converting them, if applicable, according to the corresponding conversion specifier, and
-    then writing the result to the output stream.
-4   Each conversion specification is introduced by the character %. After the %, the following
-    appear in sequence:
-    -- Zero or more flags (in any order) that modify the meaning of the conversion
-      specification.
-    -- An optional minimum field width. If the converted value has fewer characters than the
-      field width, it is padded with spaces (by default) on the left (or right, if the left
-      adjustment flag, described later, has been given) to the field width. The field width
-      takes the form of an asterisk * (described later) or a nonnegative decimal integer.<sup><a href="#note241"><b>241)</b></a></sup>
-    -- An optional precision that gives the minimum number of digits to appear for the d, i,
-      o, u, x, and X conversions, the number of digits to appear after the decimal-point
-      character for a, A, e, E, f, and F conversions, the maximum number of significant
-      digits for the g and G conversions, or the maximum number of bytes to be written for
-      s conversions. The precision takes the form of a period (.) followed either by an
-      asterisk * (described later) or by an optional decimal integer; if only the period is
-      specified, the precision is taken as zero. If a precision appears with any other
-      conversion specifier, the behavior is undefined.
-    -- An optional length modifier that specifies the size of the argument.
-    -- A conversion specifier character that specifies the type of conversion to be applied.
-5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
-    this case, an int argument supplies the field width or precision. The arguments
-    specifying field width, or precision, or both, shall appear (in that order) before the
-    argument (if any) to be converted. A negative field width argument is taken as a - flag
-    followed by a positive field width. A negative precision argument is taken as if the
-    precision were omitted.
-6   The flag characters and their meanings are:
-    -        The result of the conversion is left-justified within the field. (It is right-justified if
-             this flag is not specified.)
-    +        The result of a signed conversion always begins with a plus or minus sign. (It
-             begins with a sign only when a negative value is converted if this flag is not
-
-
-
-
-    <sup><a name="note241" href="#note241"><b>241)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
-
-[<a name="p275" href="#p275">page 275</a>] (<a href="#Contents">Contents</a>)
-
-              specified.)<sup><a href="#note242"><b>242)</b></a></sup>
-    space If the first character of a signed conversion is not a sign, or if a signed conversion
-          results in no characters, a space is prefixed to the result. If the space and + flags
-          both appear, the space flag is ignored.
-    #         The result is converted to an ''alternative form''. For o conversion, it increases
-              the precision, if and only if necessary, to force the first digit of the result to be a
-              zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
-              conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
-              and G conversions, the result of converting a floating-point number always
-              contains a decimal-point character, even if no digits follow it. (Normally, a
-              decimal-point character appears in the result of these conversions only if a digit
-              follows it.) For g and G conversions, trailing zeros are not removed from the
-              result. For other conversions, the behavior is undefined.
-    0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
-              (following any indication of sign or base) are used to pad to the field width rather
-              than performing space padding, except when converting an infinity or NaN. If the
-              0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
-              conversions, if a precision is specified, the 0 flag is ignored. For other
-              conversions, the behavior is undefined.
-7   The length modifiers and their meanings are:
-    hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   signed char or unsigned char argument (the argument will have
-                   been promoted according to the integer promotions, but its value shall be
-                   converted to signed char or unsigned char before printing); or that
-                   a following n conversion specifier applies to a pointer to a signed char
-                   argument.
-    h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   short int or unsigned short int argument (the argument will
-                   have been promoted according to the integer promotions, but its value shall
-                   be converted to short int or unsigned short int before printing);
-                   or that a following n conversion specifier applies to a pointer to a short
-                   int argument.
-    l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   long int or unsigned long int argument; that a following n
-                   conversion specifier applies to a pointer to a long int argument; that a
-
-    <sup><a name="note242" href="#note242"><b>242)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
-         include a minus sign.
-
-[<a name="p276" href="#p276">page 276</a>] (<a href="#Contents">Contents</a>)
-
-                 following c conversion specifier applies to a wint_t argument; that a
-                 following s conversion specifier applies to a pointer to a wchar_t
-                 argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
-                 specifier.
-    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 long long int or unsigned long long int argument; or that a
-                 following n conversion specifier applies to a pointer to a long long int
-                 argument.
-    j            Specifies that a following d, i, o, u, x, or X conversion specifier applies to
-                 an intmax_t or uintmax_t argument; or that a following n conversion
-                 specifier applies to a pointer to an intmax_t argument.
-    z            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 size_t or the corresponding signed integer type argument; or that a
-                 following n conversion specifier applies to a pointer to a signed integer type
-                 corresponding to size_t argument.
-    t            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 ptrdiff_t or the corresponding unsigned integer type argument; or that a
-                 following n conversion specifier applies to a pointer to a ptrdiff_t
-                 argument.
-    L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                 applies to a long double argument.
-    If a length modifier appears with any conversion specifier other than as specified above,
-    the behavior is undefined.
-8   The conversion specifiers and their meanings are:
-    d,i         The int argument is converted to signed decimal in the style [-]dddd. The
-                precision specifies the minimum number of digits to appear; if the value
-                being converted can be represented in fewer digits, it is expanded with
-                leading zeros. The default precision is 1. The result of converting a zero
-                value with a precision of zero is no characters.
-    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
-            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
-            letters abcdef are used for x conversion and the letters ABCDEF for X
-            conversion. The precision specifies the minimum number of digits to appear;
-            if the value being converted can be represented in fewer digits, it is expanded
-            with leading zeros. The default precision is 1. The result of converting a
-            zero value with a precision of zero is no characters.
-
-[<a name="p277" href="#p277">page 277</a>] (<a href="#Contents">Contents</a>)
-
-f,F          A double argument representing a floating-point number is converted to
-             decimal notation in the style [-]ddd.ddd, where the number of digits after
-             the decimal-point character is equal to the precision specification. If the
-             precision is missing, it is taken as 6; if the precision is zero and the # flag is
-             not specified, no decimal-point character appears. If a decimal-point
-             character appears, at least one digit appears before it. The value is rounded to
-             the appropriate number of digits.
-             A double argument representing an infinity is converted in one of the styles
-             [-]inf or [-]infinity -- which style is implementation-defined. A
-             double argument representing a NaN is converted in one of the styles
-             [-]nan or [-]nan(n-char-sequence) -- which style, and the meaning of
-             any n-char-sequence, is implementation-defined. The F conversion specifier
-             produces INF, INFINITY, or NAN instead of inf, infinity, or nan,
-             respectively.<sup><a href="#note243"><b>243)</b></a></sup>
-e,E          A double argument representing a floating-point number is converted in the
-             style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
-             argument is nonzero) before the decimal-point character and the number of
-             digits after it is equal to the precision; if the precision is missing, it is taken as
-             6; if the precision is zero and the # flag is not specified, no decimal-point
-             character appears. The value is rounded to the appropriate number of digits.
-             The E conversion specifier produces a number with E instead of e
-             introducing the exponent. The exponent always contains at least two digits,
-             and only as many more digits as necessary to represent the exponent. If the
-             value is zero, the exponent is zero.
-             A double argument representing an infinity or NaN is converted in the style
-             of an f or F conversion specifier.
-g,G          A double argument representing a floating-point number is converted in
-             style f or e (or in style F or E in the case of a G conversion specifier),
-             depending on the value converted and the precision. Let P equal the
-             precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
-             Then, if a conversion with style E would have an exponent of X :
-             -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
-               P - (X + 1).
-             -- otherwise, the conversion is with style e (or E) and precision P - 1.
-             Finally, unless the # flag is used, any trailing zeros are removed from the
-
-<sup><a name="note243" href="#note243"><b>243)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
-     the # and 0 flag characters have no effect.
-
-[<a name="p278" href="#p278">page 278</a>] (<a href="#Contents">Contents</a>)
-
-              fractional portion of the result and the decimal-point character is removed if
-              there is no fractional portion remaining.
-              A double argument representing an infinity or NaN is converted in the style
-              of an f or F conversion specifier.
-a,A           A double argument representing a floating-point number is converted in the
-              style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
-              nonzero if the argument is a normalized floating-point number and is
-              otherwise unspecified) before the decimal-point character<sup><a href="#note244"><b>244)</b></a></sup> and the number
-              of hexadecimal digits after it is equal to the precision; if the precision is
-              missing and FLT_RADIX is a power of 2, then the precision is sufficient for
-              an exact representation of the value; if the precision is missing and
-              FLT_RADIX is not a power of 2, then the precision is sufficient to
-              distinguish<sup><a href="#note245"><b>245)</b></a></sup> values of type double, except that trailing zeros may be
-              omitted; if the precision is zero and the # flag is not specified, no decimal-
-              point character appears. The letters abcdef are used for a conversion and
-              the letters ABCDEF for A conversion. The A conversion specifier produces a
-              number with X and P instead of x and p. The exponent always contains at
-              least one digit, and only as many more digits as necessary to represent the
-              decimal exponent of 2. If the value is zero, the exponent is zero.
-              A double argument representing an infinity or NaN is converted in the style
-              of an f or F conversion specifier.
-c             If no l length modifier is present, the int argument is converted to an
-              unsigned char, and the resulting character is written.
-              If an l length modifier is present, the wint_t argument is converted as if by
-              an ls conversion specification with no precision and an argument that points
-              to the initial element of a two-element array of wchar_t, the first element
-              containing the wint_t argument to the lc conversion specification and the
-              second a null wide character.
-s             If no l length modifier is present, the argument shall be a pointer to the initial
-              element of an array of character type.<sup><a href="#note246"><b>246)</b></a></sup> Characters from the array are
-
-
-<sup><a name="note244" href="#note244"><b>244)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
-     that subsequent digits align to nibble (4-bit) boundaries.
-<sup><a name="note245" href="#note245"><b>245)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
-     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
-     might suffice depending on the implementation's scheme for determining the digit to the left of the
-     decimal-point character.
-<sup><a name="note246" href="#note246"><b>246)</b></a></sup> No special provisions are made for multibyte characters.
-
-[<a name="p279" href="#p279">page 279</a>] (<a href="#Contents">Contents</a>)
-
-                    written up to (but not including) the terminating null character. If the
-                    precision is specified, no more than that many bytes are written. If the
-                    precision is not specified or is greater than the size of the array, the array shall
-                    contain a null character.
-                    If an l length modifier is present, the argument shall be a pointer to the initial
-                    element of an array of wchar_t type. Wide characters from the array are
-                    converted to multibyte characters (each as if by a call to the wcrtomb
-                    function, with the conversion state described by an mbstate_t object
-                    initialized to zero before the first wide character is converted) up to and
-                    including a terminating null wide character. The resulting multibyte
-                    characters are written up to (but not including) the terminating null character
-                    (byte). If no precision is specified, the array shall contain a null wide
-                    character. If a precision is specified, no more than that many bytes are
-                    written (including shift sequences, if any), and the array shall contain a null
-                    wide character if, to equal the multibyte character sequence length given by
-                    the precision, the function would need to access a wide character one past the
-                    end of the array. In no case is a partial multibyte character written.<sup><a href="#note247"><b>247)</b></a></sup>
-     p              The argument shall be a pointer to void. The value of the pointer is
-                    converted to a sequence of printing characters, in an implementation-defined
-                    manner.
-     n              The argument shall be a pointer to signed integer into which is written the
-                    number of characters written to the output stream so far by this call to
-                    fprintf. No argument is converted, but one is consumed. If the conversion
-                    specification includes any flags, a field width, or a precision, the behavior is
-                    undefined.
-     %              A % character is written. No argument is converted. The complete
-                    conversion specification shall be %%.
-9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note248"><b>248)</b></a></sup> If any argument is
-     not the correct type for the corresponding conversion specification, the behavior is
-     undefined.
-10   In no case does a nonexistent or small field width cause truncation of a field; if the result
-     of a conversion is wider than the field width, the field is expanded to contain the
-     conversion result.
-
-
-
-
-     <sup><a name="note247" href="#note247"><b>247)</b></a></sup> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
-     <sup><a name="note248" href="#note248"><b>248)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
-
-[<a name="p280" href="#p280">page 280</a>] (<a href="#Contents">Contents</a>)
-
-11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
-     to a hexadecimal floating number with the given precision.
-     Recommended practice
-12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
-     representable in the given precision, the result should be one of the two adjacent numbers
-     in hexadecimal floating style with the given precision, with the extra stipulation that the
-     error should have a correct sign for the current rounding direction.
-13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
-     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note249"><b>249)</b></a></sup> If the number of
-     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
-     representable with DECIMAL_DIG digits, then the result should be an exact
-     representation with trailing zeros. Otherwise, the source value is bounded by two
-     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
-     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
-     the error should have a correct sign for the current rounding direction.
-<b>     Returns</b>
-14   The fprintf function returns the number of characters transmitted, or a negative value
-     if an output or encoding error occurred.
-     Environmental limits
-15   The number of characters that can be produced by any single conversion shall be at least
-     4095.
-16   EXAMPLE 1 To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
-     places:
-             #include <a href="#7.12">&lt;math.h&gt;</a>
-             #include <a href="#7.19">&lt;stdio.h&gt;</a>
-             /* ... */
-             char *weekday, *month;      // pointers to strings
-             int day, hour, min;
-             fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
-                     weekday, month, day, hour, min);
-             fprintf(stdout, "pi = %.5f\n", 4 * atan(1.0));
-
-17   EXAMPLE 2 In this example, multibyte characters do not have a state-dependent encoding, and the
-     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
-     the first of which is denoted here by a and the second by an uppercase letter.
-
-
-
-
-     <sup><a name="note249" href="#note249"><b>249)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
-          given format specifier. The number of significant digits is determined by the format specifier, and in
-          the case of fixed-point conversion by the source value as well.
-
-[<a name="p281" href="#p281">page 281</a>] (<a href="#Contents">Contents</a>)
-
-18   Given the following wide string with length seven,
-              static wchar_t wstr[] = L" X Yabc Z W";
-     the seven calls
-              fprintf(stdout,          "|1234567890123|\n");
-              fprintf(stdout,          "|%13ls|\n", wstr);
-              fprintf(stdout,          "|%-13.9ls|\n", wstr);
-              fprintf(stdout,          "|%13.10ls|\n", wstr);
-              fprintf(stdout,          "|%13.11ls|\n", wstr);
-              fprintf(stdout,          "|%13.15ls|\n", &amp;wstr[2]);
-              fprintf(stdout,          "|%13lc|\n", (wint_t) wstr[5]);
-     will print the following seven lines:
-              |1234567890123|
-              |   X Yabc Z W|
-              | X Yabc Z    |
-              |     X Yabc Z|
-              |   X Yabc Z W|
-              |      abc Z W|
-              |            Z|
-
-     Forward references: conversion state (<a href="#7.24.6">7.24.6</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
-<a name="7.19.6.2" href="#7.19.6.2"><b>     7.19.6.2 The fscanf function</b></a>
-<b>     Synopsis</b>
-1             #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              int fscanf(FILE * restrict stream,
-                   const char * restrict format, ...);
-<b>     Description</b>
-2    The fscanf function reads input from the stream pointed to by stream, under control
-     of the string pointed to by format that specifies the admissible input sequences and how
-     they are to be converted for assignment, using subsequent arguments as pointers to the
-     objects to receive the converted input. If there are insufficient arguments for the format,
-     the behavior is undefined. If the format is exhausted while arguments remain, the excess
-     arguments are evaluated (as always) but are otherwise ignored.
-3    The format shall be a multibyte character sequence, beginning and ending in its initial
-     shift state. The format is composed of zero or more directives: one or more white-space
-     characters, an ordinary multibyte character (neither % nor a white-space character), or a
-     conversion specification. Each conversion specification is introduced by the character %.
-     After the %, the following appear in sequence:
-     -- An optional assignment-suppressing character *.
-     -- An optional decimal integer greater than zero that specifies the maximum field width
-       (in characters).
-
-[<a name="p282" href="#p282">page 282</a>] (<a href="#Contents">Contents</a>)
-
-     -- An optional length modifier that specifies the size of the receiving object.
-     -- A conversion specifier character that specifies the type of conversion to be applied.
-4    The fscanf function executes each directive of the format in turn. If a directive fails, as
-     detailed below, the function returns. Failures are described as input failures (due to the
-     occurrence of an encoding error or the unavailability of input characters), or matching
-     failures (due to inappropriate input).
-5    A directive composed of white-space character(s) is executed by reading input up to the
-     first non-white-space character (which remains unread), or until no more characters can
-     be read.
-6    A directive that is an ordinary multibyte character is executed by reading the next
-     characters of the stream. If any of those characters differ from the ones composing the
-     directive, the directive fails and the differing and subsequent characters remain unread.
-     Similarly, if end-of-file, an encoding error, or a read error prevents a character from being
-     read, the directive fails.
-7    A directive that is a conversion specification defines a set of matching input sequences, as
-     described below for each specifier. A conversion specification is executed in the
-     following steps:
-8    Input white-space characters (as specified by the isspace function) are skipped, unless
-     the specification includes a [, c, or n specifier.<sup><a href="#note250"><b>250)</b></a></sup>
-9    An input item is read from the stream, unless the specification includes an n specifier. An
-     input item is defined as the longest sequence of input characters which does not exceed
-     any specified field width and which is, or is a prefix of, a matching input sequence.<sup><a href="#note251"><b>251)</b></a></sup>
-     The first character, if any, after the input item remains unread. If the length of the input
-     item is zero, the execution of the directive fails; this condition is a matching failure unless
-     end-of-file, an encoding error, or a read error prevented input from the stream, in which
-     case it is an input failure.
-10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
-     count of input characters) is converted to a type appropriate to the conversion specifier. If
-     the input item is not a matching sequence, the execution of the directive fails: this
-     condition is a matching failure. Unless assignment suppression was indicated by a *, the
-     result of the conversion is placed in the object pointed to by the first argument following
-     the format argument that has not already received a conversion result. If this object
-     does not have an appropriate type, or if the result of the conversion cannot be represented
-
-
-     <sup><a name="note250" href="#note250"><b>250)</b></a></sup> These white-space characters are not counted against a specified field width.
-     <sup><a name="note251" href="#note251"><b>251)</b></a></sup> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
-          that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
-
-[<a name="p283" href="#p283">page 283</a>] (<a href="#Contents">Contents</a>)
-
-     in the object, the behavior is undefined.
-11   The length modifiers and their meanings are:
-     hh           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to signed char or unsigned char.
-     h            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to short int or unsigned short
-                  int.
-     l (ell)      Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to long int or unsigned long
-                  int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
-                  an argument with type pointer to double; or that a following c, s, or [
-                  conversion specifier applies to an argument with type pointer to wchar_t.
-     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to long long int or unsigned
-                  long long int.
-     j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to intmax_t or uintmax_t.
-     z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to size_t or the corresponding signed
-                  integer type.
-     t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to ptrdiff_t or the corresponding
-                  unsigned integer type.
-     L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                  applies to an argument with type pointer to long double.
-     If a length modifier appears with any conversion specifier other than as specified above,
-     the behavior is undefined.
-12   The conversion specifiers and their meanings are:
-     d           Matches an optionally signed decimal integer, whose format is the same as
-                 expected for the subject sequence of the strtol function with the value 10
-                 for the base argument. The corresponding argument shall be a pointer to
-                 signed integer.
-     i           Matches an optionally signed integer, whose format is the same as expected
-                 for the subject sequence of the strtol function with the value 0 for the
-                 base argument. The corresponding argument shall be a pointer to signed
-                 integer.
-
-[<a name="p284" href="#p284">page 284</a>] (<a href="#Contents">Contents</a>)
-
-o             Matches an optionally signed octal integer, whose format is the same as
-              expected for the subject sequence of the strtoul function with the value 8
-              for the base argument. The corresponding argument shall be a pointer to
-              unsigned integer.
-u             Matches an optionally signed decimal integer, whose format is the same as
-              expected for the subject sequence of the strtoul function with the value 10
-              for the base argument. The corresponding argument shall be a pointer to
-              unsigned integer.
-x             Matches an optionally signed hexadecimal integer, whose format is the same
-              as expected for the subject sequence of the strtoul function with the value
-              16 for the base argument. The corresponding argument shall be a pointer to
-              unsigned integer.
-a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
-        format is the same as expected for the subject sequence of the strtod
-        function. The corresponding argument shall be a pointer to floating.
-c             Matches a sequence of characters of exactly the number specified by the field
-              width (1 if no field width is present in the directive).<sup><a href="#note252"><b>252)</b></a></sup>
-              If no l length modifier is present, the corresponding argument shall be a
-              pointer to the initial element of a character array large enough to accept the
-              sequence. No null character is added.
-              If an l length modifier is present, the input shall be a sequence of multibyte
-              characters that begins in the initial shift state. Each multibyte character in the
-              sequence is converted to a wide character as if by a call to the mbrtowc
-              function, with the conversion state described by an mbstate_t object
-              initialized to zero before the first multibyte character is converted. The
-              corresponding argument shall be a pointer to the initial element of an array of
-              wchar_t large enough to accept the resulting sequence of wide characters.
-              No null wide character is added.
-s             Matches a sequence of non-white-space characters.252)
-              If no l length modifier is present, the corresponding argument shall be a
-              pointer to the initial element of a character array large enough to accept the
-              sequence and a terminating null character, which will be added automatically.
-              If an l length modifier is present, the input shall be a sequence of multibyte
-
-
-<sup><a name="note252" href="#note252"><b>252)</b></a></sup> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
-     conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
-     resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
-
-[<a name="p285" href="#p285">page 285</a>] (<a href="#Contents">Contents</a>)
-
-         characters that begins in the initial shift state. Each multibyte character is
-         converted to a wide character as if by a call to the mbrtowc function, with
-         the conversion state described by an mbstate_t object initialized to zero
-         before the first multibyte character is converted. The corresponding argument
-         shall be a pointer to the initial element of an array of wchar_t large enough
-         to accept the sequence and the terminating null wide character, which will be
-         added automatically.
-[        Matches a nonempty sequence of characters from a set of expected characters
-         (the scanset).252)
-         If no l length modifier is present, the corresponding argument shall be a
-         pointer to the initial element of a character array large enough to accept the
-         sequence and a terminating null character, which will be added automatically.
-         If an l length modifier is present, the input shall be a sequence of multibyte
-         characters that begins in the initial shift state. Each multibyte character is
-         converted to a wide character as if by a call to the mbrtowc function, with
-         the conversion state described by an mbstate_t object initialized to zero
-         before the first multibyte character is converted. The corresponding argument
-         shall be a pointer to the initial element of an array of wchar_t large enough
-         to accept the sequence and the terminating null wide character, which will be
-         added automatically.
-         The conversion specifier includes all subsequent characters in the format
-         string, up to and including the matching right bracket (]). The characters
-         between the brackets (the scanlist) compose the scanset, unless the character
-         after the left bracket is a circumflex (^), in which case the scanset contains all
-         characters that do not appear in the scanlist between the circumflex and the
-         right bracket. If the conversion specifier begins with [] or [^], the right
-         bracket character is in the scanlist and the next following right bracket
-         character is the matching right bracket that ends the specification; otherwise
-         the first following right bracket character is the one that ends the
-         specification. If a - character is in the scanlist and is not the first, nor the
-         second where the first character is a ^, nor the last character, the behavior is
-         implementation-defined.
-p        Matches an implementation-defined set of sequences, which should be the
-         same as the set of sequences that may be produced by the %p conversion of
-         the fprintf function. The corresponding argument shall be a pointer to a
-         pointer to void. The input item is converted to a pointer value in an
-         implementation-defined manner. If the input item is a value converted earlier
-         during the same program execution, the pointer that results shall compare
-         equal to that value; otherwise the behavior of the %p conversion is undefined.
-
-[<a name="p286" href="#p286">page 286</a>] (<a href="#Contents">Contents</a>)
-
-     n              No input is consumed. The corresponding argument shall be a pointer to
-                    signed integer into which is to be written the number of characters read from
-                    the input stream so far by this call to the fscanf function. Execution of a
-                    %n directive does not increment the assignment count returned at the
-                    completion of execution of the fscanf function. No argument is converted,
-                    but one is consumed. If the conversion specification includes an assignment-
-                    suppressing character or a field width, the behavior is undefined.
-     %              Matches a single % character; no conversion or assignment occurs. The
-                    complete conversion specification shall be %%.
-13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note253"><b>253)</b></a></sup>
-14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
-     respectively, a, e, f, g, and x.
-15   Trailing white space (including new-line characters) is left unread unless matched by a
-     directive. The success of literal matches and suppressed assignments is not directly
-     determinable other than via the %n directive.
-<b>     Returns</b>
-16   The fscanf function returns the value of the macro EOF if an input failure occurs
-     before any conversion. Otherwise, the function returns the number of input items
-     assigned, which can be fewer than provided for, or even zero, in the event of an early
-     matching failure.
-17   EXAMPLE 1        The call:
-              #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              /* ... */
-              int n, i; float x; char name[50];
-              n = fscanf(stdin, "%d%f%s", &amp;i, &amp;x, name);
-     with the input line:
-              25 54.32E-1 thompson
-     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
-     thompson\0.
-
-18   EXAMPLE 2        The call:
-              #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              /* ... */
-              int i; float x; char name[50];
-              fscanf(stdin, "%2d%f%*d %[0123456789]", &amp;i, &amp;x, name);
-     with input:
-
-
-
-     <sup><a name="note253" href="#note253"><b>253)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
-
-[<a name="p287" href="#p287">page 287</a>] (<a href="#Contents">Contents</a>)
-
-              56789 0123 56a72
-     will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
-     sequence 56\0. The next character read from the input stream will be a.
-
-19   EXAMPLE 3         To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
-              #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              /* ... */
-              int count; float quant; char units[21], item[21];
-              do {
-                      count = fscanf(stdin, "%f%20s of %20s", &amp;quant, units, item);
-                      fscanf(stdin,"%*[^\n]");
-              } while (!feof(stdin) &amp;&amp; !ferror(stdin));
-20   If the stdin stream contains the following lines:
-              2 quarts of oil
-              -12.8degrees Celsius
-              lots of luck
-              10.0LBS      of
-              dirt
-              100ergs of energy
-     the execution of the above example will be analogous to the following assignments:
-              quant     =    2; strcpy(units, "quarts"); strcpy(item, "oil");
-              count     =    3;
-              quant     =    -12.8; strcpy(units, "degrees");
-              count     =    2; // "C" fails to match "o"
-              count     =    0; // "l" fails to match "%f"
-              quant     =    10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
-              count     =    3;
-              count     =    0; // "100e" fails to match "%f"
-              count     =    EOF;
-
-21   EXAMPLE 4         In:
-              #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              /* ... */
-              int d1, d2, n1, n2, i;
-              i = sscanf("123", "%d%n%n%d", &amp;d1, &amp;n1, &amp;n2, &amp;d2);
-     the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
-     of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
-
-22   EXAMPLE 5 In these examples, multibyte characters do have a state-dependent encoding, and the
-     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
-     the first of which is denoted here by a and the second by an uppercase letter, but are only recognized as
-     such when in the alternate shift state. The shift sequences are denoted by (uparrow) and (downarrow), in which the first causes
-     entry into the alternate shift state.
-23   After the call:
-
-[<a name="p288" href="#p288">page 288</a>] (<a href="#Contents">Contents</a>)
-
-               #include <a href="#7.19">&lt;stdio.h&gt;</a>
-               /* ... */
-               char str[50];
-               fscanf(stdin, "a%s", str);
-     with the input line:
-               a(uparrow) X Y(downarrow) bc
-     str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
-     characters, in the more general case) appears to be a single-byte white-space character.
-24   In contrast, after the call:
-               #include <a href="#7.19">&lt;stdio.h&gt;</a>
-               #include <a href="#7.17">&lt;stddef.h&gt;</a>
-               /* ... */
-               wchar_t wstr[50];
-               fscanf(stdin, "a%ls", wstr);
-     with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
-     terminating null wide character.
-25   However, the call:
-               #include <a href="#7.19">&lt;stdio.h&gt;</a>
-               #include <a href="#7.17">&lt;stddef.h&gt;</a>
+          // handle other operations
+          /* ... */</pre>
+  }
+<!--page 150 indent 4-->
+</ol>
+<p><!--para 4-->
+ EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
+ modified types. A jump within the scope, however, is permitted.
+<pre>
+         goto lab3;                         // invalid: going INTO scope of VLA.
+         {
+               double a[n];
+               a[j] = <a href="#4.4">4.4</a>;
+         lab3:
+               a[j] = <a href="#3.3">3.3</a>;
+               goto lab4;                   // valid: going WITHIN scope of VLA.
+               a[j] = <a href="#5.5">5.5</a>;
+         lab4:
+               a[j] = <a href="#6.6">6.6</a>;
+         }
+         goto lab4;                         // invalid: going INTO scope of VLA.</pre>
+ 
+
+<a name="6.8.6.2" href="#6.8.6.2"><h5>6.8.6.2 The continue statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A continue statement shall appear only in or as a loop body.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A continue statement causes a jump to the loop-continuation portion of the smallest
+ enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
+ of the statements
+ while (/* ... */) {                  do {                                 for (/* ... */) {
+<pre>
+    /* ... */                            /* ... */                            /* ... */
+    continue;                            continue;                            continue;
+    /* ... */                            /* ... */                            /* ... */</pre>
+ contin: ;                            contin: ;                            contin: ;
+ }                                    } while (/* ... */);                 }
+ unless the continue statement shown is in an enclosed iteration statement (in which
+ case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note138"><b>138)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note138">138)</a> Following the contin: label is a null statement.
+
+
+<a name="6.8.6.3" href="#6.8.6.3"><h5>6.8.6.3 The break statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A break statement shall appear only in or as a switch body or loop body.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A break statement terminates execution of the smallest enclosing switch or iteration
+ statement.
+ 
+ 
+ 
+<!--page 151 indent 4-->
+
+<a name="6.8.6.4" href="#6.8.6.4"><h5>6.8.6.4 The return statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A return statement with an expression shall not appear in a function whose return type
+ is void. A return statement without an expression shall only appear in a function
+ whose return type is void.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A return statement terminates execution of the current function and returns control to
+ its caller. A function may have any number of return statements.
+<p><!--para 3-->
+ If a return statement with an expression is executed, the value of the expression is
+ returned to the caller as the value of the function call expression. If the expression has a
+ type different from the return type of the function in which it appears, the value is
+ converted as if by assignment to an object having the return type of the function.<sup><a href="#note139"><b>139)</b></a></sup>
+<p><!--para 4-->
+ EXAMPLE       In:
+<pre>
+         struct s { double i; } f(void);
+         union {
+               struct {
+                     int f1;
+                     struct s f2;
+               } u1;
+               struct {
+                     struct s f3;
+                     int f4;
+               } u2;
+         } g;
+         struct s f(void)
+         {
+               return g.u1.f2;
+         }
+         /* ... */
+         g.u2.f3 = f();</pre>
+ there is no undefined behavior, although there would be if the assignment were done directly (without using
+ a function call to fetch the value).
+ 
+ 
+ 
+ 
+<!--page 152 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note139">139)</a> The return statement is not an assignment. The overlap restriction of subclause <a href="#6.5.16.1">6.5.16.1</a> does not
+ apply to the case of function return. The representation of floating-point values may have wider range
+ or precision and is determined by FLT_EVAL_METHOD. A cast may be used to remove this extra
+ range and precision.
+
+
+<a name="6.9" href="#6.9"><h3>6.9 External definitions</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          translation-unit:
+                  external-declaration
+                  translation-unit external-declaration
+          external-declaration:
+                 function-definition
+                 declaration</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The storage-class specifiers auto and register shall not appear in the declaration
+ specifiers in an external declaration.
+<p><!--para 3-->
+ There shall be no more than one external definition for each identifier declared with
+ internal linkage in a translation unit. Moreover, if an identifier declared with internal
+ linkage is used in an expression (other than as a part of the operand of a sizeof
+ operator whose result is an integer constant), there shall be exactly one external definition
+ for the identifier in the translation unit.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
+ which consists of a sequence of external declarations. These are described as ''external''
+ because they appear outside any function (and hence have file scope). As discussed in
+ <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
+ by the identifier is a definition.
+<p><!--para 5-->
+ An external definition is an external declaration that is also a definition of a function
+ (other than an inline definition) or an object. If an identifier declared with external
+ linkage is used in an expression (other than as part of the operand of a sizeof operator
+ whose result is an integer constant), somewhere in the entire program there shall be
+ exactly one external definition for the identifier; otherwise, there shall be no more than
+ one.<sup><a href="#note140"><b>140)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 153 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note140">140)</a> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
+ external definition for it.
+
+
+<a name="6.9.1" href="#6.9.1"><h4>6.9.1 Function definitions</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          function-definition:
+                 declaration-specifiers declarator declaration-listopt compound-statement
+          declaration-list:
+                 declaration
+                 declaration-list declaration</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The identifier declared in a function definition (which is the name of the function) shall
+ have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note141"><b>141)</b></a></sup>
+<p><!--para 3-->
+ The return type of a function shall be void or an object type other than array type.
+<p><!--para 4-->
+ The storage-class specifier, if any, in the declaration specifiers shall be either extern or
+ static.
+<p><!--para 5-->
+ If the declarator includes a parameter type list, the declaration of each parameter shall
+ include an identifier, except for the special case of a parameter list consisting of a single
+ parameter of type void, in which case there shall not be an identifier. No declaration list
+ shall follow.
+<p><!--para 6-->
+ If the declarator includes an identifier list, each declaration in the declaration list shall
+ have at least one declarator, those declarators shall declare only identifiers from the
+ identifier list, and every identifier in the identifier list shall be declared. An identifier
+ declared as a typedef name shall not be redeclared as a parameter. The declarations in the
+ declaration list shall contain no storage-class specifier other than register and no
+ initializations.
+ 
+ 
+ 
+ 
+<!--page 154 indent 5-->
+<h6>Semantics</h6>
+<p><!--para 7-->
+ The declarator in a function definition specifies the name of the function being defined
+ and the identifiers of its parameters. If the declarator includes a parameter type list, the
+ list also specifies the types of all the parameters; such a declarator also serves as a
+ function prototype for later calls to the same function in the same translation unit. If the
+ declarator includes an identifier list,<sup><a href="#note142"><b>142)</b></a></sup> the types of the parameters shall be declared in a
+ following declaration list. In either case, the type of each parameter is adjusted as
+ described in <a href="#6.7.5.3">6.7.5.3</a> for a parameter type list; the resulting type shall be an object type.
+<p><!--para 8-->
+ If a function that accepts a variable number of arguments is defined without a parameter
+ type list that ends with the ellipsis notation, the behavior is undefined.
+<p><!--para 9-->
+ Each parameter has automatic storage duration. Its identifier is an lvalue, which is in
+ effect declared at the head of the compound statement that constitutes the function body
+ (and therefore cannot be redeclared in the function body except in an enclosed block).
+ The layout of the storage for parameters is unspecified.
+<p><!--para 10-->
+ On entry to the function, the size expressions of each variably modified parameter are
+ evaluated and the value of each argument expression is converted to the type of the
+ corresponding parameter as if by assignment. (Array expressions and function
+ designators as arguments were converted to pointers before the call.)
+<p><!--para 11-->
+ After all parameters have been assigned, the compound statement that constitutes the
+ body of the function definition is executed.
+<p><!--para 12-->
+ If the } that terminates a function is reached, and the value of the function call is used by
+ the caller, the behavior is undefined.
+<p><!--para 13-->
+ EXAMPLE 1       In the following:
+<pre>
+          extern int max(int a, int b)
+          {
+                return a &gt; b ? a : b;
+          }</pre>
+ extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
+ function declarator; and
+<pre>
+          { return a &gt; b ? a : b; }</pre>
+ is the function body. The following similar definition uses the identifier-list form for the parameter
+ declarations:
+ 
+ 
+ 
+ 
+<!--page 155 indent 5-->
+<pre>
+          extern int max(a, b)
+          int a, b;
+          {
+                return a &gt; b ? a : b;
+          }</pre>
+ Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
+ that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
+ to the function, whereas the second form does not.
+ 
+<p><!--para 14-->
+ EXAMPLE 2           To pass one function to another, one might say
+<pre>
+                      int f(void);
+                      /* ... */
+                      g(f);</pre>
+ Then the definition of g might read
+<pre>
+          void g(int (*funcp)(void))
+          {
+                /* ... */
+                (*funcp)(); /* or funcp(); ...                    */
+          }</pre>
+ or, equivalently,
+<pre>
+          void g(int func(void))
+          {
+                /* ... */
+                func(); /* or (*func)(); ...                   */
+          }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note141">141)</a> The intent is that the type category in a function definition cannot be inherited from a typedef:
+
+<pre>
+          typedef int F(void);                          //   type F is ''function with no parameters
+                                                        //                  returning int''
+          F f, g;                                       //   f and g both have type compatible with F
+          F f { /* ... */ }                             //   WRONG: syntax/constraint error
+          F g() { /* ... */ }                           //   WRONG: declares that g returns a function
+          int f(void) { /* ... */ }                     //   RIGHT: f has type compatible with F
+          int g() { /* ... */ }                         //   RIGHT: g has type compatible with F
+          F *e(void) { /* ... */ }                      //   e returns a pointer to a function
+          F *((e))(void) { /* ... */ }                  //   same: parentheses irrelevant
+          int (*fp)(void);                              //   fp points to a function that has type F
+          F *Fp;                                        //   Fp points to a function that has type F</pre>
+
+<p><a name="note142">142)</a> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
+
+
+<a name="6.9.2" href="#6.9.2"><h4>6.9.2 External object definitions</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If the declaration of an identifier for an object has file scope and an initializer, the
+ declaration is an external definition for the identifier.
+<p><!--para 2-->
+ A declaration of an identifier for an object that has file scope without an initializer, and
+ without a storage-class specifier or with the storage-class specifier static, constitutes a
+ tentative definition. If a translation unit contains one or more tentative definitions for an
+ identifier, and the translation unit contains no external definition for that identifier, then
+ the behavior is exactly as if the translation unit contains a file scope declaration of that
+ identifier, with the composite type as of the end of the translation unit, with an initializer
+ equal to 0.
+<p><!--para 3-->
+ If the declaration of an identifier for an object is a tentative definition and has internal
+ linkage, the declared type shall not be an incomplete type.
+<!--page 156 indent 4-->
+<p><!--para 4-->
+ EXAMPLE 1
+<pre>
+          int i1 = 1;                    // definition, external linkage
+          static int i2 = 2;             // definition, internal linkage
+          extern int i3 = 3;             // definition, external linkage
+          int i4;                        // tentative definition, external linkage
+          static int i5;                 // tentative definition, internal linkage
+          int   i1;                      // valid tentative definition, refers to previous
+          int   i2;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+          int   i3;                      // valid tentative definition, refers to previous
+          int   i4;                      // valid tentative definition, refers to previous
+          int   i5;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+          extern    int   i1;            // refers to previous, whose linkage is external
+          extern    int   i2;            // refers to previous, whose linkage is internal
+          extern    int   i3;            // refers to previous, whose linkage is external
+          extern    int   i4;            // refers to previous, whose linkage is external
+          extern    int   i5;            // refers to previous, whose linkage is internal</pre>
+ 
+<p><!--para 5-->
+ EXAMPLE 2       If at the end of the translation unit containing
+<pre>
+          int i[];</pre>
+ the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
+ zero on program startup.
+<!--page 157 indent 4-->
+
+<a name="6.10" href="#6.10"><h3>6.10 Preprocessing directives</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 158 indent 4-->
+<pre>
+          preprocessing-file:
+                 groupopt
+          group:
+                   group-part
+                   group group-part
+          group-part:
+                 if-section
+                 control-line
+                 text-line
+                 # non-directive
+          if-section:
+                   if-group elif-groupsopt else-groupopt endif-line
+          if-group:
+                  # if     constant-expression new-line groupopt
+                  # ifdef identifier new-line groupopt
+                  # ifndef identifier new-line groupopt
+          elif-groups:
+                  elif-group
+                  elif-groups elif-group
+          elif-group:
+                  # elif       constant-expression new-line groupopt
+          else-group:
+                  # else       new-line groupopt
+          endif-line:
+                  # endif      new-line
+          control-line:
+                 # include pp-tokens new-line
+                 # define identifier replacement-list new-line
+                 # define identifier lparen identifier-listopt )
+                                                 replacement-list new-line
+                 # define identifier lparen ... ) replacement-list new-line
+                 # define identifier lparen identifier-list , ... )
+                                                 replacement-list new-line
+                 # undef   identifier new-line
+                 # line    pp-tokens new-line
+                 # error   pp-tokensopt new-line
+                 # pragma pp-tokensopt new-line
+                 #         new-line
+          text-line:
+                  pp-tokensopt new-line
+          non-directive:
+                 pp-tokens new-line
+          lparen:
+                    a ( character not immediately preceded by white-space
+          replacement-list:
+                 pp-tokensopt
+          pp-tokens:
+                 preprocessing-token
+                 pp-tokens preprocessing-token
+          new-line:
+                 the new-line character</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
+ following constraints: The first token in the sequence is a # preprocessing token that (at
+ the start of translation phase 4) is either the first character in the source file (optionally
+ after white space containing no new-line characters) or that follows white space
+ containing at least one new-line character. The last token in the sequence is the first new-
+ line character that follows the first token in the sequence.<sup><a href="#note143"><b>143)</b></a></sup> A new-line character ends
+ the preprocessing directive even if it occurs within what would otherwise be an
+ 
+<!--page 159 indent 4-->
+ invocation of a function-like macro.
+<p><!--para 3-->
+ A text line shall not begin with a # preprocessing token. A non-directive shall not begin
+ with any of the directive names appearing in the syntax.
+<p><!--para 4-->
+ When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
+ sequence of preprocessing tokens to occur between the directive name and the following
+ new-line character.
+<h6>Constraints</h6>
+<p><!--para 5-->
+ The only white-space characters that shall appear between preprocessing tokens within a
+ preprocessing directive (from just after the introducing # preprocessing token through
+ just before the terminating new-line character) are space and horizontal-tab (including
+ spaces that have replaced comments or possibly other white-space characters in
+ translation phase 3).
+<h6>Semantics</h6>
+<p><!--para 6-->
+ The implementation can process and skip sections of source files conditionally, include
+ other source files, and replace macros. These capabilities are called preprocessing,
+ because conceptually they occur before translation of the resulting translation unit.
+<p><!--para 7-->
+ The preprocessing tokens within a preprocessing directive are not subject to macro
+ expansion unless otherwise stated.
+<p><!--para 8-->
+ EXAMPLE        In:
+<pre>
+          #define EMPTY
+          EMPTY # include &lt;file.h&gt;</pre>
+ the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
+ begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
+ replaced.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note143">143)</a> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
+ significance, as all white space is equivalent except in certain situations during preprocessing (see the
+ # character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
+
+
+<a name="6.10.1" href="#6.10.1"><h4>6.10.1 Conditional inclusion</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The expression that controls conditional inclusion shall be an integer constant expression
+ except that: it shall not contain a cast; identifiers (including those lexically identical to
+ keywords) are interpreted as described below;<sup><a href="#note144"><b>144)</b></a></sup> and it may contain unary operator
+ expressions of the form
+ 
+ 
+ 
+ 
+<!--page 160 indent 4-->
+<pre>
+      defined identifier</pre>
+ or
+<pre>
+      defined ( identifier )</pre>
+ which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
+ predefined or if it has been the subject of a #define preprocessing directive without an
+ intervening #undef directive with the same subject identifier), 0 if it is not.
+<p><!--para 2-->
+ Each preprocessing token that remains (in the list of preprocessing tokens that will
+ become the controlling expression) after all macro replacements have occurred shall be in
+ the lexical form of a token (<a href="#6.4">6.4</a>).
+<h6>Semantics</h6>
+<p><!--para 3-->
+ Preprocessing directives of the forms
+<pre>
+      # if   constant-expression new-line groupopt
+      # elif constant-expression new-line groupopt</pre>
+ check whether the controlling constant expression evaluates to nonzero.
+<p><!--para 4-->
+ Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
+ the controlling constant expression are replaced (except for those macro names modified
+ by the defined unary operator), just as in normal text. If the token defined is
+ generated as a result of this replacement process or use of the defined unary operator
+ does not match one of the two specified forms prior to macro replacement, the behavior is
+ undefined. After all replacements due to macro expansion and the defined unary
+ operator have been performed, all remaining identifiers (including those lexically
+ identical to keywords) are replaced with the pp-number 0, and then each preprocessing
+ token is converted into a token. The resulting tokens compose the controlling constant
+ expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
+ token conversion and evaluation, all signed integer types and all unsigned integer types
+ act as if they have the same representation as, respectively, the types intmax_t and
+ uintmax_t defined in the header &lt;stdint.h&gt;.<sup><a href="#note145"><b>145)</b></a></sup> This includes interpreting
+ character constants, which may involve converting escape sequences into execution
+ character set members. Whether the numeric value for these character constants matches
+ the value obtained when an identical character constant occurs in an expression (other
+ than within a #if or #elif directive) is implementation-defined.<sup><a href="#note146"><b>146)</b></a></sup> Also, whether a
+ single-character character constant may have a negative value is implementation-defined.
+<p><!--para 5-->
+ Preprocessing directives of the forms
+ 
+ 
+ 
+<!--page 161 indent 4-->
+<pre>
+    # ifdef identifier new-line groupopt
+    # ifndef identifier new-line groupopt</pre>
+ check whether the identifier is or is not currently defined as a macro name. Their
+ conditions are equivalent to #if defined identifier and #if !defined identifier
+ respectively.
+<p><!--para 6-->
+ Each directive's condition is checked in order. If it evaluates to false (zero), the group
+ that it controls is skipped: directives are processed only through the name that determines
+ the directive in order to keep track of the level of nested conditionals; the rest of the
+ directives' preprocessing tokens are ignored, as are the other preprocessing tokens in the
+ group. Only the first group whose control condition evaluates to true (nonzero) is
+ processed. If none of the conditions evaluates to true, and there is a #else directive, the
+ group controlled by the #else is processed; lacking a #else directive, all the groups
+ until the #endif are skipped.<sup><a href="#note147"><b>147)</b></a></sup>
+ Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
+ integer types (<a href="#7.18.1.5">7.18.1.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note144">144)</a> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
+ either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
+
+<p><a name="note145">145)</a> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
+ 0x8000 is signed and positive within a #if expression even though it would be unsigned in
+ translation phase 7.
+
+<p><a name="note146">146)</a> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
+ evaluate to the same value in these two contexts.
+   #if 'z' - 'a' == 25
+   if ('z' - 'a' == 25)
+ 
+
+<p><a name="note147">147)</a> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
+ before the terminating new-line character. However, comments may appear anywhere in a source file,
+ including within a preprocessing directive.
+
+
+<a name="6.10.2" href="#6.10.2"><h4>6.10.2 Source file inclusion</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A #include directive shall identify a header or source file that can be processed by the
+ implementation.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A preprocessing directive of the form
+<pre>
+    # include &lt;h-char-sequence&gt; new-line</pre>
+ searches a sequence of implementation-defined places for a header identified uniquely by
+ the specified sequence between the &lt; and &gt; delimiters, and causes the replacement of that
+ directive by the entire contents of the header. How the places are specified or the header
+ identified is implementation-defined.
+<p><!--para 3-->
+ A preprocessing directive of the form
+ 
+ 
+ 
+<!--page 162 indent 4-->
+<pre>
+    # include "q-char-sequence" new-line</pre>
+ causes the replacement of that directive by the entire contents of the source file identified
+ by the specified sequence between the " delimiters. The named source file is searched
+ for in an implementation-defined manner. If this search is not supported, or if the search
+ fails, the directive is reprocessed as if it read
+<pre>
+    # include &lt;h-char-sequence&gt; new-line</pre>
+ with the identical contained sequence (including &gt; characters, if any) from the original
+ directive.
+<p><!--para 4-->
+ A preprocessing directive of the form
+<pre>
+    # include pp-tokens new-line</pre>
+ (that does not match one of the two previous forms) is permitted. The preprocessing
+ tokens after include in the directive are processed just as in normal text. (Each
+ identifier currently defined as a macro name is replaced by its replacement list of
+ preprocessing tokens.) The directive resulting after all replacements shall match one of
+ the two previous forms.<sup><a href="#note148"><b>148)</b></a></sup> The method by which a sequence of preprocessing tokens
+ between a &lt; and a &gt; preprocessing token pair or a pair of " characters is combined into a
+ single header name preprocessing token is implementation-defined.
+<p><!--para 5-->
+ The implementation shall provide unique mappings for sequences consisting of one or
+ more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
+ first character shall not be a digit. The implementation may ignore distinctions of
+ alphabetical case and restrict the mapping to eight significant characters before the
+ period.
+<p><!--para 6-->
+ A #include preprocessing directive may appear in a source file that has been read
+ because of a #include directive in another file, up to an implementation-defined
+ nesting limit (see <a href="#5.2.4.1">5.2.4.1</a>).
+<p><!--para 7-->
+ EXAMPLE 1       The most common uses of #include preprocessing directives are as in the following:
+<pre>
+          #include &lt;stdio.h&gt;
+          #include "myprog.h"</pre>
+ 
+<p><!--para 8-->
+ EXAMPLE 2       This illustrates macro-replaced #include directives:
+ 
+ 
+ 
+ 
+<!--page 163 indent 4-->
+<pre>
+        #if VERSION == 1
+              #define INCFILE        "vers1.h"
+        #elif VERSION == 2
+              #define INCFILE        "vers2.h"      // and so on
+        #else
+              #define INCFILE        "versN.h"
+        #endif
+        #include INCFILE</pre>
+ 
+ Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note148">148)</a> Note that adjacent string literals are not concatenated into a single string literal (see the translation
+ phases in <a href="#5.1.1.2">5.1.1.2</a>); thus, an expansion that results in two string literals is an invalid directive.
+
+
+<a name="6.10.3" href="#6.10.3"><h4>6.10.3 Macro replacement</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ Two replacement lists are identical if and only if the preprocessing tokens in both have
+ the same number, ordering, spelling, and white-space separation, where all white-space
+ separations are considered identical.
+<p><!--para 2-->
+ An identifier currently defined as an object-like macro shall not be redefined by another
+ #define preprocessing directive unless the second definition is an object-like macro
+ definition and the two replacement lists are identical. Likewise, an identifier currently
+ defined as a function-like macro shall not be redefined by another #define
+ preprocessing directive unless the second definition is a function-like macro definition
+ that has the same number and spelling of parameters, and the two replacement lists are
+ identical.
+<p><!--para 3-->
+ There shall be white-space between the identifier and the replacement list in the definition
+ of an object-like macro.
+<p><!--para 4-->
+ If the identifier-list in the macro definition does not end with an ellipsis, the number of
+ arguments (including those arguments consisting of no preprocessing tokens) in an
+ invocation of a function-like macro shall equal the number of parameters in the macro
+ definition. Otherwise, there shall be more arguments in the invocation than there are
+ parameters in the macro definition (excluding the ...). There shall exist a )
+ preprocessing token that terminates the invocation.
+<p><!--para 5-->
+ The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
+ macro that uses the ellipsis notation in the parameters.
+<p><!--para 6-->
+ A parameter identifier in a function-like macro shall be uniquely declared within its
+ scope.
+<h6>Semantics</h6>
+<p><!--para 7-->
+ The identifier immediately following the define is called the macro name. There is one
+ name space for macro names. Any white-space characters preceding or following the
+ replacement list of preprocessing tokens are not considered part of the replacement list
+ for either form of macro.
+<!--page 164 indent 5-->
+<p><!--para 8-->
+ If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
+ a preprocessing directive could begin, the identifier is not subject to macro replacement.
+<p><!--para 9-->
+ A preprocessing directive of the form
+<pre>
+    # define identifier replacement-list new-line</pre>
+ defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note149"><b>149)</b></a></sup>
+ to be replaced by the replacement list of preprocessing tokens that constitute the
+ remainder of the directive. The replacement list is then rescanned for more macro names
+ as specified below.
+<p><!--para 10-->
+ A preprocessing directive of the form
+<pre>
+    # define identifier lparen identifier-listopt ) replacement-list new-line
+    # define identifier lparen ... ) replacement-list new-line
+    # define identifier lparen identifier-list , ... ) replacement-list new-line</pre>
+ defines a function-like macro with parameters, whose use is similar syntactically to a
+ function call. The parameters are specified by the optional list of identifiers, whose scope
+ extends from their declaration in the identifier list until the new-line character that
+ terminates the #define preprocessing directive. Each subsequent instance of the
+ function-like macro name followed by a ( as the next preprocessing token introduces the
+ sequence of preprocessing tokens that is replaced by the replacement list in the definition
+ (an invocation of the macro). The replaced sequence of preprocessing tokens is
+ terminated by the matching ) preprocessing token, skipping intervening matched pairs of
+ left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
+ tokens making up an invocation of a function-like macro, new-line is considered a normal
+ white-space character.
+<p><!--para 11-->
+ The sequence of preprocessing tokens bounded by the outside-most matching parentheses
+ forms the list of arguments for the function-like macro. The individual arguments within
+ the list are separated by comma preprocessing tokens, but comma preprocessing tokens
+ between matching inner parentheses do not separate arguments. If there are sequences of
+ preprocessing tokens within the list of arguments that would otherwise act as
+ preprocessing directives,<sup><a href="#note150"><b>150)</b></a></sup> the behavior is undefined.
+<p><!--para 12-->
+ If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
+ including any separating comma preprocessing tokens, are merged to form a single item:
+ the variable arguments. The number of arguments so combined is such that, following
+ 
+ 
+<!--page 165 indent 4-->
+ merger, the number of arguments is one more than the number of parameters in the macro
+ definition (excluding the ...).
+
+<h6>footnotes</h6>
+<p><a name="note149">149)</a> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
+ not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
+ are never scanned for macro names or parameters.
+
+<p><a name="note150">150)</a> Despite the name, a non-directive is a preprocessing directive.
+
+
+<a name="6.10.3.1" href="#6.10.3.1"><h5>6.10.3.1 Argument substitution</h5></a>
+<p><!--para 1-->
+ After the arguments for the invocation of a function-like macro have been identified,
+ argument substitution takes place. A parameter in the replacement list, unless preceded
+ by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
+ replaced by the corresponding argument after all macros contained therein have been
+ expanded. Before being substituted, each argument's preprocessing tokens are
+ completely macro replaced as if they formed the rest of the preprocessing file; no other
+ preprocessing tokens are available.
+<p><!--para 2-->
+ An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
+ were a parameter, and the variable arguments shall form the preprocessing tokens used to
+ replace it.
+
+<a name="6.10.3.2" href="#6.10.3.2"><h5>6.10.3.2 The # operator</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ Each # preprocessing token in the replacement list for a function-like macro shall be
+ followed by a parameter as the next preprocessing token in the replacement list.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ If, in the replacement list, a parameter is immediately preceded by a # preprocessing
+ token, both are replaced by a single character string literal preprocessing token that
+ contains the spelling of the preprocessing token sequence for the corresponding
+ argument. Each occurrence of white space between the argument's preprocessing tokens
+ becomes a single space character in the character string literal. White space before the
+ first preprocessing token and after the last preprocessing token composing the argument
+ is deleted. Otherwise, the original spelling of each preprocessing token in the argument
+ is retained in the character string literal, except for special handling for producing the
+ spelling of string literals and character constants: a \ character is inserted before each "
+ and \ character of a character constant or string literal (including the delimiting "
+ characters), except that it is implementation-defined whether a \ character is inserted
+ before the \ character beginning a universal character name. If the replacement that
+ results is not a valid character string literal, the behavior is undefined. The character
+ string literal corresponding to an empty argument is "". The order of evaluation of # and
+ ## operators is unspecified.
+<!--page 166 indent 4-->
+
+<a name="6.10.3.3" href="#6.10.3.3"><h5>6.10.3.3 The ## operator</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A ## preprocessing token shall not occur at the beginning or at the end of a replacement
+ list for either form of macro definition.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ If, in the replacement list of a function-like macro, a parameter is immediately preceded
+ or followed by a ## preprocessing token, the parameter is replaced by the corresponding
+ argument's preprocessing token sequence; however, if an argument consists of no
+ preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
+ instead.<sup><a href="#note151"><b>151)</b></a></sup>
+<p><!--para 3-->
+ For both object-like and function-like macro invocations, before the replacement list is
+ reexamined for more macro names to replace, each instance of a ## preprocessing token
+ in the replacement list (not from an argument) is deleted and the preceding preprocessing
+ token is concatenated with the following preprocessing token. Placemarker
+ preprocessing tokens are handled specially: concatenation of two placemarkers results in
+ a single placemarker preprocessing token, and concatenation of a placemarker with a
+ non-placemarker preprocessing token results in the non-placemarker preprocessing token.
+ If the result is not a valid preprocessing token, the behavior is undefined. The resulting
+ token is available for further macro replacement. The order of evaluation of ## operators
+ is unspecified.
+<p><!--para 4-->
+ EXAMPLE       In the following fragment:
+<pre>
+         #define     hash_hash # ## #
+         #define     mkstr(a) # a
+         #define     in_between(a) mkstr(a)
+         #define     join(c, d) in_between(c hash_hash d)
+         char p[] = join(x, y); // equivalent to
+                                // char p[] = "x ## y";</pre>
+ The expansion produces, at various stages:
+<pre>
+         join(x, y)
+         in_between(x hash_hash y)
+         in_between(x ## y)
+         mkstr(x ## y)
+         "x ## y"</pre>
+ In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
+ this new token is not the ## operator.
+ 
+ 
+<!--page 167 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note151">151)</a> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
+ exist only within translation phase 4.
+
+
+<a name="6.10.3.4" href="#6.10.3.4"><h5>6.10.3.4 Rescanning and further replacement</h5></a>
+<p><!--para 1-->
+ After all parameters in the replacement list have been substituted and # and ##
+ processing has taken place, all placemarker preprocessing tokens are removed. Then, the
+ resulting preprocessing token sequence is rescanned, along with all subsequent
+ preprocessing tokens of the source file, for more macro names to replace.
+<p><!--para 2-->
+ If the name of the macro being replaced is found during this scan of the replacement list
+ (not including the rest of the source file's preprocessing tokens), it is not replaced.
+ Furthermore, if any nested replacements encounter the name of the macro being replaced,
+ it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
+ available for further replacement even if they are later (re)examined in contexts in which
+ that macro name preprocessing token would otherwise have been replaced.
+<p><!--para 3-->
+ The resulting completely macro-replaced preprocessing token sequence is not processed
+ as a preprocessing directive even if it resembles one, but all pragma unary operator
+ expressions within it are then processed as specified in <a href="#6.10.9">6.10.9</a> below.
+
+<a name="6.10.3.5" href="#6.10.3.5"><h5>6.10.3.5 Scope of macro definitions</h5></a>
+<p><!--para 1-->
+ A macro definition lasts (independent of block structure) until a corresponding #undef
+ directive is encountered or (if none is encountered) until the end of the preprocessing
+ translation unit. Macro definitions have no significance after translation phase 4.
+<p><!--para 2-->
+ A preprocessing directive of the form
+<pre>
+    # undef identifier new-line</pre>
+ causes the specified identifier no longer to be defined as a macro name. It is ignored if
+ the specified identifier is not currently defined as a macro name.
+<p><!--para 3-->
+ EXAMPLE 1      The simplest use of this facility is to define a ''manifest constant'', as in
+<pre>
+         #define TABSIZE 100
+         int table[TABSIZE];</pre>
+ 
+<p><!--para 4-->
+ EXAMPLE 2 The following defines a function-like macro whose value is the maximum of its arguments.
+ It has the advantages of working for any compatible types of the arguments and of generating in-line code
+ without the overhead of function calling. It has the disadvantages of evaluating one or the other of its
+ arguments a second time (including side effects) and generating more code than a function if invoked
+ several times. It also cannot have its address taken, as it has none.
+<pre>
+         #define max(a, b) ((a) &gt; (b) ? (a) : (b))</pre>
+ The parentheses ensure that the arguments and the resulting expression are bound properly.
+<!--page 168 indent 4-->
+<p><!--para 5-->
+ EXAMPLE 3     To illustrate the rules for redefinition and reexamination, the sequence
+<pre>
+          #define   x         3
+          #define   f(a)      f(x * (a))
+          #undef    x
+          #define   x         2
+          #define   g         f
+          #define   z         z[0]
+          #define   h         g(~
+          #define   m(a)      a(w)
+          #define   w         0,1
+          #define   t(a)      a
+          #define   p()       int
+          #define   q(x)      x
+          #define   r(x,y)    x ## y
+          #define   str(x)    # x
+          f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);
+          g(x+(3,4)-w) | h 5) &amp; m
+                (f)^m(m);
+          p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
+          char c[2][6] = { str(hello), str() };</pre>
+ results in
+<pre>
+          f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
+          f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) &amp; f(2 * (0,1))^m(0,1);
+          int i[] = { 1, 23, 4, 5, };
+          char c[2][6] = { "hello", "" };</pre>
+ 
+<p><!--para 6-->
+ EXAMPLE 4     To illustrate the rules for creating character string literals and concatenating tokens, the
+ sequence
+<pre>
+          #define str(s)      # s
+          #define xstr(s)     str(s)
+          #define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
+                                  x ## s, x ## t)
+          #define INCFILE(n) vers ## n
+          #define glue(a, b) a ## b
+          #define xglue(a, b) glue(a, b)
+          #define HIGHLOW     "hello"
+          #define LOW         LOW ", world"
+          debug(1, 2);
+          fputs(str(strncmp("abc\0d", "abc", '\4') // this goes away
+                == 0) str(: @\n), s);
+          #include xstr(INCFILE(2).h)
+          glue(HIGH, LOW);
+          xglue(HIGH, LOW)</pre>
+ results in
+<!--page 169 indent 4-->
+<pre>
+          printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
+          fputs(
+            "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0" ": @\n",
+            s);
+          #include "vers2.h"    (after macro replacement, before file access)
+          "hello";
+          "hello" ", world"</pre>
+ or, after concatenation of the character string literals,
+<pre>
+          printf("x1= %d, x2= %s", x1, x2);
+          fputs(
+            "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: @\n",
+            s);
+          #include "vers2.h"    (after macro replacement, before file access)
+          "hello";
+          "hello, world"</pre>
+ Space around the # and ## tokens in the macro definition is optional.
+ 
+<p><!--para 7-->
+ EXAMPLE 5        To illustrate the rules for placemarker preprocessing tokens, the sequence
+<pre>
+          #define t(x,y,z) x ## y ## z
+          int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
+                     t(10,,), t(,11,), t(,,12), t(,,) };</pre>
+ results in
+<pre>
+          int j[] = { 123, 45, 67, 89,
+                      10, 11, 12, };</pre>
+ 
+<p><!--para 8-->
+ EXAMPLE 6        To demonstrate the redefinition rules, the following sequence is valid.
+<pre>
+          #define      OBJ_LIKE      (1-1)
+          #define      OBJ_LIKE      /* white space */ (1-1) /* other */
+          #define      FUNC_LIKE(a)   ( a )
+          #define      FUNC_LIKE( a )( /* note the white space */ \
+                                       a /* other stuff on this line
+                                           */ )</pre>
+ But the following redefinitions are invalid:
+<pre>
+          #define      OBJ_LIKE    (0)     // different token sequence
+          #define      OBJ_LIKE    (1 - 1) // different white space
+          #define      FUNC_LIKE(b) ( a ) // different parameter usage
+          #define      FUNC_LIKE(b) ( b ) // different parameter spelling</pre>
+ 
+<p><!--para 9-->
+ EXAMPLE 7        Finally, to show the variable argument list macro facilities:
+<!--page 170 indent 4-->
+<pre>
+          #define debug(...)       fprintf(stderr, __VA_ARGS__)
+          #define showlist(...)    puts(#__VA_ARGS__)
+          #define report(test, ...) ((test)?puts(#test):\
+                      printf(__VA_ARGS__))
+          debug("Flag");
+          debug("X = %d\n", x);
+          showlist(The first, second, and third items.);
+          report(x&gt;y, "x is %d but y is %d", x, y);</pre>
+ results in
+<pre>
+          fprintf(stderr, "Flag" );
+          fprintf(stderr, "X = %d\n", x );
+          puts( "The first, second, and third items." );
+          ((x&gt;y)?puts("x&gt;y"):
+                      printf("x is %d but y is %d", x, y));</pre>
+ 
+
+<a name="6.10.4" href="#6.10.4"><h4>6.10.4 Line control</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The string literal of a #line directive, if present, shall be a character string literal.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The line number of the current source line is one greater than the number of new-line
+ characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
+ file to the current token.
+<p><!--para 3-->
+ A preprocessing directive of the form
+<pre>
+    # line digit-sequence new-line</pre>
+ causes the implementation to behave as if the following sequence of source lines begins
+ with a source line that has a line number as specified by the digit sequence (interpreted as
+ a decimal integer). The digit sequence shall not specify zero, nor a number greater than
+ 2147483647.
+<p><!--para 4-->
+ A preprocessing directive of the form
+<pre>
+    # line digit-sequence "s-char-sequenceopt" new-line</pre>
+ sets the presumed line number similarly and changes the presumed name of the source
+ file to be the contents of the character string literal.
+<p><!--para 5-->
+ A preprocessing directive of the form
+<pre>
+    # line pp-tokens new-line</pre>
+ (that does not match one of the two previous forms) is permitted. The preprocessing
+ tokens after line on the directive are processed just as in normal text (each identifier
+ currently defined as a macro name is replaced by its replacement list of preprocessing
+ tokens). The directive resulting after all replacements shall match one of the two
+ previous forms and is then processed as appropriate.
+<!--page 171 indent 4-->
+
+<a name="6.10.5" href="#6.10.5"><h4>6.10.5 Error directive</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A preprocessing directive of the form
+<pre>
+    # error pp-tokensopt new-line</pre>
+ causes the implementation to produce a diagnostic message that includes the specified
+ sequence of preprocessing tokens.
+
+<a name="6.10.6" href="#6.10.6"><h4>6.10.6 Pragma directive</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A preprocessing directive of the form
+<pre>
+    # pragma pp-tokensopt new-line</pre>
+ where the preprocessing token STDC does not immediately follow pragma in the
+ directive (prior to any macro replacement)<sup><a href="#note152"><b>152)</b></a></sup> causes the implementation to behave in an
+ implementation-defined manner. The behavior might cause translation to fail or cause the
+ translator or the resulting program to behave in a non-conforming manner. Any such
+ pragma that is not recognized by the implementation is ignored.
+<p><!--para 2-->
+ If the preprocessing token STDC does immediately follow pragma in the directive (prior
+ to any macro replacement), then no macro replacement is performed on the directive, and
+ the directive shall have one of the following forms<sup><a href="#note153"><b>153)</b></a></sup> whose meanings are described
+ elsewhere:
+<pre>
+    #pragma STDC FP_CONTRACT on-off-switch
+    #pragma STDC FENV_ACCESS on-off-switch
+    #pragma STDC CX_LIMITED_RANGE on-off-switch
+    on-off-switch: one of
+                ON     OFF           DEFAULT</pre>
+ Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
+ (<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
+ 
+ 
+ 
+ 
+<!--page 172 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note152">152)</a> An implementation is not required to perform macro replacement in pragmas, but it is permitted
+ except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
+ replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
+ implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
+ but is not required to.
+
+<p><a name="note153">153)</a> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
+
+
+<a name="6.10.7" href="#6.10.7"><h4>6.10.7 Null directive</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A preprocessing directive of the form
+<pre>
+    # new-line</pre>
+ has no effect.
+
+<a name="6.10.8" href="#6.10.8"><h4>6.10.8 Predefined macro names</h4></a>
+<p><!--para 1-->
+ The following macro names<sup><a href="#note154"><b>154)</b></a></sup> shall be defined by the implementation:
+ __DATE__ The date of translation of the preprocessing translation unit: a character
+<pre>
+            string literal of the form "Mmm dd yyyy", where the names of the
+            months are the same as those generated by the asctime function, and the
+            first character of dd is a space character if the value is less than 10. If the
+            date of translation is not available, an implementation-defined valid date
+            shall be supplied.</pre>
+ __FILE__ The presumed name of the current source file (a character string literal).<sup><a href="#note155"><b>155)</b></a></sup>
+ __LINE__ The presumed line number (within the current source file) of the current
+<pre>
+            source line (an integer constant).155)</pre>
+ __STDC__ The integer constant 1, intended to indicate a conforming implementation.
+ __STDC_HOSTED__ The integer constant 1 if the implementation is a hosted
+<pre>
+           implementation or the integer constant 0 if it is not.</pre>
+ __STDC_MB_MIGHT_NEQ_WC__ The integer constant 1, intended to indicate that, in
+<pre>
+           the encoding for wchar_t, a member of the basic character set need not
+           have a code value equal to its value when used as the lone character in an
+           integer character constant.</pre>
+ __STDC_VERSION__ The integer constant 199901L.<sup><a href="#note156"><b>156)</b></a></sup>
+ __TIME__ The time of translation of the preprocessing translation unit: a character
+<pre>
+            string literal of the form "hh:mm:ss" as in the time generated by the
+            asctime function. If the time of translation is not available, an
+            implementation-defined valid time shall be supplied.</pre>
+ 
+ 
+ 
+<!--page 173 indent 4-->
+<p><!--para 2-->
+ The following macro names are conditionally defined by the implementation:
+ __STDC_IEC_559__ The integer constant 1, intended to indicate conformance to the
+<pre>
+           specifications in <a href="#F">annex F</a> (IEC 60559 floating-point arithmetic).</pre>
+ __STDC_IEC_559_COMPLEX__ The integer constant 1, intended to indicate
+<pre>
+           adherence to the specifications in informative <a href="#G">annex G</a> (IEC 60559
+           compatible complex arithmetic).</pre>
+ __STDC_ISO_10646__ An integer constant of the form yyyymmL (for example,
+<p><!--para 3-->
+<pre>
+           199712L). If this symbol is defined, then every character in the Unicode
+           required set, when stored in an object of type wchar_t, has the same
+           value as the short identifier of that character. The Unicode required set
+           consists of all the characters that are defined by ISO/IEC 10646, along with
+           all amendments and technical corrigenda, as of the specified year and
+           month.</pre>
+ The values of the predefined macros (except for __FILE__ and __LINE__) remain
+ constant throughout the translation unit.
+<p><!--para 4-->
+ None of these macro names, nor the identifier defined, shall be the subject of a
+ #define or a #undef preprocessing directive. Any other predefined macro names
+ shall begin with a leading underscore followed by an uppercase letter or a second
+ underscore.
+<p><!--para 5-->
+ The implementation shall not predefine the macro __cplusplus, nor shall it define it
+ in any standard header.
+ Forward references: the asctime function (<a href="#7.23.3.1">7.23.3.1</a>), standard headers (<a href="#7.1.2">7.1.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note154">154)</a> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
+
+<p><a name="note155">155)</a> The presumed source file name and line number can be changed by the #line directive.
+
+<p><a name="note156">156)</a> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
+ ISO/IEC 9899/AMD1:1995. The intention is that this will remain an integer constant of type long
+ int that is increased with each revision of this International Standard.
+
+
+<a name="6.10.9" href="#6.10.9"><h4>6.10.9 Pragma operator</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A unary operator expression of the form:
+<pre>
+    _Pragma ( string-literal )</pre>
+ is processed as follows: The string literal is destringized by deleting the L prefix, if
+ present, deleting the leading and trailing double-quotes, replacing each escape sequence
+ \" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
+ resulting sequence of characters is processed through translation phase 3 to produce
+ preprocessing tokens that are executed as if they were the pp-tokens in a pragma
+ directive. The original four preprocessing tokens in the unary operator expression are
+ removed.
+<p><!--para 2-->
+ EXAMPLE       A directive of the form:
+<pre>
+          #pragma listing on "..\listing.dir"</pre>
+ can also be expressed as:
+<!--page 174 indent 0-->
+<pre>
+         _Pragma ( "listing on \"..\\listing.dir\"" )</pre>
+ The latter form is processed in the same way whether it appears literally as shown, or results from macro
+ replacement, as in:
+<!--page 175 indent 4-->
+<pre>
+         #define LISTING(x) PRAGMA(listing on #x)
+         #define PRAGMA(x) _Pragma(#x)
+         LISTING ( ..\listing.dir )</pre>
+
+<a name="6.11" href="#6.11"><h3>6.11 Future language directions</h3></a>
+
+<a name="6.11.1" href="#6.11.1"><h4>6.11.1 Floating types</h4></a>
+<p><!--para 1-->
+ Future standardization may include additional floating-point types, including those with
+ greater range, precision, or both than long double.
+
+<a name="6.11.2" href="#6.11.2"><h4>6.11.2 Linkages of identifiers</h4></a>
+<p><!--para 1-->
+ Declaring an identifier with internal linkage at file scope without the static storage-
+ class specifier is an obsolescent feature.
+
+<a name="6.11.3" href="#6.11.3"><h4>6.11.3 External names</h4></a>
+<p><!--para 1-->
+ Restriction of the significance of an external name to fewer than 255 characters
+ (considering each universal character name or extended source character as a single
+ character) is an obsolescent feature that is a concession to existing implementations.
+
+<a name="6.11.4" href="#6.11.4"><h4>6.11.4 Character escape sequences</h4></a>
+<p><!--para 1-->
+ Lowercase letters as escape sequences are reserved for future standardization. Other
+ characters may be used in extensions.
+
+<a name="6.11.5" href="#6.11.5"><h4>6.11.5 Storage-class specifiers</h4></a>
+<p><!--para 1-->
+ The placement of a storage-class specifier other than at the beginning of the declaration
+ specifiers in a declaration is an obsolescent feature.
+
+<a name="6.11.6" href="#6.11.6"><h4>6.11.6 Function declarators</h4></a>
+<p><!--para 1-->
+ The use of function declarators with empty parentheses (not prototype-format parameter
+ type declarators) is an obsolescent feature.
+
+<a name="6.11.7" href="#6.11.7"><h4>6.11.7 Function definitions</h4></a>
+<p><!--para 1-->
+ The use of function definitions with separate parameter identifier and declaration lists
+ (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
+
+<a name="6.11.8" href="#6.11.8"><h4>6.11.8 Pragma directives</h4></a>
+<p><!--para 1-->
+ Pragmas whose first preprocessing token is STDC are reserved for future standardization.
+
+<a name="6.11.9" href="#6.11.9"><h4>6.11.9 Predefined macro names</h4></a>
+<p><!--para 1-->
+ Macro names beginning with __STDC_ are reserved for future standardization.
+<!--page 176 indent 4-->
+
+<a name="7" href="#7"><h2>7. Library</h2></a>
+ 
+
+<a name="7.1" href="#7.1"><h3>7.1 Introduction</h3></a>
+
+<a name="7.1.1" href="#7.1.1"><h4>7.1.1 Definitions of terms</h4></a>
+<p><!--para 1-->
+ A string is a contiguous sequence of characters terminated by and including the first null
+ character. The term multibyte string is sometimes used instead to emphasize special
+ processing given to multibyte characters contained in the string or to avoid confusion
+ with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
+ character. The length of a string is the number of bytes preceding the null character and
+ the value of a string is the sequence of the values of the contained characters, in order.
+<p><!--para 2-->
+ The decimal-point character is the character used by functions that convert floating-point
+ numbers to or from character sequences to denote the beginning of the fractional part of
+ such character sequences.<sup><a href="#note157"><b>157)</b></a></sup> It is represented in the text and examples by a period, but
+ may be changed by the setlocale function.
+<p><!--para 3-->
+ A null wide character is a wide character with code value zero.
+<p><!--para 4-->
+ A wide string is a contiguous sequence of wide characters terminated by and including
+ the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
+ addressed) wide character. The length of a wide string is the number of wide characters
+ preceding the null wide character and the value of a wide string is the sequence of code
+ values of the contained wide characters, in order.
+<p><!--para 5-->
+ A shift sequence is a contiguous sequence of bytes within a multibyte string that
+ (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
+ corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
+ character.<sup><a href="#note158"><b>158)</b></a></sup>
+ Forward references: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+ 
+ 
+ 
+ 
+<!--page 177 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note157">157)</a> The functions that make use of the decimal-point character are the numeric conversion functions
+ (<a href="#7.20.1">7.20.1</a>, <a href="#7.24.4.1">7.24.4.1</a>) and the formatted input/output functions (<a href="#7.19.6">7.19.6</a>, <a href="#7.24.2">7.24.2</a>).
+
+<p><a name="note158">158)</a> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
+ enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
+ sequence of maximum length. Whether these counts provide for more than one shift sequence is the
+ implementation's choice.
+
+
+<a name="7.1.2" href="#7.1.2"><h4>7.1.2 Standard headers</h4></a>
+<p><!--para 1-->
+ Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note159"><b>159)</b></a></sup>
+ whose contents are made available by the #include preprocessing directive. The
+ header declares a set of related functions, plus any necessary types and additional macros
+ needed to facilitate their use. Declarations of types described in this clause shall not
+ include type qualifiers, unless explicitly stated otherwise.
+<p><!--para 2-->
+ The standard headers are
+<p><!--para 3-->
+<pre>
+        &lt;assert.h&gt;             &lt;inttypes.h&gt;            &lt;signal.h&gt;              &lt;stdlib.h&gt;
+        &lt;complex.h&gt;            &lt;iso646.h&gt;              &lt;stdarg.h&gt;              &lt;string.h&gt;
+        &lt;ctype.h&gt;              &lt;limits.h&gt;              &lt;stdbool.h&gt;             &lt;tgmath.h&gt;
+        &lt;errno.h&gt;              &lt;locale.h&gt;              &lt;stddef.h&gt;              &lt;time.h&gt;
+        &lt;fenv.h&gt;               &lt;math.h&gt;                &lt;stdint.h&gt;              &lt;wchar.h&gt;
+        &lt;float.h&gt;              &lt;setjmp.h&gt;              &lt;stdio.h&gt;               &lt;wctype.h&gt;</pre>
+ If a file with the same name as one of the above &lt; and &gt; delimited sequences, not
+ provided as part of the implementation, is placed in any of the standard places that are
+ searched for included source files, the behavior is undefined.
+<p><!--para 4-->
+ Standard headers may be included in any order; each may be included more than once in
+ a given scope, with no effect different from being included only once, except that the
+ effect of including &lt;assert.h&gt; depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
+ used, a header shall be included outside of any external declaration or definition, and it
+ shall first be included before the first reference to any of the functions or objects it
+ declares, or to any of the types or macros it defines. However, if an identifier is declared
+ or defined in more than one header, the second and subsequent associated headers may be
+ included after the initial reference to the identifier. The program shall not have any
+ macros with names lexically identical to keywords currently defined prior to the
+ inclusion.
+<p><!--para 5-->
+ Any definition of an object-like macro described in this clause shall expand to code that is
+ fully protected by parentheses where necessary, so that it groups in an arbitrary
+ expression as if it were a single identifier.
+<p><!--para 6-->
+ Any declaration of a library function shall have external linkage.
+<p><!--para 7-->
+ A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
+ Forward references: diagnostics (<a href="#7.2">7.2</a>).
+ 
+ 
+ 
+ 
+<!--page 178 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note159">159)</a> A header is not necessarily a source file, nor are the &lt; and &gt; delimited sequences in header names
+ necessarily valid source file names.
+
+
+<a name="7.1.3" href="#7.1.3"><h4>7.1.3 Reserved identifiers</h4></a>
+<p><!--para 1-->
+ Each header declares or defines all identifiers listed in its associated subclause, and
+ optionally declares or defines identifiers listed in its associated future library directions
+ subclause and identifiers which are always reserved either for any use or for use as file
+ scope identifiers.
+<ul>
+<li>  All identifiers that begin with an underscore and either an uppercase letter or another
+ underscore are always reserved for any use.
+<li>  All identifiers that begin with an underscore are always reserved for use as identifiers
+ with file scope in both the ordinary and tag name spaces.
+<li>  Each macro name in any of the following subclauses (including the future library
+ directions) is reserved for use as specified if any of its associated headers is included;
+ unless explicitly stated otherwise (see <a href="#7.1.4">7.1.4</a>).
+<li>  All identifiers with external linkage in any of the following subclauses (including the
+ future library directions) are always reserved for use as identifiers with external
+ linkage.<sup><a href="#note160"><b>160)</b></a></sup>
+<li>  Each identifier with file scope listed in any of the following subclauses (including the
+ future library directions) is reserved for use as a macro name and as an identifier with
+ file scope in the same name space if any of its associated headers is included.
+</ul>
+<p><!--para 2-->
+ No other identifiers are reserved. If the program declares or defines an identifier in a
+ context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
+ identifier as a macro name, the behavior is undefined.
+<p><!--para 3-->
+ If the program removes (with #undef) any macro definition of an identifier in the first
+ group listed above, the behavior is undefined.
+
+<h6>footnotes</h6>
+<p><a name="note160">160)</a> The list of reserved identifiers with external linkage includes errno, math_errhandling,
+ setjmp, and va_end.
+
+
+<a name="7.1.4" href="#7.1.4"><h4>7.1.4 Use of library functions</h4></a>
+<p><!--para 1-->
+ Each of the following statements applies unless explicitly stated otherwise in the detailed
+ descriptions that follow: If an argument to a function has an invalid value (such as a value
+ outside the domain of the function, or a pointer outside the address space of the program,
+ or a null pointer, or a pointer to non-modifiable storage when the corresponding
+ parameter is not const-qualified) or a type (after promotion) not expected by a function
+ with variable number of arguments, the behavior is undefined. If a function argument is
+ described as being an array, the pointer actually passed to the function shall have a value
+ such that all address computations and accesses to objects (that would be valid if the
+ pointer did point to the first element of such an array) are in fact valid. Any function
+ declared in a header may be additionally implemented as a function-like macro defined in
+ 
+<!--page 179 indent 4-->
+ the header, so if a library function is declared explicitly when its header is included, one
+ of the techniques shown below can be used to ensure the declaration is not affected by
+ such a macro. Any macro definition of a function can be suppressed locally by enclosing
+ the name of the function in parentheses, because the name is then not followed by the left
+ parenthesis that indicates expansion of a macro function name. For the same syntactic
+ reason, it is permitted to take the address of a library function even if it is also defined as
+ a macro.<sup><a href="#note161"><b>161)</b></a></sup> The use of #undef to remove any macro definition will also ensure that an
+ actual function is referred to. Any invocation of a library function that is implemented as
+ a macro shall expand to code that evaluates each of its arguments exactly once, fully
+ protected by parentheses where necessary, so it is generally safe to use arbitrary
+ expressions as arguments.<sup><a href="#note162"><b>162)</b></a></sup> Likewise, those function-like macros described in the
+ following subclauses may be invoked in an expression anywhere a function with a
+ compatible return type could be called.<sup><a href="#note163"><b>163)</b></a></sup> All object-like macros listed as expanding to
+ integer constant expressions shall additionally be suitable for use in #if preprocessing
+ directives.
+<p><!--para 2-->
+ Provided that a library function can be declared without reference to any type defined in a
+ header, it is also permissible to declare the function and use it without including its
+ associated header.
+<p><!--para 3-->
+ There is a sequence point immediately before a library function returns.
+<p><!--para 4-->
+ The functions in the standard library are not guaranteed to be reentrant and may modify
+ objects with static storage duration.<sup><a href="#note164"><b>164)</b></a></sup>
+ 
+ 
+ 
+<!--page 180 indent 4-->
+<p><!--para 5-->
+ EXAMPLE       The function atoi may be used in any of several ways:
+<ul>
+<li>  by use of its associated header (possibly generating a macro expansion)
+<pre>
+           #include &lt;stdlib.h&gt;
+           const char *str;
+           /* ... */
+           i = atoi(str);</pre>
+<li>  by use of its associated header (assuredly generating a true function reference)
+<pre>
+           #include &lt;stdlib.h&gt;
+           #undef atoi
+           const char *str;
+           /* ... */
+           i = atoi(str);</pre>
+  or
+<pre>
+           #include &lt;stdlib.h&gt;
+           const char *str;
+           /* ... */
+           i = (atoi)(str);</pre>
+<li>  by explicit declaration
+<!--page 181 indent 4-->
+<pre>
+           extern int atoi(const char *);
+           const char *str;
+           /* ... */
+           i = atoi(str);</pre>
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note161">161)</a> This means that an implementation shall provide an actual function for each library function, even if it
+ also provides a macro for that function.
+
+<p><a name="note162">162)</a> Such macros might not contain the sequence points that the corresponding function calls do.
+
+<p><a name="note163">163)</a> Because external identifiers and some macro names beginning with an underscore are reserved,
+ implementations may provide special semantics for such names. For example, the identifier
+ _BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
+ appropriate header could specify
+
+<pre>
+          #define abs(x) _BUILTIN_abs(x)</pre>
+ for a compiler whose code generator will accept it.
+ In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
+ function may write
+
+<pre>
+          #undef abs</pre>
+ whether the implementation's header provides a macro implementation of abs or a built-in
+ implementation. The prototype for the function, which precedes and is hidden by any macro
+ definition, is thereby revealed also.
+
+<p><a name="note164">164)</a> Thus, a signal handler cannot, in general, call standard library functions.
+
+
+<a name="7.2" href="#7.2"><h3>7.2 Diagnostics <assert.h></h3></a>
+<p><!--para 1-->
+ The header &lt;assert.h&gt; defines the assert macro and refers to another macro,
+<pre>
+         NDEBUG</pre>
+ which is not defined by &lt;assert.h&gt;. If NDEBUG is defined as a macro name at the
+ point in the source file where &lt;assert.h&gt; is included, the assert macro is defined
+ simply as
+<pre>
+         #define assert(ignore) ((void)0)</pre>
+ The assert macro is redefined according to the current state of NDEBUG each time that
+ &lt;assert.h&gt; is included.
+<p><!--para 2-->
+ The assert macro shall be implemented as a macro, not as an actual function. If the
+ macro definition is suppressed in order to access an actual function, the behavior is
+ undefined.
+
+<a name="7.2.1" href="#7.2.1"><h4>7.2.1 Program diagnostics</h4></a>
+
+<a name="7.2.1.1" href="#7.2.1.1"><h5>7.2.1.1 The assert macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;assert.h&gt;
+         void assert(scalar expression);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The assert macro puts diagnostic tests into programs; it expands to a void expression.
+ When it is executed, if expression (which shall have a scalar type) is false (that is,
+ compares equal to 0), the assert macro writes information about the particular call that
+ failed (including the text of the argument, the name of the source file, the source line
+ number, and the name of the enclosing function -- the latter are respectively the values of
+ the preprocessing macros __FILE__ and __LINE__ and of the identifier
+ __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note165"><b>165)</b></a></sup> It
+ then calls the abort function.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The assert macro returns no value.
+ Forward references: the abort function (<a href="#7.20.4.1">7.20.4.1</a>).
+ 
+ 
+ 
+ 
+<!--page 182 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note165">165)</a> The message written might be of the form:
+ Assertion failed: expression, function abc, file xyz, line nnn.
+
+
+<a name="7.3" href="#7.3"><h3>7.3 Complex arithmetic <complex.h></h3></a>
+
+<a name="7.3.1" href="#7.3.1"><h4>7.3.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;complex.h&gt; defines macros and declares functions that support complex
+ arithmetic.<sup><a href="#note166"><b>166)</b></a></sup> Each synopsis specifies a family of functions consisting of a principal
+ function with one or more double complex parameters and a double complex or
+ double return value; and other functions with the same name but with f and l suffixes
+ which are corresponding functions with float and long double parameters and
+ return values.
+<p><!--para 2-->
+ The macro
+<pre>
+          complex</pre>
+ expands to _Complex; the macro
+<pre>
+          _Complex_I</pre>
+ expands to a constant expression of type const float _Complex, with the value of
+ the imaginary unit.<sup><a href="#note167"><b>167)</b></a></sup>
+<p><!--para 3-->
+ The macros
+<pre>
+          imaginary</pre>
+ and
+<pre>
+          _Imaginary_I</pre>
+ are defined if and only if the implementation supports imaginary types;<sup><a href="#note168"><b>168)</b></a></sup> if defined,
+ they expand to _Imaginary and a constant expression of type const float
+ _Imaginary with the value of the imaginary unit.
+<p><!--para 4-->
+ The macro
+<pre>
+          I</pre>
+ expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
+ defined, I shall expand to _Complex_I.
+<p><!--para 5-->
+ Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+ redefine the macros complex, imaginary, and I.
+ Forward references: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
+ 
+ 
+ 
+<!--page 183 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note166">166)</a> See ''future library directions'' (<a href="#7.26.1">7.26.1</a>).
+
+<p><a name="note167">167)</a> The imaginary unit is a number i such that i 2   = -1.
+
+<p><a name="note168">168)</a> A specification for imaginary types is in informative <a href="#G">annex G</a>.
+
+
+<a name="7.3.2" href="#7.3.2"><h4>7.3.2 Conventions</h4></a>
+<p><!--para 1-->
+ Values are interpreted as radians, not degrees. An implementation may set errno but is
+ not required to.
+
+<a name="7.3.3" href="#7.3.3"><h4>7.3.3 Branch cuts</h4></a>
+<p><!--para 1-->
+ Some of the functions below have branch cuts, across which the function is
+ discontinuous. For implementations with a signed zero (including all IEC 60559
+ implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
+ one side of a cut from another so the function is continuous (except for format
+ limitations) as the cut is approached from either side. For example, for the square root
+ function, which has a branch cut along the negative real axis, the top of the cut, with
+ imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
+ imaginary part -0, maps to the negative imaginary axis.
+<p><!--para 2-->
+ Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
+ sides of branch cuts. These implementations shall map a cut so the function is continuous
+ as the cut is approached coming around the finite endpoint of the cut in a counter
+ clockwise direction. (Branch cuts for the functions specified here have just one finite
+ endpoint.) For example, for the square root function, coming counter clockwise around
+ the finite endpoint of the cut along the negative real axis approaches the cut from above,
+ so the cut maps to the positive imaginary axis.
+
+<a name="7.3.4" href="#7.3.4"><h4>7.3.4 The CX_LIMITED_RANGE pragma</h4></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;complex.h&gt;
+          #pragma STDC CX_LIMITED_RANGE on-off-switch</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The usual mathematical formulas for complex multiply, divide, and absolute value are
+ problematic because of their treatment of infinities and because of undue overflow and
+ underflow. The CX_LIMITED_RANGE pragma can be used to inform the
+ implementation that (where the state is ''on'') the usual mathematical formulas are
+ acceptable.<sup><a href="#note169"><b>169)</b></a></sup> The pragma can occur either outside external declarations or preceding all
+ explicit declarations and statements inside a compound statement. When outside external
+ 
+<!--page 184 indent 4-->
+ declarations, the pragma takes effect from its occurrence until another
+ CX_LIMITED_RANGE pragma is encountered, or until the end of the translation unit.
+ When inside a compound statement, the pragma takes effect from its occurrence until
+ another CX_LIMITED_RANGE pragma is encountered (including within a nested
+ compound statement), or until the end of the compound statement; at the end of a
+ compound statement the state for the pragma is restored to its condition just before the
+ compound statement. If this pragma is used in any other context, the behavior is
+ undefined. The default state for the pragma is ''off''.
+
+<h6>footnotes</h6>
+<p><a name="note169">169)</a> The purpose of the pragma is to allow the implementation to use the formulas:
+
+<pre>
+     (x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
+     (x + iy) / (u + iv) = [(xu + yv) + i(yu - xv)]/(u2 + v 2 )
+     | x + iy | = (sqrt) x 2 + y 2
+                  ???????????????</pre>
+ where the programmer can determine they are safe.
+
+
+<a name="7.3.5" href="#7.3.5"><h4>7.3.5 Trigonometric functions</h4></a>
+
+<a name="7.3.5.1" href="#7.3.5.1"><h5>7.3.5.1 The cacos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex cacos(double complex z);
+        float complex cacosf(float complex z);
+        long double complex cacosl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cacos functions compute the complex arc cosine of z, with branch cuts outside the
+ interval [-1, +1] along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cacos functions return the complex arc cosine value, in the range of a strip
+ mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
+ real axis.
+
+<a name="7.3.5.2" href="#7.3.5.2"><h5>7.3.5.2 The casin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex casin(double complex z);
+        float complex casinf(float complex z);
+        long double complex casinl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The casin functions compute the complex arc sine of z, with branch cuts outside the
+ interval [-1, +1] along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The casin functions return the complex arc sine value, in the range of a strip
+ mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+ along the real axis.
+<!--page 185 indent 4-->
+
+<a name="7.3.5.3" href="#7.3.5.3"><h5>7.3.5.3 The catan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex catan(double complex z);
+        float complex catanf(float complex z);
+        long double complex catanl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The catan functions compute the complex arc tangent of z, with branch cuts outside the
+ interval [-i, +i] along the imaginary axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The catan functions return the complex arc tangent value, in the range of a strip
+ mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+ along the real axis.
+
+<a name="7.3.5.4" href="#7.3.5.4"><h5>7.3.5.4 The ccos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex ccos(double complex z);
+        float complex ccosf(float complex z);
+        long double complex ccosl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ccos functions compute the complex cosine of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ccos functions return the complex cosine value.
+
+<a name="7.3.5.5" href="#7.3.5.5"><h5>7.3.5.5 The csin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex csin(double complex z);
+        float complex csinf(float complex z);
+        long double complex csinl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The csin functions compute the complex sine of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The csin functions return the complex sine value.
+<!--page 186 indent 4-->
+
+<a name="7.3.5.6" href="#7.3.5.6"><h5>7.3.5.6 The ctan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex ctan(double complex z);
+        float complex ctanf(float complex z);
+        long double complex ctanl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ctan functions compute the complex tangent of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ctan functions return the complex tangent value.
+
+<a name="7.3.6" href="#7.3.6"><h4>7.3.6 Hyperbolic functions</h4></a>
+
+<a name="7.3.6.1" href="#7.3.6.1"><h5>7.3.6.1 The cacosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex cacosh(double complex z);
+        float complex cacoshf(float complex z);
+        long double complex cacoshl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
+ cut at values less than 1 along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
+ half-strip of non-negative values along the real axis and in the interval [-ipi , +ipi ] along
+ the imaginary axis.
+
+<a name="7.3.6.2" href="#7.3.6.2"><h5>7.3.6.2 The casinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex casinh(double complex z);
+        float complex casinhf(float complex z);
+        long double complex casinhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
+ outside the interval [-i, +i] along the imaginary axis.
+<!--page 187 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The casinh functions return the complex arc hyperbolic sine value, in the range of a
+ strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+ along the imaginary axis.
+
+<a name="7.3.6.3" href="#7.3.6.3"><h5>7.3.6.3 The catanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex catanh(double complex z);
+        float complex catanhf(float complex z);
+        long double complex catanhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The catanh functions compute the complex arc hyperbolic tangent of z, with branch
+ cuts outside the interval [-1, +1] along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The catanh functions return the complex arc hyperbolic tangent value, in the range of a
+ strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+ along the imaginary axis.
+
+<a name="7.3.6.4" href="#7.3.6.4"><h5>7.3.6.4 The ccosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex ccosh(double complex z);
+        float complex ccoshf(float complex z);
+        long double complex ccoshl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ccosh functions compute the complex hyperbolic cosine of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ccosh functions return the complex hyperbolic cosine value.
+
+<a name="7.3.6.5" href="#7.3.6.5"><h5>7.3.6.5 The csinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 188 indent 4-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex csinh(double complex z);
+        float complex csinhf(float complex z);
+        long double complex csinhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The csinh functions compute the complex hyperbolic sine of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The csinh functions return the complex hyperbolic sine value.
+
+<a name="7.3.6.6" href="#7.3.6.6"><h5>7.3.6.6 The ctanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex ctanh(double complex z);
+        float complex ctanhf(float complex z);
+        long double complex ctanhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ctanh functions compute the complex hyperbolic tangent of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ctanh functions return the complex hyperbolic tangent value.
+
+<a name="7.3.7" href="#7.3.7"><h4>7.3.7 Exponential and logarithmic functions</h4></a>
+
+<a name="7.3.7.1" href="#7.3.7.1"><h5>7.3.7.1 The cexp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex cexp(double complex z);
+        float complex cexpf(float complex z);
+        long double complex cexpl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cexp functions compute the complex base-e exponential of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cexp functions return the complex base-e exponential value.
+
+<a name="7.3.7.2" href="#7.3.7.2"><h5>7.3.7.2 The clog functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 189 indent 4-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex clog(double complex z);
+        float complex clogf(float complex z);
+        long double complex clogl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The clog functions compute the complex natural (base-e) logarithm of z, with a branch
+ cut along the negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The clog functions return the complex natural logarithm value, in the range of a strip
+ mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
+ imaginary axis.
+
+<a name="7.3.8" href="#7.3.8"><h4>7.3.8 Power and absolute-value functions</h4></a>
+
+<a name="7.3.8.1" href="#7.3.8.1"><h5>7.3.8.1 The cabs functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double cabs(double complex z);
+        float cabsf(float complex z);
+        long double cabsl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cabs functions compute the complex absolute value (also called norm, modulus, or
+ magnitude) of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cabs functions return the complex absolute value.
+
+<a name="7.3.8.2" href="#7.3.8.2"><h5>7.3.8.2 The cpow functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex cpow(double complex x, double complex y);
+        float complex cpowf(float complex x, float complex y);
+        long double complex cpowl(long double complex x,
+             long double complex y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cpow functions compute the complex power function xy , with a branch cut for the
+ first parameter along the negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cpow functions return the complex power function value.
+<!--page 190 indent 4-->
+
+<a name="7.3.8.3" href="#7.3.8.3"><h5>7.3.8.3 The csqrt functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex csqrt(double complex z);
+        float complex csqrtf(float complex z);
+        long double complex csqrtl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The csqrt functions compute the complex square root of z, with a branch cut along the
+ negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The csqrt functions return the complex square root value, in the range of the right half-
+ plane (including the imaginary axis).
+
+<a name="7.3.9" href="#7.3.9"><h4>7.3.9 Manipulation functions</h4></a>
+
+<a name="7.3.9.1" href="#7.3.9.1"><h5>7.3.9.1 The carg functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double carg(double complex z);
+        float cargf(float complex z);
+        long double cargl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The carg functions compute the argument (also called phase angle) of z, with a branch
+ cut along the negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The carg functions return the value of the argument in the interval [-pi , +pi ].
+
+<a name="7.3.9.2" href="#7.3.9.2"><h5>7.3.9.2 The cimag functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 191 indent 4-->
+<pre>
+        #include &lt;complex.h&gt;
+        double cimag(double complex z);
+        float cimagf(float complex z);
+        long double cimagl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cimag functions compute the imaginary part of z.<sup><a href="#note170"><b>170)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cimag functions return the imaginary part value (as a real).
+
+<h6>footnotes</h6>
+<p><a name="note170">170)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+
+<a name="7.3.9.3" href="#7.3.9.3"><h5>7.3.9.3 The conj functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex conj(double complex z);
+        float complex conjf(float complex z);
+        long double complex conjl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The conj functions compute the complex conjugate of z, by reversing the sign of its
+ imaginary part.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The conj functions return the complex conjugate value.
+
+<a name="7.3.9.4" href="#7.3.9.4"><h5>7.3.9.4 The cproj functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex cproj(double complex z);
+        float complex cprojf(float complex z);
+        long double complex cprojl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cproj functions compute a projection of z onto the Riemann sphere: z projects to
+ z except that all complex infinities (even those with one infinite part and one NaN part)
+ project to positive infinity on the real axis. If z has an infinite part, then cproj(z) is
+ equivalent to
+<pre>
+        INFINITY + I * copysign(0.0, cimag(z))</pre>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cproj functions return the value of the projection onto the Riemann sphere.
+ 
+ 
+ 
+ 
+<!--page 192 indent 4-->
+
+<a name="7.3.9.5" href="#7.3.9.5"><h5>7.3.9.5 The creal functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double creal(double complex z);
+        float crealf(float complex z);
+        long double creall(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The creal functions compute the real part of z.<sup><a href="#note171"><b>171)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The creal functions return the real part value.
+ 
+ 
+ 
+ 
+<!--page 193 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note171">171)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+
+<a name="7.4" href="#7.4"><h3>7.4 Character handling <ctype.h></h3></a>
+<p><!--para 1-->
+ The header &lt;ctype.h&gt; declares several functions useful for classifying and mapping
+ characters.<sup><a href="#note172"><b>172)</b></a></sup> In all cases the argument is an int, the value of which shall be
+ representable as an unsigned char or shall equal the value of the macro EOF. If the
+ argument has any other value, the behavior is undefined.
+<p><!--para 2-->
+ The behavior of these functions is affected by the current locale. Those functions that
+ have locale-specific aspects only when not in the "C" locale are noted below.
+<p><!--para 3-->
+ The term printing character refers to a member of a locale-specific set of characters, each
+ of which occupies one printing position on a display device; the term control character
+ refers to a member of a locale-specific set of characters that are not printing
+ characters.<sup><a href="#note173"><b>173)</b></a></sup> All letters and digits are printing characters.
+ Forward references: EOF (<a href="#7.19.1">7.19.1</a>), localization (<a href="#7.11">7.11</a>).
+
+<h6>footnotes</h6>
+<p><a name="note172">172)</a> See ''future library directions'' (<a href="#7.26.2">7.26.2</a>).
+
+<p><a name="note173">173)</a> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
+ whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
+ values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
+
+
+<a name="7.4.1" href="#7.4.1"><h4>7.4.1 Character classification functions</h4></a>
+<p><!--para 1-->
+ The functions in this subclause return nonzero (true) if and only if the value of the
+ argument c conforms to that in the description of the function.
+
+<a name="7.4.1.1" href="#7.4.1.1"><h5>7.4.1.1 The isalnum function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;ctype.h&gt;
+          int isalnum(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isalnum function tests for any character for which isalpha or isdigit is true.
+
+<a name="7.4.1.2" href="#7.4.1.2"><h5>7.4.1.2 The isalpha function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;ctype.h&gt;
+          int isalpha(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isalpha function tests for any character for which isupper or islower is true,
+ or any character that is one of a locale-specific set of alphabetic characters for which
+ 
+ 
+ 
+<!--page 194 indent 4-->
+ none of iscntrl, isdigit, ispunct, or isspace is true.<sup><a href="#note174"><b>174)</b></a></sup> In the "C" locale,
+ isalpha returns true only for the characters for which isupper or islower is true.
+
+<h6>footnotes</h6>
+<p><a name="note174">174)</a> The functions islower and isupper test true or false separately for each of these additional
+ characters; all four combinations are possible.
+
+
+<a name="7.4.1.3" href="#7.4.1.3"><h5>7.4.1.3 The isblank function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isblank(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isblank function tests for any character that is a standard blank character or is one
+ of a locale-specific set of characters for which isspace is true and that is used to
+ separate words within a line of text. The standard blank characters are the following:
+ space (' '), and horizontal tab ('\t'). In the "C" locale, isblank returns true only
+ for the standard blank characters.
+
+<a name="7.4.1.4" href="#7.4.1.4"><h5>7.4.1.4 The iscntrl function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int iscntrl(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iscntrl function tests for any control character.
+
+<a name="7.4.1.5" href="#7.4.1.5"><h5>7.4.1.5 The isdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isdigit(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.4.1.6" href="#7.4.1.6"><h5>7.4.1.6 The isgraph function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isgraph(int c);</pre>
+ 
+ 
+ 
+ 
+<!--page 195 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The isgraph function tests for any printing character except space (' ').
+
+<a name="7.4.1.7" href="#7.4.1.7"><h5>7.4.1.7 The islower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int islower(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The islower function tests for any character that is a lowercase letter or is one of a
+ locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+ isspace is true. In the "C" locale, islower returns true only for the lowercase
+ letters (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.4.1.8" href="#7.4.1.8"><h5>7.4.1.8 The isprint function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int isprint(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isprint function tests for any printing character including space (' ').
+
+<a name="7.4.1.9" href="#7.4.1.9"><h5>7.4.1.9 The ispunct function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int ispunct(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ispunct function tests for any printing character that is one of a locale-specific set
+ of punctuation characters for which neither isspace nor isalnum is true. In the "C"
+ locale, ispunct returns true for every printing character for which neither isspace
+ nor isalnum is true.
+
+<a name="7.4.1.10" href="#7.4.1.10"><h5>7.4.1.10 The isspace function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int isspace(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isspace function tests for any character that is a standard white-space character or
+ is one of a locale-specific set of characters for which isalnum is false. The standard
+<!--page 196 indent 4-->
+ white-space characters are the following: space (' '), form feed ('\f'), new-line
+ ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). In the
+ "C" locale, isspace returns true only for the standard white-space characters.
+
+<a name="7.4.1.11" href="#7.4.1.11"><h5>7.4.1.11 The isupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int isupper(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isupper function tests for any character that is an uppercase letter or is one of a
+ locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+ isspace is true. In the "C" locale, isupper returns true only for the uppercase
+ letters (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.4.1.12" href="#7.4.1.12"><h5>7.4.1.12 The isxdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int isxdigit(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isxdigit function tests for any hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+
+<a name="7.4.2" href="#7.4.2"><h4>7.4.2 Character case mapping functions</h4></a>
+
+<a name="7.4.2.1" href="#7.4.2.1"><h5>7.4.2.1 The tolower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int tolower(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tolower function converts an uppercase letter to a corresponding lowercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a character for which isupper is true and there are one or more
+ corresponding characters, as specified by the current locale, for which islower is true,
+ the tolower function returns one of the corresponding characters (always the same one
+ for any given locale); otherwise, the argument is returned unchanged.
+<!--page 197 indent 4-->
+
+<a name="7.4.2.2" href="#7.4.2.2"><h5>7.4.2.2 The toupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int toupper(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The toupper function converts a lowercase letter to a corresponding uppercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a character for which islower is true and there are one or more
+ corresponding characters, as specified by the current locale, for which isupper is true,
+ the toupper function returns one of the corresponding characters (always the same one
+ for any given locale); otherwise, the argument is returned unchanged.
+<!--page 198 indent 4-->
+
+<a name="7.5" href="#7.5"><h3>7.5 Errors <errno.h></h3></a>
+<p><!--para 1-->
+ The header &lt;errno.h&gt; defines several macros, all relating to the reporting of error
+ conditions.
+<p><!--para 2-->
+ The macros are
+<pre>
+          EDOM
+          EILSEQ
+          ERANGE</pre>
+ which expand to integer constant expressions with type int, distinct positive values, and
+ which are suitable for use in #if preprocessing directives; and
+<pre>
+          errno</pre>
+ which expands to a modifiable lvalue<sup><a href="#note175"><b>175)</b></a></sup> that has type int, the value of which is set to a
+ positive error number by several library functions. It is unspecified whether errno is a
+ macro or an identifier declared with external linkage. If a macro definition is suppressed
+ in order to access an actual object, or a program defines an identifier with the name
+ errno, the behavior is undefined.
+<p><!--para 3-->
+ The value of errno is zero at program startup, but is never set to zero by any library
+ function.<sup><a href="#note176"><b>176)</b></a></sup> The value of errno may be set to nonzero by a library function call
+ whether or not there is an error, provided the use of errno is not documented in the
+ description of the function in this International Standard.
+<p><!--para 4-->
+ Additional macro definitions, beginning with E and a digit or E and an uppercase
+ letter,<sup><a href="#note177"><b>177)</b></a></sup> may also be specified by the implementation.
+ 
+ 
+ 
+ 
+<!--page 199 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note175">175)</a> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
+ resulting from a function call (for example, *errno()).
+
+<p><a name="note176">176)</a> Thus, a program that uses errno for error checking should set it to zero before a library function call,
+ then inspect it before a subsequent library function call. Of course, a library function can save the
+ value of errno on entry and then set it to zero, as long as the original value is restored if errno's
+ value is still zero just before the return.
+
+<p><a name="note177">177)</a> See ''future library directions'' (<a href="#7.26.3">7.26.3</a>).
+
+
+<a name="7.6" href="#7.6"><h3>7.6 Floating-point environment <fenv.h></h3></a>
+<p><!--para 1-->
+ The header &lt;fenv.h&gt; declares two types and several macros and functions to provide
+ access to the floating-point environment. The floating-point environment refers
+ collectively to any floating-point status flags and control modes supported by the
+ implementation.<sup><a href="#note178"><b>178)</b></a></sup> A floating-point status flag is a system variable whose value is set
+ (but never cleared) when a floating-point exception is raised, which occurs as a side effect
+ of exceptional floating-point arithmetic to provide auxiliary information.<sup><a href="#note179"><b>179)</b></a></sup> A floating-
+ point control mode is a system variable whose value may be set by the user to affect the
+ subsequent behavior of floating-point arithmetic.
+<p><!--para 2-->
+ Certain programming conventions support the intended model of use for the floating-
+ point environment:<sup><a href="#note180"><b>180)</b></a></sup>
+<ul>
+<li>  a function call does not alter its caller's floating-point control modes, clear its caller's
+ floating-point status flags, nor depend on the state of its caller's floating-point status
+ flags unless the function is so documented;
+<li>  a function call is assumed to require default floating-point control modes, unless its
+ documentation promises otherwise;
+<li>  a function call is assumed to have the potential for raising floating-point exceptions,
+ unless its documentation promises otherwise.
+</ul>
+<p><!--para 3-->
+ The type
+<pre>
+         fenv_t</pre>
+ represents the entire floating-point environment.
+<p><!--para 4-->
+ The type
+<pre>
+         fexcept_t</pre>
+ represents the floating-point status flags collectively, including any status the
+ implementation associates with the flags.
+ 
+ 
+ 
+ 
+<!--page 200 indent 4-->
+<p><!--para 5-->
+ Each of the macros
+<pre>
+         FE_DIVBYZERO
+         FE_INEXACT
+         FE_INVALID
+         FE_OVERFLOW
+         FE_UNDERFLOW</pre>
+ is defined if and only if the implementation supports the floating-point exception by
+ means of the functions in 7.6.2.<sup><a href="#note181"><b>181)</b></a></sup> Additional implementation-defined floating-point
+ exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
+ be specified by the implementation. The defined macros expand to integer constant
+ expressions with values such that bitwise ORs of all combinations of the macros result in
+ distinct values, and furthermore, bitwise ANDs of all combinations of the macros result in
+ zero.<sup><a href="#note182"><b>182)</b></a></sup>
+<p><!--para 6-->
+ The macro
+<pre>
+         FE_ALL_EXCEPT</pre>
+ is simply the bitwise OR of all floating-point exception macros defined by the
+ implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
+<p><!--para 7-->
+ Each of the macros
+<pre>
+         FE_DOWNWARD
+         FE_TONEAREST
+         FE_TOWARDZERO
+         FE_UPWARD</pre>
+ is defined if and only if the implementation supports getting and setting the represented
+ rounding direction by means of the fegetround and fesetround functions.
+ Additional implementation-defined rounding directions, with macro definitions beginning
+ with FE_ and an uppercase letter, may also be specified by the implementation. The
+ defined macros expand to integer constant expressions whose values are distinct
+ nonnegative values.<sup><a href="#note183"><b>183)</b></a></sup>
+<p><!--para 8-->
+ The macro
+ 
+ 
+ 
+<!--page 201 indent 4-->
+<pre>
+          FE_DFL_ENV</pre>
+ represents the default floating-point environment -- the one installed at program startup
+<ul>
+<li>  and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
+</ul>
+ &lt;fenv.h&gt; functions that manage the floating-point environment.
+<p><!--para 9-->
+ Additional implementation-defined environments, with macro definitions beginning with
+ FE_ and an uppercase letter, and having type ''pointer to const-qualified fenv_t'', may
+ also be specified by the implementation.
+
+<h6>footnotes</h6>
+<p><a name="note178">178)</a> This header is designed to support the floating-point exception status flags and directed-rounding
+ control modes required by IEC 60559, and other similar floating-point state information. Also it is
+ designed to facilitate code portability among all systems.
+
+<p><a name="note179">179)</a> A floating-point status flag is not an object and can be set more than once within an expression.
+
+<p><a name="note180">180)</a> With these conventions, a programmer can safely assume default floating-point control modes (or be
+ unaware of them). The responsibilities associated with accessing the floating-point environment fall
+ on the programmer or program that does so explicitly.
+
+<p><a name="note181">181)</a> The implementation supports an exception if there are circumstances where a call to at least one of the
+ functions in <a href="#7.6.2">7.6.2</a>, using the macro as the appropriate argument, will succeed. It is not necessary for
+ all the functions to succeed all the time.
+
+<p><a name="note182">182)</a> The macros should be distinct powers of two.
+
+<p><a name="note183">183)</a> Even though the rounding direction macros may expand to constants corresponding to the values of
+ FLT_ROUNDS, they are not required to do so.
+
+
+<a name="7.6.1" href="#7.6.1"><h4>7.6.1 The FENV_ACCESS pragma</h4></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;fenv.h&gt;
+          #pragma STDC FENV_ACCESS on-off-switch</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The FENV_ACCESS pragma provides a means to inform the implementation when a
+ program might access the floating-point environment to test floating-point status flags or
+ run under non-default floating-point control modes.<sup><a href="#note184"><b>184)</b></a></sup> The pragma shall occur either
+ outside external declarations or preceding all explicit declarations and statements inside a
+ compound statement. When outside external declarations, the pragma takes effect from
+ its occurrence until another FENV_ACCESS pragma is encountered, or until the end of
+ the translation unit. When inside a compound statement, the pragma takes effect from its
+ occurrence until another FENV_ACCESS pragma is encountered (including within a
+ nested compound statement), or until the end of the compound statement; at the end of a
+ compound statement the state for the pragma is restored to its condition just before the
+ compound statement. If this pragma is used in any other context, the behavior is
+ undefined. If part of a program tests floating-point status flags, sets floating-point control
+ modes, or runs under non-default mode settings, but was translated with the state for the
+ FENV_ACCESS pragma ''off'', the behavior is undefined. The default state (''on'' or
+ ''off'') for the pragma is implementation-defined. (When execution passes from a part of
+ the program translated with FENV_ACCESS ''off'' to a part translated with
+ FENV_ACCESS ''on'', the state of the floating-point status flags is unspecified and the
+ floating-point control modes have their default settings.)
+ 
+ 
+ 
+ 
+<!--page 202 indent 4-->
+<p><!--para 3-->
+ EXAMPLE
+<p><!--para 4-->
+<pre>
+         #include &lt;fenv.h&gt;
+         void f(double x)
+         {
+               #pragma STDC FENV_ACCESS ON
+               void g(double);
+               void h(double);
                /* ... */
-               wchar_t wstr[50];
-               fscanf(stdin, "a(uparrow) X(downarrow)%ls", wstr);
-     with the same input line will return zero due to a matching failure against the (downarrow) sequence in the format
-     string.
-26   Assuming that the first byte of the multibyte character X is the same as the first byte of the multibyte
-     character Y, after the call:
-               #include <a href="#7.19">&lt;stdio.h&gt;</a>
-               #include <a href="#7.17">&lt;stddef.h&gt;</a>
+               g(x + 1);
+               h(x + 1);
                /* ... */
-               wchar_t wstr[50];
-               fscanf(stdin, "a(uparrow) Y(downarrow)%ls", wstr);
-     with the same input line, zero will again be returned, but stdin will be left with a partially consumed
-     multibyte character.
-
-     Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>), the
-     strtol, strtoll, strtoul, and strtoull functions (<a href="#7.20.1.4">7.20.1.4</a>), conversion state
-     (<a href="#7.24.6">7.24.6</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
-
-[<a name="p289" href="#p289">page 289</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.6.3" href="#7.19.6.3"><b>    7.19.6.3 The printf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int printf(const char * restrict format, ...);
-<b>    Description</b>
-2   The printf function is equivalent to fprintf with the argument stdout interposed
-    before the arguments to printf.
-<b>    Returns</b>
-3   The printf function returns the number of characters transmitted, or a negative value if
-    an output or encoding error occurred.
-<a name="7.19.6.4" href="#7.19.6.4"><b>    7.19.6.4 The scanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int scanf(const char * restrict format, ...);
-<b>    Description</b>
-2   The scanf function is equivalent to fscanf with the argument stdin interposed
-    before the arguments to scanf.
-<b>    Returns</b>
-3   The scanf function returns the value of the macro EOF if an input failure occurs before
-    any conversion. Otherwise, the scanf function returns the number of input items
-    assigned, which can be fewer than provided for, or even zero, in the event of an early
-    matching failure.
-<a name="7.19.6.5" href="#7.19.6.5"><b>    7.19.6.5 The snprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int snprintf(char * restrict s, size_t n,
-                const char * restrict format, ...);
-<b>    Description</b>
-2   The snprintf function is equivalent to fprintf, except that the output is written into
-    an array (specified by argument s) rather than to a stream. If n is zero, nothing is written,
-    and s may be a null pointer. Otherwise, output characters beyond the n-1st are
-    discarded rather than being written to the array, and a null character is written at the end
-    of the characters actually written into the array. If copying takes place between objects
-    that overlap, the behavior is undefined.
-
-[<a name="p290" href="#p290">page 290</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The snprintf function returns the number of characters that would have been written
-    had n been sufficiently large, not counting the terminating null character, or a negative
-    value if an encoding error occurred. Thus, the null-terminated output has been
-    completely written if and only if the returned value is nonnegative and less than n.
-<a name="7.19.6.6" href="#7.19.6.6"><b>    7.19.6.6 The sprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int sprintf(char * restrict s,
-                const char * restrict format, ...);
-<b>    Description</b>
-2   The sprintf function is equivalent to fprintf, except that the output is written into
-    an array (specified by the argument s) rather than to a stream. A null character is written
-    at the end of the characters written; it is not counted as part of the returned value. If
-    copying takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The sprintf function returns the number of characters written in the array, not
-    counting the terminating null character, or a negative value if an encoding error occurred.
-<a name="7.19.6.7" href="#7.19.6.7"><b>    7.19.6.7 The sscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int sscanf(const char * restrict s,
-                const char * restrict format, ...);
-<b>    Description</b>
-2   The sscanf function is equivalent to fscanf, except that input is obtained from a
-    string (specified by the argument s) rather than from a stream. Reaching the end of the
-    string is equivalent to encountering end-of-file for the fscanf function. If copying
-    takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The sscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the sscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-
-[<a name="p291" href="#p291">page 291</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.6.8" href="#7.19.6.8"><b>    7.19.6.8 The vfprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int vfprintf(FILE * restrict stream,
-                const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vfprintf function is equivalent to fprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfprintf function does not invoke the
-    va_end macro.<sup><a href="#note254"><b>254)</b></a></sup>
-<b>    Returns</b>
-3   The vfprintf function returns the number of characters transmitted, or a negative
-    value if an output or encoding error occurred.
-4   EXAMPLE       The following shows the use of the vfprintf function in a general error-reporting routine.
-           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           void error(char *function_name, char *format, ...)
-           {
-                 va_list args;
-                    va_start(args, format);
-                    // print out name of function causing error
-                    fprintf(stderr, "ERROR in %s: ", function_name);
-                    // print out remainder of message
-                    vfprintf(stderr, format, args);
-                    va_end(args);
-           }
-
-
-
-
-    <sup><a name="note254" href="#note254"><b>254)</b></a></sup> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
-         vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
-
-[<a name="p292" href="#p292">page 292</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.6.9" href="#7.19.6.9"><b>    7.19.6.9 The vfscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int vfscanf(FILE * restrict stream,
-                const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vfscanf function is equivalent to fscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfscanf function does not invoke the
-    va_end macro.254)
-<b>    Returns</b>
-3   The vfscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the vfscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-<a name="7.19.6.10" href="#7.19.6.10"><b>    7.19.6.10 The vprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int vprintf(const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vprintf function is equivalent to printf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vprintf function does not invoke the
-    va_end macro.254)
-<b>    Returns</b>
-3   The vprintf function returns the number of characters transmitted, or a negative value
-    if an output or encoding error occurred.
-
-[<a name="p293" href="#p293">page 293</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.6.11" href="#7.19.6.11"><b>    7.19.6.11 The vscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int vscanf(const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vscanf function is equivalent to scanf, with the variable argument list replaced
-    by arg, which shall have been initialized by the va_start macro (and possibly
-    subsequent va_arg calls). The vscanf function does not invoke the va_end
-    macro.254)
-<b>    Returns</b>
-3   The vscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the vscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-<a name="7.19.6.12" href="#7.19.6.12"><b>    7.19.6.12 The vsnprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int vsnprintf(char * restrict s, size_t n,
-                const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vsnprintf function is equivalent to snprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vsnprintf function does not invoke the
-    va_end macro.254) If copying takes place between objects that overlap, the behavior is
-    undefined.
-<b>    Returns</b>
-3   The vsnprintf function returns the number of characters that would have been written
-    had n been sufficiently large, not counting the terminating null character, or a negative
-    value if an encoding error occurred. Thus, the null-terminated output has been
-    completely written if and only if the returned value is nonnegative and less than n.
-
-[<a name="p294" href="#p294">page 294</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.6.13" href="#7.19.6.13"><b>    7.19.6.13 The vsprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int vsprintf(char * restrict s,
-                const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vsprintf function is equivalent to sprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vsprintf function does not invoke the
-    va_end macro.254) If copying takes place between objects that overlap, the behavior is
-    undefined.
-<b>    Returns</b>
-3   The vsprintf function returns the number of characters written in the array, not
-    counting the terminating null character, or a negative value if an encoding error occurred.
-<a name="7.19.6.14" href="#7.19.6.14"><b>    7.19.6.14 The vsscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int vsscanf(const char * restrict s,
-                const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vsscanf function is equivalent to sscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vsscanf function does not invoke the
-    va_end macro.254)
-<b>    Returns</b>
-3   The vsscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the vsscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-
-[<a name="p295" href="#p295">page 295</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.7" href="#7.19.7"><b>    7.19.7 Character input/output functions</b></a>
-<a name="7.19.7.1" href="#7.19.7.1"><b>    7.19.7.1 The fgetc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            int fgetc(FILE *stream);
-<b>    Description</b>
-2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
-    next character is present, the fgetc function obtains that character as an unsigned
-    char converted to an int and advances the associated file position indicator for the
-    stream (if defined).
-<b>    Returns</b>
-3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
-    of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the
-    fgetc function returns the next character from the input stream pointed to by stream.
-    If a read error occurs, the error indicator for the stream is set and the fgetc function
-    returns EOF.<sup><a href="#note255"><b>255)</b></a></sup>
-<a name="7.19.7.2" href="#7.19.7.2"><b>    7.19.7.2 The fgets function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            char *fgets(char * restrict s, int n,
-                 FILE * restrict stream);
-<b>    Description</b>
-2   The fgets function reads at most one less than the number of characters specified by n
-    from the stream pointed to by stream into the array pointed to by s. No additional
-    characters are read after a new-line character (which is retained) or after end-of-file. A
-    null character is written immediately after the last character read into the array.
-<b>    Returns</b>
-3   The fgets function returns s if successful. If end-of-file is encountered and no
-    characters have been read into the array, the contents of the array remain unchanged and a
-    null pointer is returned. If a read error occurs during the operation, the array contents are
-    indeterminate and a null pointer is returned.
-
-
-
-
-    <sup><a name="note255" href="#note255"><b>255)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
-
-[<a name="p296" href="#p296">page 296</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.7.3" href="#7.19.7.3"><b>    7.19.7.3 The fputc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int fputc(int c, FILE *stream);
-<b>    Description</b>
-2   The fputc function writes the character specified by c (converted to an unsigned
-    char) to the output stream pointed to by stream, at the position indicated by the
-    associated file position indicator for the stream (if defined), and advances the indicator
-    appropriately. If the file cannot support positioning requests, or if the stream was opened
-    with append mode, the character is appended to the output stream.
-<b>    Returns</b>
-3   The fputc function returns the character written. If a write error occurs, the error
-    indicator for the stream is set and fputc returns EOF.
-<a name="7.19.7.4" href="#7.19.7.4"><b>    7.19.7.4 The fputs function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int fputs(const char * restrict s,
-                FILE * restrict stream);
-<b>    Description</b>
-2   The fputs function writes the string pointed to by s to the stream pointed to by
-    stream. The terminating null character is not written.
-<b>    Returns</b>
-3   The fputs function returns EOF if a write error occurs; otherwise it returns a
-    nonnegative value.
-<a name="7.19.7.5" href="#7.19.7.5"><b>    7.19.7.5 The getc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int getc(FILE *stream);
-<b>    Description</b>
-2   The getc function is equivalent to fgetc, except that if it is implemented as a macro, it
-    may evaluate stream more than once, so the argument should never be an expression
-    with side effects.
-
-[<a name="p297" href="#p297">page 297</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The getc function returns the next character from the input stream pointed to by
-    stream. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
-    getc returns EOF. If a read error occurs, the error indicator for the stream is set and
-    getc returns EOF.
-<a name="7.19.7.6" href="#7.19.7.6"><b>    7.19.7.6 The getchar function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int getchar(void);
-<b>    Description</b>
-2   The getchar function is equivalent to getc with the argument stdin.
-<b>    Returns</b>
-3   The getchar function returns the next character from the input stream pointed to by
-    stdin. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
-    getchar returns EOF. If a read error occurs, the error indicator for the stream is set and
-    getchar returns EOF.
-<a name="7.19.7.7" href="#7.19.7.7"><b>    7.19.7.7 The gets function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           char *gets(char *s);
-<b>    Description</b>
-2   The gets function reads characters from the input stream pointed to by stdin, into the
-    array pointed to by s, until end-of-file is encountered or a new-line character is read.
-    Any new-line character is discarded, and a null character is written immediately after the
-    last character read into the array.
-<b>    Returns</b>
-3   The gets function returns s if successful. If end-of-file is encountered and no
-    characters have been read into the array, the contents of the array remain unchanged and a
-    null pointer is returned. If a read error occurs during the operation, the array contents are
-    indeterminate and a null pointer is returned.
-    Forward references: future library directions (<a href="#7.26.9">7.26.9</a>).
-
-[<a name="p298" href="#p298">page 298</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.7.8" href="#7.19.7.8"><b>    7.19.7.8 The putc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int putc(int c, FILE *stream);
-<b>    Description</b>
-2   The putc function is equivalent to fputc, except that if it is implemented as a macro, it
-    may evaluate stream more than once, so that argument should never be an expression
-    with side effects.
-<b>    Returns</b>
-3   The putc function returns the character written. If a write error occurs, the error
-    indicator for the stream is set and putc returns EOF.
-<a name="7.19.7.9" href="#7.19.7.9"><b>    7.19.7.9 The putchar function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int putchar(int c);
-<b>    Description</b>
-2   The putchar function is equivalent to putc with the second argument stdout.
-<b>    Returns</b>
-3   The putchar function returns the character written. If a write error occurs, the error
-    indicator for the stream is set and putchar returns EOF.
-<a name="7.19.7.10" href="#7.19.7.10"><b>    7.19.7.10 The puts function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int puts(const char *s);
-<b>    Description</b>
-2   The puts function writes the string pointed to by s to the stream pointed to by stdout,
-    and appends a new-line character to the output. The terminating null character is not
-    written.
-<b>    Returns</b>
-3   The puts function returns EOF if a write error occurs; otherwise it returns a nonnegative
-    value.
-
-[<a name="p299" href="#p299">page 299</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.7.11" href="#7.19.7.11"><b>    7.19.7.11 The ungetc function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.19">&lt;stdio.h&gt;</a>
-             int ungetc(int c, FILE *stream);
-<b>    Description</b>
-2   The ungetc function pushes the character specified by c (converted to an unsigned
-    char) back onto the input stream pointed to by stream. Pushed-back characters will be
-    returned by subsequent reads on that stream in the reverse order of their pushing. A
-    successful intervening call (with the stream pointed to by stream) to a file positioning
-    function (fseek, fsetpos, or rewind) discards any pushed-back characters for the
-    stream. The external storage corresponding to the stream is unchanged.
-3   One character of pushback is guaranteed. If the ungetc function is called too many
-    times on the same stream without an intervening read or file positioning operation on that
-    stream, the operation may fail.
-4   If the value of c equals that of the macro EOF, the operation fails and the input stream is
-    unchanged.
-5   A successful call to the ungetc function clears the end-of-file indicator for the stream.
-    The value of the file position indicator for the stream after reading or discarding all
-    pushed-back characters shall be the same as it was before the characters were pushed
-    back. For a text stream, the value of its file position indicator after a successful call to the
-    ungetc function is unspecified until all pushed-back characters are read or discarded.
-    For a binary stream, its file position indicator is decremented by each successful call to
-    the ungetc function; if its value was zero before a call, it is indeterminate after the
-    call.<sup><a href="#note256"><b>256)</b></a></sup>
-<b>    Returns</b>
-6   The ungetc function returns the character pushed back after conversion, or EOF if the
-    operation fails.
-    Forward references: file positioning functions (<a href="#7.19.9">7.19.9</a>).
-
-
-
-
-    <sup><a name="note256" href="#note256"><b>256)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
-
-[<a name="p300" href="#p300">page 300</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.8" href="#7.19.8"><b>    7.19.8 Direct input/output functions</b></a>
-<a name="7.19.8.1" href="#7.19.8.1"><b>    7.19.8.1 The fread function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           size_t fread(void * restrict ptr,
-                size_t size, size_t nmemb,
-                FILE * restrict stream);
-<b>    Description</b>
-2   The fread function reads, into the array pointed to by ptr, up to nmemb elements
-    whose size is specified by size, from the stream pointed to by stream. For each
-    object, size calls are made to the fgetc function and the results stored, in the order
-    read, in an array of unsigned char exactly overlaying the object. The file position
-    indicator for the stream (if defined) is advanced by the number of characters successfully
-    read. If an error occurs, the resulting value of the file position indicator for the stream is
-    indeterminate. If a partial element is read, its value is indeterminate.
-<b>    Returns</b>
-3   The fread function returns the number of elements successfully read, which may be
-    less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero,
-    fread returns zero and the contents of the array and the state of the stream remain
-    unchanged.
-<a name="7.19.8.2" href="#7.19.8.2"><b>    7.19.8.2 The fwrite function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           size_t fwrite(const void * restrict ptr,
-                size_t size, size_t nmemb,
-                FILE * restrict stream);
-<b>    Description</b>
-2   The fwrite function writes, from the array pointed to by ptr, up to nmemb elements
-    whose size is specified by size, to the stream pointed to by stream. For each object,
-    size calls are made to the fputc function, taking the values (in order) from an array of
-    unsigned char exactly overlaying the object. The file position indicator for the
-    stream (if defined) is advanced by the number of characters successfully written. If an
-    error occurs, the resulting value of the file position indicator for the stream is
-    indeterminate.
-
-[<a name="p301" href="#p301">page 301</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The fwrite function returns the number of elements successfully written, which will be
-    less than nmemb only if a write error is encountered. If size or nmemb is zero,
-    fwrite returns zero and the state of the stream remains unchanged.
-<a name="7.19.9" href="#7.19.9"><b>    7.19.9 File positioning functions</b></a>
-<a name="7.19.9.1" href="#7.19.9.1"><b>    7.19.9.1 The fgetpos function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int fgetpos(FILE * restrict stream,
-                fpos_t * restrict pos);
-<b>    Description</b>
-2   The fgetpos function stores the current values of the parse state (if any) and file
-    position indicator for the stream pointed to by stream in the object pointed to by pos.
-    The values stored contain unspecified information usable by the fsetpos function for
-    repositioning the stream to its position at the time of the call to the fgetpos function.
-<b>    Returns</b>
-3   If successful, the fgetpos function returns zero; on failure, the fgetpos function
-    returns nonzero and stores an implementation-defined positive value in errno.
-    Forward references: the fsetpos function (<a href="#7.19.9.3">7.19.9.3</a>).
-<a name="7.19.9.2" href="#7.19.9.2"><b>    7.19.9.2 The fseek function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int fseek(FILE *stream, long int offset, int whence);
-<b>    Description</b>
-2   The fseek function sets the file position indicator for the stream pointed to by stream.
-    If a read or write error occurs, the error indicator for the stream is set and fseek fails.
-3   For a binary stream, the new position, measured in characters from the beginning of the
-    file, is obtained by adding offset to the position specified by whence. The specified
-    position is the beginning of the file if whence is SEEK_SET, the current value of the file
-    position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
-    meaningfully support fseek calls with a whence value of SEEK_END.
-4   For a text stream, either offset shall be zero, or offset shall be a value returned by
-    an earlier successful call to the ftell function on a stream associated with the same file
-    and whence shall be SEEK_SET.
-
-[<a name="p302" href="#p302">page 302</a>] (<a href="#Contents">Contents</a>)
-
-5   After determining the new position, a successful call to the fseek function undoes any
-    effects of the ungetc function on the stream, clears the end-of-file indicator for the
-    stream, and then establishes the new position. After a successful fseek call, the next
-    operation on an update stream may be either input or output.
-<b>    Returns</b>
-6   The fseek function returns nonzero only for a request that cannot be satisfied.
-    Forward references: the ftell function (<a href="#7.19.9.4">7.19.9.4</a>).
-<a name="7.19.9.3" href="#7.19.9.3"><b>    7.19.9.3 The fsetpos function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int fsetpos(FILE *stream, const fpos_t *pos);
-<b>    Description</b>
-2   The fsetpos function sets the mbstate_t object (if any) and file position indicator
-    for the stream pointed to by stream according to the value of the object pointed to by
-    pos, which shall be a value obtained from an earlier successful call to the fgetpos
-    function on a stream associated with the same file. If a read or write error occurs, the
-    error indicator for the stream is set and fsetpos fails.
-3   A successful call to the fsetpos function undoes any effects of the ungetc function
-    on the stream, clears the end-of-file indicator for the stream, and then establishes the new
-    parse state and position. After a successful fsetpos call, the next operation on an
-    update stream may be either input or output.
-<b>    Returns</b>
-4   If successful, the fsetpos function returns zero; on failure, the fsetpos function
-    returns nonzero and stores an implementation-defined positive value in errno.
-<a name="7.19.9.4" href="#7.19.9.4"><b>    7.19.9.4 The ftell function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           long int ftell(FILE *stream);
-<b>    Description</b>
-2   The ftell function obtains the current value of the file position indicator for the stream
-    pointed to by stream. For a binary stream, the value is the number of characters from
-    the beginning of the file. For a text stream, its file position indicator contains unspecified
-    information, usable by the fseek function for returning the file position indicator for the
-    stream to its position at the time of the ftell call; the difference between two such
-    return values is not necessarily a meaningful measure of the number of characters written
-
-[<a name="p303" href="#p303">page 303</a>] (<a href="#Contents">Contents</a>)
-
-    or read.
-<b>    Returns</b>
-3   If successful, the ftell function returns the current value of the file position indicator
-    for the stream. On failure, the ftell function returns -1L and stores an
-    implementation-defined positive value in errno.
-<a name="7.19.9.5" href="#7.19.9.5"><b>    7.19.9.5 The rewind function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           void rewind(FILE *stream);
-<b>    Description</b>
-2   The rewind function sets the file position indicator for the stream pointed to by
-    stream to the beginning of the file. It is equivalent to
-           (void)fseek(stream, 0L, SEEK_SET)
-    except that the error indicator for the stream is also cleared.
-<b>    Returns</b>
-3   The rewind function returns no value.
-<a name="7.19.10" href="#7.19.10"><b>    7.19.10 Error-handling functions</b></a>
-<a name="7.19.10.1" href="#7.19.10.1"><b>    7.19.10.1 The clearerr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           void clearerr(FILE *stream);
-<b>    Description</b>
-2   The clearerr function clears the end-of-file and error indicators for the stream pointed
-    to by stream.
-<b>    Returns</b>
-3   The clearerr function returns no value.
-
-[<a name="p304" href="#p304">page 304</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19.10.2" href="#7.19.10.2"><b>    7.19.10.2 The feof function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int feof(FILE *stream);
-<b>    Description</b>
-2   The feof function tests the end-of-file indicator for the stream pointed to by stream.
-<b>    Returns</b>
-3   The feof function returns nonzero if and only if the end-of-file indicator is set for
-    stream.
-<a name="7.19.10.3" href="#7.19.10.3"><b>    7.19.10.3 The ferror function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           int ferror(FILE *stream);
-<b>    Description</b>
-2   The ferror function tests the error indicator for the stream pointed to by stream.
-<b>    Returns</b>
-3   The ferror function returns nonzero if and only if the error indicator is set for
-    stream.
-<a name="7.19.10.4" href="#7.19.10.4"><b>    7.19.10.4 The perror function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           void perror(const char *s);
-<b>    Description</b>
-2   The perror function maps the error number in the integer expression errno to an
-    error message. It writes a sequence of characters to the standard error stream thus: first
-    (if s is not a null pointer and the character pointed to by s is not the null character), the
-    string pointed to by s followed by a colon (:) and a space; then an appropriate error
-    message string followed by a new-line character. The contents of the error message
-    strings are the same as those returned by the strerror function with argument errno.
-<b>    Returns</b>
-3   The perror function returns no value.
-    Forward references: the strerror function (<a href="#7.21.6.2">7.21.6.2</a>).
-
-[<a name="p305" href="#p305">page 305</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20" href="#7.20"><b>    7.20 General utilities &lt;stdlib.h&gt;</b></a>
-1   The header <a href="#7.20">&lt;stdlib.h&gt;</a> declares five types and several functions of general utility, and
-    defines several macros.<sup><a href="#note257"><b>257)</b></a></sup>
-2   The types declared are size_t and wchar_t (both described in <a href="#7.17">7.17</a>),
-             div_t
-    which is a structure type that is the type of the value returned by the div function,
-             ldiv_t
-    which is a structure type that is the type of the value returned by the ldiv function, and
-             lldiv_t
-    which is a structure type that is the type of the value returned by the lldiv function.
-3   The macros defined are NULL (described in <a href="#7.17">7.17</a>);
-             EXIT_FAILURE
-    and
-             EXIT_SUCCESS
-    which expand to integer constant expressions that can be used as the argument to the
-    exit function to return unsuccessful or successful termination status, respectively, to the
-    host environment;
-             RAND_MAX
-    which expands to an integer constant expression that is the maximum value returned by
-    the rand function; and
-             MB_CUR_MAX
-    which expands to a positive integer expression with type size_t that is the maximum
-    number of bytes in a multibyte character for the extended character set specified by the
-    current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
-
-
-
-
-    <sup><a name="note257" href="#note257"><b>257)</b></a></sup> See ''future library directions'' (<a href="#7.26.10">7.26.10</a>).
-
-[<a name="p306" href="#p306">page 306</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.1" href="#7.20.1"><b>    7.20.1 Numeric conversion functions</b></a>
-1   The functions atof, atoi, atol, and atoll need not affect the value of the integer
-    expression errno on an error. If the value of the result cannot be represented, the
-    behavior is undefined.
-<a name="7.20.1.1" href="#7.20.1.1"><b>    7.20.1.1 The atof function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           double atof(const char *nptr);
-<b>    Description</b>
-2   The atof function converts the initial portion of the string pointed to by nptr to
-    double representation. Except for the behavior on error, it is equivalent to
-           strtod(nptr, (char **)NULL)
-<b>    Returns</b>
-3   The atof function returns the converted value.
-    Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>).
-<a name="7.20.1.2" href="#7.20.1.2"><b>    7.20.1.2 The atoi, atol, and atoll functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           int atoi(const char *nptr);
-           long int atol(const char *nptr);
-           long long int atoll(const char *nptr);
-<b>    Description</b>
-2   The atoi, atol, and atoll functions convert the initial portion of the string pointed
-    to by nptr to int, long int, and long long int representation, respectively.
-    Except for the behavior on error, they are equivalent to
-           atoi: (int)strtol(nptr, (char **)NULL, 10)
-           atol: strtol(nptr, (char **)NULL, 10)
-           atoll: strtoll(nptr, (char **)NULL, 10)
-<b>    Returns</b>
-3   The atoi, atol, and atoll functions return the converted value.
-    Forward references: the strtol, strtoll, strtoul, and strtoull functions
-    (<a href="#7.20.1.4">7.20.1.4</a>).
-
-[<a name="p307" href="#p307">page 307</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.1.3" href="#7.20.1.3"><b>    7.20.1.3 The strtod, strtof, and strtold functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           double strtod(const char * restrict nptr,
-                char ** restrict endptr);
-           float strtof(const char * restrict nptr,
-                char ** restrict endptr);
-           long double strtold(const char * restrict nptr,
-                char ** restrict endptr);
-<b>    Description</b>
-2   The strtod, strtof, and strtold functions convert the initial portion of the string
-    pointed to by nptr to double, float, and long double representation,
-    respectively. First, they decompose the input string into three parts: an initial, possibly
-    empty, sequence of white-space characters (as specified by the isspace function), a
-    subject sequence resembling a floating-point constant or representing an infinity or NaN;
-    and a final string of one or more unrecognized characters, including the terminating null
-    character of the input string. Then, they attempt to convert the subject sequence to a
-    floating-point number, and return the result.
-3   The expected form of the subject sequence is an optional plus or minus sign, then one of
-    the following:
-    -- a nonempty sequence of decimal digits optionally containing a decimal-point
-      character, then an optional exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
-    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
-      decimal-point character, then an optional binary exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
-    -- INF or INFINITY, ignoring case
-    -- NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part, where:
-               n-char-sequence:
-                      digit
-                      nondigit
-                      n-char-sequence digit
-                      n-char-sequence nondigit
-    The subject sequence is defined as the longest initial subsequence of the input string,
-    starting with the first non-white-space character, that is of the expected form. The subject
-    sequence contains no characters if the input string is not of the expected form.
-4   If the subject sequence has the expected form for a floating-point number, the sequence of
-    characters starting with the first digit or the decimal-point character (whichever occurs
-    first) is interpreted as a floating constant according to the rules of <a href="#6.4.4.2">6.4.4.2</a>, except that the
-
-[<a name="p308" href="#p308">page 308</a>] (<a href="#Contents">Contents</a>)
-
-    decimal-point character is used in place of a period, and that if neither an exponent part
-    nor a decimal-point character appears in a decimal floating point number, or if a binary
-    exponent part does not appear in a hexadecimal floating point number, an exponent part
-    of the appropriate type with value zero is assumed to follow the last digit in the string. If
-    the subject sequence begins with a minus sign, the sequence is interpreted as negated.<sup><a href="#note258"><b>258)</b></a></sup>
-    A character sequence INF or INFINITY is interpreted as an infinity, if representable in
-    the return type, else like a floating constant that is too large for the range of the return
-    type. A character sequence NAN or NAN(n-char-sequenceopt), is interpreted as a quiet
-    NaN, if supported in the return type, else like a subject sequence part that does not have
-    the expected form; the meaning of the n-char sequences is implementation-defined.<sup><a href="#note259"><b>259)</b></a></sup> A
-    pointer to the final string is stored in the object pointed to by endptr, provided that
-    endptr is not a null pointer.
-5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
-    value resulting from the conversion is correctly rounded.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-    Recommended practice
-8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
-    the result is not exactly representable, the result should be one of the two numbers in the
-    appropriate internal format that are adjacent to the hexadecimal floating source value,
-    with the extra stipulation that the error should have a correct sign for the current rounding
-    direction.
-9   If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
-    <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
-    sequence D has the decimal form and more than DECIMAL_DIG significant digits,
-    consider the two bounding, adjacent decimal strings L and U, both having
-    DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
-    The result should be one of the (equal or adjacent) values that would be obtained by
-    correctly rounding L and U according to the current rounding direction, with the extra
-
-    <sup><a name="note258" href="#note258"><b>258)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
-         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
-         methods may yield different results if rounding is toward positive or negative infinity. In either case,
-         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
-    <sup><a name="note259" href="#note259"><b>259)</b></a></sup> An implementation may use the n-char sequence to determine extra information to be represented in
-         the NaN's significand.
-
-[<a name="p309" href="#p309">page 309</a>] (<a href="#Contents">Contents</a>)
-
-     stipulation that the error with respect to D should have a correct sign for the current
-     rounding direction.<sup><a href="#note260"><b>260)</b></a></sup>
-<b>     Returns</b>
-10   The functions return the converted value, if any. If no conversion could be performed,
-     zero is returned. If the correct value is outside the range of representable values, plus or
-     minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the return
-     type and sign of the value), and the value of the macro ERANGE is stored in errno. If
-     the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is no greater
-     than the smallest normalized positive number in the return type; whether errno acquires
-     the value ERANGE is implementation-defined.
-<a name="7.20.1.4" href="#7.20.1.4"><b>     7.20.1.4 The strtol, strtoll, strtoul, and strtoull functions</b></a>
-<b>     Synopsis</b>
-1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-             long int strtol(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-             long long int strtoll(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-             unsigned long int strtoul(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-             unsigned long long int strtoull(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-<b>     Description</b>
-2    The strtol, strtoll, strtoul, and strtoull functions convert the initial
-     portion of the string pointed to by nptr to long int, long long int, unsigned
-     long int, and unsigned long long int representation, respectively. First,
-     they decompose the input string into three parts: an initial, possibly empty, sequence of
-     white-space characters (as specified by the isspace function), a subject sequence
-
-
-     <sup><a name="note260" href="#note260"><b>260)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
-          to the same internal floating value, but if not will round to adjacent values.
-
-[<a name="p310" href="#p310">page 310</a>] (<a href="#Contents">Contents</a>)
-
-    resembling an integer represented in some radix determined by the value of base, and a
-    final string of one or more unrecognized characters, including the terminating null
-    character of the input string. Then, they attempt to convert the subject sequence to an
-    integer, and return the result.
-3   If the value of base is zero, the expected form of the subject sequence is that of an
-    integer constant as described in <a href="#6.4.4.1">6.4.4.1</a>, optionally preceded by a plus or minus sign, but
-    not including an integer suffix. If the value of base is between 2 and 36 (inclusive), the
-    expected form of the subject sequence is a sequence of letters and digits representing an
-    integer with the radix specified by base, optionally preceded by a plus or minus sign,
-    but not including an integer suffix. The letters from a (or A) through z (or Z) are
-    ascribed the values 10 through 35; only letters and digits whose ascribed values are less
-    than that of base are permitted. If the value of base is 16, the characters 0x or 0X may
-    optionally precede the sequence of letters and digits, following the sign if present.
-4   The subject sequence is defined as the longest initial subsequence of the input string,
-    starting with the first non-white-space character, that is of the expected form. The subject
-    sequence contains no characters if the input string is empty or consists entirely of white
-    space, or if the first non-white-space character is other than a sign or a permissible letter
-    or digit.
-5   If the subject sequence has the expected form and the value of base is zero, the sequence
-    of characters starting with the first digit is interpreted as an integer constant according to
-    the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the value of base
-    is between 2 and 36, it is used as the base for conversion, ascribing to each letter its value
-    as given above. If the subject sequence begins with a minus sign, the value resulting from
-    the conversion is negated (in the return type). A pointer to the final string is stored in the
-    object pointed to by endptr, provided that endptr is not a null pointer.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-<b>    Returns</b>
-8   The strtol, strtoll, strtoul, and strtoull functions return the converted
-    value, if any. If no conversion could be performed, zero is returned. If the correct value
-    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
-    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
-    and sign of the value, if any), and the value of the macro ERANGE is stored in errno.
-
-[<a name="p311" href="#p311">page 311</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.2" href="#7.20.2"><b>    7.20.2 Pseudo-random sequence generation functions</b></a>
-<a name="7.20.2.1" href="#7.20.2.1"><b>    7.20.2.1 The rand function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           int rand(void);
-<b>    Description</b>
-2   The rand function computes a sequence of pseudo-random integers in the range 0 to
-    RAND_MAX.
-3   The implementation shall behave as if no library function calls the rand function.
-<b>    Returns</b>
-4   The rand function returns a pseudo-random integer.
-    Environmental limits
-5   The value of the RAND_MAX macro shall be at least 32767.
-<a name="7.20.2.2" href="#7.20.2.2"><b>    7.20.2.2 The srand function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           void srand(unsigned int seed);
-<b>    Description</b>
-2   The srand function uses the argument as a seed for a new sequence of pseudo-random
-    numbers to be returned by subsequent calls to rand. If srand is then called with the
-    same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is
-    called before any calls to srand have been made, the same sequence shall be generated
-    as when srand is first called with a seed value of 1.
-3   The implementation shall behave as if no library function calls the srand function.
-<b>    Returns</b>
-4   The srand function returns no value.
-5   EXAMPLE       The following functions define a portable implementation of rand and srand.
-           static unsigned long int next = 1;
-           int rand(void)   // RAND_MAX assumed to be 32767
-           {
-                 next = next * 1103515245 + 12345;
-                 return (unsigned int)(next/65536) % 32768;
-           }
-
-[<a name="p312" href="#p312">page 312</a>] (<a href="#Contents">Contents</a>)
-
-            void srand(unsigned int seed)
-            {
-                  next = seed;
-            }
-
-<a name="7.20.3" href="#7.20.3"><b>    7.20.3 Memory management functions</b></a>
-1   The order and contiguity of storage allocated by successive calls to the calloc,
-    malloc, and realloc functions is unspecified. The pointer returned if the allocation
-    succeeds is suitably aligned so that it may be assigned to a pointer to any type of object
-    and then used to access such an object or an array of such objects in the space allocated
-    (until the space is explicitly deallocated). The lifetime of an allocated object extends
-    from the allocation until the deallocation. Each such allocation shall yield a pointer to an
-    object disjoint from any other object. The pointer returned points to the start (lowest byte
-    address) of the allocated space. If the space cannot be allocated, a null pointer is
-    returned. If the size of the space requested is zero, the behavior is implementation-
-    defined: either a null pointer is returned, or the behavior is as if the size were some
-    nonzero value, except that the returned pointer shall not be used to access an object.
-<a name="7.20.3.1" href="#7.20.3.1"><b>    7.20.3.1 The calloc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-            void *calloc(size_t nmemb, size_t size);
-<b>    Description</b>
-2   The calloc function allocates space for an array of nmemb objects, each of whose size
-    is size. The space is initialized to all bits zero.<sup><a href="#note261"><b>261)</b></a></sup>
-<b>    Returns</b>
-3   The calloc function returns either a null pointer or a pointer to the allocated space.
-<a name="7.20.3.2" href="#7.20.3.2"><b>    7.20.3.2 The free function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-            void free(void *ptr);
-<b>    Description</b>
-2   The free function causes the space pointed to by ptr to be deallocated, that is, made
-    available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if
-    the argument does not match a pointer earlier returned by the calloc, malloc, or
-
-
-    <sup><a name="note261" href="#note261"><b>261)</b></a></sup> Note that this need not be the same as the representation of floating-point zero or a null pointer
-         constant.
-
-[<a name="p313" href="#p313">page 313</a>] (<a href="#Contents">Contents</a>)
-
-    realloc function, or if the space has been deallocated by a call to free or realloc,
-    the behavior is undefined.
-<b>    Returns</b>
-3   The free function returns no value.
-<a name="7.20.3.3" href="#7.20.3.3"><b>    7.20.3.3 The malloc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           void *malloc(size_t size);
-<b>    Description</b>
-2   The malloc function allocates space for an object whose size is specified by size and
-    whose value is indeterminate.
-<b>    Returns</b>
-3   The malloc function returns either a null pointer or a pointer to the allocated space.
-<a name="7.20.3.4" href="#7.20.3.4"><b>    7.20.3.4 The realloc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           void *realloc(void *ptr, size_t size);
-<b>    Description</b>
-2   The realloc function deallocates the old object pointed to by ptr and returns a
-    pointer to a new object that has the size specified by size. The contents of the new
-    object shall be the same as that of the old object prior to deallocation, up to the lesser of
-    the new and old sizes. Any bytes in the new object beyond the size of the old object have
-    indeterminate values.
-3   If ptr is a null pointer, the realloc function behaves like the malloc function for the
-    specified size. Otherwise, if ptr does not match a pointer earlier returned by the
-    calloc, malloc, or realloc function, or if the space has been deallocated by a call
-    to the free or realloc function, the behavior is undefined. If memory for the new
-    object cannot be allocated, the old object is not deallocated and its value is unchanged.
-<b>    Returns</b>
-4   The realloc function returns a pointer to the new object (which may have the same
-    value as a pointer to the old object), or a null pointer if the new object could not be
-    allocated.
-
-[<a name="p314" href="#p314">page 314</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.4" href="#7.20.4"><b>    7.20.4 Communication with the environment</b></a>
-<a name="7.20.4.1" href="#7.20.4.1"><b>    7.20.4.1 The abort function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           void abort(void);
-<b>    Description</b>
-2   The abort function causes abnormal program termination to occur, unless the signal
-    SIGABRT is being caught and the signal handler does not return. Whether open streams
-    with unwritten buffered data are flushed, open streams are closed, or temporary files are
-    removed is implementation-defined. An implementation-defined form of the status
-    unsuccessful termination is returned to the host environment by means of the function
-    call raise(SIGABRT).
-<b>    Returns</b>
-3   The abort function does not return to its caller.
-<a name="7.20.4.2" href="#7.20.4.2"><b>    7.20.4.2 The atexit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           int atexit(void (*func)(void));
-<b>    Description</b>
-2   The atexit function registers the function pointed to by func, to be called without
-    arguments at normal program termination.
-    Environmental limits
-3   The implementation shall support the registration of at least 32 functions.
-<b>    Returns</b>
-4   The atexit function returns zero if the registration succeeds, nonzero if it fails.
-    Forward references: the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
-<a name="7.20.4.3" href="#7.20.4.3"><b>    7.20.4.3 The exit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           void exit(int status);
-<b>    Description</b>
-2   The exit function causes normal program termination to occur. If more than one call to
-    the exit function is executed by a program, the behavior is undefined.
-
-[<a name="p315" href="#p315">page 315</a>] (<a href="#Contents">Contents</a>)
-
-3   First, all functions registered by the atexit function are called, in the reverse order of
-    their registration,<sup><a href="#note262"><b>262)</b></a></sup> except that a function is called after any previously registered
-    functions that had already been called at the time it was registered. If, during the call to
-    any such function, a call to the longjmp function is made that would terminate the call
-    to the registered function, the behavior is undefined.
-4   Next, all open streams with unwritten buffered data are flushed, all open streams are
-    closed, and all files created by the tmpfile function are removed.
-5   Finally, control is returned to the host environment. If the value of status is zero or
-    EXIT_SUCCESS, an implementation-defined form of the status successful termination is
-    returned. If the value of status is EXIT_FAILURE, an implementation-defined form
-    of the status unsuccessful termination is returned. Otherwise the status returned is
-    implementation-defined.
-<b>    Returns</b>
-6   The exit function cannot return to its caller.
-<a name="7.20.4.4" href="#7.20.4.4"><b>    7.20.4.4 The _Exit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-            void _Exit(int status);
-<b>    Description</b>
-2   The _Exit function causes normal program termination to occur and control to be
-    returned to the host environment. No functions registered by the atexit function or
-    signal handlers registered by the signal function are called. The status returned to the
-    host environment is determined in the same way as for the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
-    Whether open streams with unwritten buffered data are flushed, open streams are closed,
-    or temporary files are removed is implementation-defined.
-<b>    Returns</b>
-3   The _Exit function cannot return to its caller.
-
-
-
-
-    <sup><a name="note262" href="#note262"><b>262)</b></a></sup> Each function is called as many times as it was registered, and in the correct order with respect to
-         other registered functions.
-
-[<a name="p316" href="#p316">page 316</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.4.5" href="#7.20.4.5"><b>    7.20.4.5 The getenv function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           char *getenv(const char *name);
-<b>    Description</b>
-2   The getenv function searches an environment list, provided by the host environment,
-    for a string that matches the string pointed to by name. The set of environment names
-    and the method for altering the environment list are implementation-defined.
-3   The implementation shall behave as if no library function calls the getenv function.
-<b>    Returns</b>
-4   The getenv function returns a pointer to a string associated with the matched list
-    member. The string pointed to shall not be modified by the program, but may be
-    overwritten by a subsequent call to the getenv function. If the specified name cannot
-    be found, a null pointer is returned.
-<a name="7.20.4.6" href="#7.20.4.6"><b>    7.20.4.6 The system function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           int system(const char *string);
-<b>    Description</b>
-2   If string is a null pointer, the system function determines whether the host
-    environment has a command processor. If string is not a null pointer, the system
-    function passes the string pointed to by string to that command processor to be
-    executed in a manner which the implementation shall document; this might then cause the
-    program calling system to behave in a non-conforming manner or to terminate.
-<b>    Returns</b>
-3   If the argument is a null pointer, the system function returns nonzero only if a
-    command processor is available. If the argument is not a null pointer, and the system
-    function does return, it returns an implementation-defined value.
-
-[<a name="p317" href="#p317">page 317</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.5" href="#7.20.5"><b>    7.20.5 Searching and sorting utilities</b></a>
-1   These utilities make use of a comparison function to search or sort arrays of unspecified
-    type. Where an argument declared as size_t nmemb specifies the length of the array
-    for a function, nmemb can have the value zero on a call to that function; the comparison
-    function is not called, a search finds no matching element, and sorting performs no
-    rearrangement. Pointer arguments on such a call shall still have valid values, as described
-    in <a href="#7.1.4">7.1.4</a>.
-2   The implementation shall ensure that the second argument of the comparison function
-    (when called from bsearch), or both arguments (when called from qsort), are
-    pointers to elements of the array.<sup><a href="#note263"><b>263)</b></a></sup> The first argument when called from bsearch
-    shall equal key.
-3   The comparison function shall not alter the contents of the array. The implementation
-    may reorder elements of the array between calls to the comparison function, but shall not
-    alter the contents of any individual element.
-4   When the same objects (consisting of size bytes, irrespective of their current positions
-    in the array) are passed more than once to the comparison function, the results shall be
-    consistent with one another. That is, for qsort they shall define a total ordering on the
-    array, and for bsearch the same object shall always compare the same way with the
-    key.
-5   A sequence point occurs immediately before and immediately after each call to the
-    comparison function, and also between any call to the comparison function and any
-    movement of the objects passed as arguments to that call.
-<a name="7.20.5.1" href="#7.20.5.1"><b>    7.20.5.1 The bsearch function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-             void *bsearch(const void *key, const void *base,
-                  size_t nmemb, size_t size,
-                  int (*compar)(const void *, const void *));
-<b>    Description</b>
-2   The bsearch function searches an array of nmemb objects, the initial element of which
-    is pointed to by base, for an element that matches the object pointed to by key. The
-
-
-    <sup><a name="note263" href="#note263"><b>263)</b></a></sup> That is, if the value passed is p, then the following expressions are always nonzero:
-                  ((char *)p - (char *)base) % size == 0
-                  (char *)p &gt;= (char *)base
-                  (char *)p &lt; (char *)base + nmemb * size
-
-[<a name="p318" href="#p318">page 318</a>] (<a href="#Contents">Contents</a>)
-
-    size of each element of the array is specified by size.
-3   The comparison function pointed to by compar is called with two arguments that point
-    to the key object and to an array element, in that order. The function shall return an
-    integer less than, equal to, or greater than zero if the key object is considered,
-    respectively, to be less than, to match, or to be greater than the array element. The array
-    shall consist of: all the elements that compare less than, all the elements that compare
-    equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note264"><b>264)</b></a></sup>
-<b>    Returns</b>
-4   The bsearch function returns a pointer to a matching element of the array, or a null
-    pointer if no match is found. If two elements compare as equal, which element is
-    matched is unspecified.
-<a name="7.20.5.2" href="#7.20.5.2"><b>    7.20.5.2 The qsort function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-             void qsort(void *base, size_t nmemb, size_t size,
-                  int (*compar)(const void *, const void *));
-<b>    Description</b>
-2   The qsort function sorts an array of nmemb objects, the initial element of which is
-    pointed to by base. The size of each object is specified by size.
-3   The contents of the array are sorted into ascending order according to a comparison
-    function pointed to by compar, which is called with two arguments that point to the
-    objects being compared. The function shall return an integer less than, equal to, or
-    greater than zero if the first argument is considered to be respectively less than, equal to,
-    or greater than the second.
-4   If two elements compare as equal, their order in the resulting sorted array is unspecified.
-<b>    Returns</b>
-5   The qsort function returns no value.
-
-
-
-
-    <sup><a name="note264" href="#note264"><b>264)</b></a></sup> In practice, the entire array is sorted according to the comparison function.
-
-[<a name="p319" href="#p319">page 319</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.6" href="#7.20.6"><b>    7.20.6 Integer arithmetic functions</b></a>
-<a name="7.20.6.1" href="#7.20.6.1"><b>    7.20.6.1 The abs, labs and llabs functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-            int abs(int j);
-            long int labs(long int j);
-            long long int llabs(long long int j);
-<b>    Description</b>
-2   The abs, labs, and llabs functions compute the absolute value of an integer j. If the
-    result cannot be represented, the behavior is undefined.<sup><a href="#note265"><b>265)</b></a></sup>
-<b>    Returns</b>
-3   The abs, labs, and llabs, functions return the absolute value.
-<a name="7.20.6.2" href="#7.20.6.2"><b>    7.20.6.2 The div, ldiv, and lldiv functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-            div_t div(int numer, int denom);
-            ldiv_t ldiv(long int numer, long int denom);
-            lldiv_t lldiv(long long int numer, long long int denom);
-<b>    Description</b>
-2   The div, ldiv, and lldiv, functions compute numer / denom and numer %
-    denom in a single operation.
-<b>    Returns</b>
-3   The div, ldiv, and lldiv functions return a structure of type div_t, ldiv_t, and
-    lldiv_t, respectively, comprising both the quotient and the remainder. The structures
-    shall contain (in either order) the members quot (the quotient) and rem (the remainder),
-    each of which has the same type as the arguments numer and denom. If either part of
-    the result cannot be represented, the behavior is undefined.
-
-
-
-
-    <sup><a name="note265" href="#note265"><b>265)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
-
-[<a name="p320" href="#p320">page 320</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.7" href="#7.20.7"><b>    7.20.7 Multibyte/wide character conversion functions</b></a>
-1   The behavior of the multibyte character functions is affected by the LC_CTYPE category
-    of the current locale. For a state-dependent encoding, each function is placed into its
-    initial conversion state by a call for which its character pointer argument, s, is a null
-    pointer. Subsequent calls with s as other than a null pointer cause the internal conversion
-    state of the function to be altered as necessary. A call with s as a null pointer causes
-    these functions to return a nonzero value if encodings have state dependency, and zero
-    otherwise.<sup><a href="#note266"><b>266)</b></a></sup> Changing the LC_CTYPE category causes the conversion state of these
-    functions to be indeterminate.
-<a name="7.20.7.1" href="#7.20.7.1"><b>    7.20.7.1 The mblen function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-            int mblen(const char *s, size_t n);
-<b>    Description</b>
-2   If s is not a null pointer, the mblen function determines the number of bytes contained
-    in the multibyte character pointed to by s. Except that the conversion state of the
-    mbtowc function is not affected, it is equivalent to
-            mbtowc((wchar_t *)0, s, n);
-3   The implementation shall behave as if no library function calls the mblen function.
-<b>    Returns</b>
-4   If s is a null pointer, the mblen function returns a nonzero or zero value, if multibyte
-    character encodings, respectively, do or do not have state-dependent encodings. If s is
-    not a null pointer, the mblen function either returns 0 (if s points to the null character),
-    or returns the number of bytes that are contained in the multibyte character (if the next n
-    or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
-    multibyte character).
-    Forward references: the mbtowc function (<a href="#7.20.7.2">7.20.7.2</a>).
-
-
-
-
-    <sup><a name="note266" href="#note266"><b>266)</b></a></sup> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
-         character codes, but are grouped with an adjacent multibyte character.
-
-[<a name="p321" href="#p321">page 321</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.7.2" href="#7.20.7.2"><b>    7.20.7.2 The mbtowc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           int mbtowc(wchar_t * restrict pwc,
-                const char * restrict s,
-                size_t n);
-<b>    Description</b>
-2   If s is not a null pointer, the mbtowc function inspects at most n bytes beginning with
-    the byte pointed to by s to determine the number of bytes needed to complete the next
-    multibyte character (including any shift sequences). If the function determines that the
-    next multibyte character is complete and valid, it determines the value of the
-    corresponding wide character and then, if pwc is not a null pointer, stores that value in
-    the object pointed to by pwc. If the corresponding wide character is the null wide
-    character, the function is left in the initial conversion state.
-3   The implementation shall behave as if no library function calls the mbtowc function.
-<b>    Returns</b>
-4   If s is a null pointer, the mbtowc function returns a nonzero or zero value, if multibyte
-    character encodings, respectively, do or do not have state-dependent encodings. If s is
-    not a null pointer, the mbtowc function either returns 0 (if s points to the null character),
-    or returns the number of bytes that are contained in the converted multibyte character (if
-    the next n or fewer bytes form a valid multibyte character), or returns -1 (if they do not
-    form a valid multibyte character).
-5   In no case will the value returned be greater than n or the value of the MB_CUR_MAX
-    macro.
-<a name="7.20.7.3" href="#7.20.7.3"><b>    7.20.7.3 The wctomb function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           int wctomb(char *s, wchar_t wc);
-<b>    Description</b>
-2   The wctomb function determines the number of bytes needed to represent the multibyte
-    character corresponding to the wide character given by wc (including any shift
-    sequences), and stores the multibyte character representation in the array whose first
-    element is pointed to by s (if s is not a null pointer). At most MB_CUR_MAX characters
-    are stored. If wc is a null wide character, a null byte is stored, preceded by any shift
-    sequence needed to restore the initial shift state, and the function is left in the initial
-    conversion state.
-
-[<a name="p322" href="#p322">page 322</a>] (<a href="#Contents">Contents</a>)
-
-3   The implementation shall behave as if no library function calls the wctomb function.
-<b>    Returns</b>
-4   If s is a null pointer, the wctomb function returns a nonzero or zero value, if multibyte
-    character encodings, respectively, do or do not have state-dependent encodings. If s is
-    not a null pointer, the wctomb function returns -1 if the value of wc does not correspond
-    to a valid multibyte character, or returns the number of bytes that are contained in the
-    multibyte character corresponding to the value of wc.
-5   In no case will the value returned be greater than the value of the MB_CUR_MAX macro.
-<a name="7.20.8" href="#7.20.8"><b>    7.20.8 Multibyte/wide string conversion functions</b></a>
-1   The behavior of the multibyte string functions is affected by the LC_CTYPE category of
-    the current locale.
-<a name="7.20.8.1" href="#7.20.8.1"><b>    7.20.8.1 The mbstowcs function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-             size_t mbstowcs(wchar_t * restrict pwcs,
-                  const char * restrict s,
-                  size_t n);
-<b>    Description</b>
-2   The mbstowcs function converts a sequence of multibyte characters that begins in the
-    initial shift state from the array pointed to by s into a sequence of corresponding wide
-    characters and stores not more than n wide characters into the array pointed to by pwcs.
-    No multibyte characters that follow a null character (which is converted into a null wide
-    character) will be examined or converted. Each multibyte character is converted as if by
-    a call to the mbtowc function, except that the conversion state of the mbtowc function is
-    not affected.
-3   No more than n elements will be modified in the array pointed to by pwcs. If copying
-    takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-4   If an invalid multibyte character is encountered, the mbstowcs function returns
-    (size_t)(-1). Otherwise, the mbstowcs function returns the number of array
-    elements modified, not including a terminating null wide character, if any.<sup><a href="#note267"><b>267)</b></a></sup>
-
-
-
-
-    <sup><a name="note267" href="#note267"><b>267)</b></a></sup> The array will not be null-terminated if the value returned is n.
-
-[<a name="p323" href="#p323">page 323</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.8.2" href="#7.20.8.2"><b>    7.20.8.2 The wcstombs function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
-           size_t wcstombs(char * restrict s,
-                const wchar_t * restrict pwcs,
-                size_t n);
-<b>    Description</b>
-2   The wcstombs function converts a sequence of wide characters from the array pointed
-    to by pwcs into a sequence of corresponding multibyte characters that begins in the
-    initial shift state, and stores these multibyte characters into the array pointed to by s,
-    stopping if a multibyte character would exceed the limit of n total bytes or if a null
-    character is stored. Each wide character is converted as if by a call to the wctomb
-    function, except that the conversion state of the wctomb function is not affected.
-3   No more than n bytes will be modified in the array pointed to by s. If copying takes place
-    between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-4   If a wide character is encountered that does not correspond to a valid multibyte character,
-    the wcstombs function returns (size_t)(-1). Otherwise, the wcstombs function
-    returns the number of bytes modified, not including a terminating null character, if
-    any.267)
-
-[<a name="p324" href="#p324">page 324</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21" href="#7.21"><b>    7.21 String handling &lt;string.h&gt;</b></a>
-<a name="7.21.1" href="#7.21.1"><b>    7.21.1 String function conventions</b></a>
-1   The header <a href="#7.21">&lt;string.h&gt;</a> declares one type and several functions, and defines one
-    macro useful for manipulating arrays of character type and other objects treated as arrays
-    of character type.<sup><a href="#note268"><b>268)</b></a></sup> The type is size_t and the macro is NULL (both described in
-<a name="7.17)" href="#7.17)"><b>    7.17). Various methods are used for determining the lengths of the arrays, but in all cases</b></a>
-    a char * or void * argument points to the initial (lowest addressed) character of the
-    array. If an array is accessed beyond the end of an object, the behavior is undefined.
-2   Where an argument declared as size_t n specifies the length of the array for a
-    function, n can have the value zero on a call to that function. Unless explicitly stated
-    otherwise in the description of a particular function in this subclause, pointer arguments
-    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
-    function that locates a character finds no occurrence, a function that compares two
-    character sequences returns zero, and a function that copies characters copies zero
-    characters.
-3   For all functions in this subclause, each character shall be interpreted as if it had the type
-    unsigned char (and therefore every possible object representation is valid and has a
-    different value).
-<a name="7.21.2" href="#7.21.2"><b>    7.21.2 Copying functions</b></a>
-<a name="7.21.2.1" href="#7.21.2.1"><b>    7.21.2.1 The memcpy function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.21">&lt;string.h&gt;</a>
-             void *memcpy(void * restrict s1,
-                  const void * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The memcpy function copies n characters from the object pointed to by s2 into the
-    object pointed to by s1. If copying takes place between objects that overlap, the behavior
-    is undefined.
-<b>    Returns</b>
-3   The memcpy function returns the value of s1.
-
-
-
-
-    <sup><a name="note268" href="#note268"><b>268)</b></a></sup> See ''future library directions'' (<a href="#7.26.11">7.26.11</a>).
-
-[<a name="p325" href="#p325">page 325</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.2.2" href="#7.21.2.2"><b>    7.21.2.2 The memmove function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           void *memmove(void *s1, const void *s2, size_t n);
-<b>    Description</b>
-2   The memmove function copies n characters from the object pointed to by s2 into the
-    object pointed to by s1. Copying takes place as if the n characters from the object
-    pointed to by s2 are first copied into a temporary array of n characters that does not
-    overlap the objects pointed to by s1 and s2, and then the n characters from the
-    temporary array are copied into the object pointed to by s1.
-<b>    Returns</b>
-3   The memmove function returns the value of s1.
-<a name="7.21.2.3" href="#7.21.2.3"><b>    7.21.2.3 The strcpy function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strcpy(char * restrict s1,
-                const char * restrict s2);
-<b>    Description</b>
-2   The strcpy function copies the string pointed to by s2 (including the terminating null
-    character) into the array pointed to by s1. If copying takes place between objects that
-    overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The strcpy function returns the value of s1.
-<a name="7.21.2.4" href="#7.21.2.4"><b>    7.21.2.4 The strncpy function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strncpy(char * restrict s1,
-                const char * restrict s2,
-                size_t n);
-<b>    Description</b>
-2   The strncpy function copies not more than n characters (characters that follow a null
-    character are not copied) from the array pointed to by s2 to the array pointed to by
-
-[<a name="p326" href="#p326">page 326</a>] (<a href="#Contents">Contents</a>)
-
-    s1.<sup><a href="#note269"><b>269)</b></a></sup> If copying takes place between objects that overlap, the behavior is undefined.
-3   If the array pointed to by s2 is a string that is shorter than n characters, null characters
-    are appended to the copy in the array pointed to by s1, until n characters in all have been
-    written.
-<b>    Returns</b>
-4   The strncpy function returns the value of s1.
-<a name="7.21.3" href="#7.21.3"><b>    7.21.3 Concatenation functions</b></a>
-<a name="7.21.3.1" href="#7.21.3.1"><b>    7.21.3.1 The strcat function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.21">&lt;string.h&gt;</a>
-             char *strcat(char * restrict s1,
-                  const char * restrict s2);
-<b>    Description</b>
-2   The strcat function appends a copy of the string pointed to by s2 (including the
-    terminating null character) to the end of the string pointed to by s1. The initial character
-    of s2 overwrites the null character at the end of s1. If copying takes place between
-    objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The strcat function returns the value of s1.
-<a name="7.21.3.2" href="#7.21.3.2"><b>    7.21.3.2 The strncat function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.21">&lt;string.h&gt;</a>
-             char *strncat(char * restrict s1,
-                  const char * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The strncat function appends not more than n characters (a null character and
-    characters that follow it are not appended) from the array pointed to by s2 to the end of
-    the string pointed to by s1. The initial character of s2 overwrites the null character at the
-    end of s1. A terminating null character is always appended to the result.<sup><a href="#note270"><b>270)</b></a></sup> If copying
-
-    <sup><a name="note269" href="#note269"><b>269)</b></a></sup> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
-         not be null-terminated.
-    <sup><a name="note270" href="#note270"><b>270)</b></a></sup> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
-         strlen(s1)+n+1.
-
-[<a name="p327" href="#p327">page 327</a>] (<a href="#Contents">Contents</a>)
-
-    takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The strncat function returns the value of s1.
-    Forward references: the strlen function (<a href="#7.21.6.3">7.21.6.3</a>).
-<a name="7.21.4" href="#7.21.4"><b>    7.21.4 Comparison functions</b></a>
-1   The sign of a nonzero value returned by the comparison functions memcmp, strcmp,
-    and strncmp is determined by the sign of the difference between the values of the first
-    pair of characters (both interpreted as unsigned char) that differ in the objects being
-    compared.
-<a name="7.21.4.1" href="#7.21.4.1"><b>    7.21.4.1 The memcmp function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;string.h&gt;</a>
-            int memcmp(const void *s1, const void *s2, size_t n);
-<b>    Description</b>
-2   The memcmp function compares the first n characters of the object pointed to by s1 to
-    the first n characters of the object pointed to by s2.<sup><a href="#note271"><b>271)</b></a></sup>
-<b>    Returns</b>
-3   The memcmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
-    pointed to by s2.
-<a name="7.21.4.2" href="#7.21.4.2"><b>    7.21.4.2 The strcmp function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;string.h&gt;</a>
-            int strcmp(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strcmp function compares the string pointed to by s1 to the string pointed to by
-    s2.
-<b>    Returns</b>
-3   The strcmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
-
-    <sup><a name="note271" href="#note271"><b>271)</b></a></sup> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
-         indeterminate. Strings shorter than their allocated space and unions may also cause problems in
-         comparison.
-
-[<a name="p328" href="#p328">page 328</a>] (<a href="#Contents">Contents</a>)
-
-    pointed to by s2.
-<a name="7.21.4.3" href="#7.21.4.3"><b>    7.21.4.3 The strcoll function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           int strcoll(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strcoll function compares the string pointed to by s1 to the string pointed to by
-    s2, both interpreted as appropriate to the LC_COLLATE category of the current locale.
-<b>    Returns</b>
-3   The strcoll function returns an integer greater than, equal to, or less than zero,
-    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
-    pointed to by s2 when both are interpreted as appropriate to the current locale.
-<a name="7.21.4.4" href="#7.21.4.4"><b>    7.21.4.4 The strncmp function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           int strncmp(const char *s1, const char *s2, size_t n);
-<b>    Description</b>
-2   The strncmp function compares not more than n characters (characters that follow a
-    null character are not compared) from the array pointed to by s1 to the array pointed to
-    by s2.
-<b>    Returns</b>
-3   The strncmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
-    to, or less than the possibly null-terminated array pointed to by s2.
-<a name="7.21.4.5" href="#7.21.4.5"><b>    7.21.4.5 The strxfrm function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           size_t strxfrm(char * restrict s1,
-                const char * restrict s2,
-                size_t n);
-<b>    Description</b>
-2   The strxfrm function transforms the string pointed to by s2 and places the resulting
-    string into the array pointed to by s1. The transformation is such that if the strcmp
-    function is applied to two transformed strings, it returns a value greater than, equal to, or
-
-[<a name="p329" href="#p329">page 329</a>] (<a href="#Contents">Contents</a>)
-
-    less than zero, corresponding to the result of the strcoll function applied to the same
-    two original strings. No more than n characters are placed into the resulting array
-    pointed to by s1, including the terminating null character. If n is zero, s1 is permitted to
-    be a null pointer. If copying takes place between objects that overlap, the behavior is
-    undefined.
-<b>    Returns</b>
-3   The strxfrm function returns the length of the transformed string (not including the
-    terminating null character). If the value returned is n or more, the contents of the array
-    pointed to by s1 are indeterminate.
-4   EXAMPLE The value of the following expression is the size of the array needed to hold the
-    transformation of the string pointed to by s.
-           1 + strxfrm(NULL, s, 0)
-
-<a name="7.21.5" href="#7.21.5"><b>    7.21.5 Search functions</b></a>
-<a name="7.21.5.1" href="#7.21.5.1"><b>    7.21.5.1 The memchr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           void *memchr(const void *s, int c, size_t n);
-<b>    Description</b>
-2   The memchr function locates the first occurrence of c (converted to an unsigned
-    char) in the initial n characters (each interpreted as unsigned char) of the object
-    pointed to by s.
-<b>    Returns</b>
-3   The memchr function returns a pointer to the located character, or a null pointer if the
-    character does not occur in the object.
-<a name="7.21.5.2" href="#7.21.5.2"><b>    7.21.5.2 The strchr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strchr(const char *s, int c);
-<b>    Description</b>
-2   The strchr function locates the first occurrence of c (converted to a char) in the
-    string pointed to by s. The terminating null character is considered to be part of the
-    string.
-<b>    Returns</b>
-3   The strchr function returns a pointer to the located character, or a null pointer if the
-    character does not occur in the string.
-
-[<a name="p330" href="#p330">page 330</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.5.3" href="#7.21.5.3"><b>    7.21.5.3 The strcspn function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           size_t strcspn(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strcspn function computes the length of the maximum initial segment of the string
-    pointed to by s1 which consists entirely of characters not from the string pointed to by
-    s2.
-<b>    Returns</b>
-3   The strcspn function returns the length of the segment.
-<a name="7.21.5.4" href="#7.21.5.4"><b>    7.21.5.4 The strpbrk function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strpbrk(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strpbrk function locates the first occurrence in the string pointed to by s1 of any
-    character from the string pointed to by s2.
-<b>    Returns</b>
-3   The strpbrk function returns a pointer to the character, or a null pointer if no character
-    from s2 occurs in s1.
-<a name="7.21.5.5" href="#7.21.5.5"><b>    7.21.5.5 The strrchr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strrchr(const char *s, int c);
-<b>    Description</b>
-2   The strrchr function locates the last occurrence of c (converted to a char) in the
-    string pointed to by s. The terminating null character is considered to be part of the
-    string.
-<b>    Returns</b>
-3   The strrchr function returns a pointer to the character, or a null pointer if c does not
-    occur in the string.
-
-[<a name="p331" href="#p331">page 331</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.5.6" href="#7.21.5.6"><b>    7.21.5.6 The strspn function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           size_t strspn(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strspn function computes the length of the maximum initial segment of the string
-    pointed to by s1 which consists entirely of characters from the string pointed to by s2.
-<b>    Returns</b>
-3   The strspn function returns the length of the segment.
-<a name="7.21.5.7" href="#7.21.5.7"><b>    7.21.5.7 The strstr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strstr(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strstr function locates the first occurrence in the string pointed to by s1 of the
-    sequence of characters (excluding the terminating null character) in the string pointed to
-    by s2.
-<b>    Returns</b>
-3   The strstr function returns a pointer to the located string, or a null pointer if the string
-    is not found. If s2 points to a string with zero length, the function returns s1.
-<a name="7.21.5.8" href="#7.21.5.8"><b>    7.21.5.8 The strtok function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strtok(char * restrict s1,
-                const char * restrict s2);
-<b>    Description</b>
-2   A sequence of calls to the strtok function breaks the string pointed to by s1 into a
-    sequence of tokens, each of which is delimited by a character from the string pointed to
-    by s2. The first call in the sequence has a non-null first argument; subsequent calls in the
-    sequence have a null first argument. The separator string pointed to by s2 may be
-    different from call to call.
-3   The first call in the sequence searches the string pointed to by s1 for the first character
-    that is not contained in the current separator string pointed to by s2. If no such character
-    is found, then there are no tokens in the string pointed to by s1 and the strtok function
-
-[<a name="p332" href="#p332">page 332</a>] (<a href="#Contents">Contents</a>)
-
-    returns a null pointer. If such a character is found, it is the start of the first token.
-4   The strtok function then searches from there for a character that is contained in the
-    current separator string. If no such character is found, the current token extends to the
-    end of the string pointed to by s1, and subsequent searches for a token will return a null
-    pointer. If such a character is found, it is overwritten by a null character, which
-    terminates the current token. The strtok function saves a pointer to the following
-    character, from which the next search for a token will start.
-5   Each subsequent call, with a null pointer as the value of the first argument, starts
-    searching from the saved pointer and behaves as described above.
-6   The implementation shall behave as if no library function calls the strtok function.
-<b>    Returns</b>
-7   The strtok function returns a pointer to the first character of a token, or a null pointer
-    if there is no token.
-8   EXAMPLE
-            #include <a href="#7.21">&lt;string.h&gt;</a>
-            static char str[] = "?a???b,,,#c";
-            char *t;
-            t   =   strtok(str, "?");       //   t   points to the token "a"
-            t   =   strtok(NULL, ",");      //   t   points to the token "??b"
-            t   =   strtok(NULL, "#,");     //   t   points to the token "c"
-            t   =   strtok(NULL, "?");      //   t   is a null pointer
-
-<a name="7.21.6" href="#7.21.6"><b>    7.21.6 Miscellaneous functions</b></a>
-<a name="7.21.6.1" href="#7.21.6.1"><b>    7.21.6.1 The memset function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;string.h&gt;</a>
-            void *memset(void *s, int c, size_t n);
-<b>    Description</b>
-2   The memset function copies the value of c (converted to an unsigned char) into
-    each of the first n characters of the object pointed to by s.
-<b>    Returns</b>
-3   The memset function returns the value of s.
-
-[<a name="p333" href="#p333">page 333</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.6.2" href="#7.21.6.2"><b>    7.21.6.2 The strerror function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           char *strerror(int errnum);
-<b>    Description</b>
-2   The strerror function maps the number in errnum to a message string. Typically,
-    the values for errnum come from errno, but strerror shall map any value of type
-    int to a message.
-3   The implementation shall behave as if no library function calls the strerror function.
-<b>    Returns</b>
-4   The strerror function returns a pointer to the string, the contents of which are locale-
-    specific. The array pointed to shall not be modified by the program, but may be
-    overwritten by a subsequent call to the strerror function.
-<a name="7.21.6.3" href="#7.21.6.3"><b>    7.21.6.3 The strlen function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;string.h&gt;</a>
-           size_t strlen(const char *s);
-<b>    Description</b>
-2   The strlen function computes the length of the string pointed to by s.
-<b>    Returns</b>
-3   The strlen function returns the number of characters that precede the terminating null
-    character.
-
-[<a name="p334" href="#p334">page 334</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22" href="#7.22"><b>    7.22 Type-generic math &lt;tgmath.h&gt;</b></a>
-1   The header <a href="#7.22">&lt;tgmath.h&gt;</a> includes the headers <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> and
-    defines several type-generic macros.
-2   Of the <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> functions without an f (float) or l (long
-    double) suffix, several have one or more parameters whose corresponding real type is
-    double. For each such function, except modf, there is a corresponding type-generic
-    macro.<sup><a href="#note272"><b>272)</b></a></sup> The parameters whose corresponding real type is double in the function
-    synopsis are generic parameters. Use of the macro invokes a function whose
-    corresponding real type and type domain are determined by the arguments for the generic
-    parameters.<sup><a href="#note273"><b>273)</b></a></sup>
-3   Use of the macro invokes a function whose generic parameters have the corresponding
-    real type determined as follows:
-    -- First, if any argument for generic parameters has type long double, the type
-      determined is long double.
-    -- Otherwise, if any argument for generic parameters has type double or is of integer
-      type, the type determined is double.
-    -- Otherwise, the type determined is float.
-4   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> for which there is a function in
-    <a href="#7.3">&lt;complex.h&gt;</a> with the same name except for a c prefix, the corresponding type-
-    generic macro (for both functions) has the same name as the function in <a href="#7.12">&lt;math.h&gt;</a>. The
-    corresponding type-generic macro for fabs and cabs is fabs.
-
-
-
-
-    <sup><a name="note272" href="#note272"><b>272)</b></a></sup> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
-         make available the corresponding ordinary function.
-    <sup><a name="note273" href="#note273"><b>273)</b></a></sup> If the type of the argument is not compatible with the type of the parameter for the selected function,
-         the behavior is undefined.
-
-[<a name="p335" href="#p335">page 335</a>] (<a href="#Contents">Contents</a>)
-
-            <a href="#7.12">&lt;math.h&gt;</a>          <a href="#7.3">&lt;complex.h&gt;</a>           type-generic
-             function            function              macro
-              acos               cacos                acos
-              asin               casin                asin
-              atan               catan                atan
-              acosh              cacosh               acosh
-              asinh              casinh               asinh
-              atanh              catanh               atanh
-              cos                ccos                 cos
-              sin                csin                 sin
-              tan                ctan                 tan
-              cosh               ccosh                cosh
-              sinh               csinh                sinh
-              tanh               ctanh                tanh
-              exp                cexp                 exp
-              log                clog                 log
-              pow                cpow                 pow
-              sqrt               csqrt                sqrt
-              fabs               cabs                 fabs
-    If at least one argument for a generic parameter is complex, then use of the macro invokes
-    a complex function; otherwise, use of the macro invokes a real function.
-5   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> without a c-prefixed counterpart in
-    <a href="#7.3">&lt;complex.h&gt;</a> (except modf), the corresponding type-generic macro has the same
-    name as the function. These type-generic macros are:
-          atan2                fma                  llround              remainder
-          cbrt                 fmax                 log10                remquo
-          ceil                 fmin                 log1p                rint
-          copysign             fmod                 log2                 round
-          erf                  frexp                logb                 scalbn
-          erfc                 hypot                lrint                scalbln
-          exp2                 ilogb                lround               tgamma
-          expm1                ldexp                nearbyint            trunc
-          fdim                 lgamma               nextafter
-          floor                llrint               nexttoward
-    If all arguments for generic parameters are real, then use of the macro invokes a real
-    function; otherwise, use of the macro results in undefined behavior.
-6   For each unsuffixed function in <a href="#7.3">&lt;complex.h&gt;</a> that is not a c-prefixed counterpart to a
-    function in <a href="#7.12">&lt;math.h&gt;</a>, the corresponding type-generic macro has the same name as the
-    function. These type-generic macros are:
-
-[<a name="p336" href="#p336">page 336</a>] (<a href="#Contents">Contents</a>)
-
-            carg                    conj                     creal
-            cimag                   cproj
-    Use of the macro with any real or complex argument invokes a complex function.
-7   EXAMPLE       With the declarations
-            #include <a href="#7.22">&lt;tgmath.h&gt;</a>
-            int n;
-            float f;
-            double d;
-            long double ld;
-            float complex fc;
-            double complex dc;
-            long double complex ldc;
-    functions invoked by use of type-generic macros are shown in the following table:
-                     macro use                                  invokes
-                exp(n)                              exp(n), the function
-                acosh(f)                            acoshf(f)
-                sin(d)                              sin(d), the function
-                atan(ld)                            atanl(ld)
-                log(fc)                             clogf(fc)
-                sqrt(dc)                            csqrt(dc)
-                pow(ldc, f)                         cpowl(ldc, f)
-                remainder(n, n)                     remainder(n, n), the function
-                nextafter(d, f)                     nextafter(d, f), the function
-                nexttoward(f, ld)                   nexttowardf(f, ld)
-                copysign(n, ld)                     copysignl(n, ld)
-                ceil(fc)                            undefined behavior
-                rint(dc)                            undefined behavior
-                fmax(ldc, ld)                       undefined behavior
-                carg(n)                             carg(n), the function
-                cproj(f)                            cprojf(f)
-                creal(d)                            creal(d), the function
-                cimag(ld)                           cimagl(ld)
-                fabs(fc)                            cabsf(fc)
-                carg(dc)                            carg(dc), the function
-                cproj(ldc)                          cprojl(ldc)
-
-[<a name="p337" href="#p337">page 337</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.23" href="#7.23"><b>    7.23 Date and time &lt;time.h&gt;</b></a>
-<a name="7.23.1" href="#7.23.1"><b>    7.23.1 Components of time</b></a>
-1   The header <a href="#7.23">&lt;time.h&gt;</a> defines two macros, and declares several types and functions for
-    manipulating time. Many functions deal with a calendar time that represents the current
-    date (according to the Gregorian calendar) and time. Some functions deal with local
-    time, which is the calendar time expressed for some specific time zone, and with Daylight
-    Saving Time, which is a temporary change in the algorithm for determining local time.
-    The local time zone and Daylight Saving Time are implementation-defined.
-2   The macros defined are NULL (described in <a href="#7.17">7.17</a>); and
-            CLOCKS_PER_SEC
-    which expands to an expression with type clock_t (described below) that is the
-    number per second of the value returned by the clock function.
-3   The types declared are size_t (described in <a href="#7.17">7.17</a>);
-            clock_t
-    and
-            time_t
-    which are arithmetic types capable of representing times; and
-            struct tm
-    which holds the components of a calendar time, called the broken-down time.
-4   The range and precision of times representable in clock_t and time_t are
-    implementation-defined. The tm structure shall contain at least the following members,
-    in any order. The semantics of the members and their normal ranges are expressed in the
-    comments.<sup><a href="#note274"><b>274)</b></a></sup>
-            int    tm_sec;           //   seconds after the minute -- [0, 60]
-            int    tm_min;           //   minutes after the hour -- [0, 59]
-            int    tm_hour;          //   hours since midnight -- [0, 23]
-            int    tm_mday;          //   day of the month -- [1, 31]
-            int    tm_mon;           //   months since January -- [0, 11]
-            int    tm_year;          //   years since 1900
-            int    tm_wday;          //   days since Sunday -- [0, 6]
-            int    tm_yday;          //   days since January 1 -- [0, 365]
-            int    tm_isdst;         //   Daylight Saving Time flag
-
-
-
-    <sup><a name="note274" href="#note274"><b>274)</b></a></sup> The range [0, 60] for tm_sec allows for a positive leap second.
-
-[<a name="p338" href="#p338">page 338</a>] (<a href="#Contents">Contents</a>)
-
-    The value of tm_isdst is positive if Daylight Saving Time is in effect, zero if Daylight
-    Saving Time is not in effect, and negative if the information is not available.
-<a name="7.23.2" href="#7.23.2"><b>    7.23.2 Time manipulation functions</b></a>
-<a name="7.23.2.1" href="#7.23.2.1"><b>    7.23.2.1 The clock function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;time.h&gt;</a>
-            clock_t clock(void);
-<b>    Description</b>
-2   The clock function determines the processor time used.
-<b>    Returns</b>
-3   The clock function returns the implementation's best approximation to the processor
-    time used by the program since the beginning of an implementation-defined era related
-    only to the program invocation. To determine the time in seconds, the value returned by
-    the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
-    the processor time used is not available or its value cannot be represented, the function
-    returns the value (clock_t)(-1).<sup><a href="#note275"><b>275)</b></a></sup>
-<a name="7.23.2.2" href="#7.23.2.2"><b>    7.23.2.2 The difftime function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;time.h&gt;</a>
-            double difftime(time_t time1, time_t time0);
-<b>    Description</b>
-2   The difftime function computes the difference between two calendar times: time1 -
-    time0.
-<b>    Returns</b>
-3   The difftime function returns the difference expressed in seconds as a double.
-
-
-
-
-    <sup><a name="note275" href="#note275"><b>275)</b></a></sup> In order to measure the time spent in a program, the clock function should be called at the start of
-         the program and its return value subtracted from the value returned by subsequent calls.
-
-[<a name="p339" href="#p339">page 339</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.23.2.3" href="#7.23.2.3"><b>    7.23.2.3 The mktime function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;time.h&gt;</a>
-            time_t mktime(struct tm *timeptr);
-<b>    Description</b>
-2   The mktime function converts the broken-down time, expressed as local time, in the
-    structure pointed to by timeptr into a calendar time value with the same encoding as
-    that of the values returned by the time function. The original values of the tm_wday
-    and tm_yday components of the structure are ignored, and the original values of the
-    other components are not restricted to the ranges indicated above.<sup><a href="#note276"><b>276)</b></a></sup> On successful
-    completion, the values of the tm_wday and tm_yday components of the structure are
-    set appropriately, and the other components are set to represent the specified calendar
-    time, but with their values forced to the ranges indicated above; the final value of
-    tm_mday is not set until tm_mon and tm_year are determined.
-<b>    Returns</b>
-3   The mktime function returns the specified calendar time encoded as a value of type
-    time_t. If the calendar time cannot be represented, the function returns the value
-    (time_t)(-1).
-4   EXAMPLE       What day of the week is July 4, 2001?
-            #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.23">&lt;time.h&gt;</a>
-            static const char *const wday[] = {
-                    "Sunday", "Monday", "Tuesday", "Wednesday",
-                    "Thursday", "Friday", "Saturday", "-unknown-"
-            };
-            struct tm time_str;
-            /* ... */
-
-
-
-
-    <sup><a name="note276" href="#note276"><b>276)</b></a></sup> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
-         Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
-         causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
-
-[<a name="p340" href="#p340">page 340</a>] (<a href="#Contents">Contents</a>)
-
-           time_str.tm_year   = 2001 - 1900;
-           time_str.tm_mon    = 7 - 1;
-           time_str.tm_mday   = 4;
-           time_str.tm_hour   = 0;
-           time_str.tm_min    = 0;
-           time_str.tm_sec    = 1;
-           time_str.tm_isdst = -1;
-           if (mktime(&amp;time_str) == (time_t)(-1))
-                 time_str.tm_wday = 7;
-           printf("%s\n", wday[time_str.tm_wday]);
-
-<a name="7.23.2.4" href="#7.23.2.4"><b>    7.23.2.4 The time function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;time.h&gt;</a>
-           time_t time(time_t *timer);
-<b>    Description</b>
-2   The time function determines the current calendar time. The encoding of the value is
-    unspecified.
-<b>    Returns</b>
-3   The time function returns the implementation's best approximation to the current
-    calendar time. The value (time_t)(-1) is returned if the calendar time is not
-    available. If timer is not a null pointer, the return value is also assigned to the object it
-    points to.
-<a name="7.23.3" href="#7.23.3"><b>    7.23.3 Time conversion functions</b></a>
-1   Except for the strftime function, these functions each return a pointer to one of two
-    types of static objects: a broken-down time structure or an array of char. Execution of
-    any of the functions that return a pointer to one of these object types may overwrite the
-    information in any object of the same type pointed to by the value returned from any
-    previous call to any of them. The implementation shall behave as if no other library
-    functions call these functions.
-<a name="7.23.3.1" href="#7.23.3.1"><b>    7.23.3.1 The asctime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;time.h&gt;</a>
-           char *asctime(const struct tm *timeptr);
-<b>    Description</b>
-2   The asctime function converts the broken-down time in the structure pointed to by
-    timeptr into a string in the form
-           Sun Sep 16 01:03:52 1973\n\0
-
-[<a name="p341" href="#p341">page 341</a>] (<a href="#Contents">Contents</a>)
-
-    using the equivalent of the following algorithm.
-    char *asctime(const struct tm *timeptr)
-    {
-         static const char wday_name[7][3] = {
-              "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-         };
-         static const char mon_name[12][3] = {
-              "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-         };
-         static char result[26];
-           sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
-                wday_name[timeptr-&gt;tm_wday],
-                mon_name[timeptr-&gt;tm_mon],
-                timeptr-&gt;tm_mday, timeptr-&gt;tm_hour,
-                timeptr-&gt;tm_min, timeptr-&gt;tm_sec,
-                1900 + timeptr-&gt;tm_year);
-           return result;
-    }
-<b>    Returns</b>
-3   The asctime function returns a pointer to the string.
-<a name="7.23.3.2" href="#7.23.3.2"><b>    7.23.3.2 The ctime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;time.h&gt;</a>
-           char *ctime(const time_t *timer);
-<b>    Description</b>
-2   The ctime function converts the calendar time pointed to by timer to local time in the
-    form of a string. It is equivalent to
-           asctime(localtime(timer))
-<b>    Returns</b>
-3   The ctime function returns the pointer returned by the asctime function with that
-    broken-down time as argument.
-    Forward references: the localtime function (<a href="#7.23.3.4">7.23.3.4</a>).
-
-[<a name="p342" href="#p342">page 342</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.23.3.3" href="#7.23.3.3"><b>    7.23.3.3 The gmtime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;time.h&gt;</a>
-           struct tm *gmtime(const time_t *timer);
-<b>    Description</b>
-2   The gmtime function converts the calendar time pointed to by timer into a broken-
-    down time, expressed as UTC.
-<b>    Returns</b>
-3   The gmtime function returns a pointer to the broken-down time, or a null pointer if the
-    specified time cannot be converted to UTC.
-<a name="7.23.3.4" href="#7.23.3.4"><b>    7.23.3.4 The localtime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;time.h&gt;</a>
-           struct tm *localtime(const time_t *timer);
-<b>    Description</b>
-2   The localtime function converts the calendar time pointed to by timer into a
-    broken-down time, expressed as local time.
-<b>    Returns</b>
-3   The localtime function returns a pointer to the broken-down time, or a null pointer if
-    the specified time cannot be converted to local time.
-<a name="7.23.3.5" href="#7.23.3.5"><b>    7.23.3.5 The strftime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;time.h&gt;</a>
-           size_t strftime(char * restrict s,
-                size_t maxsize,
-                const char * restrict format,
-                const struct tm * restrict timeptr);
-<b>    Description</b>
-2   The strftime function places characters into the array pointed to by s as controlled by
-    the string pointed to by format. The format shall be a multibyte character sequence,
-    beginning and ending in its initial shift state. The format string consists of zero or
-    more conversion specifiers and ordinary multibyte characters. A conversion specifier
-    consists of a % character, possibly followed by an E or O modifier character (described
-    below), followed by a character that determines the behavior of the conversion specifier.
-    All ordinary multibyte characters (including the terminating null character) are copied
-
-[<a name="p343" href="#p343">page 343</a>] (<a href="#Contents">Contents</a>)
-
-    unchanged into the array. If copying takes place between objects that overlap, the
-    behavior is undefined. No more than maxsize characters are placed into the array.
-3   Each conversion specifier is replaced by appropriate characters as described in the
-    following list. The appropriate characters are determined using the LC_TIME category
-    of the current locale and by the values of zero or more members of the broken-down time
-    structure pointed to by timeptr, as specified in brackets in the description. If any of
-    the specified values is outside the normal range, the characters stored are unspecified.
-    %a    is replaced by the locale's abbreviated weekday name. [tm_wday]
-    %A    is replaced by the locale's full weekday name. [tm_wday]
-    %b    is replaced by the locale's abbreviated month name. [tm_mon]
-    %B    is replaced by the locale's full month name. [tm_mon]
-    %c    is replaced by the locale's appropriate date and time representation. [all specified
-          in <a href="#7.23.1">7.23.1</a>]
-    %C    is replaced by the year divided by 100 and truncated to an integer, as a decimal
-          number (00-99). [tm_year]
-    %d    is replaced by the day of the month as a decimal number (01-31). [tm_mday]
-    %D    is equivalent to ''%m/%d/%y''. [tm_mon, tm_mday, tm_year]
-    %e    is replaced by the day of the month as a decimal number (1-31); a single digit is
-          preceded by a space. [tm_mday]
-    %F    is equivalent to ''%Y-%m-%d'' (the ISO 8601 date format). [tm_year, tm_mon,
-          tm_mday]
-    %g    is replaced by the last 2 digits of the week-based year (see below) as a decimal
-          number (00-99). [tm_year, tm_wday, tm_yday]
-    %G    is replaced by the week-based year (see below) as a decimal number (e.g., 1997).
-          [tm_year, tm_wday, tm_yday]
-    %h    is equivalent to ''%b''. [tm_mon]
-    %H    is replaced by the hour (24-hour clock) as a decimal number (00-23). [tm_hour]
-    %I    is replaced by the hour (12-hour clock) as a decimal number (01-12). [tm_hour]
-    %j    is replaced by the day of the year as a decimal number (001-366). [tm_yday]
-    %m    is replaced by the month as a decimal number (01-12). [tm_mon]
-    %M    is replaced by the minute as a decimal number (00-59). [tm_min]
-    %n    is replaced by a new-line character.
-    %p    is replaced by the locale's equivalent of the AM/PM designations associated with a
-          12-hour clock. [tm_hour]
-    %r    is replaced by the locale's 12-hour clock time. [tm_hour, tm_min, tm_sec]
-    %R    is equivalent to ''%H:%M''. [tm_hour, tm_min]
-    %S    is replaced by the second as a decimal number (00-60). [tm_sec]
-    %t    is replaced by a horizontal-tab character.
-    %T    is equivalent to ''%H:%M:%S'' (the ISO 8601 time format). [tm_hour, tm_min,
-          tm_sec]
-
-[<a name="p344" href="#p344">page 344</a>] (<a href="#Contents">Contents</a>)
-
-    %u   is replaced by the ISO 8601 weekday as a decimal number (1-7), where Monday
-         is 1. [tm_wday]
-    %U   is replaced by the week number of the year (the first Sunday as the first day of week
-         <sup><a name="note1" href="#note1"><b>1)</b></a></sup> as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
-    %V   is replaced by the ISO 8601 week number (see below) as a decimal number
-         (01-53). [tm_year, tm_wday, tm_yday]
-    %w   is replaced by the weekday as a decimal number (0-6), where Sunday is 0.
-         [tm_wday]
-    %W   is replaced by the week number of the year (the first Monday as the first day of
-         week 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
-    %x   is replaced by the locale's appropriate date representation. [all specified in <a href="#7.23.1">7.23.1</a>]
-    %X   is replaced by the locale's appropriate time representation. [all specified in <a href="#7.23.1">7.23.1</a>]
-    %y   is replaced by the last 2 digits of the year as a decimal number (00-99).
-         [tm_year]
-    %Y   is replaced by the year as a decimal number (e.g., 1997). [tm_year]
-    %z   is replaced by the offset from UTC in the ISO 8601 format ''-0430'' (meaning 4
-         hours 30 minutes behind UTC, west of Greenwich), or by no characters if no time
-         zone is determinable. [tm_isdst]
-    %Z   is replaced by the locale's time zone name or abbreviation, or by no characters if no
-         time zone is determinable. [tm_isdst]
-    %%   is replaced by %.
-4   Some conversion specifiers can be modified by the inclusion of an E or O modifier
-    character to indicate an alternative format or specification. If the alternative format or
-    specification does not exist for the current locale, the modifier is ignored.
-    %Ec is replaced by the locale's alternative date and time representation.
-    %EC is replaced by the name of the base year (period) in the locale's alternative
-        representation.
-    %Ex is replaced by the locale's alternative date representation.
-    %EX is replaced by the locale's alternative time representation.
-    %Ey is replaced by the offset from %EC (year only) in the locale's alternative
-        representation.
-    %EY is replaced by the locale's full alternative year representation.
-    %Od is replaced by the day of the month, using the locale's alternative numeric symbols
-        (filled as needed with leading zeros, or with leading spaces if there is no alternative
-        symbol for zero).
-    %Oe is replaced by the day of the month, using the locale's alternative numeric symbols
-        (filled as needed with leading spaces).
-    %OH is replaced by the hour (24-hour clock), using the locale's alternative numeric
-        symbols.
-
-[<a name="p345" href="#p345">page 345</a>] (<a href="#Contents">Contents</a>)
-
-    %OI is replaced by the hour (12-hour clock), using the locale's alternative numeric
-        symbols.
-    %Om is replaced by the month, using the locale's alternative numeric symbols.
-    %OM is replaced by the minutes, using the locale's alternative numeric symbols.
-    %OS is replaced by the seconds, using the locale's alternative numeric symbols.
-    %Ou is replaced by the ISO 8601 weekday as a number in the locale's alternative
-        representation, where Monday is 1.
-    %OU is replaced by the week number, using the locale's alternative numeric symbols.
-    %OV is replaced by the ISO 8601 week number, using the locale's alternative numeric
-        symbols.
-    %Ow is replaced by the weekday as a number, using the locale's alternative numeric
-        symbols.
-    %OW is replaced by the week number of the year, using the locale's alternative numeric
-        symbols.
-    %Oy is replaced by the last 2 digits of the year, using the locale's alternative numeric
-        symbols.
-5   %g, %G, and %V give values according to the ISO 8601 week-based year. In this system,
-    weeks begin on a Monday and week 1 of the year is the week that includes January 4th,
-    which is also the week that includes the first Thursday of the year, and is also the first
-    week that contains at least four days in the year. If the first Monday of January is the
-    2nd, 3rd, or 4th, the preceding days are part of the last week of the preceding year; thus,
-    for Saturday 2nd January 1999, %G is replaced by 1998 and %V is replaced by 53. If
-    December 29th, 30th, or 31st is a Monday, it and any following days are part of week 1 of
-    the following year. Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and
-    %V is replaced by 01.
-6   If a conversion specifier is not one of the above, the behavior is undefined.
-7   In the "C" locale, the E and O modifiers are ignored and the replacement strings for the
-    following specifiers are:
-    %a    the first three characters of %A.
-    %A    one of ''Sunday'', ''Monday'', ... , ''Saturday''.
-    %b    the first three characters of %B.
-    %B    one of ''January'', ''February'', ... , ''December''.
-    %c    equivalent to ''%a %b %e %T %Y''.
-    %p    one of ''AM'' or ''PM''.
-    %r    equivalent to ''%I:%M:%S %p''.
-    %x    equivalent to ''%m/%d/%y''.
-    %X    equivalent to %T.
-    %Z    implementation-defined.
-
-[<a name="p346" href="#p346">page 346</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-8   If the total number of resulting characters including the terminating null character is not
-    more than maxsize, the strftime function returns the number of characters placed
-    into the array pointed to by s not including the terminating null character. Otherwise,
-    zero is returned and the contents of the array are indeterminate.
-
-[<a name="p347" href="#p347">page 347</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24" href="#7.24"><b>    7.24 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
-<a name="7.24.1" href="#7.24.1"><b>    7.24.1 Introduction</b></a>
-1   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares four data types, one tag, four macros, and many
-    functions.<sup><a href="#note277"><b>277)</b></a></sup>
-2   The types declared are wchar_t and size_t (both described in <a href="#7.17">7.17</a>);
-             mbstate_t
-    which is an object type other than an array type that can hold the conversion state
-    information necessary to convert between sequences of multibyte characters and wide
-    characters;
-             wint_t
-    which is an integer type unchanged by default argument promotions that can hold any
-    value corresponding to members of the extended character set, as well as at least one
-    value that does not correspond to any member of the extended character set (see WEOF
-    below);<sup><a href="#note278"><b>278)</b></a></sup> and
-             struct tm
-    which is declared as an incomplete structure type (the contents are described in <a href="#7.23.1">7.23.1</a>).
-3   The macros defined are NULL (described in <a href="#7.17">7.17</a>); WCHAR_MIN and WCHAR_MAX
-    (described in <a href="#7.18.3">7.18.3</a>); and
-             WEOF
-    which expands to a constant expression of type wint_t whose value does not
-    correspond to any member of the extended character set.<sup><a href="#note279"><b>279)</b></a></sup> It is accepted (and returned)
-    by several functions in this subclause to indicate end-of-file, that is, no more input from a
-    stream. It is also used as a wide character value that does not correspond to any member
-    of the extended character set.
-4   The functions declared are grouped as follows:
-    -- Functions that perform input and output of wide characters, or multibyte characters,
-      or both;
-    -- Functions that provide wide string numeric conversion;
-    -- Functions that perform general wide string manipulation;
-
-
-    <sup><a name="note277" href="#note277"><b>277)</b></a></sup> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
-    <sup><a name="note278" href="#note278"><b>278)</b></a></sup> wchar_t and wint_t can be the same integer type.
-    <sup><a name="note279" href="#note279"><b>279)</b></a></sup> The value of the macro WEOF may differ from that of EOF and need not be negative.
-
-[<a name="p348" href="#p348">page 348</a>] (<a href="#Contents">Contents</a>)
-
-    -- Functions for wide string date and time conversion; and
-    -- Functions that provide extended capabilities for conversion between multibyte and
-      wide character sequences.
-5   Unless explicitly stated otherwise, if the execution of a function described in this
-    subclause causes copying to take place between objects that overlap, the behavior is
-    undefined.
-<a name="7.24.2" href="#7.24.2"><b>    7.24.2 Formatted wide character input/output functions</b></a>
-1   The formatted wide character input/output functions shall behave as if there is a sequence
-    point after the actions associated with each specifier.<sup><a href="#note280"><b>280)</b></a></sup>
-<a name="7.24.2.1" href="#7.24.2.1"><b>    7.24.2.1 The fwprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            int fwprintf(FILE * restrict stream,
-                 const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The fwprintf function writes output to the stream pointed to by stream, under
-    control of the wide string pointed to by format that specifies how subsequent arguments
-    are converted for output. If there are insufficient arguments for the format, the behavior
-    is undefined. If the format is exhausted while arguments remain, the excess arguments
-    are evaluated (as always) but are otherwise ignored. The fwprintf function returns
-    when the end of the format string is encountered.
-3   The format is composed of zero or more directives: ordinary wide characters (not %),
-    which are copied unchanged to the output stream; and conversion specifications, each of
-    which results in fetching zero or more subsequent arguments, converting them, if
-    applicable, according to the corresponding conversion specifier, and then writing the
-    result to the output stream.
-4   Each conversion specification is introduced by the wide character %. After the %, the
-    following appear in sequence:
-    -- Zero or more flags (in any order) that modify the meaning of the conversion
-      specification.
-    -- An optional minimum field width. If the converted value has fewer wide characters
-      than the field width, it is padded with spaces (by default) on the left (or right, if the
-
-
-    <sup><a name="note280" href="#note280"><b>280)</b></a></sup> The fwprintf functions perform writes to memory for the %n specifier.
-
-[<a name="p349" href="#p349">page 349</a>] (<a href="#Contents">Contents</a>)
-
-        left adjustment flag, described later, has been given) to the field width. The field
-        width takes the form of an asterisk * (described later) or a nonnegative decimal
-        integer.<sup><a href="#note281"><b>281)</b></a></sup>
-    -- An optional precision that gives the minimum number of digits to appear for the d, i,
-      o, u, x, and X conversions, the number of digits to appear after the decimal-point
-      wide character for a, A, e, E, f, and F conversions, the maximum number of
-      significant digits for the g and G conversions, or the maximum number of wide
-      characters to be written for s conversions. The precision takes the form of a period
-      (.) followed either by an asterisk * (described later) or by an optional decimal
-      integer; if only the period is specified, the precision is taken as zero. If a precision
-      appears with any other conversion specifier, the behavior is undefined.
-    -- An optional length modifier that specifies the size of the argument.
-    -- A conversion specifier wide character that specifies the type of conversion to be
-      applied.
-5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
-    this case, an int argument supplies the field width or precision. The arguments
-    specifying field width, or precision, or both, shall appear (in that order) before the
-    argument (if any) to be converted. A negative field width argument is taken as a - flag
-    followed by a positive field width. A negative precision argument is taken as if the
-    precision were omitted.
-6   The flag wide characters and their meanings are:
-    -        The result of the conversion is left-justified within the field. (It is right-justified if
-             this flag is not specified.)
-    +        The result of a signed conversion always begins with a plus or minus sign. (It
-             begins with a sign only when a negative value is converted if this flag is not
-             specified.)<sup><a href="#note282"><b>282)</b></a></sup>
-    space If the first wide character of a signed conversion is not a sign, or if a signed
-          conversion results in no wide characters, a space is prefixed to the result. If the
-          space and + flags both appear, the space flag is ignored.
-    #        The result is converted to an ''alternative form''. For o conversion, it increases
-             the precision, if and only if necessary, to force the first digit of the result to be a
-             zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
-             conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
-
-    <sup><a name="note281" href="#note281"><b>281)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
-    <sup><a name="note282" href="#note282"><b>282)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
-         include a minus sign.
-
-[<a name="p350" href="#p350">page 350</a>] (<a href="#Contents">Contents</a>)
-
-              and G conversions, the result of converting a floating-point number always
-              contains a decimal-point wide character, even if no digits follow it. (Normally, a
-              decimal-point wide character appears in the result of these conversions only if a
-              digit follows it.) For g and G conversions, trailing zeros are not removed from the
-              result. For other conversions, the behavior is undefined.
-    0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
-              (following any indication of sign or base) are used to pad to the field width rather
-              than performing space padding, except when converting an infinity or NaN. If the
-              0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
-              conversions, if a precision is specified, the 0 flag is ignored. For other
-              conversions, the behavior is undefined.
-7   The length modifiers and their meanings are:
-    hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   signed char or unsigned char argument (the argument will have
-                   been promoted according to the integer promotions, but its value shall be
-                   converted to signed char or unsigned char before printing); or that
-                   a following n conversion specifier applies to a pointer to a signed char
-                   argument.
-    h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   short int or unsigned short int argument (the argument will
-                   have been promoted according to the integer promotions, but its value shall
-                   be converted to short int or unsigned short int before printing);
-                   or that a following n conversion specifier applies to a pointer to a short
-                   int argument.
-    l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   long int or unsigned long int argument; that a following n
-                   conversion specifier applies to a pointer to a long int argument; that a
-                   following c conversion specifier applies to a wint_t argument; that a
-                   following s conversion specifier applies to a pointer to a wchar_t
-                   argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
-                   specifier.
-    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 long long int or unsigned long long int argument; or that a
-                 following n conversion specifier applies to a pointer to a long long int
-                 argument.
-    j              Specifies that a following d, i, o, u, x, or X conversion specifier applies to
-                   an intmax_t or uintmax_t argument; or that a following n conversion
-                   specifier applies to a pointer to an intmax_t argument.
-
-[<a name="p351" href="#p351">page 351</a>] (<a href="#Contents">Contents</a>)
-
-    z           Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                size_t or the corresponding signed integer type argument; or that a
-                following n conversion specifier applies to a pointer to a signed integer type
-                corresponding to size_t argument.
-    t           Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                ptrdiff_t or the corresponding unsigned integer type argument; or that a
-                following n conversion specifier applies to a pointer to a ptrdiff_t
-                argument.
-    L           Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                applies to a long double argument.
-    If a length modifier appears with any conversion specifier other than as specified above,
-    the behavior is undefined.
-8   The conversion specifiers and their meanings are:
-    d,i        The int argument is converted to signed decimal in the style [-]dddd. The
-               precision specifies the minimum number of digits to appear; if the value
-               being converted can be represented in fewer digits, it is expanded with
-               leading zeros. The default precision is 1. The result of converting a zero
-               value with a precision of zero is no wide characters.
-    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
-            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
-            letters abcdef are used for x conversion and the letters ABCDEF for X
-            conversion. The precision specifies the minimum number of digits to appear;
-            if the value being converted can be represented in fewer digits, it is expanded
-            with leading zeros. The default precision is 1. The result of converting a
-            zero value with a precision of zero is no wide characters.
-    f,F        A double argument representing a floating-point number is converted to
-               decimal notation in the style [-]ddd.ddd, where the number of digits after
-               the decimal-point wide character is equal to the precision specification. If the
-               precision is missing, it is taken as 6; if the precision is zero and the # flag is
-               not specified, no decimal-point wide character appears. If a decimal-point
-               wide character appears, at least one digit appears before it. The value is
-               rounded to the appropriate number of digits.
-               A double argument representing an infinity is converted in one of the styles
-               [-]inf or [-]infinity -- which style is implementation-defined. A
-               double argument representing a NaN is converted in one of the styles
-               [-]nan or [-]nan(n-wchar-sequence) -- which style, and the meaning of
-               any n-wchar-sequence, is implementation-defined. The F conversion
-               specifier produces INF, INFINITY, or NAN instead of inf, infinity, or
-
-[<a name="p352" href="#p352">page 352</a>] (<a href="#Contents">Contents</a>)
-
-             nan, respectively.<sup><a href="#note283"><b>283)</b></a></sup>
-e,E          A double argument representing a floating-point number is converted in the
-             style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
-             argument is nonzero) before the decimal-point wide character and the number
-             of digits after it is equal to the precision; if the precision is missing, it is taken
-             as 6; if the precision is zero and the # flag is not specified, no decimal-point
-             wide character appears. The value is rounded to the appropriate number of
-             digits. The E conversion specifier produces a number with E instead of e
-             introducing the exponent. The exponent always contains at least two digits,
-             and only as many more digits as necessary to represent the exponent. If the
-             value is zero, the exponent is zero.
-             A double argument representing an infinity or NaN is converted in the style
-             of an f or F conversion specifier.
-g,G          A double argument representing a floating-point number is converted in
-             style f or e (or in style F or E in the case of a G conversion specifier),
-             depending on the value converted and the precision. Let P equal the
-             precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
-             Then, if a conversion with style E would have an exponent of X :
-             -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
-               P - (X + 1).
-             -- otherwise, the conversion is with style e (or E) and precision P - 1.
-             Finally, unless the # flag is used, any trailing zeros are removed from the
-             fractional portion of the result and the decimal-point wide character is
-             removed if there is no fractional portion remaining.
-             A double argument representing an infinity or NaN is converted in the style
-             of an f or F conversion specifier.
-a,A          A double argument representing a floating-point number is converted in the
-             style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
-             nonzero if the argument is a normalized floating-point number and is
-             otherwise unspecified) before the decimal-point wide character<sup><a href="#note284"><b>284)</b></a></sup> and the
-             number of hexadecimal digits after it is equal to the precision; if the precision
-             is missing and FLT_RADIX is a power of 2, then the precision is sufficient
-
-
-<sup><a name="note283" href="#note283"><b>283)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
-     meaning; the # and 0 flag wide characters have no effect.
-<sup><a name="note284" href="#note284"><b>284)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
-     character so that subsequent digits align to nibble (4-bit) boundaries.
-
-[<a name="p353" href="#p353">page 353</a>] (<a href="#Contents">Contents</a>)
-
-             for an exact representation of the value; if the precision is missing and
-             FLT_RADIX is not a power of 2, then the precision is sufficient to
-             distinguish<sup><a href="#note285"><b>285)</b></a></sup> values of type double, except that trailing zeros may be
-             omitted; if the precision is zero and the # flag is not specified, no decimal-
-             point wide character appears. The letters abcdef are used for a conversion
-             and the letters ABCDEF for A conversion. The A conversion specifier
-             produces a number with X and P instead of x and p. The exponent always
-             contains at least one digit, and only as many more digits as necessary to
-             represent the decimal exponent of 2. If the value is zero, the exponent is
-             zero.
-             A double argument representing an infinity or NaN is converted in the style
-             of an f or F conversion specifier.
-c            If no l length modifier is present, the int argument is converted to a wide
-             character as if by calling btowc and the resulting wide character is written.
-             If an l length modifier is present, the wint_t argument is converted to
-             wchar_t and written.
-s            If no l length modifier is present, the argument shall be a pointer to the initial
-             element of a character array containing a multibyte character sequence
-             beginning in the initial shift state. Characters from the array are converted as
-             if by repeated calls to the mbrtowc function, with the conversion state
-             described by an mbstate_t object initialized to zero before the first
-             multibyte character is converted, and written up to (but not including) the
-             terminating null wide character. If the precision is specified, no more than
-             that many wide characters are written. If the precision is not specified or is
-             greater than the size of the converted array, the converted array shall contain a
-             null wide character.
-             If an l length modifier is present, the argument shall be a pointer to the initial
-             element of an array of wchar_t type. Wide characters from the array are
-             written up to (but not including) a terminating null wide character. If the
-             precision is specified, no more than that many wide characters are written. If
-             the precision is not specified or is greater than the size of the array, the array
-             shall contain a null wide character.
-p            The argument shall be a pointer to void. The value of the pointer is
-             converted to a sequence of printing wide characters, in an implementation-
-
-<sup><a name="note285" href="#note285"><b>285)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
-     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
-     might suffice depending on the implementation's scheme for determining the digit to the left of the
-     decimal-point wide character.
-
-[<a name="p354" href="#p354">page 354</a>] (<a href="#Contents">Contents</a>)
-
-                    defined manner.
-     n              The argument shall be a pointer to signed integer into which is written the
-                    number of wide characters written to the output stream so far by this call to
-                    fwprintf. No argument is converted, but one is consumed. If the
-                    conversion specification includes any flags, a field width, or a precision, the
-                    behavior is undefined.
-     %              A % wide character is written. No argument is converted. The complete
-                    conversion specification shall be %%.
-9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note286"><b>286)</b></a></sup> If any argument is
-     not the correct type for the corresponding conversion specification, the behavior is
-     undefined.
-10   In no case does a nonexistent or small field width cause truncation of a field; if the result
-     of a conversion is wider than the field width, the field is expanded to contain the
-     conversion result.
-11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
-     to a hexadecimal floating number with the given precision.
-     Recommended practice
-12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
-     representable in the given precision, the result should be one of the two adjacent numbers
-     in hexadecimal floating style with the given precision, with the extra stipulation that the
-     error should have a correct sign for the current rounding direction.
-13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
-     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note287"><b>287)</b></a></sup> If the number of
-     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
-     representable with DECIMAL_DIG digits, then the result should be an exact
-     representation with trailing zeros. Otherwise, the source value is bounded by two
-     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
-     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
-     the error should have a correct sign for the current rounding direction.
-<b>     Returns</b>
-14   The fwprintf function returns the number of wide characters transmitted, or a negative
-     value if an output or encoding error occurred.
-
-     <sup><a name="note286" href="#note286"><b>286)</b></a></sup> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
-     <sup><a name="note287" href="#note287"><b>287)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
-          given format specifier. The number of significant digits is determined by the format specifier, and in
-          the case of fixed-point conversion by the source value as well.
-
-[<a name="p355" href="#p355">page 355</a>] (<a href="#Contents">Contents</a>)
-
-     Environmental limits
-15   The number of wide characters that can be produced by any single conversion shall be at
-     least 4095.
-16   EXAMPLE       To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
-     places:
-            #include <a href="#7.12">&lt;math.h&gt;</a>
-            #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            /* ... */
-            wchar_t *weekday, *month; // pointers to wide strings
-            int day, hour, min;
-            fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
-                    weekday, month, day, hour, min);
-            fwprintf(stdout, L"pi = %.5f\n", 4 * atan(1.0));
-
-     Forward references:          the btowc function (<a href="#7.24.6.1.1">7.24.6.1.1</a>), the mbrtowc function
-     (<a href="#7.24.6.3.2">7.24.6.3.2</a>).
-<a name="7.24.2.2" href="#7.24.2.2"><b>     7.24.2.2 The fwscanf function</b></a>
-<b>     Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            int fwscanf(FILE * restrict stream,
-                 const wchar_t * restrict format, ...);
-<b>     Description</b>
-2    The fwscanf function reads input from the stream pointed to by stream, under
-     control of the wide string pointed to by format that specifies the admissible input
-     sequences and how they are to be converted for assignment, using subsequent arguments
-     as pointers to the objects to receive the converted input. If there are insufficient
-     arguments for the format, the behavior is undefined. If the format is exhausted while
-     arguments remain, the excess arguments are evaluated (as always) but are otherwise
-     ignored.
-3    The format is composed of zero or more directives: one or more white-space wide
-     characters, an ordinary wide character (neither % nor a white-space wide character), or a
-     conversion specification. Each conversion specification is introduced by the wide
-     character %. After the %, the following appear in sequence:
-     -- An optional assignment-suppressing wide character *.
-     -- An optional decimal integer greater than zero that specifies the maximum field width
-       (in wide characters).
-
-[<a name="p356" href="#p356">page 356</a>] (<a href="#Contents">Contents</a>)
-
-     -- An optional length modifier that specifies the size of the receiving object.
-     -- A conversion specifier wide character that specifies the type of conversion to be
-       applied.
-4    The fwscanf function executes each directive of the format in turn. If a directive fails,
-     as detailed below, the function returns. Failures are described as input failures (due to the
-     occurrence of an encoding error or the unavailability of input characters), or matching
-     failures (due to inappropriate input).
-5    A directive composed of white-space wide character(s) is executed by reading input up to
-     the first non-white-space wide character (which remains unread), or until no more wide
-     characters can be read.
-6    A directive that is an ordinary wide character is executed by reading the next wide
-     character of the stream. If that wide character differs from the directive, the directive
-     fails and the differing and subsequent wide characters remain unread. Similarly, if end-
-     of-file, an encoding error, or a read error prevents a wide character from being read, the
-     directive fails.
-7    A directive that is a conversion specification defines a set of matching input sequences, as
-     described below for each specifier. A conversion specification is executed in the
-     following steps:
-8    Input white-space wide characters (as specified by the iswspace function) are skipped,
-     unless the specification includes a [, c, or n specifier.<sup><a href="#note288"><b>288)</b></a></sup>
-9    An input item is read from the stream, unless the specification includes an n specifier. An
-     input item is defined as the longest sequence of input wide characters which does not
-     exceed any specified field width and which is, or is a prefix of, a matching input
-     sequence.<sup><a href="#note289"><b>289)</b></a></sup> The first wide character, if any, after the input item remains unread. If the
-     length of the input item is zero, the execution of the directive fails; this condition is a
-     matching failure unless end-of-file, an encoding error, or a read error prevented input
-     from the stream, in which case it is an input failure.
-10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
-     count of input wide characters) is converted to a type appropriate to the conversion
-     specifier. If the input item is not a matching sequence, the execution of the directive fails:
-     this condition is a matching failure. Unless assignment suppression was indicated by a *,
-     the result of the conversion is placed in the object pointed to by the first argument
-     following the format argument that has not already received a conversion result. If this
-
-
-     <sup><a name="note288" href="#note288"><b>288)</b></a></sup> These white-space wide characters are not counted against a specified field width.
-     <sup><a name="note289" href="#note289"><b>289)</b></a></sup> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
-          sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
-
-[<a name="p357" href="#p357">page 357</a>] (<a href="#Contents">Contents</a>)
-
-     object does not have an appropriate type, or if the result of the conversion cannot be
-     represented in the object, the behavior is undefined.
-11   The length modifiers and their meanings are:
-     hh          Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                 to an argument with type pointer to signed char or unsigned char.
-     h           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                 to an argument with type pointer to short int or unsigned short
-                 int.
-     l (ell)     Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                 to an argument with type pointer to long int or unsigned long
-                 int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
-                 an argument with type pointer to double; or that a following c, s, or [
-                 conversion specifier applies to an argument with type pointer to wchar_t.
-     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to long long int or unsigned
-                  long long int.
-     j           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                 to an argument with type pointer to intmax_t or uintmax_t.
-     z           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                 to an argument with type pointer to size_t or the corresponding signed
-                 integer type.
-     t           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                 to an argument with type pointer to ptrdiff_t or the corresponding
-                 unsigned integer type.
-     L           Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                 applies to an argument with type pointer to long double.
-     If a length modifier appears with any conversion specifier other than as specified above,
-     the behavior is undefined.
-12   The conversion specifiers and their meanings are:
-     d          Matches an optionally signed decimal integer, whose format is the same as
-                expected for the subject sequence of the wcstol function with the value 10
-                for the base argument. The corresponding argument shall be a pointer to
-                signed integer.
-     i          Matches an optionally signed integer, whose format is the same as expected
-                for the subject sequence of the wcstol function with the value 0 for the
-                base argument. The corresponding argument shall be a pointer to signed
-
-[<a name="p358" href="#p358">page 358</a>] (<a href="#Contents">Contents</a>)
-
-            integer.
-o           Matches an optionally signed octal integer, whose format is the same as
-            expected for the subject sequence of the wcstoul function with the value 8
-            for the base argument. The corresponding argument shall be a pointer to
-            unsigned integer.
-u           Matches an optionally signed decimal integer, whose format is the same as
-            expected for the subject sequence of the wcstoul function with the value 10
-            for the base argument. The corresponding argument shall be a pointer to
-            unsigned integer.
-x           Matches an optionally signed hexadecimal integer, whose format is the same
-            as expected for the subject sequence of the wcstoul function with the value
-            16 for the base argument. The corresponding argument shall be a pointer to
-            unsigned integer.
-a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
-        format is the same as expected for the subject sequence of the wcstod
-        function. The corresponding argument shall be a pointer to floating.
-c           Matches a sequence of wide characters of exactly the number specified by the
-            field width (1 if no field width is present in the directive).
-            If no l length modifier is present, characters from the input field are
-            converted as if by repeated calls to the wcrtomb function, with the
-            conversion state described by an mbstate_t object initialized to zero
-            before the first wide character is converted. The corresponding argument
-            shall be a pointer to the initial element of a character array large enough to
-            accept the sequence. No null character is added.
-            If an l length modifier is present, the corresponding argument shall be a
-            pointer to the initial element of an array of wchar_t large enough to accept
-            the sequence. No null wide character is added.
-s           Matches a sequence of non-white-space wide characters.
-            If no l length modifier is present, characters from the input field are
-            converted as if by repeated calls to the wcrtomb function, with the
-            conversion state described by an mbstate_t object initialized to zero
-            before the first wide character is converted. The corresponding argument
-            shall be a pointer to the initial element of a character array large enough to
-            accept the sequence and a terminating null character, which will be added
-            automatically.
-            If an l length modifier is present, the corresponding argument shall be a
-            pointer to the initial element of an array of wchar_t large enough to accept
-
-[<a name="p359" href="#p359">page 359</a>] (<a href="#Contents">Contents</a>)
-
-         the sequence and the terminating null wide character, which will be added
-         automatically.
-[        Matches a nonempty sequence of wide characters from a set of expected
-         characters (the scanset).
-         If no l length modifier is present, characters from the input field are
-         converted as if by repeated calls to the wcrtomb function, with the
-         conversion state described by an mbstate_t object initialized to zero
-         before the first wide character is converted. The corresponding argument
-         shall be a pointer to the initial element of a character array large enough to
-         accept the sequence and a terminating null character, which will be added
-         automatically.
-         If an l length modifier is present, the corresponding argument shall be a
-         pointer to the initial element of an array of wchar_t large enough to accept
-         the sequence and the terminating null wide character, which will be added
-         automatically.
-         The conversion specifier includes all subsequent wide characters in the
-         format string, up to and including the matching right bracket (]). The wide
-         characters between the brackets (the scanlist) compose the scanset, unless the
-         wide character after the left bracket is a circumflex (^), in which case the
-         scanset contains all wide characters that do not appear in the scanlist between
-         the circumflex and the right bracket. If the conversion specifier begins with
-         [] or [^], the right bracket wide character is in the scanlist and the next
-         following right bracket wide character is the matching right bracket that ends
-         the specification; otherwise the first following right bracket wide character is
-         the one that ends the specification. If a - wide character is in the scanlist and
-         is not the first, nor the second where the first wide character is a ^, nor the
-         last character, the behavior is implementation-defined.
-p        Matches an implementation-defined set of sequences, which should be the
-         same as the set of sequences that may be produced by the %p conversion of
-         the fwprintf function. The corresponding argument shall be a pointer to a
-         pointer to void. The input item is converted to a pointer value in an
-         implementation-defined manner. If the input item is a value converted earlier
-         during the same program execution, the pointer that results shall compare
-         equal to that value; otherwise the behavior of the %p conversion is undefined.
-n        No input is consumed. The corresponding argument shall be a pointer to
-         signed integer into which is to be written the number of wide characters read
-         from the input stream so far by this call to the fwscanf function. Execution
-         of a %n directive does not increment the assignment count returned at the
-         completion of execution of the fwscanf function. No argument is
-
-[<a name="p360" href="#p360">page 360</a>] (<a href="#Contents">Contents</a>)
-
-                    converted, but one is consumed. If the conversion specification includes an
-                    assignment-suppressing wide character or a field width, the behavior is
-                    undefined.
-     %              Matches a single % wide character; no conversion or assignment occurs. The
-                    complete conversion specification shall be %%.
-13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note290"><b>290)</b></a></sup>
-14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
-     respectively, a, e, f, g, and x.
-15   Trailing white space (including new-line wide characters) is left unread unless matched
-     by a directive. The success of literal matches and suppressed assignments is not directly
-     determinable other than via the %n directive.
-<b>     Returns</b>
-16   The fwscanf function returns the value of the macro EOF if an input failure occurs
-     before any conversion. Otherwise, the function returns the number of input items
-     assigned, which can be fewer than provided for, or even zero, in the event of an early
-     matching failure.
-17   EXAMPLE 1        The call:
-              #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              #include <a href="#7.24">&lt;wchar.h&gt;</a>
+         }</pre>
+ If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
+ x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
+ contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note185"><b>185)</b></a></sup>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note184">184)</a> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
+ tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
+ folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
+ modes are in effect and the flags are not tested.
+
+<p><a name="note185">185)</a> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
+ hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
+ ''off'', just one evaluation of x + 1 would suffice.
+
+
+<a name="7.6.2" href="#7.6.2"><h4>7.6.2 Floating-point exceptions</h4></a>
+<p><!--para 1-->
+ The following functions provide access to the floating-point status flags.<sup><a href="#note186"><b>186)</b></a></sup> The int
+ input argument for the functions represents a subset of floating-point exceptions, and can
+ be zero or the bitwise OR of one or more floating-point exception macros, for example
+ FE_OVERFLOW | FE_INEXACT. For other argument values the behavior of these
+ functions is undefined.
+
+<h6>footnotes</h6>
+<p><a name="note186">186)</a> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
+ abstraction of flags that are either set or clear. An implementation may endow floating-point status
+ flags with more information -- for example, the address of the code which first raised the floating-
+ point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
+ content of flags.
+
+
+<a name="7.6.2.1" href="#7.6.2.1"><h5>7.6.2.1 The feclearexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int feclearexcept(int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feclearexcept function attempts to clear the supported floating-point exceptions
+ represented by its argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feclearexcept function returns zero if the excepts argument is zero or if all
+ the specified exceptions were successfully cleared. Otherwise, it returns a nonzero value.
+ 
+ 
+<!--page 203 indent 4-->
+
+<a name="7.6.2.2" href="#7.6.2.2"><h5>7.6.2.2 The fegetexceptflag function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;fenv.h&gt;
+          int fegetexceptflag(fexcept_t *flagp,
+               int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fegetexceptflag function attempts to store an implementation-defined
+ representation of the states of the floating-point status flags indicated by the argument
+ excepts in the object pointed to by the argument flagp.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fegetexceptflag function returns zero if the representation was successfully
+ stored. Otherwise, it returns a nonzero value.
+
+<a name="7.6.2.3" href="#7.6.2.3"><h5>7.6.2.3 The feraiseexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;fenv.h&gt;
+          int feraiseexcept(int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feraiseexcept function attempts to raise the supported floating-point exceptions
+ represented by its argument.<sup><a href="#note187"><b>187)</b></a></sup> The order in which these floating-point exceptions are
+ raised is unspecified, except as stated in <a href="#F.7.6">F.7.6</a>. Whether the feraiseexcept function
+ additionally raises the ''inexact'' floating-point exception whenever it raises the
+ ''overflow'' or ''underflow'' floating-point exception is implementation-defined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feraiseexcept function returns zero if the excepts argument is zero or if all
+ the specified exceptions were successfully raised. Otherwise, it returns a nonzero value.
+ 
+ 
+ 
+ 
+<!--page 204 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note187">187)</a> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
+ Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
+ in <a href="#F.7.6">F.7.6</a> is in the same spirit.
+
+
+<a name="7.6.2.4" href="#7.6.2.4"><h5>7.6.2.4 The fesetexceptflag function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fesetexceptflag(const fexcept_t *flagp,
+              int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fesetexceptflag function attempts to set the floating-point status flags
+ indicated by the argument excepts to the states stored in the object pointed to by
+ flagp. The value of *flagp shall have been set by a previous call to
+ fegetexceptflag whose second argument represented at least those floating-point
+ exceptions represented by the argument excepts. This function does not raise floating-
+ point exceptions, but only sets the state of the flags.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fesetexceptflag function returns zero if the excepts argument is zero or if
+ all the specified flags were successfully set to the appropriate state. Otherwise, it returns
+ a nonzero value.
+
+<a name="7.6.2.5" href="#7.6.2.5"><h5>7.6.2.5 The fetestexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fetestexcept(int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fetestexcept function determines which of a specified subset of the floating-
+ point exception flags are currently set. The excepts argument specifies the floating-
+ point status flags to be queried.<sup><a href="#note188"><b>188)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fetestexcept function returns the value of the bitwise OR of the floating-point
+ exception macros corresponding to the currently set floating-point exceptions included in
+ excepts.
+<p><!--para 4-->
+ EXAMPLE       Call f if ''invalid'' is set, then g if ''overflow'' is set:
+ 
+ 
+ 
+ 
+<!--page 205 indent 4-->
+<pre>
+        #include &lt;fenv.h&gt;
+        /* ... */
+        {
+                #pragma STDC FENV_ACCESS ON
+                int set_excepts;
+                feclearexcept(FE_INVALID | FE_OVERFLOW);
+                // maybe raise exceptions
+                set_excepts = fetestexcept(FE_INVALID | FE_OVERFLOW);
+                if (set_excepts &amp; FE_INVALID) f();
+                if (set_excepts &amp; FE_OVERFLOW) g();
+                /* ... */
+        }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note188">188)</a> This mechanism allows testing several floating-point exceptions with just one function call.
+
+
+<a name="7.6.3" href="#7.6.3"><h4>7.6.3 Rounding</h4></a>
+<p><!--para 1-->
+ The fegetround and fesetround functions provide control of rounding direction
+ modes.
+
+<a name="7.6.3.1" href="#7.6.3.1"><h5>7.6.3.1 The fegetround function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;fenv.h&gt;
+        int fegetround(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fegetround function gets the current rounding direction.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fegetround function returns the value of the rounding direction macro
+ representing the current rounding direction or a negative value if there is no such
+ rounding direction macro or the current rounding direction is not determinable.
+
+<a name="7.6.3.2" href="#7.6.3.2"><h5>7.6.3.2 The fesetround function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;fenv.h&gt;
+        int fesetround(int round);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fesetround function establishes the rounding direction represented by its
+ argument round. If the argument is not equal to the value of a rounding direction macro,
+ the rounding direction is not changed.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fesetround function returns zero if and only if the requested rounding direction
+ was established.
+<!--page 206 indent 4-->
+<p><!--para 4-->
+ EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
+ rounding direction fails.
+<pre>
+        #include &lt;fenv.h&gt;
+        #include &lt;assert.h&gt;
+        void f(int round_dir)
+        {
+              #pragma STDC FENV_ACCESS ON
+              int save_round;
+              int setround_ok;
+              save_round = fegetround();
+              setround_ok = fesetround(round_dir);
+              assert(setround_ok == 0);
               /* ... */
-              int n, i; float x; wchar_t name[50];
-              n = fwscanf(stdin, L"%d%f%ls", &amp;i, &amp;x, name);
-     with the input line:
-              25 54.32E-1 thompson
-     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
-     thompson\0.
-
-18   EXAMPLE 2        The call:
-              #include <a href="#7.19">&lt;stdio.h&gt;</a>
-              #include <a href="#7.24">&lt;wchar.h&gt;</a>
+              fesetround(save_round);
               /* ... */
-              int i; float x; double y;
-              fwscanf(stdin, L"%2d%f%*d %lf", &amp;i, &amp;x, &amp;y);
-     with input:
-              56789 0123 56a72
-     will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
-     56.0. The next wide character read from the input stream will be a.
-
-
-     <sup><a name="note290" href="#note290"><b>290)</b></a></sup> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
-
-[<a name="p361" href="#p361">page 361</a>] (<a href="#Contents">Contents</a>)
-
-    Forward references: the wcstod, wcstof, and wcstold functions (<a href="#7.24.4.1.1">7.24.4.1.1</a>), the
-    wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.24.4.1.2">7.24.4.1.2</a>), the wcrtomb
-    function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
-<a name="7.24.2.3" href="#7.24.2.3"><b>    7.24.2.3 The swprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int swprintf(wchar_t * restrict s,
-                size_t n,
-                const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The swprintf function is equivalent to fwprintf, except that the argument s
-    specifies an array of wide characters into which the generated output is to be written,
-    rather than written to a stream. No more than n wide characters are written, including a
-    terminating null wide character, which is always added (unless n is zero).
-<b>    Returns</b>
-3   The swprintf function returns the number of wide characters written in the array, not
-    counting the terminating null wide character, or a negative value if an encoding error
-    occurred or if n or more wide characters were requested to be written.
-<a name="7.24.2.4" href="#7.24.2.4"><b>    7.24.2.4 The swscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int swscanf(const wchar_t * restrict s,
-                const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The swscanf function is equivalent to fwscanf, except that the argument s specifies a
-    wide string from which the input is to be obtained, rather than from a stream. Reaching
-    the end of the wide string is equivalent to encountering end-of-file for the fwscanf
-    function.
-<b>    Returns</b>
-3   The swscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the swscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-
-[<a name="p362" href="#p362">page 362</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.2.5" href="#7.24.2.5"><b>    7.24.2.5 The vfwprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int vfwprintf(FILE * restrict stream,
-                const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vfwprintf function is equivalent to fwprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfwprintf function does not invoke the
-    va_end macro.<sup><a href="#note291"><b>291)</b></a></sup>
-<b>    Returns</b>
-3   The vfwprintf function returns the number of wide characters transmitted, or a
-    negative value if an output or encoding error occurred.
-4   EXAMPLE       The following shows the use of the vfwprintf function in a general error-reporting
-    routine.
-           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           void error(char *function_name, wchar_t *format, ...)
-           {
-                 va_list args;
-                    va_start(args, format);
-                    // print out name of function causing error
-                    fwprintf(stderr, L"ERROR in %s: ", function_name);
-                    // print out remainder of message
-                    vfwprintf(stderr, format, args);
-                    va_end(args);
-           }
-
-
-
-
-    <sup><a name="note291" href="#note291"><b>291)</b></a></sup> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
-         invoke the va_arg macro, the value of arg after the return is indeterminate.
-
-[<a name="p363" href="#p363">page 363</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.2.6" href="#7.24.2.6"><b>    7.24.2.6 The vfwscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int vfwscanf(FILE * restrict stream,
-                const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vfwscanf function is equivalent to fwscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfwscanf function does not invoke the
-    va_end macro.291)
-<b>    Returns</b>
-3   The vfwscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the vfwscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-<a name="7.24.2.7" href="#7.24.2.7"><b>    7.24.2.7 The vswprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int vswprintf(wchar_t * restrict s,
-                size_t n,
-                const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vswprintf function is equivalent to swprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vswprintf function does not invoke the
-    va_end macro.291)
-<b>    Returns</b>
-3   The vswprintf function returns the number of wide characters written in the array, not
-    counting the terminating null wide character, or a negative value if an encoding error
-    occurred or if n or more wide characters were requested to be generated.
-
-[<a name="p364" href="#p364">page 364</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.2.8" href="#7.24.2.8"><b>    7.24.2.8 The vswscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int vswscanf(const wchar_t * restrict s,
-                const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vswscanf function is equivalent to swscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vswscanf function does not invoke the
-    va_end macro.291)
-<b>    Returns</b>
-3   The vswscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the vswscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-<a name="7.24.2.9" href="#7.24.2.9"><b>    7.24.2.9 The vwprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int vwprintf(const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vwprintf function is equivalent to wprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vwprintf function does not invoke the
-    va_end macro.291)
-<b>    Returns</b>
-3   The vwprintf function returns the number of wide characters transmitted, or a negative
-    value if an output or encoding error occurred.
-
-[<a name="p365" href="#p365">page 365</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.2.10" href="#7.24.2.10"><b>    7.24.2.10 The vwscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int vwscanf(const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vwscanf function is equivalent to wscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vwscanf function does not invoke the
-    va_end macro.291)
-<b>    Returns</b>
-3   The vwscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the vwscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-<a name="7.24.2.11" href="#7.24.2.11"><b>    7.24.2.11 The wprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int wprintf(const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The wprintf function is equivalent to fwprintf with the argument stdout
-    interposed before the arguments to wprintf.
-<b>    Returns</b>
-3   The wprintf function returns the number of wide characters transmitted, or a negative
-    value if an output or encoding error occurred.
-<a name="7.24.2.12" href="#7.24.2.12"><b>    7.24.2.12 The wscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int wscanf(const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The wscanf function is equivalent to fwscanf with the argument stdin interposed
-    before the arguments to wscanf.
-
-[<a name="p366" href="#p366">page 366</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The wscanf function returns the value of the macro EOF if an input failure occurs
-    before any conversion. Otherwise, the wscanf function returns the number of input
-    items assigned, which can be fewer than provided for, or even zero, in the event of an
-    early matching failure.
-<a name="7.24.3" href="#7.24.3"><b>    7.24.3 Wide character input/output functions</b></a>
-<a name="7.24.3.1" href="#7.24.3.1"><b>    7.24.3.1 The fgetwc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            wint_t fgetwc(FILE *stream);
-<b>    Description</b>
-2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
-    next wide character is present, the fgetwc function obtains that wide character as a
-    wchar_t converted to a wint_t and advances the associated file position indicator for
-    the stream (if defined).
-<b>    Returns</b>
-3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
-    of-file indicator for the stream is set and the fgetwc function returns WEOF. Otherwise,
-    the fgetwc function returns the next wide character from the input stream pointed to by
-    stream. If a read error occurs, the error indicator for the stream is set and the fgetwc
-    function returns WEOF. If an encoding error occurs (including too few bytes), the value of
-    the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note292"><b>292)</b></a></sup>
-<a name="7.24.3.2" href="#7.24.3.2"><b>    7.24.3.2 The fgetws function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            wchar_t *fgetws(wchar_t * restrict s,
-                 int n, FILE * restrict stream);
-<b>    Description</b>
-2   The fgetws function reads at most one less than the number of wide characters
-    specified by n from the stream pointed to by stream into the array pointed to by s. No
-
-
-    <sup><a name="note292" href="#note292"><b>292)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
-         Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
-
-[<a name="p367" href="#p367">page 367</a>] (<a href="#Contents">Contents</a>)
-
-    additional wide characters are read after a new-line wide character (which is retained) or
-    after end-of-file. A null wide character is written immediately after the last wide
-    character read into the array.
-<b>    Returns</b>
-3   The fgetws function returns s if successful. If end-of-file is encountered and no
-    characters have been read into the array, the contents of the array remain unchanged and a
-    null pointer is returned. If a read or encoding error occurs during the operation, the array
-    contents are indeterminate and a null pointer is returned.
-<a name="7.24.3.3" href="#7.24.3.3"><b>    7.24.3.3 The fputwc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wint_t fputwc(wchar_t c, FILE *stream);
-<b>    Description</b>
-2   The fputwc function writes the wide character specified by c to the output stream
-    pointed to by stream, at the position indicated by the associated file position indicator
-    for the stream (if defined), and advances the indicator appropriately. If the file cannot
-    support positioning requests, or if the stream was opened with append mode, the
-    character is appended to the output stream.
-<b>    Returns</b>
-3   The fputwc function returns the wide character written. If a write error occurs, the
-    error indicator for the stream is set and fputwc returns WEOF. If an encoding error
-    occurs, the value of the macro EILSEQ is stored in errno and fputwc returns WEOF.
-<a name="7.24.3.4" href="#7.24.3.4"><b>    7.24.3.4 The fputws function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int fputws(const wchar_t * restrict s,
-                FILE * restrict stream);
-<b>    Description</b>
-2   The fputws function writes the wide string pointed to by s to the stream pointed to by
-    stream. The terminating null wide character is not written.
-<b>    Returns</b>
-3   The fputws function returns EOF if a write or encoding error occurs; otherwise, it
-    returns a nonnegative value.
-
-[<a name="p368" href="#p368">page 368</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.3.5" href="#7.24.3.5"><b>    7.24.3.5 The fwide function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            int fwide(FILE *stream, int mode);
-<b>    Description</b>
-2   The fwide function determines the orientation of the stream pointed to by stream. If
-    mode is greater than zero, the function first attempts to make the stream wide oriented. If
-    mode is less than zero, the function first attempts to make the stream byte oriented.<sup><a href="#note293"><b>293)</b></a></sup>
-    Otherwise, mode is zero and the function does not alter the orientation of the stream.
-<b>    Returns</b>
-3   The fwide function returns a value greater than zero if, after the call, the stream has
-    wide orientation, a value less than zero if the stream has byte orientation, or zero if the
-    stream has no orientation.
-<a name="7.24.3.6" href="#7.24.3.6"><b>    7.24.3.6 The getwc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
-            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            wint_t getwc(FILE *stream);
-<b>    Description</b>
-2   The getwc function is equivalent to fgetwc, except that if it is implemented as a
-    macro, it may evaluate stream more than once, so the argument should never be an
-    expression with side effects.
-<b>    Returns</b>
-3   The getwc function returns the next wide character from the input stream pointed to by
-    stream, or WEOF.
-<a name="7.24.3.7" href="#7.24.3.7"><b>    7.24.3.7 The getwchar function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            wint_t getwchar(void);
-
-
-
-
-    <sup><a name="note293" href="#note293"><b>293)</b></a></sup> If the orientation of the stream has already been determined, fwide does not change it.
-
-[<a name="p369" href="#p369">page 369</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The getwchar function is equivalent to getwc with the argument stdin.
-<b>    Returns</b>
-3   The getwchar function returns the next wide character from the input stream pointed to
-    by stdin, or WEOF.
-<a name="7.24.3.8" href="#7.24.3.8"><b>    7.24.3.8 The putwc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wint_t putwc(wchar_t c, FILE *stream);
-<b>    Description</b>
-2   The putwc function is equivalent to fputwc, except that if it is implemented as a
-    macro, it may evaluate stream more than once, so that argument should never be an
-    expression with side effects.
-<b>    Returns</b>
-3   The putwc function returns the wide character written, or WEOF.
-<a name="7.24.3.9" href="#7.24.3.9"><b>    7.24.3.9 The putwchar function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wint_t putwchar(wchar_t c);
-<b>    Description</b>
-2   The putwchar function is equivalent to putwc with the second argument stdout.
-<b>    Returns</b>
-3   The putwchar function returns the character written, or WEOF.
-<a name="7.24.3.10" href="#7.24.3.10"><b>    7.24.3.10 The ungetwc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wint_t ungetwc(wint_t c, FILE *stream);
-<b>    Description</b>
-2   The ungetwc function pushes the wide character specified by c back onto the input
-    stream pointed to by stream. Pushed-back wide characters will be returned by
-    subsequent reads on that stream in the reverse order of their pushing. A successful
-
-[<a name="p370" href="#p370">page 370</a>] (<a href="#Contents">Contents</a>)
-
-    intervening call (with the stream pointed to by stream) to a file positioning function
-    (fseek, fsetpos, or rewind) discards any pushed-back wide characters for the
-    stream. The external storage corresponding to the stream is unchanged.
-3   One wide character of pushback is guaranteed, even if the call to the ungetwc function
-    follows just after a call to a formatted wide character input function fwscanf,
-    vfwscanf, vwscanf, or wscanf. If the ungetwc function is called too many times
-    on the same stream without an intervening read or file positioning operation on that
-    stream, the operation may fail.
-4   If the value of c equals that of the macro WEOF, the operation fails and the input stream is
-    unchanged.
-5   A successful call to the ungetwc function clears the end-of-file indicator for the stream.
-    The value of the file position indicator for the stream after reading or discarding all
-    pushed-back wide characters is the same as it was before the wide characters were pushed
-    back. For a text or binary stream, the value of its file position indicator after a successful
-    call to the ungetwc function is unspecified until all pushed-back wide characters are
-    read or discarded.
-<b>    Returns</b>
-6   The ungetwc function returns the wide character pushed back, or WEOF if the operation
-    fails.
-<a name="7.24.4" href="#7.24.4"><b>    7.24.4 General wide string utilities</b></a>
-1   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares a number of functions useful for wide string
-    manipulation. Various methods are used for determining the lengths of the arrays, but in
-    all cases a wchar_t * argument points to the initial (lowest addressed) element of the
-    array. If an array is accessed beyond the end of an object, the behavior is undefined.
-2   Where an argument declared as size_t n determines the length of the array for a
-    function, n can have the value zero on a call to that function. Unless explicitly stated
-    otherwise in the description of a particular function in this subclause, pointer arguments
-    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
-    function that locates a wide character finds no occurrence, a function that compares two
-    wide character sequences returns zero, and a function that copies wide characters copies
-    zero wide characters.
-
-[<a name="p371" href="#p371">page 371</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.4.1" href="#7.24.4.1"><b>    7.24.4.1 Wide string numeric conversion functions</b></a>
-<a name="7.24.4.1.1" href="#7.24.4.1.1"><b>    7.24.4.1.1 The wcstod, wcstof, and wcstold functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           double wcstod(const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr);
-           float wcstof(const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr);
-           long double wcstold(const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr);
-<b>    Description</b>
-2   The wcstod, wcstof, and wcstold functions convert the initial portion of the wide
-    string pointed to by nptr to double, float, and long double representation,
-    respectively. First, they decompose the input string into three parts: an initial, possibly
-    empty, sequence of white-space wide characters (as specified by the iswspace
-    function), a subject sequence resembling a floating-point constant or representing an
-    infinity or NaN; and a final wide string of one or more unrecognized wide characters,
-    including the terminating null wide character of the input wide string. Then, they attempt
-    to convert the subject sequence to a floating-point number, and return the result.
-3   The expected form of the subject sequence is an optional plus or minus sign, then one of
-    the following:
-    -- a nonempty sequence of decimal digits optionally containing a decimal-point wide
-      character, then an optional exponent part as defined for the corresponding single-byte
-      characters in <a href="#6.4.4.2">6.4.4.2</a>;
-    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
-      decimal-point wide character, then an optional binary exponent part as defined in
-      <a href="#6.4.4.2">6.4.4.2</a>;
-    -- INF or INFINITY, or any other wide string equivalent except for case
-    -- NAN or NAN(n-wchar-sequenceopt), or any other wide string equivalent except for
-      case in the NAN part, where:
-               n-wchar-sequence:
-                     digit
-                     nondigit
-                     n-wchar-sequence digit
-                     n-wchar-sequence nondigit
-    The subject sequence is defined as the longest initial subsequence of the input wide
-    string, starting with the first non-white-space wide character, that is of the expected form.
-
-[<a name="p372" href="#p372">page 372</a>] (<a href="#Contents">Contents</a>)
-
-    The subject sequence contains no wide characters if the input wide string is not of the
-    expected form.
-4   If the subject sequence has the expected form for a floating-point number, the sequence of
-    wide characters starting with the first digit or the decimal-point wide character
-    (whichever occurs first) is interpreted as a floating constant according to the rules of
-    <a href="#6.4.4.2">6.4.4.2</a>, except that the decimal-point wide character is used in place of a period, and that
-    if neither an exponent part nor a decimal-point wide character appears in a decimal
-    floating point number, or if a binary exponent part does not appear in a hexadecimal
-    floating point number, an exponent part of the appropriate type with value zero is
-    assumed to follow the last digit in the string. If the subject sequence begins with a minus
-    sign, the sequence is interpreted as negated.<sup><a href="#note294"><b>294)</b></a></sup> A wide character sequence INF or
-    INFINITY is interpreted as an infinity, if representable in the return type, else like a
-    floating constant that is too large for the range of the return type. A wide character
-    sequence NAN or NAN(n-wchar-sequenceopt) is interpreted as a quiet NaN, if supported
-    in the return type, else like a subject sequence part that does not have the expected form;
-    the meaning of the n-wchar sequences is implementation-defined.<sup><a href="#note295"><b>295)</b></a></sup> A pointer to the
-    final wide string is stored in the object pointed to by endptr, provided that endptr is
-    not a null pointer.
-5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
-    value resulting from the conversion is correctly rounded.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-    Recommended practice
-8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
-    the result is not exactly representable, the result should be one of the two numbers in the
-    appropriate internal format that are adjacent to the hexadecimal floating source value,
-    with the extra stipulation that the error should have a correct sign for the current rounding
-    direction.
-
-
-
-    <sup><a name="note294" href="#note294"><b>294)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
-         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
-         methods may yield different results if rounding is toward positive or negative infinity. In either case,
-         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
-    <sup><a name="note295" href="#note295"><b>295)</b></a></sup> An implementation may use the n-wchar sequence to determine extra information to be represented in
-         the NaN's significand.
-
-[<a name="p373" href="#p373">page 373</a>] (<a href="#Contents">Contents</a>)
-
-9    If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
-     <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
-     sequence D has the decimal form and more than DECIMAL_DIG significant digits,
-     consider the two bounding, adjacent decimal strings L and U, both having
-     DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
-     The result should be one of the (equal or adjacent) values that would be obtained by
-     correctly rounding L and U according to the current rounding direction, with the extra
-     stipulation that the error with respect to D should have a correct sign for the current
-     rounding direction.<sup><a href="#note296"><b>296)</b></a></sup>
-<b>     Returns</b>
-10   The functions return the converted value, if any. If no conversion could be performed,
-     zero is returned. If the correct value is outside the range of representable values, plus or
-     minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the return
-     type and sign of the value), and the value of the macro ERANGE is stored in errno. If
-     the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is no greater
-     than the smallest normalized positive number in the return type; whether errno acquires
-     the value ERANGE is implementation-defined.
-
-
-
-
-     <sup><a name="note296" href="#note296"><b>296)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
-          to the same internal floating value, but if not will round to adjacent values.
-
-[<a name="p374" href="#p374">page 374</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.4.1.2" href="#7.24.4.1.2"><b>    7.24.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           long int wcstol(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-           long long int wcstoll(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-           unsigned long int wcstoul(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-           unsigned long long int wcstoull(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-<b>    Description</b>
-2   The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
-    portion of the wide string pointed to by nptr to long int, long long int,
-    unsigned long int, and unsigned long long int representation,
-    respectively. First, they decompose the input string into three parts: an initial, possibly
-    empty, sequence of white-space wide characters (as specified by the iswspace
-    function), a subject sequence resembling an integer represented in some radix determined
-    by the value of base, and a final wide string of one or more unrecognized wide
-    characters, including the terminating null wide character of the input wide string. Then,
-    they attempt to convert the subject sequence to an integer, and return the result.
-3   If the value of base is zero, the expected form of the subject sequence is that of an
-    integer constant as described for the corresponding single-byte characters in <a href="#6.4.4.1">6.4.4.1</a>,
-    optionally preceded by a plus or minus sign, but not including an integer suffix. If the
-    value of base is between 2 and 36 (inclusive), the expected form of the subject sequence
-    is a sequence of letters and digits representing an integer with the radix specified by
-    base, optionally preceded by a plus or minus sign, but not including an integer suffix.
-    The letters from a (or A) through z (or Z) are ascribed the values 10 through 35; only
-    letters and digits whose ascribed values are less than that of base are permitted. If the
-    value of base is 16, the wide characters 0x or 0X may optionally precede the sequence
-    of letters and digits, following the sign if present.
-
-[<a name="p375" href="#p375">page 375</a>] (<a href="#Contents">Contents</a>)
-
-4   The subject sequence is defined as the longest initial subsequence of the input wide
-    string, starting with the first non-white-space wide character, that is of the expected form.
-    The subject sequence contains no wide characters if the input wide string is empty or
-    consists entirely of white space, or if the first non-white-space wide character is other
-    than a sign or a permissible letter or digit.
-5   If the subject sequence has the expected form and the value of base is zero, the sequence
-    of wide characters starting with the first digit is interpreted as an integer constant
-    according to the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the
-    value of base is between 2 and 36, it is used as the base for conversion, ascribing to each
-    letter its value as given above. If the subject sequence begins with a minus sign, the value
-    resulting from the conversion is negated (in the return type). A pointer to the final wide
-    string is stored in the object pointed to by endptr, provided that endptr is not a null
-    pointer.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-<b>    Returns</b>
-8   The wcstol, wcstoll, wcstoul, and wcstoull functions return the converted
-    value, if any. If no conversion could be performed, zero is returned. If the correct value
-    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
-    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
-    sign of the value, if any), and the value of the macro ERANGE is stored in errno.
-<a name="7.24.4.2" href="#7.24.4.2"><b>    7.24.4.2 Wide string copying functions</b></a>
-<a name="7.24.4.2.1" href="#7.24.4.2.1"><b>    7.24.4.2.1 The wcscpy function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcscpy(wchar_t * restrict s1,
-                const wchar_t * restrict s2);
-<b>    Description</b>
-2   The wcscpy function copies the wide string pointed to by s2 (including the terminating
-    null wide character) into the array pointed to by s1.
-<b>    Returns</b>
-3   The wcscpy function returns the value of s1.
-
-[<a name="p376" href="#p376">page 376</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.4.2.2" href="#7.24.4.2.2"><b>    7.24.4.2.2 The wcsncpy function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-             wchar_t *wcsncpy(wchar_t * restrict s1,
-                  const wchar_t * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The wcsncpy function copies not more than n wide characters (those that follow a null
-    wide character are not copied) from the array pointed to by s2 to the array pointed to by
-    s1.<sup><a href="#note297"><b>297)</b></a></sup>
-3   If the array pointed to by s2 is a wide string that is shorter than n wide characters, null
-    wide characters are appended to the copy in the array pointed to by s1, until n wide
-    characters in all have been written.
-<b>    Returns</b>
-4   The wcsncpy function returns the value of s1.
-<a name="7.24.4.2.3" href="#7.24.4.2.3"><b>    7.24.4.2.3 The wmemcpy function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-             wchar_t *wmemcpy(wchar_t * restrict s1,
-                  const wchar_t * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The wmemcpy function copies n wide characters from the object pointed to by s2 to the
-    object pointed to by s1.
-<b>    Returns</b>
-3   The wmemcpy function returns the value of s1.
-
-
-
-
-    <sup><a name="note297" href="#note297"><b>297)</b></a></sup> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
-         result will not be null-terminated.
-
-[<a name="p377" href="#p377">page 377</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.4.2.4" href="#7.24.4.2.4"><b>    7.24.4.2.4 The wmemmove function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
-                size_t n);
-<b>    Description</b>
-2   The wmemmove function copies n wide characters from the object pointed to by s2 to
-    the object pointed to by s1. Copying takes place as if the n wide characters from the
-    object pointed to by s2 are first copied into a temporary array of n wide characters that
-    does not overlap the objects pointed to by s1 or s2, and then the n wide characters from
-    the temporary array are copied into the object pointed to by s1.
-<b>    Returns</b>
-3   The wmemmove function returns the value of s1.
-<a name="7.24.4.3" href="#7.24.4.3"><b>    7.24.4.3 Wide string concatenation functions</b></a>
-<a name="7.24.4.3.1" href="#7.24.4.3.1"><b>    7.24.4.3.1 The wcscat function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcscat(wchar_t * restrict s1,
-                const wchar_t * restrict s2);
-<b>    Description</b>
-2   The wcscat function appends a copy of the wide string pointed to by s2 (including the
-    terminating null wide character) to the end of the wide string pointed to by s1. The initial
-    wide character of s2 overwrites the null wide character at the end of s1.
-<b>    Returns</b>
-3   The wcscat function returns the value of s1.
-<a name="7.24.4.3.2" href="#7.24.4.3.2"><b>    7.24.4.3.2 The wcsncat function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcsncat(wchar_t * restrict s1,
-                const wchar_t * restrict s2,
-                size_t n);
-<b>    Description</b>
-2   The wcsncat function appends not more than n wide characters (a null wide character
-    and those that follow it are not appended) from the array pointed to by s2 to the end of
-
-[<a name="p378" href="#p378">page 378</a>] (<a href="#Contents">Contents</a>)
-
-    the wide string pointed to by s1. The initial wide character of s2 overwrites the null
-    wide character at the end of s1. A terminating null wide character is always appended to
-    the result.<sup><a href="#note298"><b>298)</b></a></sup>
-<b>    Returns</b>
-3   The wcsncat function returns the value of s1.
-<a name="7.24.4.4" href="#7.24.4.4"><b>    7.24.4.4 Wide string comparison functions</b></a>
-1   Unless explicitly stated otherwise, the functions described in this subclause order two
-    wide characters the same way as two integers of the underlying integer type designated
-    by wchar_t.
-<a name="7.24.4.4.1" href="#7.24.4.4.1"><b>    7.24.4.4.1 The wcscmp function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            int wcscmp(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcscmp function compares the wide string pointed to by s1 to the wide string
-    pointed to by s2.
-<b>    Returns</b>
-3   The wcscmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
-    wide string pointed to by s2.
-<a name="7.24.4.4.2" href="#7.24.4.4.2"><b>    7.24.4.4.2 The wcscoll function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            int wcscoll(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcscoll function compares the wide string pointed to by s1 to the wide string
-    pointed to by s2, both interpreted as appropriate to the LC_COLLATE category of the
-    current locale.
-<b>    Returns</b>
-3   The wcscoll function returns an integer greater than, equal to, or less than zero,
-    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
-
-
-    <sup><a name="note298" href="#note298"><b>298)</b></a></sup> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
-         wcslen(s1)+n+1.
-
-[<a name="p379" href="#p379">page 379</a>] (<a href="#Contents">Contents</a>)
-
-    wide string pointed to by s2 when both are interpreted as appropriate to the current
-    locale.
-<a name="7.24.4.4.3" href="#7.24.4.4.3"><b>    7.24.4.4.3 The wcsncmp function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int wcsncmp(const wchar_t *s1, const wchar_t *s2,
-                size_t n);
-<b>    Description</b>
-2   The wcsncmp function compares not more than n wide characters (those that follow a
-    null wide character are not compared) from the array pointed to by s1 to the array
-    pointed to by s2.
-<b>    Returns</b>
-3   The wcsncmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
-    to, or less than the possibly null-terminated array pointed to by s2.
-<a name="7.24.4.4.4" href="#7.24.4.4.4"><b>    7.24.4.4.4 The wcsxfrm function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           size_t wcsxfrm(wchar_t * restrict s1,
-                const wchar_t * restrict s2,
-                size_t n);
-<b>    Description</b>
-2   The wcsxfrm function transforms the wide string pointed to by s2 and places the
-    resulting wide string into the array pointed to by s1. The transformation is such that if
-    the wcscmp function is applied to two transformed wide strings, it returns a value greater
-    than, equal to, or less than zero, corresponding to the result of the wcscoll function
-    applied to the same two original wide strings. No more than n wide characters are placed
-    into the resulting array pointed to by s1, including the terminating null wide character. If
-    n is zero, s1 is permitted to be a null pointer.
-<b>    Returns</b>
-3   The wcsxfrm function returns the length of the transformed wide string (not including
-    the terminating null wide character). If the value returned is n or greater, the contents of
-    the array pointed to by s1 are indeterminate.
-4   EXAMPLE The value of the following expression is the length of the array needed to hold the
-    transformation of the wide string pointed to by s:
-
-[<a name="p380" href="#p380">page 380</a>] (<a href="#Contents">Contents</a>)
-
-           1 + wcsxfrm(NULL, s, 0)
-
-<a name="7.24.4.4.5" href="#7.24.4.4.5"><b>    7.24.4.4.5 The wmemcmp function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int wmemcmp(const wchar_t *s1, const wchar_t *s2,
-                size_t n);
-<b>    Description</b>
-2   The wmemcmp function compares the first n wide characters of the object pointed to by
-    s1 to the first n wide characters of the object pointed to by s2.
-<b>    Returns</b>
-3   The wmemcmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
-    pointed to by s2.
-<a name="7.24.4.5" href="#7.24.4.5"><b>    7.24.4.5 Wide string search functions</b></a>
-<a name="7.24.4.5.1" href="#7.24.4.5.1"><b>    7.24.4.5.1 The wcschr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcschr(const wchar_t *s, wchar_t c);
-<b>    Description</b>
-2   The wcschr function locates the first occurrence of c in the wide string pointed to by s.
-    The terminating null wide character is considered to be part of the wide string.
-<b>    Returns</b>
-3   The wcschr function returns a pointer to the located wide character, or a null pointer if
-    the wide character does not occur in the wide string.
-<a name="7.24.4.5.2" href="#7.24.4.5.2"><b>    7.24.4.5.2 The wcscspn function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcscspn function computes the length of the maximum initial segment of the wide
-    string pointed to by s1 which consists entirely of wide characters not from the wide
-    string pointed to by s2.
-
-[<a name="p381" href="#p381">page 381</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The wcscspn function returns the length of the segment.
-<a name="7.24.4.5.3" href="#7.24.4.5.3"><b>    7.24.4.5.3 The wcspbrk function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcspbrk function locates the first occurrence in the wide string pointed to by s1 of
-    any wide character from the wide string pointed to by s2.
-<b>    Returns</b>
-3   The wcspbrk function returns a pointer to the wide character in s1, or a null pointer if
-    no wide character from s2 occurs in s1.
-<a name="7.24.4.5.4" href="#7.24.4.5.4"><b>    7.24.4.5.4 The wcsrchr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
-<b>    Description</b>
-2   The wcsrchr function locates the last occurrence of c in the wide string pointed to by
-    s. The terminating null wide character is considered to be part of the wide string.
-<b>    Returns</b>
-3   The wcsrchr function returns a pointer to the wide character, or a null pointer if c does
-    not occur in the wide string.
-<a name="7.24.4.5.5" href="#7.24.4.5.5"><b>    7.24.4.5.5 The wcsspn function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcsspn function computes the length of the maximum initial segment of the wide
-    string pointed to by s1 which consists entirely of wide characters from the wide string
-    pointed to by s2.
-<b>    Returns</b>
-3   The wcsspn function returns the length of the segment.
-
-[<a name="p382" href="#p382">page 382</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.4.5.6" href="#7.24.4.5.6"><b>    7.24.4.5.6 The wcsstr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcsstr function locates the first occurrence in the wide string pointed to by s1 of
-    the sequence of wide characters (excluding the terminating null wide character) in the
-    wide string pointed to by s2.
-<b>    Returns</b>
-3   The wcsstr function returns a pointer to the located wide string, or a null pointer if the
-    wide string is not found. If s2 points to a wide string with zero length, the function
-    returns s1.
-<a name="7.24.4.5.7" href="#7.24.4.5.7"><b>    7.24.4.5.7 The wcstok function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wcstok(wchar_t * restrict s1,
-                const wchar_t * restrict s2,
-                wchar_t ** restrict ptr);
-<b>    Description</b>
-2   A sequence of calls to the wcstok function breaks the wide string pointed to by s1 into
-    a sequence of tokens, each of which is delimited by a wide character from the wide string
-    pointed to by s2. The third argument points to a caller-provided wchar_t pointer into
-    which the wcstok function stores information necessary for it to continue scanning the
-    same wide string.
-3   The first call in a sequence has a non-null first argument and stores an initial value in the
-    object pointed to by ptr. Subsequent calls in the sequence have a null first argument and
-    the object pointed to by ptr is required to have the value stored by the previous call in
-    the sequence, which is then updated. The separator wide string pointed to by s2 may be
-    different from call to call.
-4   The first call in the sequence searches the wide string pointed to by s1 for the first wide
-    character that is not contained in the current separator wide string pointed to by s2. If no
-    such wide character is found, then there are no tokens in the wide string pointed to by s1
-    and the wcstok function returns a null pointer. If such a wide character is found, it is
-    the start of the first token.
-5   The wcstok function then searches from there for a wide character that is contained in
-    the current separator wide string. If no such wide character is found, the current token
-
-[<a name="p383" href="#p383">page 383</a>] (<a href="#Contents">Contents</a>)
-
-    extends to the end of the wide string pointed to by s1, and subsequent searches in the
-    same wide string for a token return a null pointer. If such a wide character is found, it is
-    overwritten by a null wide character, which terminates the current token.
-6   In all cases, the wcstok function stores sufficient information in the pointer pointed to
-    by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
-    value for ptr, shall start searching just past the element overwritten by a null wide
-    character (if any).
-<b>    Returns</b>
-7   The wcstok function returns a pointer to the first wide character of a token, or a null
-    pointer if there is no token.
-8   EXAMPLE
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           static wchar_t str1[] = L"?a???b,,,#c";
-           static wchar_t str2[] = L"\t \t";
-           wchar_t *t, *ptr1, *ptr2;
-           t   =   wcstok(str1,   L"?", &amp;ptr1);          //   t   points to the token L"a"
-           t   =   wcstok(NULL,   L",", &amp;ptr1);          //   t   points to the token L"??b"
-           t   =   wcstok(str2,   L" \t", &amp;ptr2);        //   t   is a null pointer
-           t   =   wcstok(NULL,   L"#,", &amp;ptr1);         //   t   points to the token L"c"
-           t   =   wcstok(NULL,   L"?", &amp;ptr1);          //   t   is a null pointer
-
-<a name="7.24.4.5.8" href="#7.24.4.5.8"><b>    7.24.4.5.8 The wmemchr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wmemchr(const wchar_t *s, wchar_t c,
-                size_t n);
-<b>    Description</b>
-2   The wmemchr function locates the first occurrence of c in the initial n wide characters of
-    the object pointed to by s.
-<b>    Returns</b>
-3   The wmemchr function returns a pointer to the located wide character, or a null pointer if
-    the wide character does not occur in the object.
-
-[<a name="p384" href="#p384">page 384</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.4.6" href="#7.24.4.6"><b>    7.24.4.6 Miscellaneous functions</b></a>
-<a name="7.24.4.6.1" href="#7.24.4.6.1"><b>    7.24.4.6.1 The wcslen function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           size_t wcslen(const wchar_t *s);
-<b>    Description</b>
-2   The wcslen function computes the length of the wide string pointed to by s.
-<b>    Returns</b>
-3   The wcslen function returns the number of wide characters that precede the terminating
-    null wide character.
-<a name="7.24.4.6.2" href="#7.24.4.6.2"><b>    7.24.4.6.2 The wmemset function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
-<b>    Description</b>
-2   The wmemset function copies the value of c into each of the first n wide characters of
-    the object pointed to by s.
-<b>    Returns</b>
-3   The wmemset function returns the value of s.
-<a name="7.24.5" href="#7.24.5"><b>    7.24.5 Wide character time conversion functions</b></a>
-<a name="7.24.5.1" href="#7.24.5.1"><b>    7.24.5.1 The wcsftime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;time.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           size_t wcsftime(wchar_t * restrict s,
-                size_t maxsize,
-                const wchar_t * restrict format,
-                const struct tm * restrict timeptr);
-<b>    Description</b>
-2   The wcsftime function is equivalent to the strftime function, except that:
-    -- The argument s points to the initial element of an array of wide characters into which
-      the generated output is to be placed.
-
-[<a name="p385" href="#p385">page 385</a>] (<a href="#Contents">Contents</a>)
-
-    -- The argument maxsize indicates the limiting number of wide characters.
-    -- The argument format is a wide string and the conversion specifiers are replaced by
-      corresponding sequences of wide characters.
-    -- The return value indicates the number of wide characters.
-<b>    Returns</b>
-3   If the total number of resulting wide characters including the terminating null wide
-    character is not more than maxsize, the wcsftime function returns the number of
-    wide characters placed into the array pointed to by s not including the terminating null
-    wide character. Otherwise, zero is returned and the contents of the array are
-    indeterminate.
-<a name="7.24.6" href="#7.24.6"><b>    7.24.6 Extended multibyte/wide character conversion utilities</b></a>
-1   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares an extended set of functions useful for conversion
-    between multibyte characters and wide characters.
-2   Most of the following functions -- those that are listed as ''restartable'', <a href="#7.24.6.3">7.24.6.3</a> and
-    <a href="#7.24.6.4">7.24.6.4</a> -- take as a last argument a pointer to an object of type mbstate_t that is used
-    to describe the current conversion state from a particular multibyte character sequence to
-    a wide character sequence (or the reverse) under the rules of a particular setting for the
-    LC_CTYPE category of the current locale.
-3   The initial conversion state corresponds, for a conversion in either direction, to the
-    beginning of a new multibyte character in the initial shift state. A zero-valued
-    mbstate_t object is (at least) one way to describe an initial conversion state. A zero-
-    valued mbstate_t object can be used to initiate conversion involving any multibyte
-    character sequence, in any LC_CTYPE category setting. If an mbstate_t object has
-    been altered by any of the functions described in this subclause, and is then used with a
-    different multibyte character sequence, or in the other conversion direction, or with a
-    different LC_CTYPE category setting than on earlier function calls, the behavior is
-    undefined.<sup><a href="#note299"><b>299)</b></a></sup>
-4   On entry, each function takes the described conversion state (either internal or pointed to
-    by an argument) as current. The conversion state described by the pointed-to object is
-    altered as needed to track the shift state, and the position within a multibyte character, for
-    the associated multibyte character sequence.
-
-
-
-
-    <sup><a name="note299" href="#note299"><b>299)</b></a></sup> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
-         mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
-         character string.
-
-[<a name="p386" href="#p386">page 386</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.6.1" href="#7.24.6.1"><b>    7.24.6.1 Single-byte/wide character conversion functions</b></a>
-<a name="7.24.6.1.1" href="#7.24.6.1.1"><b>    7.24.6.1.1 The btowc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           wint_t btowc(int c);
-<b>    Description</b>
-2   The btowc function determines whether c constitutes a valid single-byte character in the
-    initial shift state.
-<b>    Returns</b>
-3   The btowc function returns WEOF if c has the value EOF or if (unsigned char)c
-    does not constitute a valid single-byte character in the initial shift state. Otherwise, it
-    returns the wide character representation of that character.
-<a name="7.24.6.1.2" href="#7.24.6.1.2"><b>    7.24.6.1.2 The wctob function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
-           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int wctob(wint_t c);
-<b>    Description</b>
-2   The wctob function determines whether c corresponds to a member of the extended
-    character set whose multibyte character representation is a single byte when in the initial
-    shift state.
-<b>    Returns</b>
-3   The wctob function returns EOF if c does not correspond to a multibyte character with
-    length one in the initial shift state. Otherwise, it returns the single-byte representation of
-    that character as an unsigned char converted to an int.
-<a name="7.24.6.2" href="#7.24.6.2"><b>    7.24.6.2 Conversion state functions</b></a>
-<a name="7.24.6.2.1" href="#7.24.6.2.1"><b>    7.24.6.2.1 The mbsinit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           int mbsinit(const mbstate_t *ps);
-<b>    Description</b>
-2   If ps is not a null pointer, the mbsinit function determines whether the pointed-to
-    mbstate_t object describes an initial conversion state.
-
-[<a name="p387" href="#p387">page 387</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The mbsinit function returns nonzero if ps is a null pointer or if the pointed-to object
-    describes an initial conversion state; otherwise, it returns zero.
-<a name="7.24.6.3" href="#7.24.6.3"><b>    7.24.6.3 Restartable multibyte/wide character conversion functions</b></a>
-1   These functions differ from the corresponding multibyte character functions of <a href="#7.20.7">7.20.7</a>
-    (mblen, mbtowc, and wctomb) in that they have an extra parameter, ps, of type
-    pointer to mbstate_t that points to an object that can completely describe the current
-    conversion state of the associated multibyte character sequence. If ps is a null pointer,
-    each function uses its own internal mbstate_t object instead, which is initialized at
-    program startup to the initial conversion state. The implementation behaves as if no
-    library function calls these functions with a null pointer for ps.
-2   Also unlike their corresponding functions, the return value does not represent whether the
-    encoding is state-dependent.
-<a name="7.24.6.3.1" href="#7.24.6.3.1"><b>    7.24.6.3.1 The mbrlen function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
-           size_t mbrlen(const char * restrict s,
-                size_t n,
-                mbstate_t * restrict ps);
-<b>    Description</b>
-2   The mbrlen function is equivalent to the call:
-           mbrtowc(NULL, s, n, ps != NULL ? ps : &amp;internal)
-    where internal is the mbstate_t object for the mbrlen function, except that the
-    expression designated by ps is evaluated only once.
-<b>    Returns</b>
-3   The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
-    or (size_t)(-1).
-    Forward references: the mbrtowc function (<a href="#7.24.6.3.2">7.24.6.3.2</a>).
-
-[<a name="p388" href="#p388">page 388</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.6.3.2" href="#7.24.6.3.2"><b>    7.24.6.3.2 The mbrtowc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            size_t mbrtowc(wchar_t * restrict pwc,
-                 const char * restrict s,
-                 size_t n,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the mbrtowc function is equivalent to the call:
-                    mbrtowc(NULL, "", 1, ps)
-    In this case, the values of the parameters pwc and n are ignored.
-3   If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
-    the byte pointed to by s to determine the number of bytes needed to complete the next
-    multibyte character (including any shift sequences). If the function determines that the
-    next multibyte character is complete and valid, it determines the value of the
-    corresponding wide character and then, if pwc is not a null pointer, stores that value in
-    the object pointed to by pwc. If the corresponding wide character is the null wide
-    character, the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The mbrtowc function returns the first of the following that applies (given the current
-    conversion state):
-    0                     if the next n or fewer bytes complete the multibyte character that
-                          corresponds to the null wide character (which is the value stored).
-    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
-                       character (which is the value stored); the value returned is the number
-                       of bytes that complete the multibyte character.
-    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
-                 multibyte character, and all n bytes have been processed (no value is
-                 stored).<sup><a href="#note300"><b>300)</b></a></sup>
-    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
-                 do not contribute to a complete and valid multibyte character (no
-                 value is stored); the value of the macro EILSEQ is stored in errno,
-                 and the conversion state is unspecified.
-
-    <sup><a name="note300" href="#note300"><b>300)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
-         sequence of redundant shift sequences (for implementations with state-dependent encodings).
-
-[<a name="p389" href="#p389">page 389</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.6.3.3" href="#7.24.6.3.3"><b>    7.24.6.3.3 The wcrtomb function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            size_t wcrtomb(char * restrict s,
-                 wchar_t wc,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the wcrtomb function is equivalent to the call
-                    wcrtomb(buf, L'\0', ps)
-    where buf is an internal buffer.
-3   If s is not a null pointer, the wcrtomb function determines the number of bytes needed
-    to represent the multibyte character that corresponds to the wide character given by wc
-    (including any shift sequences), and stores the multibyte character representation in the
-    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
-    wc is a null wide character, a null byte is stored, preceded by any shift sequence needed
-    to restore the initial shift state; the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The wcrtomb function returns the number of bytes stored in the array object (including
-    any shift sequences). When wc is not a valid wide character, an encoding error occurs:
-    the function stores the value of the macro EILSEQ in errno and returns
-    (size_t)(-1); the conversion state is unspecified.
-<a name="7.24.6.4" href="#7.24.6.4"><b>    7.24.6.4 Restartable multibyte/wide string conversion functions</b></a>
-1   These functions differ from the corresponding multibyte string functions of <a href="#7.20.8">7.20.8</a>
-    (mbstowcs and wcstombs) in that they have an extra parameter, ps, of type pointer to
-    mbstate_t that points to an object that can completely describe the current conversion
-    state of the associated multibyte character sequence. If ps is a null pointer, each function
-    uses its own internal mbstate_t object instead, which is initialized at program startup
-    to the initial conversion state. The implementation behaves as if no library function calls
-    these functions with a null pointer for ps.
-2   Also unlike their corresponding functions, the conversion source parameter, src, has a
-    pointer-to-pointer type. When the function is storing the results of conversions (that is,
-    when dst is not a null pointer), the pointer object pointed to by this parameter is updated
-    to reflect the amount of the source processed by that invocation.
-
-[<a name="p390" href="#p390">page 390</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.6.4.1" href="#7.24.6.4.1"><b>    7.24.6.4.1 The mbsrtowcs function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.24">&lt;wchar.h&gt;</a>
-             size_t mbsrtowcs(wchar_t * restrict dst,
-                  const char ** restrict src,
-                  size_t len,
-                  mbstate_t * restrict ps);
-<b>    Description</b>
-2   The mbsrtowcs function converts a sequence of multibyte characters that begins in the
-    conversion state described by the object pointed to by ps, from the array indirectly
-    pointed to by src into a sequence of corresponding wide characters. If dst is not a null
-    pointer, the converted characters are stored into the array pointed to by dst. Conversion
-    continues up to and including a terminating null character, which is also stored.
-    Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
-    not form a valid multibyte character, or (if dst is not a null pointer) when len wide
-    characters have been stored into the array pointed to by dst.<sup><a href="#note301"><b>301)</b></a></sup> Each conversion takes
-    place as if by a call to the mbrtowc function.
-3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
-    pointer (if conversion stopped due to reaching a terminating null character) or the address
-    just past the last multibyte character converted (if any). If conversion stopped due to
-    reaching a terminating null character and if dst is not a null pointer, the resulting state
-    described is the initial conversion state.
-<b>    Returns</b>
-4   If the input conversion encounters a sequence of bytes that do not form a valid multibyte
-    character, an encoding error occurs: the mbsrtowcs function stores the value of the
-    macro EILSEQ in errno and returns (size_t)(-1); the conversion state is
-    unspecified. Otherwise, it returns the number of multibyte characters successfully
-    converted, not including the terminating null character (if any).
-
-
-
-
-    <sup><a name="note301" href="#note301"><b>301)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
-
-[<a name="p391" href="#p391">page 391</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24.6.4.2" href="#7.24.6.4.2"><b>    7.24.6.4.2 The wcsrtombs function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
-            size_t wcsrtombs(char * restrict dst,
-                 const wchar_t ** restrict src,
-                 size_t len,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   The wcsrtombs function converts a sequence of wide characters from the array
-    indirectly pointed to by src into a sequence of corresponding multibyte characters that
-    begins in the conversion state described by the object pointed to by ps. If dst is not a
-    null pointer, the converted characters are then stored into the array pointed to by dst.
-    Conversion continues up to and including a terminating null wide character, which is also
-    stored. Conversion stops earlier in two cases: when a wide character is reached that does
-    not correspond to a valid multibyte character, or (if dst is not a null pointer) when the
-    next multibyte character would exceed the limit of len total bytes to be stored into the
-    array pointed to by dst. Each conversion takes place as if by a call to the wcrtomb
-    function.<sup><a href="#note302"><b>302)</b></a></sup>
-3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
-    pointer (if conversion stopped due to reaching a terminating null wide character) or the
-    address just past the last wide character converted (if any). If conversion stopped due to
-    reaching a terminating null wide character, the resulting state described is the initial
-    conversion state.
-<b>    Returns</b>
-4   If conversion stops because a wide character is reached that does not correspond to a
-    valid multibyte character, an encoding error occurs: the wcsrtombs function stores the
-    value of the macro EILSEQ in errno and returns (size_t)(-1); the conversion
-    state is unspecified. Otherwise, it returns the number of bytes in the resulting multibyte
-    character sequence, not including the terminating null character (if any).
-
-
-
-
-    <sup><a name="note302" href="#note302"><b>302)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
-         include those necessary to reach the initial shift state immediately before the null byte.
-
-[<a name="p392" href="#p392">page 392</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.25" href="#7.25"><b>    7.25 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
-<a name="7.25.1" href="#7.25.1"><b>    7.25.1 Introduction</b></a>
-1   The header <a href="#7.25">&lt;wctype.h&gt;</a> declares three data types, one macro, and many functions.<sup><a href="#note303"><b>303)</b></a></sup>
-2   The types declared are
-             wint_t
-    described in <a href="#7.24.1">7.24.1</a>;
-             wctrans_t
-    which is a scalar type that can hold values which represent locale-specific character
-    mappings; and
-             wctype_t
-    which is a scalar type that can hold values which represent locale-specific character
-    classifications.
-3   The macro defined is WEOF (described in <a href="#7.24.1">7.24.1</a>).
-4   The functions declared are grouped as follows:
-    -- Functions that provide wide character classification;
-    -- Extensible functions that provide wide character classification;
-    -- Functions that provide wide character case mapping;
-    -- Extensible functions that provide wide character mapping.
-5   For all functions described in this subclause that accept an argument of type wint_t, the
-    value shall be representable as a wchar_t or shall equal the value of the macro WEOF. If
-    this argument has any other value, the behavior is undefined.
-6   The behavior of these functions is affected by the LC_CTYPE category of the current
-    locale.
-
-
-
-
-    <sup><a name="note303" href="#note303"><b>303)</b></a></sup> See ''future library directions'' (<a href="#7.26.13">7.26.13</a>).
-
-[<a name="p393" href="#p393">page 393</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.25.2" href="#7.25.2"><b>    7.25.2 Wide character classification utilities</b></a>
-1   The header <a href="#7.25">&lt;wctype.h&gt;</a> declares several functions useful for classifying wide
-    characters.
-2   The term printing wide character refers to a member of a locale-specific set of wide
-    characters, each of which occupies at least one printing position on a display device. The
-    term control wide character refers to a member of a locale-specific set of wide characters
-    that are not printing wide characters.
-<a name="7.25.2.1" href="#7.25.2.1"><b>    7.25.2.1 Wide character classification functions</b></a>
-1   The functions in this subclause return nonzero (true) if and only if the value of the
-    argument wc conforms to that in the description of the function.
-2   Each of the following functions returns true for each wide character that corresponds (as
-    if by a call to the wctob function) to a single-byte character for which the corresponding
-    character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
-    iswpunct functions may differ with respect to wide characters other than L' ' that are
-    both printing and white-space wide characters.<sup><a href="#note304"><b>304)</b></a></sup>
-    Forward references: the wctob function (<a href="#7.24.6.1.2">7.24.6.1.2</a>).
-<a name="7.25.2.1.1" href="#7.25.2.1.1"><b>    7.25.2.1.1 The iswalnum function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           int iswalnum(wint_t wc);
-<b>    Description</b>
-2   The iswalnum function tests for any wide character for which iswalpha or
-    iswdigit is true.
-<a name="7.25.2.1.2" href="#7.25.2.1.2"><b>    7.25.2.1.2 The iswalpha function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           int iswalpha(wint_t wc);
-<b>    Description</b>
-2   The iswalpha function tests for any wide character for which iswupper or
-    iswlower is true, or any wide character that is one of a locale-specific set of alphabetic
-
-    <sup><a name="note304" href="#note304"><b>304)</b></a></sup> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
-         iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
-         (which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
-         &amp;&amp; iswspace(wc) is true, but not both.
-
-[<a name="p394" href="#p394">page 394</a>] (<a href="#Contents">Contents</a>)
-
-    wide characters for which none of iswcntrl, iswdigit, iswpunct, or iswspace
-    is true.<sup><a href="#note305"><b>305)</b></a></sup>
-<a name="7.25.2.1.3" href="#7.25.2.1.3"><b>    7.25.2.1.3 The iswblank function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswblank(wint_t wc);
-<b>    Description</b>
-2   The iswblank function tests for any wide character that is a standard blank wide
-    character or is one of a locale-specific set of wide characters for which iswspace is true
-    and that is used to separate words within a line of text. The standard blank wide
-    characters are the following: space (L' '), and horizontal tab (L'\t'). In the "C"
-    locale, iswblank returns true only for the standard blank characters.
-<a name="7.25.2.1.4" href="#7.25.2.1.4"><b>    7.25.2.1.4 The iswcntrl function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswcntrl(wint_t wc);
-<b>    Description</b>
-2   The iswcntrl function tests for any control wide character.
-<a name="7.25.2.1.5" href="#7.25.2.1.5"><b>    7.25.2.1.5 The iswdigit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswdigit(wint_t wc);
-<b>    Description</b>
-2   The iswdigit function tests for any wide character that corresponds to a decimal-digit
-    character (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.25.2.1.6" href="#7.25.2.1.6"><b>    7.25.2.1.6 The iswgraph function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswgraph(wint_t wc);
-
-
-
-
-    <sup><a name="note305" href="#note305"><b>305)</b></a></sup> The functions iswlower and iswupper test true or false separately for each of these additional
-         wide characters; all four combinations are possible.
-
-[<a name="p395" href="#p395">page 395</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The iswgraph function tests for any wide character for which iswprint is true and
-    iswspace is false.<sup><a href="#note306"><b>306)</b></a></sup>
-<a name="7.25.2.1.7" href="#7.25.2.1.7"><b>    7.25.2.1.7 The iswlower function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswlower(wint_t wc);
-<b>    Description</b>
-2   The iswlower function tests for any wide character that corresponds to a lowercase
-    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
-    iswdigit, iswpunct, or iswspace is true.
-<a name="7.25.2.1.8" href="#7.25.2.1.8"><b>    7.25.2.1.8 The iswprint function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswprint(wint_t wc);
-<b>    Description</b>
-2   The iswprint function tests for any printing wide character.
-<a name="7.25.2.1.9" href="#7.25.2.1.9"><b>    7.25.2.1.9 The iswpunct function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswpunct(wint_t wc);
-<b>    Description</b>
-2   The iswpunct function tests for any printing wide character that is one of a locale-
-    specific set of punctuation wide characters for which neither iswspace nor iswalnum
-    is true.306)
-<a name="7.25.2.1.10" href="#7.25.2.1.10"><b>    7.25.2.1.10 The iswspace function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
-            int iswspace(wint_t wc);
-
-
-
-    <sup><a name="note306" href="#note306"><b>306)</b></a></sup> Note that the behavior of the iswgraph and iswpunct functions may differ from their
-         corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
-         characters other than ' '.
-
-[<a name="p396" href="#p396">page 396</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The iswspace function tests for any wide character that corresponds to a locale-specific
-    set of white-space wide characters for which none of iswalnum, iswgraph, or
-    iswpunct is true.
-<a name="7.25.2.1.11" href="#7.25.2.1.11"><b>    7.25.2.1.11 The iswupper function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           int iswupper(wint_t wc);
-<b>    Description</b>
-2   The iswupper function tests for any wide character that corresponds to an uppercase
-    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
-    iswdigit, iswpunct, or iswspace is true.
-<a name="7.25.2.1.12" href="#7.25.2.1.12"><b>    7.25.2.1.12 The iswxdigit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           int iswxdigit(wint_t wc);
-<b>    Description</b>
-2   The iswxdigit function tests for any wide character that corresponds to a
-    hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
-<a name="7.25.2.2" href="#7.25.2.2"><b>    7.25.2.2 Extensible wide character classification functions</b></a>
-1   The functions wctype and iswctype provide extensible wide character classification
-    as well as testing equivalent to that performed by the functions described in the previous
-    subclause (<a href="#7.25.2.1">7.25.2.1</a>).
-<a name="7.25.2.2.1" href="#7.25.2.2.1"><b>    7.25.2.2.1 The iswctype function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           int iswctype(wint_t wc, wctype_t desc);
-<b>    Description</b>
-2   The iswctype function determines whether the wide character wc has the property
-    described by desc. The current setting of the LC_CTYPE category shall be the same as
-    during the call to wctype that returned the value desc.
-3   Each of the following expressions has a truth-value equivalent to the call to the wide
-    character classification function (<a href="#7.25.2.1">7.25.2.1</a>) in the comment that follows the expression:
-
-[<a name="p397" href="#p397">page 397</a>] (<a href="#Contents">Contents</a>)
-
-           iswctype(wc,       wctype("alnum"))             //   iswalnum(wc)
-           iswctype(wc,       wctype("alpha"))             //   iswalpha(wc)
-           iswctype(wc,       wctype("blank"))             //   iswblank(wc)
-           iswctype(wc,       wctype("cntrl"))             //   iswcntrl(wc)
-           iswctype(wc,       wctype("digit"))             //   iswdigit(wc)
-           iswctype(wc,       wctype("graph"))             //   iswgraph(wc)
-           iswctype(wc,       wctype("lower"))             //   iswlower(wc)
-           iswctype(wc,       wctype("print"))             //   iswprint(wc)
-           iswctype(wc,       wctype("punct"))             //   iswpunct(wc)
-           iswctype(wc,       wctype("space"))             //   iswspace(wc)
-           iswctype(wc,       wctype("upper"))             //   iswupper(wc)
-           iswctype(wc,       wctype("xdigit"))            //   iswxdigit(wc)
-<b>    Returns</b>
-4   The iswctype function returns nonzero (true) if and only if the value of the wide
-    character wc has the property described by desc.
-    Forward references: the wctype function (<a href="#7.25.2.2.2">7.25.2.2.2</a>).
-<a name="7.25.2.2.2" href="#7.25.2.2.2"><b>    7.25.2.2.2 The wctype function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           wctype_t wctype(const char *property);
-<b>    Description</b>
-2   The wctype function constructs a value with type wctype_t that describes a class of
-    wide characters identified by the string argument property.
-3   The strings listed in the description of the iswctype function shall be valid in all
-    locales as property arguments to the wctype function.
-<b>    Returns</b>
-4   If property identifies a valid class of wide characters according to the LC_CTYPE
-    category of the current locale, the wctype function returns a nonzero value that is valid
-    as the second argument to the iswctype function; otherwise, it returns zero.              *
-
-[<a name="p398" href="#p398">page 398</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.25.3" href="#7.25.3"><b>    7.25.3 Wide character case mapping utilities</b></a>
-1   The header <a href="#7.25">&lt;wctype.h&gt;</a> declares several functions useful for mapping wide characters.
-<a name="7.25.3.1" href="#7.25.3.1"><b>    7.25.3.1 Wide character case mapping functions</b></a>
-<a name="7.25.3.1.1" href="#7.25.3.1.1"><b>    7.25.3.1.1 The towlower function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           wint_t towlower(wint_t wc);
-<b>    Description</b>
-2   The towlower function converts an uppercase letter to a corresponding lowercase letter.
-<b>    Returns</b>
-3   If the argument is a wide character for which iswupper is true and there are one or
-    more corresponding wide characters, as specified by the current locale, for which
-    iswlower is true, the towlower function returns one of the corresponding wide
-    characters (always the same one for any given locale); otherwise, the argument is
-    returned unchanged.
-<a name="7.25.3.1.2" href="#7.25.3.1.2"><b>    7.25.3.1.2 The towupper function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           wint_t towupper(wint_t wc);
-<b>    Description</b>
-2   The towupper function converts a lowercase letter to a corresponding uppercase letter.
-<b>    Returns</b>
-3   If the argument is a wide character for which iswlower is true and there are one or
-    more corresponding wide characters, as specified by the current locale, for which
-    iswupper is true, the towupper function returns one of the corresponding wide
-    characters (always the same one for any given locale); otherwise, the argument is
-    returned unchanged.
-<a name="7.25.3.2" href="#7.25.3.2"><b>    7.25.3.2 Extensible wide character case mapping functions</b></a>
-1   The functions wctrans and towctrans provide extensible wide character mapping as
-    well as case mapping equivalent to that performed by the functions described in the
-    previous subclause (<a href="#7.25.3.1">7.25.3.1</a>).
-
-[<a name="p399" href="#p399">page 399</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.25.3.2.1" href="#7.25.3.2.1"><b>    7.25.3.2.1 The towctrans function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           wint_t towctrans(wint_t wc, wctrans_t desc);
-<b>    Description</b>
-2   The towctrans function maps the wide character wc using the mapping described by
-    desc. The current setting of the LC_CTYPE category shall be the same as during the call
-    to wctrans that returned the value desc.
-3   Each of the following expressions behaves the same as the call to the wide character case
-    mapping function (<a href="#7.25.3.1">7.25.3.1</a>) in the comment that follows the expression:
-           towctrans(wc, wctrans("tolower"))                      // towlower(wc)
-           towctrans(wc, wctrans("toupper"))                      // towupper(wc)
-<b>    Returns</b>
-4   The towctrans function returns the mapped value of wc using the mapping described
-    by desc.
-<a name="7.25.3.2.2" href="#7.25.3.2.2"><b>    7.25.3.2.2 The wctrans function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
-           wctrans_t wctrans(const char *property);
-<b>    Description</b>
-2   The wctrans function constructs a value with type wctrans_t that describes a
-    mapping between wide characters identified by the string argument property.
-3   The strings listed in the description of the towctrans function shall be valid in all
-    locales as property arguments to the wctrans function.
-<b>    Returns</b>
-4   If property identifies a valid mapping of wide characters according to the LC_CTYPE
-    category of the current locale, the wctrans function returns a nonzero value that is valid
-    as the second argument to the towctrans function; otherwise, it returns zero.
-
-[<a name="p400" href="#p400">page 400</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.26" href="#7.26"><b>    7.26 Future library directions</b></a>
-1   The following names are grouped under individual headers for convenience. All external
-    names described below are reserved no matter what headers are included by the program.
-<a name="7.26.1" href="#7.26.1"><b>    7.26.1 Complex arithmetic &lt;complex.h&gt;</b></a>
-1   The function names
-         cerf                cexpm1              clog2
-         cerfc               clog10              clgamma
-         cexp2               clog1p              ctgamma
-    and the same names suffixed with f or l may be added to the declarations in the
-    <a href="#7.3">&lt;complex.h&gt;</a> header.
-<a name="7.26.2" href="#7.26.2"><b>    7.26.2 Character handling &lt;ctype.h&gt;</b></a>
-1   Function names that begin with either is or to, and a lowercase letter may be added to
-    the declarations in the <a href="#7.4">&lt;ctype.h&gt;</a> header.
-<a name="7.26.3" href="#7.26.3"><b>    7.26.3 Errors &lt;errno.h&gt;</b></a>
-1   Macros that begin with E and a digit or E and an uppercase letter may be added to the
-    declarations in the <a href="#7.5">&lt;errno.h&gt;</a> header.
-<a name="7.26.4" href="#7.26.4"><b>    7.26.4 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
-1   Macro names beginning with PRI or SCN followed by any lowercase letter or X may be
-    added to the macros defined in the <a href="#7.8">&lt;inttypes.h&gt;</a> header.
-<a name="7.26.5" href="#7.26.5"><b>    7.26.5 Localization &lt;locale.h&gt;</b></a>
-1   Macros that begin with LC_ and an uppercase letter may be added to the definitions in
-    the <a href="#7.11">&lt;locale.h&gt;</a> header.
-<a name="7.26.6" href="#7.26.6"><b>    7.26.6 Signal handling &lt;signal.h&gt;</b></a>
-1   Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
-    letter may be added to the definitions in the <a href="#7.14">&lt;signal.h&gt;</a> header.
-<a name="7.26.7" href="#7.26.7"><b>    7.26.7 Boolean type and values &lt;stdbool.h&gt;</b></a>
-1   The ability to undefine and perhaps then redefine the macros bool, true, and false is
-    an obsolescent feature.
-<a name="7.26.8" href="#7.26.8"><b>    7.26.8 Integer types &lt;stdint.h&gt;</b></a>
-1   Typedef names beginning with int or uint and ending with _t may be added to the
-    types defined in the <a href="#7.18">&lt;stdint.h&gt;</a> header. Macro names beginning with INT or UINT
-    and ending with _MAX, _MIN, or _C may be added to the macros defined in the
-    <a href="#7.18">&lt;stdint.h&gt;</a> header.
-
-[<a name="p401" href="#p401">page 401</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.26.9" href="#7.26.9"><b>    7.26.9 Input/output &lt;stdio.h&gt;</b></a>
-1   Lowercase letters may be added to the conversion specifiers and length modifiers in
-    fprintf and fscanf. Other characters may be used in extensions.
-2   The gets function is obsolescent, and is deprecated.
-3   The use of ungetc on a binary stream where the file position indicator is zero prior to
-    the call is an obsolescent feature.
-<a name="7.26.10" href="#7.26.10"><b>    7.26.10 General utilities &lt;stdlib.h&gt;</b></a>
-1   Function names that begin with str and a lowercase letter may be added to the
-    declarations in the <a href="#7.20">&lt;stdlib.h&gt;</a> header.
-<a name="7.26.11" href="#7.26.11"><b>    7.26.11 String handling &lt;string.h&gt;</b></a>
-1   Function names that begin with str, mem, or wcs and a lowercase letter may be added
-    to the declarations in the <a href="#7.21">&lt;string.h&gt;</a> header.
-<a name="7.26.12" href="#7.26.12"><b>    7.26.12 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
-1   Function names that begin with wcs and a lowercase letter may be added to the
-    declarations in the <a href="#7.24">&lt;wchar.h&gt;</a> header.
-2   Lowercase letters may be added to the conversion specifiers and length modifiers in
-    fwprintf and fwscanf. Other characters may be used in extensions.
-<a name="7.26.13" href="#7.26.13"><b>    7.26.13 Wide character classification and mapping utilities</b></a>
-    <a href="#7.25">&lt;wctype.h&gt;</a>
-1   Function names that begin with is or to and a lowercase letter may be added to the
-    declarations in the <a href="#7.25">&lt;wctype.h&gt;</a> header.
-
-[<a name="p402" href="#p402">page 402</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A" href="#A"><b>                                                   Annex A</b></a>
-                                                 (informative)
-                                  Language syntax summary
-1   NOTE     The notation is described in <a href="#6.1">6.1</a>.
-
-<a name="A.1" href="#A.1"><b>    A.1 Lexical grammar</b></a>
-<a name="A.1.1" href="#A.1.1"><b>    A.1.1 Lexical elements</b></a>
-    (<a href="#6.4">6.4</a>) token:
-                     keyword
-                     identifier
-                     constant
-                     string-literal
-                     punctuator
-    (<a href="#6.4">6.4</a>) preprocessing-token:
-                  header-name
-                  identifier
-                  pp-number
-                  character-constant
-                  string-literal
-                  punctuator
-                  each non-white-space character that cannot be one of the above
-<a name="A.1.2" href="#A.1.2"><b>    A.1.2 Keywords</b></a>
-    (<a href="#6.4.1">6.4.1</a>) keyword: one of
-                  auto                      enum             restrict    unsigned
-                  break                     extern           return      void
-                  case                      float            short       volatile
-                  char                      for              signed      while
-                  const                     goto             sizeof      _Bool
-                  continue                  if               static      _Complex
-                  default                   inline           struct      _Imaginary
-                  do                        int              switch
-                  double                    long             typedef
-                  else                      register         union
-
-[<a name="p403" href="#p403">page 403</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.1.3" href="#A.1.3"><b>A.1.3 Identifiers</b></a>
-(<a href="#6.4.2.1">6.4.2.1</a>) identifier:
-               identifier-nondigit
-               identifier identifier-nondigit
-               identifier digit
-(<a href="#6.4.2.1">6.4.2.1</a>) identifier-nondigit:
-               nondigit
-               universal-character-name
-               other implementation-defined characters
-(<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
-              _ a b          c    d   e   f   g   h     i   j   k   l   m
-                   n o       p    q   r   s   t   u     v   w   x   y   z
-                   A B       C    D   E   F   G   H     I   J   K   L   M
-                   N O       P    Q   R   S   T   U     V   W   X   Y   Z
-(<a href="#6.4.2.1">6.4.2.1</a>) digit: one of
-               0 1 2         3    4   5   6   7   8     9
-<a name="A.1.4" href="#A.1.4"><b>A.1.4 Universal character names</b></a>
-(<a href="#6.4.3">6.4.3</a>) universal-character-name:
-              \u hex-quad
-              \U hex-quad hex-quad
-(<a href="#6.4.3">6.4.3</a>) hex-quad:
-              hexadecimal-digit hexadecimal-digit
-                           hexadecimal-digit hexadecimal-digit
-<a name="A.1.5" href="#A.1.5"><b>A.1.5 Constants</b></a>
-(<a href="#6.4.4">6.4.4</a>) constant:
-              integer-constant
-              floating-constant
-              enumeration-constant
-              character-constant
-(<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
-               decimal-constant integer-suffixopt
-               octal-constant integer-suffixopt
-               hexadecimal-constant integer-suffixopt
-(<a href="#6.4.4.1">6.4.4.1</a>) decimal-constant:
-              nonzero-digit
-              decimal-constant digit
-
-[<a name="p404" href="#p404">page 404</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.4.4.1">6.4.4.1</a>) octal-constant:
-               0
-               octal-constant octal-digit
-(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-constant:
-              hexadecimal-prefix hexadecimal-digit
-              hexadecimal-constant hexadecimal-digit
-(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-prefix: one of
-              0x 0X
-(<a href="#6.4.4.1">6.4.4.1</a>) nonzero-digit: one of
-              1 2 3 4 5              6      7   8   9
-(<a href="#6.4.4.1">6.4.4.1</a>) octal-digit: one of
-               0 1 2 3           4   5      6   7
-(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-digit: one of
-              0 1 2 3 4 5                   6   7   8   9
-              a b c d e f
-              A B C D E F
-(<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
-               unsigned-suffix long-suffixopt
-               unsigned-suffix long-long-suffix
-               long-suffix unsigned-suffixopt
-               long-long-suffix unsigned-suffixopt
-(<a href="#6.4.4.1">6.4.4.1</a>) unsigned-suffix: one of
-               u U
-(<a href="#6.4.4.1">6.4.4.1</a>) long-suffix: one of
-               l L
-(<a href="#6.4.4.1">6.4.4.1</a>) long-long-suffix: one of
-               ll LL
-(<a href="#6.4.4.2">6.4.4.2</a>) floating-constant:
-               decimal-floating-constant
-               hexadecimal-floating-constant
-(<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
-              fractional-constant exponent-partopt floating-suffixopt
-              digit-sequence exponent-part floating-suffixopt
-
-[<a name="p405" href="#p405">page 405</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
-              hexadecimal-prefix hexadecimal-fractional-constant
-                            binary-exponent-part floating-suffixopt
-              hexadecimal-prefix hexadecimal-digit-sequence
-                            binary-exponent-part floating-suffixopt
-(<a href="#6.4.4.2">6.4.4.2</a>) fractional-constant:
-               digit-sequenceopt . digit-sequence
-               digit-sequence .
-(<a href="#6.4.4.2">6.4.4.2</a>) exponent-part:
-              e signopt digit-sequence
-              E signopt digit-sequence
-(<a href="#6.4.4.2">6.4.4.2</a>) sign: one of
-               + -
-(<a href="#6.4.4.2">6.4.4.2</a>) digit-sequence:
-               digit
-               digit-sequence digit
-(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
-              hexadecimal-digit-sequenceopt .
-                             hexadecimal-digit-sequence
-              hexadecimal-digit-sequence .
-(<a href="#6.4.4.2">6.4.4.2</a>) binary-exponent-part:
-               p signopt digit-sequence
-               P signopt digit-sequence
-(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-digit-sequence:
-              hexadecimal-digit
-              hexadecimal-digit-sequence hexadecimal-digit
-(<a href="#6.4.4.2">6.4.4.2</a>) floating-suffix: one of
-               f l F L
-(<a href="#6.4.4.3">6.4.4.3</a>) enumeration-constant:
-              identifier
-(<a href="#6.4.4.4">6.4.4.4</a>) character-constant:
-              ' c-char-sequence '
-              L' c-char-sequence '
-
-[<a name="p406" href="#p406">page 406</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.4.4.4">6.4.4.4</a>) c-char-sequence:
-               c-char
-               c-char-sequence c-char
-(<a href="#6.4.4.4">6.4.4.4</a>) c-char:
-               any member of the source character set except
-                            the single-quote ', backslash \, or new-line character
-               escape-sequence
-(<a href="#6.4.4.4">6.4.4.4</a>) escape-sequence:
-              simple-escape-sequence
-              octal-escape-sequence
-              hexadecimal-escape-sequence
-              universal-character-name
-(<a href="#6.4.4.4">6.4.4.4</a>) simple-escape-sequence: one of
-              \' \" \? \\
-              \a \b \f \n \r \t                   \v
-(<a href="#6.4.4.4">6.4.4.4</a>) octal-escape-sequence:
-               \ octal-digit
-               \ octal-digit octal-digit
-               \ octal-digit octal-digit octal-digit
-(<a href="#6.4.4.4">6.4.4.4</a>) hexadecimal-escape-sequence:
-              \x hexadecimal-digit
-              hexadecimal-escape-sequence hexadecimal-digit
-<a name="A.1.6" href="#A.1.6"><b>A.1.6 String literals</b></a>
-(<a href="#6.4.5">6.4.5</a>) string-literal:
-               " s-char-sequenceopt "
-               L" s-char-sequenceopt "
-(<a href="#6.4.5">6.4.5</a>) s-char-sequence:
-               s-char
-               s-char-sequence s-char
-(<a href="#6.4.5">6.4.5</a>) s-char:
-               any member of the source character set except
-                            the double-quote ", backslash \, or new-line character
-               escape-sequence
-
-[<a name="p407" href="#p407">page 407</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.1.7" href="#A.1.7"><b>A.1.7 Punctuators</b></a>
-(<a href="#6.4.6">6.4.6</a>) punctuator: one of
-              [ ] ( ) { } . -&gt;
-              ++ -- &amp; * + - ~ !
-              / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                     ==      !=    ^    |    &amp;&amp;   ||
-              ? : ; ...
-              = *= /= %= += -= &lt;&lt;=                    &gt;&gt;=      &amp;=       ^=   |=
-              , # ##
-              &lt;: :&gt; &lt;% %&gt; %: %:%:
-<a name="A.1.8" href="#A.1.8"><b>A.1.8 Header names</b></a>
-(<a href="#6.4.7">6.4.7</a>) header-name:
-              &lt; h-char-sequence &gt;
-              " q-char-sequence "
-(<a href="#6.4.7">6.4.7</a>) h-char-sequence:
-              h-char
-              h-char-sequence h-char
-(<a href="#6.4.7">6.4.7</a>) h-char:
-              any member of the source character set except
-                           the new-line character and &gt;
-(<a href="#6.4.7">6.4.7</a>) q-char-sequence:
-              q-char
-              q-char-sequence q-char
-(<a href="#6.4.7">6.4.7</a>) q-char:
-              any member of the source character set except
-                           the new-line character and "
-<a name="A.1.9" href="#A.1.9"><b>A.1.9 Preprocessing numbers</b></a>
-(<a href="#6.4.8">6.4.8</a>) pp-number:
-              digit
-              . digit
-              pp-number   digit
-              pp-number   identifier-nondigit
-              pp-number   e sign
-              pp-number   E sign
-              pp-number   p sign
-              pp-number   P sign
-              pp-number   .
-
-[<a name="p408" href="#p408">page 408</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.2" href="#A.2"><b>A.2 Phrase structure grammar</b></a>
-<a name="A.2.1" href="#A.2.1"><b>A.2.1 Expressions</b></a>
-(<a href="#6.5.1">6.5.1</a>) primary-expression:
-              identifier
-              constant
-              string-literal
-              ( expression )
-(<a href="#6.5.2">6.5.2</a>) postfix-expression:
-              primary-expression
-              postfix-expression [ expression ]
-              postfix-expression ( argument-expression-listopt )
-              postfix-expression . identifier
-              postfix-expression -&gt; identifier
-              postfix-expression ++
-              postfix-expression --
-              ( type-name ) { initializer-list }
-              ( type-name ) { initializer-list , }
-(<a href="#6.5.2">6.5.2</a>) argument-expression-list:
-             assignment-expression
-             argument-expression-list , assignment-expression
-(<a href="#6.5.3">6.5.3</a>) unary-expression:
-              postfix-expression
-              ++ unary-expression
-              -- unary-expression
-              unary-operator cast-expression
-              sizeof unary-expression
-              sizeof ( type-name )
-(<a href="#6.5.3">6.5.3</a>) unary-operator: one of
-              &amp; * + - ~             !
-(<a href="#6.5.4">6.5.4</a>) cast-expression:
-               unary-expression
-               ( type-name ) cast-expression
-(<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
-               cast-expression
-               multiplicative-expression * cast-expression
-               multiplicative-expression / cast-expression
-               multiplicative-expression % cast-expression
-
-[<a name="p409" href="#p409">page 409</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.5.6">6.5.6</a>) additive-expression:
-               multiplicative-expression
-               additive-expression + multiplicative-expression
-               additive-expression - multiplicative-expression
-(<a href="#6.5.7">6.5.7</a>) shift-expression:
-                additive-expression
-                shift-expression &lt;&lt; additive-expression
-                shift-expression &gt;&gt; additive-expression
-(<a href="#6.5.8">6.5.8</a>) relational-expression:
-               shift-expression
-               relational-expression   &lt;    shift-expression
-               relational-expression   &gt;    shift-expression
-               relational-expression   &lt;=   shift-expression
-               relational-expression   &gt;=   shift-expression
-(<a href="#6.5.9">6.5.9</a>) equality-expression:
-               relational-expression
-               equality-expression == relational-expression
-               equality-expression != relational-expression
-(<a href="#6.5.10">6.5.10</a>) AND-expression:
-             equality-expression
-             AND-expression &amp; equality-expression
-(<a href="#6.5.11">6.5.11</a>) exclusive-OR-expression:
-              AND-expression
-              exclusive-OR-expression ^ AND-expression
-(<a href="#6.5.12">6.5.12</a>) inclusive-OR-expression:
-               exclusive-OR-expression
-               inclusive-OR-expression | exclusive-OR-expression
-(<a href="#6.5.13">6.5.13</a>) logical-AND-expression:
-              inclusive-OR-expression
-              logical-AND-expression &amp;&amp; inclusive-OR-expression
-(<a href="#6.5.14">6.5.14</a>) logical-OR-expression:
-              logical-AND-expression
-              logical-OR-expression || logical-AND-expression
-(<a href="#6.5.15">6.5.15</a>) conditional-expression:
-              logical-OR-expression
-              logical-OR-expression ? expression : conditional-expression
-
-[<a name="p410" href="#p410">page 410</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.5.16">6.5.16</a>) assignment-expression:
-              conditional-expression
-              unary-expression assignment-operator assignment-expression
-(<a href="#6.5.16">6.5.16</a>) assignment-operator: one of
-              = *= /= %= +=                -=    &lt;&lt;=    &gt;&gt;=      &amp;=   ^=   |=
-(<a href="#6.5.17">6.5.17</a>) expression:
-              assignment-expression
-              expression , assignment-expression
-(<a href="#6.6">6.6</a>) constant-expression:
-              conditional-expression
-<a name="A.2.2" href="#A.2.2"><b>A.2.2 Declarations</b></a>
-(<a href="#6.7">6.7</a>) declaration:
-               declaration-specifiers init-declarator-listopt ;
-(<a href="#6.7">6.7</a>) declaration-specifiers:
-               storage-class-specifier declaration-specifiersopt
-               type-specifier declaration-specifiersopt
-               type-qualifier declaration-specifiersopt
-               function-specifier declaration-specifiersopt
-(<a href="#6.7">6.7</a>) init-declarator-list:
-               init-declarator
-               init-declarator-list , init-declarator
-(<a href="#6.7">6.7</a>) init-declarator:
-               declarator
-               declarator = initializer
-(<a href="#6.7.1">6.7.1</a>) storage-class-specifier:
-              typedef
-              extern
-              static
-              auto
-              register
-
-[<a name="p411" href="#p411">page 411</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7.2">6.7.2</a>) type-specifier:
-               void
-               char
-               short
-               int
-               long
-               float
-               double
-               signed
-               unsigned
-               _Bool
-               _Complex
-               struct-or-union-specifier                                                 *
-               enum-specifier
-               typedef-name
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
-               struct-or-union identifieropt { struct-declaration-list }
-               struct-or-union identifier
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union:
-               struct
-               union
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration-list:
-               struct-declaration
-               struct-declaration-list struct-declaration
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration:
-               specifier-qualifier-list struct-declarator-list ;
-(<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
-               type-specifier specifier-qualifier-listopt
-               type-qualifier specifier-qualifier-listopt
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator-list:
-               struct-declarator
-               struct-declarator-list , struct-declarator
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator:
-               declarator
-               declaratoropt : constant-expression
-
-[<a name="p412" href="#p412">page 412</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
-              enum identifieropt { enumerator-list }
-              enum identifieropt { enumerator-list , }
-              enum identifier
-(<a href="#6.7.2.2">6.7.2.2</a>) enumerator-list:
-              enumerator
-              enumerator-list , enumerator
-(<a href="#6.7.2.2">6.7.2.2</a>) enumerator:
-              enumeration-constant
-              enumeration-constant = constant-expression
-(<a href="#6.7.3">6.7.3</a>) type-qualifier:
-              const
-              restrict
-              volatile
-(<a href="#6.7.4">6.7.4</a>) function-specifier:
-               inline
-(<a href="#6.7.5">6.7.5</a>) declarator:
-              pointeropt direct-declarator
-(<a href="#6.7.5">6.7.5</a>) direct-declarator:
-               identifier
-               ( declarator )
-               direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
-               direct-declarator [ static type-qualifier-listopt assignment-expression ]
-               direct-declarator [ type-qualifier-list static assignment-expression ]
-               direct-declarator [ type-qualifier-listopt * ]
-               direct-declarator ( parameter-type-list )
-               direct-declarator ( identifier-listopt )
-(<a href="#6.7.5">6.7.5</a>) pointer:
-               * type-qualifier-listopt
-               * type-qualifier-listopt pointer
-(<a href="#6.7.5">6.7.5</a>) type-qualifier-list:
-              type-qualifier
-              type-qualifier-list type-qualifier
-(<a href="#6.7.5">6.7.5</a>) parameter-type-list:
-             parameter-list
-             parameter-list , ...
-
-[<a name="p413" href="#p413">page 413</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7.5">6.7.5</a>) parameter-list:
-             parameter-declaration
-             parameter-list , parameter-declaration
-(<a href="#6.7.5">6.7.5</a>) parameter-declaration:
-             declaration-specifiers declarator
-             declaration-specifiers abstract-declaratoropt
-(<a href="#6.7.5">6.7.5</a>) identifier-list:
-               identifier
-               identifier-list , identifier
-(<a href="#6.7.6">6.7.6</a>) type-name:
-              specifier-qualifier-list abstract-declaratoropt
-(<a href="#6.7.6">6.7.6</a>) abstract-declarator:
-              pointer
-              pointeropt direct-abstract-declarator
-(<a href="#6.7.6">6.7.6</a>) direct-abstract-declarator:
-               ( abstract-declarator )
-               direct-abstract-declaratoropt [ type-qualifier-listopt
-                              assignment-expressionopt ]
-               direct-abstract-declaratoropt [ static type-qualifier-listopt
-                              assignment-expression ]
-               direct-abstract-declaratoropt [ type-qualifier-list static
-                              assignment-expression ]
-               direct-abstract-declaratoropt [ * ]
-               direct-abstract-declaratoropt ( parameter-type-listopt )
-(<a href="#6.7.7">6.7.7</a>) typedef-name:
-              identifier
-(<a href="#6.7.8">6.7.8</a>) initializer:
-                assignment-expression
-                { initializer-list }
-                { initializer-list , }
-(<a href="#6.7.8">6.7.8</a>) initializer-list:
-                designationopt initializer
-                initializer-list , designationopt initializer
-(<a href="#6.7.8">6.7.8</a>) designation:
-              designator-list =
-
-[<a name="p414" href="#p414">page 414</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7.8">6.7.8</a>) designator-list:
-              designator
-              designator-list designator
-(<a href="#6.7.8">6.7.8</a>) designator:
-              [ constant-expression ]
-              . identifier
-<a name="A.2.3" href="#A.2.3"><b>A.2.3 Statements</b></a>
-(<a href="#6.8">6.8</a>) statement:
-              labeled-statement
-              compound-statement
-              expression-statement
-              selection-statement
-              iteration-statement
-              jump-statement
-(<a href="#6.8.1">6.8.1</a>) labeled-statement:
-               identifier : statement
-               case constant-expression : statement
-               default : statement
-(<a href="#6.8.2">6.8.2</a>) compound-statement:
-             { block-item-listopt }
-(<a href="#6.8.2">6.8.2</a>) block-item-list:
-               block-item
-               block-item-list block-item
-(<a href="#6.8.2">6.8.2</a>) block-item:
-               declaration
-               statement
-(<a href="#6.8.3">6.8.3</a>) expression-statement:
-              expressionopt ;
-(<a href="#6.8.4">6.8.4</a>) selection-statement:
-               if ( expression ) statement
-               if ( expression ) statement else statement
-               switch ( expression ) statement
-
-[<a name="p415" href="#p415">page 415</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.8.5">6.8.5</a>) iteration-statement:
-                while ( expression ) statement
-                do statement while ( expression ) ;
-                for ( expressionopt ; expressionopt ; expressionopt ) statement
-                for ( declaration expressionopt ; expressionopt ) statement
-(<a href="#6.8.6">6.8.6</a>) jump-statement:
-              goto identifier ;
-              continue ;
-              break ;
-              return expressionopt ;
-<a name="A.2.4" href="#A.2.4"><b>A.2.4 External definitions</b></a>
-(<a href="#6.9">6.9</a>) translation-unit:
-               external-declaration
-               translation-unit external-declaration
-(<a href="#6.9">6.9</a>) external-declaration:
-               function-definition
-               declaration
-(<a href="#6.9.1">6.9.1</a>) function-definition:
-               declaration-specifiers declarator declaration-listopt compound-statement
-(<a href="#6.9.1">6.9.1</a>) declaration-list:
-              declaration
-              declaration-list declaration
-<a name="A.3" href="#A.3"><b>A.3 Preprocessing directives</b></a>
-(<a href="#6.10">6.10</a>) preprocessing-file:
-              groupopt
-(<a href="#6.10">6.10</a>) group:
-                group-part
-                group group-part
-(<a href="#6.10">6.10</a>) group-part:
-              if-section
-              control-line
-              text-line
-              # non-directive
-(<a href="#6.10">6.10</a>) if-section:
-                if-group elif-groupsopt else-groupopt endif-line
-
-[<a name="p416" href="#p416">page 416</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.10">6.10</a>) if-group:
-               # if     constant-expression new-line groupopt
-               # ifdef identifier new-line groupopt
-               # ifndef identifier new-line groupopt
-(<a href="#6.10">6.10</a>) elif-groups:
-               elif-group
-               elif-groups elif-group
-(<a href="#6.10">6.10</a>) elif-group:
-               # elif        constant-expression new-line groupopt
-(<a href="#6.10">6.10</a>) else-group:
-               # else        new-line groupopt
-(<a href="#6.10">6.10</a>) endif-line:
-               # endif       new-line
-(<a href="#6.10">6.10</a>) control-line:
-              # include pp-tokens new-line
-              # define identifier replacement-list new-line
-              # define identifier lparen identifier-listopt )
-                                              replacement-list new-line
-              # define identifier lparen ... ) replacement-list new-line
-              # define identifier lparen identifier-list , ... )
-                                              replacement-list new-line
-              # undef   identifier new-line
-              # line    pp-tokens new-line
-              # error   pp-tokensopt new-line
-              # pragma pp-tokensopt new-line
-              #         new-line
-(<a href="#6.10">6.10</a>) text-line:
-               pp-tokensopt new-line
-(<a href="#6.10">6.10</a>) non-directive:
-              pp-tokens new-line
-(<a href="#6.10">6.10</a>) lparen:
-                 a ( character not immediately preceded by white-space
-(<a href="#6.10">6.10</a>) replacement-list:
-              pp-tokensopt
-
-[<a name="p417" href="#p417">page 417</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.10">6.10</a>) pp-tokens:
-              preprocessing-token
-              pp-tokens preprocessing-token
-(<a href="#6.10">6.10</a>) new-line:
-              the new-line character
-
-[<a name="p418" href="#p418">page 418</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B" href="#B"><b>                                Annex B</b></a>
-                              (informative)
-                          Library summary
-<a name="B.1" href="#B.1"><b>B.1 Diagnostics &lt;assert.h&gt;</b></a>
-       NDEBUG
-       void assert(scalar expression);
-<a name="B.2" href="#B.2"><b>B.2 Complex &lt;complex.h&gt;</b></a>
-       complex               imaginary               I
-       _Complex_I            _Imaginary_I
-       #pragma STDC CX_LIMITED_RANGE on-off-switch
-       double complex cacos(double complex z);
-       float complex cacosf(float complex z);
-       long double complex cacosl(long double complex z);
-       double complex casin(double complex z);
-       float complex casinf(float complex z);
-       long double complex casinl(long double complex z);
-       double complex catan(double complex z);
-       float complex catanf(float complex z);
-       long double complex catanl(long double complex z);
-       double complex ccos(double complex z);
-       float complex ccosf(float complex z);
-       long double complex ccosl(long double complex z);
-       double complex csin(double complex z);
-       float complex csinf(float complex z);
-       long double complex csinl(long double complex z);
-       double complex ctan(double complex z);
-       float complex ctanf(float complex z);
-       long double complex ctanl(long double complex z);
-       double complex cacosh(double complex z);
-       float complex cacoshf(float complex z);
-       long double complex cacoshl(long double complex z);
-       double complex casinh(double complex z);
-       float complex casinhf(float complex z);
-       long double complex casinhl(long double complex z);
-       double complex catanh(double complex z);
-       float complex catanhf(float complex z);
-       long double complex catanhl(long double complex z);
-
-[<a name="p419" href="#p419">page 419</a>] (<a href="#Contents">Contents</a>)
-
-      double complex ccosh(double complex z);
-      float complex ccoshf(float complex z);
-      long double complex ccoshl(long double complex z);
-      double complex csinh(double complex z);
-      float complex csinhf(float complex z);
-      long double complex csinhl(long double complex z);
-      double complex ctanh(double complex z);
-      float complex ctanhf(float complex z);
-      long double complex ctanhl(long double complex z);
-      double complex cexp(double complex z);
-      float complex cexpf(float complex z);
-      long double complex cexpl(long double complex z);
-      double complex clog(double complex z);
-      float complex clogf(float complex z);
-      long double complex clogl(long double complex z);
-      double cabs(double complex z);
-      float cabsf(float complex z);
-      long double cabsl(long double complex z);
-      double complex cpow(double complex x, double complex y);
-      float complex cpowf(float complex x, float complex y);
-      long double complex cpowl(long double complex x,
-           long double complex y);
-      double complex csqrt(double complex z);
-      float complex csqrtf(float complex z);
-      long double complex csqrtl(long double complex z);
-      double carg(double complex z);
-      float cargf(float complex z);
-      long double cargl(long double complex z);
-      double cimag(double complex z);
-      float cimagf(float complex z);
-      long double cimagl(long double complex z);
-      double complex conj(double complex z);
-      float complex conjf(float complex z);
-      long double complex conjl(long double complex z);
-      double complex cproj(double complex z);
-      float complex cprojf(float complex z);
-      long double complex cprojl(long double complex z);
-      double creal(double complex z);
-      float crealf(float complex z);
-      long double creall(long double complex z);
-
-[<a name="p420" href="#p420">page 420</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.3" href="#B.3"><b>B.3 Character handling &lt;ctype.h&gt;</b></a>
-       int    isalnum(int c);
-       int    isalpha(int c);
-       int    isblank(int c);
-       int    iscntrl(int c);
-       int    isdigit(int c);
-       int    isgraph(int c);
-       int    islower(int c);
-       int    isprint(int c);
-       int    ispunct(int c);
-       int    isspace(int c);
-       int    isupper(int c);
-       int    isxdigit(int c);
-       int    tolower(int c);
-       int    toupper(int c);
-<a name="B.4" href="#B.4"><b>B.4 Errors &lt;errno.h&gt;</b></a>
-       EDOM            EILSEQ             ERANGE            errno
-<a name="B.5" href="#B.5"><b>B.5 Floating-point environment &lt;fenv.h&gt;</b></a>
-       fenv_t                 FE_OVERFLOW             FE_TOWARDZERO
-       fexcept_t              FE_UNDERFLOW            FE_UPWARD
-       FE_DIVBYZERO           FE_ALL_EXCEPT           FE_DFL_ENV
-       FE_INEXACT             FE_DOWNWARD
-       FE_INVALID             FE_TONEAREST
-       #pragma STDC FENV_ACCESS on-off-switch
-       int feclearexcept(int excepts);
-       int fegetexceptflag(fexcept_t *flagp, int excepts);
-       int feraiseexcept(int excepts);
-       int fesetexceptflag(const fexcept_t *flagp,
-            int excepts);
-       int fetestexcept(int excepts);
-       int fegetround(void);
-       int fesetround(int round);
-       int fegetenv(fenv_t *envp);
-       int feholdexcept(fenv_t *envp);
-       int fesetenv(const fenv_t *envp);
-       int feupdateenv(const fenv_t *envp);
-
-[<a name="p421" href="#p421">page 421</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.6" href="#B.6"><b>B.6 Characteristics of floating types &lt;float.h&gt;</b></a>
-      FLT_ROUNDS              DBL_MIN_EXP             FLT_MAX
-      FLT_EVAL_METHOD         LDBL_MIN_EXP            DBL_MAX
-      FLT_RADIX               FLT_MIN_10_EXP          LDBL_MAX
-      FLT_MANT_DIG            DBL_MIN_10_EXP          FLT_EPSILON
-      DBL_MANT_DIG            LDBL_MIN_10_EXP         DBL_EPSILON
-      LDBL_MANT_DIG           FLT_MAX_EXP             LDBL_EPSILON
-      DECIMAL_DIG             DBL_MAX_EXP             FLT_MIN
-      FLT_DIG                 LDBL_MAX_EXP            DBL_MIN
-      DBL_DIG                 FLT_MAX_10_EXP          LDBL_MIN
-      LDBL_DIG                DBL_MAX_10_EXP
-      FLT_MIN_EXP             LDBL_MAX_10_EXP
-<a name="B.7" href="#B.7"><b>B.7 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
-      imaxdiv_t
-      PRIdN        PRIdLEASTN        PRIdFASTN        PRIdMAX     PRIdPTR
-      PRIiN        PRIiLEASTN        PRIiFASTN        PRIiMAX     PRIiPTR
-      PRIoN        PRIoLEASTN        PRIoFASTN        PRIoMAX     PRIoPTR
-      PRIuN        PRIuLEASTN        PRIuFASTN        PRIuMAX     PRIuPTR
-      PRIxN        PRIxLEASTN        PRIxFASTN        PRIxMAX     PRIxPTR
-      PRIXN        PRIXLEASTN        PRIXFASTN        PRIXMAX     PRIXPTR
-      SCNdN        SCNdLEASTN        SCNdFASTN        SCNdMAX     SCNdPTR
-      SCNiN        SCNiLEASTN        SCNiFASTN        SCNiMAX     SCNiPTR
-      SCNoN        SCNoLEASTN        SCNoFASTN        SCNoMAX     SCNoPTR
-      SCNuN        SCNuLEASTN        SCNuFASTN        SCNuMAX     SCNuPTR
-      SCNxN        SCNxLEASTN        SCNxFASTN        SCNxMAX     SCNxPTR
-      intmax_t imaxabs(intmax_t j);
-      imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
-      intmax_t strtoimax(const char * restrict nptr,
-              char ** restrict endptr, int base);
-      uintmax_t strtoumax(const char * restrict nptr,
-              char ** restrict endptr, int base);
-      intmax_t wcstoimax(const wchar_t * restrict nptr,
-              wchar_t ** restrict endptr, int base);
-      uintmax_t wcstoumax(const wchar_t * restrict nptr,
-              wchar_t ** restrict endptr, int base);
-
-[<a name="p422" href="#p422">page 422</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.8" href="#B.8"><b>B.8 Alternative spellings &lt;iso646.h&gt;</b></a>
-     and             bitor             not_eq            xor
-     and_eq          compl             or                xor_eq
-     bitand          not               or_eq
-<a name="B.9" href="#B.9"><b>B.9 Sizes of integer types &lt;limits.h&gt;</b></a>
-     CHAR_BIT        CHAR_MAX          INT_MIN           ULONG_MAX
-     SCHAR_MIN       MB_LEN_MAX        INT_MAX           LLONG_MIN
-     SCHAR_MAX       SHRT_MIN          UINT_MAX          LLONG_MAX
-     UCHAR_MAX       SHRT_MAX          LONG_MIN          ULLONG_MAX
-     CHAR_MIN        USHRT_MAX         LONG_MAX
-<a name="B.10" href="#B.10"><b>B.10 Localization &lt;locale.h&gt;</b></a>
-     struct lconv    LC_ALL            LC_CTYPE          LC_NUMERIC
-     NULL            LC_COLLATE        LC_MONETARY       LC_TIME
-     char *setlocale(int category, const char *locale);
-     struct lconv *localeconv(void);
-<a name="B.11" href="#B.11"><b>B.11 Mathematics &lt;math.h&gt;</b></a>
-     float_t               FP_INFINITE             FP_FAST_FMAL
-     double_t              FP_NAN                  FP_ILOGB0
-     HUGE_VAL              FP_NORMAL               FP_ILOGBNAN
-     HUGE_VALF             FP_SUBNORMAL            MATH_ERRNO
-     HUGE_VALL             FP_ZERO                 MATH_ERREXCEPT
-     INFINITY              FP_FAST_FMA             math_errhandling
-     NAN                   FP_FAST_FMAF
-      #pragma STDC FP_CONTRACT on-off-switch
-      int fpclassify(real-floating x);
-      int isfinite(real-floating x);
-      int isinf(real-floating x);
-      int isnan(real-floating x);
-      int isnormal(real-floating x);
-      int signbit(real-floating x);
-      double acos(double x);
-      float acosf(float x);
-      long double acosl(long double x);
-      double asin(double x);
-      float asinf(float x);
-      long double asinl(long double x);
-      double atan(double x);
-
-[<a name="p423" href="#p423">page 423</a>] (<a href="#Contents">Contents</a>)
-
-      float atanf(float x);
-      long double atanl(long double x);
-      double atan2(double y, double x);
-      float atan2f(float y, float x);
-      long double atan2l(long double y, long double x);
-      double cos(double x);
-      float cosf(float x);
-      long double cosl(long double x);
-      double sin(double x);
-      float sinf(float x);
-      long double sinl(long double x);
-      double tan(double x);
-      float tanf(float x);
-      long double tanl(long double x);
-      double acosh(double x);
-      float acoshf(float x);
-      long double acoshl(long double x);
-      double asinh(double x);
-      float asinhf(float x);
-      long double asinhl(long double x);
-      double atanh(double x);
-      float atanhf(float x);
-      long double atanhl(long double x);
-      double cosh(double x);
-      float coshf(float x);
-      long double coshl(long double x);
-      double sinh(double x);
-      float sinhf(float x);
-      long double sinhl(long double x);
-      double tanh(double x);
-      float tanhf(float x);
-      long double tanhl(long double x);
-      double exp(double x);
-      float expf(float x);
-      long double expl(long double x);
-      double exp2(double x);
-      float exp2f(float x);
-      long double exp2l(long double x);
-      double expm1(double x);
-      float expm1f(float x);
-      long double expm1l(long double x);
-
-[<a name="p424" href="#p424">page 424</a>] (<a href="#Contents">Contents</a>)
-
-        double frexp(double value, int *exp);
-        float frexpf(float value, int *exp);
-        long double frexpl(long double value, int *exp);
-        int ilogb(double x);
-        int ilogbf(float x);
-        int ilogbl(long double x);
+        }</pre>
+ 
+
+<a name="7.6.4" href="#7.6.4"><h4>7.6.4 Environment</h4></a>
+<p><!--para 1-->
+ The functions in this section manage the floating-point environment -- status flags and
+ control modes -- as one entity.
+
+<a name="7.6.4.1" href="#7.6.4.1"><h5>7.6.4.1 The fegetenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;fenv.h&gt;
+        int fegetenv(fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fegetenv function attempts to store the current floating-point environment in the
+ object pointed to by envp.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fegetenv function returns zero if the environment was successfully stored.
+ Otherwise, it returns a nonzero value.
+
+<a name="7.6.4.2" href="#7.6.4.2"><h5>7.6.4.2 The feholdexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;fenv.h&gt;
+        int feholdexcept(fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feholdexcept function saves the current floating-point environment in the object
+ pointed to by envp, clears the floating-point status flags, and then installs a non-stop
+ (continue on floating-point exceptions) mode, if available, for all floating-point
+ exceptions.<sup><a href="#note189"><b>189)</b></a></sup>
+<!--page 207 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feholdexcept function returns zero if and only if non-stop floating-point
+ exception handling was successfully installed.
+
+<h6>footnotes</h6>
+<p><a name="note189">189)</a> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
+ handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
+ such systems, the feholdexcept function can be used in conjunction with the feupdateenv
+ function to write routines that hide spurious floating-point exceptions from their callers.
+
+
+<a name="7.6.4.3" href="#7.6.4.3"><h5>7.6.4.3 The fesetenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fesetenv(const fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fesetenv function attempts to establish the floating-point environment represented
+ by the object pointed to by envp. The argument envp shall point to an object set by a
+ call to fegetenv or feholdexcept, or equal a floating-point environment macro.
+ Note that fesetenv merely installs the state of the floating-point status flags
+ represented through its argument, and does not raise these floating-point exceptions.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fesetenv function returns zero if the environment was successfully established.
+ Otherwise, it returns a nonzero value.
+
+<a name="7.6.4.4" href="#7.6.4.4"><h5>7.6.4.4 The feupdateenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int feupdateenv(const fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feupdateenv function attempts to save the currently raised floating-point
+ exceptions in its automatic storage, install the floating-point environment represented by
+ the object pointed to by envp, and then raise the saved floating-point exceptions. The
+ argument envp shall point to an object set by a call to feholdexcept or fegetenv,
+ or equal a floating-point environment macro.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feupdateenv function returns zero if all the actions were successfully carried out.
+ Otherwise, it returns a nonzero value.
+ 
+ 
+ 
+ 
+<!--page 208 indent 4-->
+<p><!--para 4-->
+ EXAMPLE   Hide spurious underflow floating-point exceptions:
+<!--page 209 indent 4-->
+<pre>
+       #include &lt;fenv.h&gt;
+       double f(double x)
+       {
+             #pragma STDC FENV_ACCESS ON
+             double result;
+             fenv_t save_env;
+             if (feholdexcept(&amp;save_env))
+                   return /* indication of an environmental problem */;
+             // compute result
+             if (/* test spurious underflow */)
+                   if (feclearexcept(FE_UNDERFLOW))
+                            return /* indication of an environmental problem */;
+             if (feupdateenv(&amp;save_env))
+                   return /* indication of an environmental problem */;
+             return result;
+       }</pre>
+
+<a name="7.7" href="#7.7"><h3>7.7 Characteristics of floating types <float.h></h3></a>
+<p><!--para 1-->
+ The header &lt;float.h&gt; defines several macros that expand to various limits and
+ parameters of the standard floating-point types.
+<p><!--para 2-->
+ The macros, their meanings, and the constraints (or restrictions) on their values are listed
+ in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+<!--page 210 indent 4-->
+
+<a name="7.8" href="#7.8"><h3>7.8 Format conversion of integer types <inttypes.h></h3></a>
+<p><!--para 1-->
+ The header &lt;inttypes.h&gt; includes the header &lt;stdint.h&gt; and extends it with
+ additional facilities provided by hosted implementations.
+<p><!--para 2-->
+ It declares functions for manipulating greatest-width integers and converting numeric
+ character strings to greatest-width integers, and it declares the type
+<pre>
+          imaxdiv_t</pre>
+ which is a structure type that is the type of the value returned by the imaxdiv function.
+ For each type declared in &lt;stdint.h&gt;, it defines corresponding macros for conversion
+ specifiers for use with the formatted input/output functions.<sup><a href="#note190"><b>190)</b></a></sup>
+ Forward references: integer types &lt;stdint.h&gt; (<a href="#7.18">7.18</a>), formatted input/output
+ functions (<a href="#7.19.6">7.19.6</a>), formatted wide character input/output functions (<a href="#7.24.2">7.24.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note190">190)</a> See ''future library directions'' (<a href="#7.26.4">7.26.4</a>).
+
+
+<a name="7.8.1" href="#7.8.1"><h4>7.8.1 Macros for format specifiers</h4></a>
+<p><!--para 1-->
+ Each of the following object-like macros<sup><a href="#note191"><b>191)</b></a></sup> expands to a character string literal
+ containing a conversion specifier, possibly modified by a length modifier, suitable for use
+ within the format argument of a formatted input/output function when converting the
+ corresponding integer type. These macro names have the general form of PRI (character
+ string literals for the fprintf and fwprintf family) or SCN (character string literals
+ for the fscanf and fwscanf family),<sup><a href="#note192"><b>192)</b></a></sup> followed by the conversion specifier,
+ followed by a name corresponding to a similar type name in <a href="#7.18.1">7.18.1</a>. In these names, N
+ represents the width of the type as described in <a href="#7.18.1">7.18.1</a>. For example, PRIdFAST32 can
+ be used in a format string to print the value of an integer of type int_fast32_t.
+<p><!--para 2-->
+ The fprintf macros for signed integers are:
+<pre>
+        PRIdN             PRIdLEASTN                PRIdFASTN          PRIdMAX             PRIdPTR
+        PRIiN             PRIiLEASTN                PRIiFASTN          PRIiMAX             PRIiPTR</pre>
+ 
+ 
+ 
+ 
+<!--page 211 indent 4-->
+<p><!--para 3-->
+ The fprintf macros for unsigned integers are:
+<p><!--para 4-->
+<pre>
+        PRIoN           PRIoLEASTN               PRIoFASTN              PRIoMAX             PRIoPTR
+        PRIuN           PRIuLEASTN               PRIuFASTN              PRIuMAX             PRIuPTR
+        PRIxN           PRIxLEASTN               PRIxFASTN              PRIxMAX             PRIxPTR
+        PRIXN           PRIXLEASTN               PRIXFASTN              PRIXMAX             PRIXPTR</pre>
+ The fscanf macros for signed integers are:
+<p><!--para 5-->
+<pre>
+        SCNdN           SCNdLEASTN               SCNdFASTN              SCNdMAX             SCNdPTR
+        SCNiN           SCNiLEASTN               SCNiFASTN              SCNiMAX             SCNiPTR</pre>
+ The fscanf macros for unsigned integers are:
+<p><!--para 6-->
+<pre>
+        SCNoN           SCNoLEASTN               SCNoFASTN              SCNoMAX             SCNoPTR
+        SCNuN           SCNuLEASTN               SCNuFASTN              SCNuMAX             SCNuPTR
+        SCNxN           SCNxLEASTN               SCNxFASTN              SCNxMAX             SCNxPTR</pre>
+ For each type that the implementation provides in &lt;stdint.h&gt;, the corresponding
+ fprintf macros shall be defined and the corresponding fscanf macros shall be
+ defined unless the implementation does not have a suitable fscanf length modifier for
+ the type.
+<p><!--para 7-->
+ EXAMPLE
+<pre>
+         #include &lt;inttypes.h&gt;
+         #include &lt;wchar.h&gt;
+         int main(void)
+         {
+               uintmax_t i = UINTMAX_MAX;    // this type always exists
+               wprintf(L"The largest integer value is %020"
+                     PRIxMAX "\n", i);
+               return 0;
+         }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note191">191)</a> C++ implementations should define these macros only when __STDC_FORMAT_MACROS is defined
+ before &lt;inttypes.h&gt; is included.
+
+<p><a name="note192">192)</a> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
+ different format specifiers may be required for fprintf and fscanf, even when the type is the
+ same.
+
+
+<a name="7.8.2" href="#7.8.2"><h4>7.8.2 Functions for greatest-width integer types</h4></a>
+
+<a name="7.8.2.1" href="#7.8.2.1"><h5>7.8.2.1 The imaxabs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;inttypes.h&gt;
+         intmax_t imaxabs(intmax_t j);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The imaxabs function computes the absolute value of an integer j. If the result cannot
+ be represented, the behavior is undefined.<sup><a href="#note193"><b>193)</b></a></sup>
+ 
+ 
+ 
+<!--page 212 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The imaxabs function returns the absolute value.
+
+<h6>footnotes</h6>
+<p><a name="note193">193)</a> The absolute value of the most negative number cannot be represented in two's complement.
+
+
+<a name="7.8.2.2" href="#7.8.2.2"><h5>7.8.2.2 The imaxdiv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+            #include &lt;inttypes.h&gt;
+            imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The imaxdiv function computes numer / denom and numer % denom in a single
+ operation.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The imaxdiv function returns a structure of type imaxdiv_t comprising both the
+ quotient and the remainder. The structure shall contain (in either order) the members
+ quot (the quotient) and rem (the remainder), each of which has type intmax_t. If
+ either part of the result cannot be represented, the behavior is undefined.
+
+<a name="7.8.2.3" href="#7.8.2.3"><h5>7.8.2.3 The strtoimax and strtoumax functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;inttypes.h&gt;
+        intmax_t strtoimax(const char * restrict nptr,
+             char ** restrict endptr, int base);
+        uintmax_t strtoumax(const char * restrict nptr,
+             char ** restrict endptr, int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strtoimax and strtoumax functions are equivalent to the strtol, strtoll,
+ strtoul, and strtoull functions, except that the initial portion of the string is
+ converted to intmax_t and uintmax_t representation, respectively.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strtoimax and strtoumax functions return the converted value, if any. If no
+ conversion could be performed, zero is returned. If the correct value is outside the range
+ of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
+ (according to the return type and sign of the value, if any), and the value of the macro
+ ERANGE is stored in errno.
+ Forward references: the strtol, strtoll, strtoul, and strtoull functions
+ (<a href="#7.20.1.4">7.20.1.4</a>).
+<!--page 213 indent 4-->
+
+<a name="7.8.2.4" href="#7.8.2.4"><h5>7.8.2.4 The wcstoimax and wcstoumax functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stddef.h&gt;           // for wchar_t
+        #include &lt;inttypes.h&gt;
+        intmax_t wcstoimax(const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr, int base);
+        uintmax_t wcstoumax(const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr, int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstoimax and wcstoumax functions are equivalent to the wcstol, wcstoll,
+ wcstoul, and wcstoull functions except that the initial portion of the wide string is
+ converted to intmax_t and uintmax_t representation, respectively.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcstoimax function returns the converted value, if any. If no conversion could be
+ performed, zero is returned. If the correct value is outside the range of representable
+ values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
+ return type and sign of the value, if any), and the value of the macro ERANGE is stored in
+ errno.
+ Forward references: the wcstol, wcstoll, wcstoul, and wcstoull functions
+ (<a href="#7.24.4.1.2">7.24.4.1.2</a>).
+<!--page 214 indent 4-->
+
+<a name="7.9" href="#7.9"><h3>7.9 Alternative spellings <iso646.h></h3></a>
+<p><!--para 1-->
+ The header &lt;iso646.h&gt; defines the following eleven macros (on the left) that expand
+ to the corresponding tokens (on the right):
+<!--page 215 indent 4-->
+<pre>
+       and          &amp;&amp;
+       and_eq       &amp;=
+       bitand       &amp;
+       bitor        |
+       compl        ~
+       not          !
+       not_eq       !=
+       or           ||
+       or_eq        |=
+       xor          ^
+       xor_eq       ^=</pre>
+
+<a name="7.10" href="#7.10"><h3>7.10 Sizes of integer types <limits.h></h3></a>
+<p><!--para 1-->
+ The header &lt;limits.h&gt; defines several macros that expand to various limits and
+ parameters of the standard integer types.
+<p><!--para 2-->
+ The macros, their meanings, and the constraints (or restrictions) on their values are listed
+ in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+<!--page 216 indent 4-->
+
+<a name="7.11" href="#7.11"><h3>7.11 Localization <locale.h></h3></a>
+<p><!--para 1-->
+ The header &lt;locale.h&gt; declares two functions, one type, and defines several macros.
+<p><!--para 2-->
+ The type is
+<pre>
+        struct lconv</pre>
+ which contains members related to the formatting of numeric values. The structure shall
+ contain at least the following members, in any order. The semantics of the members and
+ their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
+ the values specified in the comments.
+<!--page 217 indent 4-->
+<p><!--para 3-->
+<pre>
+        char   *decimal_point;                 //   "."
+        char   *thousands_sep;                 //   ""
+        char   *grouping;                      //   ""
+        char   *mon_decimal_point;             //   ""
+        char   *mon_thousands_sep;             //   ""
+        char   *mon_grouping;                  //   ""
+        char   *positive_sign;                 //   ""
+        char   *negative_sign;                 //   ""
+        char   *currency_symbol;               //   ""
+        char   frac_digits;                    //   CHAR_MAX
+        char   p_cs_precedes;                  //   CHAR_MAX
+        char   n_cs_precedes;                  //   CHAR_MAX
+        char   p_sep_by_space;                 //   CHAR_MAX
+        char   n_sep_by_space;                 //   CHAR_MAX
+        char   p_sign_posn;                    //   CHAR_MAX
+        char   n_sign_posn;                    //   CHAR_MAX
+        char   *int_curr_symbol;               //   ""
+        char   int_frac_digits;                //   CHAR_MAX
+        char   int_p_cs_precedes;              //   CHAR_MAX
+        char   int_n_cs_precedes;              //   CHAR_MAX
+        char   int_p_sep_by_space;             //   CHAR_MAX
+        char   int_n_sep_by_space;             //   CHAR_MAX
+        char   int_p_sign_posn;                //   CHAR_MAX
+        char   int_n_sign_posn;                //   CHAR_MAX</pre>
+ The macros defined are NULL (described in <a href="#7.17">7.17</a>); and
+<pre>
+          LC_ALL
+          LC_COLLATE
+          LC_CTYPE
+          LC_MONETARY
+          LC_NUMERIC
+          LC_TIME</pre>
+ which expand to integer constant expressions with distinct values, suitable for use as the
+ first argument to the setlocale function.<sup><a href="#note194"><b>194)</b></a></sup> Additional macro definitions, beginning
+ with the characters LC_ and an uppercase letter,<sup><a href="#note195"><b>195)</b></a></sup> may also be specified by the
+ implementation.
+
+<h6>footnotes</h6>
+<p><a name="note194">194)</a> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
+
+<p><a name="note195">195)</a> See ''future library directions'' (<a href="#7.26.5">7.26.5</a>).
+
+
+<a name="7.11.1" href="#7.11.1"><h4>7.11.1 Locale control</h4></a>
+
+<a name="7.11.1.1" href="#7.11.1.1"><h5>7.11.1.1 The setlocale function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;locale.h&gt;
+          char *setlocale(int category, const char *locale);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The setlocale function selects the appropriate portion of the program's locale as
+ specified by the category and locale arguments. The setlocale function may be
+ used to change or query the program's entire current locale or portions thereof. The value
+ LC_ALL for category names the program's entire locale; the other values for
+ category name only a portion of the program's locale. LC_COLLATE affects the
+ behavior of the strcoll and strxfrm functions. LC_CTYPE affects the behavior of
+ the character handling functions<sup><a href="#note196"><b>196)</b></a></sup> and the multibyte and wide character functions.
+ LC_MONETARY affects the monetary formatting information returned by the
+ localeconv function. LC_NUMERIC affects the decimal-point character for the
+ formatted input/output functions and the string conversion functions, as well as the
+ nonmonetary formatting information returned by the localeconv function. LC_TIME
+ affects the behavior of the strftime and wcsftime functions.
+<p><!--para 3-->
+ A value of "C" for locale specifies the minimal environment for C translation; a value
+ of "" for locale specifies the locale-specific native environment. Other
+ implementation-defined strings may be passed as the second argument to setlocale.
+ 
+<!--page 218 indent 4-->
+<p><!--para 4-->
+ At program startup, the equivalent of
+<pre>
+         setlocale(LC_ALL, "C");</pre>
+ is executed.
+<p><!--para 5-->
+ The implementation shall behave as if no library function calls the setlocale function.
+<h6>Returns</h6>
+<p><!--para 6-->
+ If a pointer to a string is given for locale and the selection can be honored, the
+ setlocale function returns a pointer to the string associated with the specified
+ category for the new locale. If the selection cannot be honored, the setlocale
+ function returns a null pointer and the program's locale is not changed.
+<p><!--para 7-->
+ A null pointer for locale causes the setlocale function to return a pointer to the
+ string associated with the category for the program's current locale; the program's
+ locale is not changed.<sup><a href="#note197"><b>197)</b></a></sup>
+<p><!--para 8-->
+ The pointer to string returned by the setlocale function is such that a subsequent call
+ with that string value and its associated category will restore that part of the program's
+ locale. The string pointed to shall not be modified by the program, but may be
+ overwritten by a subsequent call to the setlocale function.
+ Forward references: formatted input/output functions (<a href="#7.19.6">7.19.6</a>), multibyte/wide
+ character conversion functions (<a href="#7.20.7">7.20.7</a>), multibyte/wide string conversion functions
+ (<a href="#7.20.8">7.20.8</a>), numeric conversion functions (<a href="#7.20.1">7.20.1</a>), the strcoll function (<a href="#7.21.4.3">7.21.4.3</a>), the
+ strftime function (<a href="#7.23.3.5">7.23.3.5</a>), the strxfrm function (<a href="#7.21.4.5">7.21.4.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note196">196)</a> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
+ isxdigit.
+
+<p><a name="note197">197)</a> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
+ locale when category has the value LC_ALL.
+
+
+<a name="7.11.2" href="#7.11.2"><h4>7.11.2 Numeric formatting convention inquiry</h4></a>
+
+<a name="7.11.2.1" href="#7.11.2.1"><h5>7.11.2.1 The localeconv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;locale.h&gt;
+         struct lconv *localeconv(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The localeconv function sets the components of an object with type struct lconv
+ with values appropriate for the formatting of numeric quantities (monetary and otherwise)
+ according to the rules of the current locale.
+<p><!--para 3-->
+ The members of the structure with type char * are pointers to strings, any of which
+ (except decimal_point) can point to "", to indicate that the value is not available in
+ the current locale or is of zero length. Apart from grouping and mon_grouping, the
+ 
+<!--page 219 indent 0-->
+ strings shall start and end in the initial shift state. The members with type char are
+ nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not
+ available in the current locale. The members include the following:
+ char *decimal_point
+<pre>
+           The decimal-point character used to format nonmonetary quantities.</pre>
+ char *thousands_sep
+<pre>
+           The character used to separate groups of digits before the decimal-point
+           character in formatted nonmonetary quantities.</pre>
+ char *grouping
+<pre>
+           A string whose elements indicate the size of each group of digits in
+           formatted nonmonetary quantities.</pre>
+ char *mon_decimal_point
+<pre>
+           The decimal-point used to format monetary quantities.</pre>
+ char *mon_thousands_sep
+<pre>
+           The separator for groups of digits before the decimal-point in formatted
+           monetary quantities.</pre>
+ char *mon_grouping
+<pre>
+           A string whose elements indicate the size of each group of digits in
+           formatted monetary quantities.</pre>
+ char *positive_sign
+<pre>
+           The string used to indicate a nonnegative-valued formatted monetary
+           quantity.</pre>
+ char *negative_sign
+<pre>
+           The string used to indicate a negative-valued formatted monetary quantity.</pre>
+ char *currency_symbol
+<pre>
+           The local currency symbol applicable to the current locale.</pre>
+ char frac_digits
+<pre>
+           The number of fractional digits (those after the decimal-point) to be
+           displayed in a locally formatted monetary quantity.</pre>
+ char p_cs_precedes
+<pre>
+           Set to 1 or 0 if the currency_symbol respectively precedes or
+           succeeds the value for a nonnegative locally formatted monetary quantity.</pre>
+ char n_cs_precedes
+<!--page 220 indent 0-->
+<pre>
+           Set to 1 or 0 if the currency_symbol respectively precedes or
+           succeeds the value for a negative locally formatted monetary quantity.</pre>
+ char p_sep_by_space
+<pre>
+           Set to a value indicating the separation of the currency_symbol, the
+           sign string, and the value for a nonnegative locally formatted monetary
+           quantity.</pre>
+ char n_sep_by_space
+<pre>
+           Set to a value indicating the separation of the currency_symbol, the
+           sign string, and the value for a negative locally formatted monetary
+           quantity.</pre>
+ char p_sign_posn
+<pre>
+           Set to a value indicating the positioning of the positive_sign for a
+           nonnegative locally formatted monetary quantity.</pre>
+ char n_sign_posn
+<pre>
+           Set to a value indicating the positioning of the negative_sign for a
+           negative locally formatted monetary quantity.</pre>
+ char *int_curr_symbol
+<pre>
+           The international currency symbol applicable to the current locale. The
+           first three characters contain the alphabetic international currency symbol
+           in accordance with those specified in ISO 4217. The fourth character
+           (immediately preceding the null character) is the character used to separate
+           the international currency symbol from the monetary quantity.</pre>
+ char int_frac_digits
+<pre>
+           The number of fractional digits (those after the decimal-point) to be
+           displayed in an internationally formatted monetary quantity.</pre>
+ char int_p_cs_precedes
+<pre>
+           Set to 1 or 0 if the int_curr_symbol respectively precedes or
+           succeeds the value for a nonnegative internationally formatted monetary
+           quantity.</pre>
+ char int_n_cs_precedes
+<pre>
+           Set to 1 or 0 if the int_curr_symbol respectively precedes or
+           succeeds the value for a negative internationally formatted monetary
+           quantity.</pre>
+ char int_p_sep_by_space
+<!--page 221 indent 4-->
+<pre>
+           Set to a value indicating the separation of the int_curr_symbol, the
+           sign string, and the value for a nonnegative internationally formatted
+           monetary quantity.</pre>
+ char int_n_sep_by_space
+<pre>
+           Set to a value indicating the separation of the int_curr_symbol, the
+           sign string, and the value for a negative internationally formatted monetary
+           quantity.</pre>
+ char int_p_sign_posn
+<pre>
+           Set to a value indicating the positioning of the positive_sign for a
+           nonnegative internationally formatted monetary quantity.</pre>
+ char int_n_sign_posn
+<p><!--para 4-->
+<pre>
+           Set to a value indicating the positioning of the negative_sign for a
+           negative internationally formatted monetary quantity.</pre>
+ The elements of grouping and mon_grouping are interpreted according to the
+ following:
+ CHAR_MAX      No further grouping is to be performed.
+ 0             The previous element is to be repeatedly used for the remainder of the
+<pre>
+               digits.</pre>
+ other         The integer value is the number of digits that compose the current group.
+<p><!--para 5-->
+<pre>
+               The next element is examined to determine the size of the next group of
+               digits before the current group.</pre>
+ The values of p_sep_by_space, n_sep_by_space, int_p_sep_by_space,
+ and int_n_sep_by_space are interpreted according to the following:
+ 0   No space separates the currency symbol and value.
+ 1   If the currency symbol and sign string are adjacent, a space separates them from the
+<pre>
+     value; otherwise, a space separates the currency symbol from the value.</pre>
+ 2   If the currency symbol and sign string are adjacent, a space separates them;
+<pre>
+     otherwise, a space separates the sign string from the value.</pre>
+ For int_p_sep_by_space and int_n_sep_by_space, the fourth character of
+ int_curr_symbol is used instead of a space.
+<p><!--para 6-->
+ The values of p_sign_posn, n_sign_posn, int_p_sign_posn,                            and
+ int_n_sign_posn are interpreted according to the following:
+ 0   Parentheses surround the quantity and currency symbol.
+ 1   The sign string precedes the quantity and currency symbol.
+ 2   The sign string succeeds the quantity and currency symbol.
+ 3   The sign string immediately precedes the currency symbol.
+ 4   The sign string immediately succeeds the currency symbol.
+<!--page 222 indent 5-->
+<p><!--para 7-->
+ The implementation shall behave as if no library function calls the localeconv
+ function.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The localeconv function returns a pointer to the filled-in object. The structure
+ pointed to by the return value shall not be modified by the program, but may be
+ overwritten by a subsequent call to the localeconv function. In addition, calls to the
+ setlocale function with categories LC_ALL, LC_MONETARY, or LC_NUMERIC may
+ overwrite the contents of the structure.
+<p><!--para 9-->
+ EXAMPLE 1 The following table illustrates rules which may well be used by four countries to format
+ monetary quantities.
+<pre>
+                               Local format                                     International format</pre>
+ 
+ Country            Positive                  Negative                    Positive               Negative
+ 
+ Country1     1.234,56 mk             -1.234,56 mk                  FIM   1.234,56         FIM -1.234,56
+ Country2     L.1.234                 -L.1.234                      ITL   1.234            -ITL 1.234
+ Country3     fl. 1.234,56              fl. -1.234,56                   NLG   1.234,56         NLG -1.234,56
+ Country4     SFrs.1,234.56           SFrs.1,234.56C                CHF   1,234.56         CHF 1,234.56C
+<p><!--para 10-->
+ For these four countries, the respective values for the monetary members of the structure returned by
+ localeconv could be:
+<pre>
+                                   Country1              Country2              Country3            Country4</pre>
+ 
+ mon_decimal_point                 ","                   ""                   ","                 "."
+ mon_thousands_sep                 "."                   "."                  "."                 ","
+ mon_grouping                      "\3"                  "\3"                 "\3"                "\3"
+ positive_sign                     ""                    ""                   ""                  ""
+ negative_sign                     "-"                   "-"                  "-"                 "C"
+ currency_symbol                   "mk"                  "L."                 "\u0192"            "SFrs."
+ frac_digits                       2                     0                    2                   2
+ p_cs_precedes                     0                     1                    1                   1
+ n_cs_precedes                     0                     1                    1                   1
+ p_sep_by_space                    1                     0                    1                   0
+ n_sep_by_space                    1                     0                    2                   0
+ p_sign_posn                       1                     1                    1                   1
+ n_sign_posn                       1                     1                    4                   2
+ int_curr_symbol                   "FIM "                "ITL "               "NLG "              "CHF "
+ int_frac_digits                   2                     0                    2                   2
+ int_p_cs_precedes                 1                     1                    1                   1
+ int_n_cs_precedes                 1                     1                    1                   1
+ int_p_sep_by_space                1                     1                    1                   1
+ int_n_sep_by_space                2                     1                    2                   1
+ int_p_sign_posn                   1                     1                    1                   1
+ int_n_sign_posn                   4                     1                    4                   2
+<!--page 223 indent 5-->
+<p><!--para 11-->
+ EXAMPLE 2 The following table illustrates how the cs_precedes, sep_by_space, and sign_posn members
+ affect the formatted value.
+<pre>
+                                                               p_sep_by_space</pre>
+ 
+ p_cs_precedes           p_sign_posn                0                   1                  2
+ 
+<pre>
+                 0                    0         (<a href="#1.25">1.25</a>$)            (<a href="#1.25">1.25</a> $)            (<a href="#1.25">1.25</a>$)
+                                      1         +1.25$             +1.25 $             + <a href="#1.25">1.25</a>$
+                                      2         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
+                                      3         <a href="#1.25">1.25</a>+$             <a href="#1.25">1.25</a> +$             <a href="#1.25">1.25</a>+ $
+                                      4         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +</pre>
+ 
+<!--page 224 indent 4-->
+<pre>
+                 1                    0         ($1.25)            ($ <a href="#1.25">1.25</a>)            ($1.25)
+                                      1         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                      2         $1.25+             $ <a href="#1.25">1.25</a>+             $1.25 +
+                                      3         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                      4         $+1.25             $+ <a href="#1.25">1.25</a>             $ +1.25</pre>
+
+<a name="7.12" href="#7.12"><h3>7.12 Mathematics <math.h></h3></a>
+<p><!--para 1-->
+ The header &lt;math.h&gt; declares two types and many mathematical functions and defines
+ several macros. Most synopses specify a family of functions consisting of a principal
+ function with one or more double parameters, a double return value, or both; and
+ other functions with the same name but with f and l suffixes, which are corresponding
+ functions with float and long double parameters, return values, or both.<sup><a href="#note198"><b>198)</b></a></sup>
+ Integer arithmetic functions and conversion functions are discussed later.
+<p><!--para 2-->
+ The types
+<pre>
+         float_t
+         double_t</pre>
+ are floating types at least as wide as float and double, respectively, and such that
+ double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
+ float_t and double_t are float and double, respectively; if
+ FLT_EVAL_METHOD equals 1, they are both double; if FLT_EVAL_METHOD equals
+ 2, they are both long double; and for other values of FLT_EVAL_METHOD, they are
+ otherwise implementation-defined.<sup><a href="#note199"><b>199)</b></a></sup>
+<p><!--para 3-->
+ The macro
+<pre>
+         HUGE_VAL</pre>
+ expands to a positive double constant expression, not necessarily representable as a
+ float. The macros
+<pre>
+         HUGE_VALF
+         HUGE_VALL</pre>
+ are respectively float and long double analogs of HUGE_VAL.<sup><a href="#note200"><b>200)</b></a></sup>
+<p><!--para 4-->
+ The macro
+<pre>
+         INFINITY</pre>
+ expands to a constant expression of type float representing positive or unsigned
+ infinity, if available; else to a positive constant of type float that overflows at
+ 
+ 
+ 
+<!--page 225 indent 4-->
+ translation time.<sup><a href="#note201"><b>201)</b></a></sup>
+<p><!--para 5-->
+ The macro
+<pre>
+          NAN</pre>
+ is defined if and only if the implementation supports quiet NaNs for the float type. It
+ expands to a constant expression of type float representing a quiet NaN.
+<p><!--para 6-->
+ The number classification macros
+<pre>
+          FP_INFINITE
+          FP_NAN
+          FP_NORMAL
+          FP_SUBNORMAL
+          FP_ZERO</pre>
+ represent the mutually exclusive kinds of floating-point values. They expand to integer
+ constant expressions with distinct values. Additional implementation-defined floating-
+ point classifications, with macro definitions beginning with FP_ and an uppercase letter,
+ may also be specified by the implementation.
+<p><!--para 7-->
+ The macro
+<pre>
+          FP_FAST_FMA</pre>
+ is optionally defined. If defined, it indicates that the fma function generally executes
+ about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note202"><b>202)</b></a></sup> The
+ macros
+<pre>
+          FP_FAST_FMAF
+          FP_FAST_FMAL</pre>
+ are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
+ these macros expand to the integer constant 1.
+<p><!--para 8-->
+ The macros
+<pre>
+          FP_ILOGB0
+          FP_ILOGBNAN</pre>
+ expand to integer constant expressions whose values are returned by ilogb(x) if x is
+ zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
+ -INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
+ 
+ 
+<!--page 226 indent 4-->
+<p><!--para 9-->
+ The macros
+<pre>
+         MATH_ERRNO
+         MATH_ERREXCEPT</pre>
+ expand to the integer constants 1 and 2, respectively; the macro
+<pre>
+         math_errhandling</pre>
+ expands to an expression that has type int and the value MATH_ERRNO,
+ MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
+ constant for the duration of the program. It is unspecified whether
+ math_errhandling is a macro or an identifier with external linkage. If a macro
+ definition is suppressed or a program defines an identifier with the name
+ math_errhandling, the behavior is undefined.               If the expression
+ math_errhandling &amp; MATH_ERREXCEPT can be nonzero, the implementation
+ shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
+ &lt;fenv.h&gt;.
+
+<h6>footnotes</h6>
+<p><a name="note198">198)</a> Particularly on systems with wide expression evaluation, a &lt;math.h&gt; function might pass arguments
+ and return values in wider format than the synopsis prototype indicates.
+
+<p><a name="note199">199)</a> The types float_t and double_t are intended to be the implementation's most efficient types at
+ least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
+ type float_t is the narrowest type used by the implementation to evaluate floating expressions.
+
+<p><a name="note200">200)</a> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
+ supports infinities.
+
+<p><a name="note201">201)</a> In this case, using INFINITY will violate the constraint in <a href="#6.4.4">6.4.4</a> and thus require a diagnostic.
+
+<p><a name="note202">202)</a> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
+ directly with a hardware multiply-add instruction. Software implementations are expected to be
+ substantially slower.
+
+
+<a name="7.12.1" href="#7.12.1"><h4>7.12.1 Treatment of error conditions</h4></a>
+<p><!--para 1-->
+ The behavior of each of the functions in &lt;math.h&gt; is specified for all representable
+ values of its input arguments, except where stated otherwise. Each function shall execute
+ as if it were a single operation without generating any externally visible exceptional
+ conditions.
+<p><!--para 2-->
+ For all functions, a domain error occurs if an input argument is outside the domain over
+ which the mathematical function is defined. The description of each function lists any
+ required domain errors; an implementation may define additional domain errors, provided
+ that such errors are consistent with the mathematical definition of the function.<sup><a href="#note203"><b>203)</b></a></sup> On a
+ domain error, the function returns an implementation-defined value; if the integer
+ expression math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression
+ errno acquires the value EDOM; if the integer expression math_errhandling &amp;
+ MATH_ERREXCEPT is nonzero, the ''invalid'' floating-point exception is raised.
+<p><!--para 3-->
+ Similarly, a range error occurs if the mathematical result of the function cannot be
+ represented in an object of the specified type, due to extreme magnitude.
+<p><!--para 4-->
+ A floating result overflows if the magnitude of the mathematical result is finite but so
+ large that the mathematical result cannot be represented without extraordinary roundoff
+ error in an object of the specified type. If a floating result overflows and default rounding
+ is in effect, or if the mathematical result is an exact infinity from finite arguments (for
+ example log(0.0)), then the function returns the value of the macro HUGE_VAL,
+ 
+ 
+<!--page 227 indent 4-->
+ HUGE_VALF, or HUGE_VALL according to the return type, with the same sign as the
+ correct value of the function; if the integer expression math_errhandling &amp;
+ MATH_ERRNO is nonzero, the integer expression errno acquires the value ERANGE; if
+ the integer expression math_errhandling &amp; MATH_ERREXCEPT is nonzero, the
+ ''divide-by-zero'' floating-point exception is raised if the mathematical result is an exact
+ infinity and the ''overflow'' floating-point exception is raised otherwise.
+<p><!--para 5-->
+ The result underflows if the magnitude of the mathematical result is so small that the
+ mathematical result cannot be represented, without extraordinary roundoff error, in an
+ object of the specified type.<sup><a href="#note204"><b>204)</b></a></sup> If the result underflows, the function returns an
+ implementation-defined value whose magnitude is no greater than the smallest
+ normalized positive number in the specified type; if the integer expression
+ math_errhandling &amp; MATH_ERRNO is nonzero, whether errno acquires the
+ value    ERANGE       is    implementation-defined;     if   the  integer   expression
+ math_errhandling &amp; MATH_ERREXCEPT is nonzero, whether the ''underflow''
+ floating-point exception is raised is implementation-defined.
+
+<h6>footnotes</h6>
+<p><a name="note203">203)</a> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
+ error if the mathematical domain of the function does not include the infinity.
+
+<p><a name="note204">204)</a> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
+ also ''flush-to-zero'' underflow.
+
+
+<a name="7.12.2" href="#7.12.2"><h4>7.12.2 The FP_CONTRACT pragma</h4></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         #pragma STDC FP_CONTRACT on-off-switch</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The FP_CONTRACT pragma can be used to allow (if the state is ''on'') or disallow (if the
+ state is ''off'') the implementation to contract expressions (<a href="#6.5">6.5</a>). Each pragma can occur
+ either outside external declarations or preceding all explicit declarations and statements
+ inside a compound statement. When outside external declarations, the pragma takes
+ effect from its occurrence until another FP_CONTRACT pragma is encountered, or until
+ the end of the translation unit. When inside a compound statement, the pragma takes
+ effect from its occurrence until another FP_CONTRACT pragma is encountered
+ (including within a nested compound statement), or until the end of the compound
+ statement; at the end of a compound statement the state for the pragma is restored to its
+ condition just before the compound statement. If this pragma is used in any other
+ context, the behavior is undefined. The default state (''on'' or ''off'') for the pragma is
+ implementation-defined.
+ 
+ 
+ 
+ 
+<!--page 228 indent 4-->
+
+<a name="7.12.3" href="#7.12.3"><h4>7.12.3 Classification macros</h4></a>
+<p><!--para 1-->
+ In the synopses in this subclause, real-floating indicates that the argument shall be an
+ expression of real floating type.
+
+<a name="7.12.3.1" href="#7.12.3.1"><h5>7.12.3.1 The fpclassify macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          int fpclassify(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fpclassify macro classifies its argument value as NaN, infinite, normal,
+ subnormal, zero, or into another implementation-defined category. First, an argument
+ represented in a format wider than its semantic type is converted to its semantic type.
+ Then classification is based on the type of the argument.<sup><a href="#note205"><b>205)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fpclassify macro returns the value of the number classification macro
+ appropriate to the value of its argument.
+<p><!--para 4-->
+ EXAMPLE        The fpclassify macro might be implemented in terms of ordinary functions as
+<pre>
+          #define fpclassify(x) \
+                ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) : \
+                 (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) : \
+                                                   __fpclassifyl(x))</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note205">205)</a> Since an expression can be evaluated with more range and precision than its type has, it is important to
+ know the type that classification is based on. For example, a normal long double value might
+ become subnormal when converted to double, and zero when converted to float.
+
+
+<a name="7.12.3.2" href="#7.12.3.2"><h5>7.12.3.2 The isfinite macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          int isfinite(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isfinite macro determines whether its argument has a finite value (zero,
+ subnormal, or normal, and not infinite or NaN). First, an argument represented in a
+ format wider than its semantic type is converted to its semantic type. Then determination
+ is based on the type of the argument.
+ 
+ 
+ 
+ 
+<!--page 229 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isfinite macro returns a nonzero value if and only if its argument has a finite
+ value.
+
+<a name="7.12.3.3" href="#7.12.3.3"><h5>7.12.3.3 The isinf macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isinf(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isinf macro determines whether its argument value is an infinity (positive or
+ negative). First, an argument represented in a format wider than its semantic type is
+ converted to its semantic type. Then determination is based on the type of the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isinf macro returns a nonzero value if and only if its argument has an infinite
+ value.
+
+<a name="7.12.3.4" href="#7.12.3.4"><h5>7.12.3.4 The isnan macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isnan(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isnan macro determines whether its argument value is a NaN. First, an argument
+ represented in a format wider than its semantic type is converted to its semantic type.
+ Then determination is based on the type of the argument.<sup><a href="#note206"><b>206)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isnan macro returns a nonzero value if and only if its argument has a NaN value.
+
+<h6>footnotes</h6>
+<p><a name="note206">206)</a> For the isnan macro, the type for determination does not matter unless the implementation supports
+ NaNs in the evaluation type but not in the semantic type.
+
+
+<a name="7.12.3.5" href="#7.12.3.5"><h5>7.12.3.5 The isnormal macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isnormal(real-floating x);</pre>
+ 
+ 
+ 
+ 
+<!--page 230 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The isnormal macro determines whether its argument value is normal (neither zero,
+ subnormal, infinite, nor NaN). First, an argument represented in a format wider than its
+ semantic type is converted to its semantic type. Then determination is based on the type
+ of the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isnormal macro returns a nonzero value if and only if its argument has a normal
+ value.
+
+<a name="7.12.3.6" href="#7.12.3.6"><h5>7.12.3.6 The signbit macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int signbit(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The signbit macro determines whether the sign of its argument value is negative.<sup><a href="#note207"><b>207)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The signbit macro returns a nonzero value if and only if the sign of its argument value
+ is negative.
+
+<h6>footnotes</h6>
+<p><a name="note207">207)</a> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
+ unsigned, it is treated as positive.
+
+
+<a name="7.12.4" href="#7.12.4"><h4>7.12.4 Trigonometric functions</h4></a>
+
+<a name="7.12.4.1" href="#7.12.4.1"><h5>7.12.4.1 The acos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double acos(double x);
+         float acosf(float x);
+         long double acosl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The acos functions compute the principal value of the arc cosine of x. A domain error
+ occurs for arguments not in the interval [-1, +1].
+<h6>Returns</h6>
+<p><!--para 3-->
+ The acos functions return arccos x in the interval [0, pi ] radians.
+ 
+ 
+ 
+ 
+<!--page 231 indent 4-->
+
+<a name="7.12.4.2" href="#7.12.4.2"><h5>7.12.4.2 The asin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double asin(double x);
+        float asinf(float x);
+        long double asinl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The asin functions compute the principal value of the arc sine of x. A domain error
+ occurs for arguments not in the interval [-1, +1].
+<h6>Returns</h6>
+<p><!--para 3-->
+ The asin functions return arcsin x in the interval [-pi /2, +pi /2] radians.
+
+<a name="7.12.4.3" href="#7.12.4.3"><h5>7.12.4.3 The atan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double atan(double x);
+        float atanf(float x);
+        long double atanl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atan functions compute the principal value of the arc tangent of x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atan functions return arctan x in the interval [-pi /2, +pi /2] radians.
+
+<a name="7.12.4.4" href="#7.12.4.4"><h5>7.12.4.4 The atan2 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double atan2(double y, double x);
+        float atan2f(float y, float x);
+        long double atan2l(long double y, long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atan2 functions compute the value of the arc tangent of y/x, using the signs of both
+ arguments to determine the quadrant of the return value. A domain error may occur if
+ both arguments are zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atan2 functions return arctan y/x in the interval [-pi , +pi ] radians.
+<!--page 232 indent 4-->
+
+<a name="7.12.4.5" href="#7.12.4.5"><h5>7.12.4.5 The cos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double cos(double x);
+        float cosf(float x);
+        long double cosl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cos functions compute the cosine of x (measured in radians).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cos functions return cos x.
+
+<a name="7.12.4.6" href="#7.12.4.6"><h5>7.12.4.6 The sin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double sin(double x);
+        float sinf(float x);
+        long double sinl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sin functions compute the sine of x (measured in radians).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sin functions return sin x.
+
+<a name="7.12.4.7" href="#7.12.4.7"><h5>7.12.4.7 The tan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double tan(double x);
+        float tanf(float x);
+        long double tanl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tan functions return the tangent of x (measured in radians).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tan functions return tan x.
+<!--page 233 indent 4-->
+
+<a name="7.12.5" href="#7.12.5"><h4>7.12.5 Hyperbolic functions</h4></a>
+
+<a name="7.12.5.1" href="#7.12.5.1"><h5>7.12.5.1 The acosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double acosh(double x);
+        float acoshf(float x);
+        long double acoshl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The acosh functions compute the (nonnegative) arc hyperbolic cosine of x. A domain
+ error occurs for arguments less than 1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The acosh functions return arcosh x in the interval [0, +(inf)].
+
+<a name="7.12.5.2" href="#7.12.5.2"><h5>7.12.5.2 The asinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double asinh(double x);
+        float asinhf(float x);
+        long double asinhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The asinh functions compute the arc hyperbolic sine of x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The asinh functions return arsinh x.
+
+<a name="7.12.5.3" href="#7.12.5.3"><h5>7.12.5.3 The atanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double atanh(double x);
+        float atanhf(float x);
+        long double atanhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atanh functions compute the arc hyperbolic tangent of x. A domain error occurs
+ for arguments not in the interval [-1, +1]. A range error may occur if the argument
+ equals -1 or +1.
+<!--page 234 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atanh functions return artanh x.
+
+<a name="7.12.5.4" href="#7.12.5.4"><h5>7.12.5.4 The cosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double cosh(double x);
+        float coshf(float x);
+        long double coshl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cosh functions compute the hyperbolic cosine of x. A range error occurs if the
+ magnitude of x is too large.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cosh functions return cosh x.
+
+<a name="7.12.5.5" href="#7.12.5.5"><h5>7.12.5.5 The sinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double sinh(double x);
+        float sinhf(float x);
+        long double sinhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sinh functions compute the hyperbolic sine of x. A range error occurs if the
+ magnitude of x is too large.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sinh functions return sinh x.
+
+<a name="7.12.5.6" href="#7.12.5.6"><h5>7.12.5.6 The tanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double tanh(double x);
+        float tanhf(float x);
+        long double tanhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tanh functions compute the hyperbolic tangent of x.
+<!--page 235 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tanh functions return tanh x.
+
+<a name="7.12.6" href="#7.12.6"><h4>7.12.6 Exponential and logarithmic functions</h4></a>
+
+<a name="7.12.6.1" href="#7.12.6.1"><h5>7.12.6.1 The exp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double exp(double x);
+        float expf(float x);
+        long double expl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The exp functions compute the base-e exponential of x. A range error occurs if the
+ magnitude of x is too large.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The exp functions return ex .
+
+<a name="7.12.6.2" href="#7.12.6.2"><h5>7.12.6.2 The exp2 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double exp2(double x);
+        float exp2f(float x);
+        long double exp2l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The exp2 functions compute the base-2 exponential of x. A range error occurs if the
+ magnitude of x is too large.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The exp2 functions return 2x .
+
+<a name="7.12.6.3" href="#7.12.6.3"><h5>7.12.6.3 The expm1 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 236 indent 4-->
+<pre>
+        #include &lt;math.h&gt;
+        double expm1(double x);
+        float expm1f(float x);
+        long double expm1l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The expm1 functions compute the base-e exponential of the argument, minus 1. A range
+ error occurs if x is too large.<sup><a href="#note208"><b>208)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The expm1 functions return ex - 1.
+
+<h6>footnotes</h6>
+<p><a name="note208">208)</a> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
+
+
+<a name="7.12.6.4" href="#7.12.6.4"><h5>7.12.6.4 The frexp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double frexp(double value, int *exp);
+         float frexpf(float value, int *exp);
+         long double frexpl(long double value, int *exp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The frexp functions break a floating-point number into a normalized fraction and an
+ integral power of 2. They store the integer in the int object pointed to by exp.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If value is not a floating-point number, the results are unspecified. Otherwise, the
+ frexp functions return the value x, such that x has a magnitude in the interval [1/2, 1) or
+ zero, and value equals x x 2*exp . If value is zero, both parts of the result are zero.
+
+<a name="7.12.6.5" href="#7.12.6.5"><h5>7.12.6.5 The ilogb functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int ilogb(double x);
+         int ilogbf(float x);
+         int ilogbl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ilogb functions extract the exponent of x as a signed int value. If x is zero they
+ compute the value FP_ILOGB0; if x is infinite they compute the value INT_MAX; if x is
+ a NaN they compute the value FP_ILOGBNAN; otherwise, they are equivalent to calling
+ the corresponding logb function and casting the returned value to type int. A domain
+ error or range error may occur if x is zero, infinite, or NaN. If the correct value is outside
+ the range of the return type, the numeric result is unspecified.
+ 
+ 
+ 
+ 
+<!--page 237 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ilogb functions return the exponent of x as a signed int value.
+ Forward references: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
+
+<a name="7.12.6.6" href="#7.12.6.6"><h5>7.12.6.6 The ldexp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double ldexp(double x, int exp);
         float ldexpf(float x, int exp);
-        long double ldexpl(long double x, int exp);
+        long double ldexpl(long double x, int exp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ldexp functions multiply a floating-point number by an integral power of 2. A
+ range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ldexp functions return x x 2exp .
+
+<a name="7.12.6.7" href="#7.12.6.7"><h5>7.12.6.7 The log functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double log(double x);
         float logf(float x);
-        long double logl(long double x);
+        long double logl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log functions compute the base-e (natural) logarithm of x. A domain error occurs if
+ the argument is negative. A range error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log functions return loge x.
+
+<a name="7.12.6.8" href="#7.12.6.8"><h5>7.12.6.8 The log10 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 238 indent 4-->
+<pre>
+        #include &lt;math.h&gt;
         double log10(double x);
         float log10f(float x);
-        long double log10l(long double x);
-        double log1p(double x);
-        float log1pf(float x);
-        long double log1pl(long double x);
-        double log2(double x);
-        float log2f(float x);
-        long double log2l(long double x);
+        long double log10l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log10 functions compute the base-10 (common) logarithm of x. A domain error
+ occurs if the argument is negative. A range error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log10 functions return log10 x.
+
+<a name="7.12.6.9" href="#7.12.6.9"><h5>7.12.6.9 The log1p functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double log1p(double x);
+         float log1pf(float x);
+         long double log1pl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log1p functions compute the base-e (natural) logarithm of 1 plus the argument.<sup><a href="#note209"><b>209)</b></a></sup>
+ A domain error occurs if the argument is less than -1. A range error may occur if the
+ argument equals -1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log1p functions return loge (1 + x).
+
+<h6>footnotes</h6>
+<p><a name="note209">209)</a> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
+
+
+<a name="7.12.6.10" href="#7.12.6.10"><h5>7.12.6.10 The log2 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double log2(double x);
+         float log2f(float x);
+         long double log2l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log2 functions compute the base-2 logarithm of x. A domain error occurs if the
+ argument is less than zero. A range error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log2 functions return log2 x.
+ 
+ 
+ 
+ 
+<!--page 239 indent 4-->
+
+<a name="7.12.6.11" href="#7.12.6.11"><h5>7.12.6.11 The logb functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double logb(double x);
         float logbf(float x);
-        long double logbl(long double x);
+        long double logbl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The logb functions extract the exponent of x, as a signed integer value in floating-point
+ format. If x is subnormal it is treated as though it were normalized; thus, for positive
+ finite x,
+<pre>
+       1 &lt;= x x FLT_RADIX-logb(x) &lt; FLT_RADIX</pre>
+ A domain error or range error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The logb functions return the signed exponent of x.
+
+<a name="7.12.6.12" href="#7.12.6.12"><h5>7.12.6.12 The modf functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double modf(double value, double *iptr);
         float modff(float value, float *iptr);
-        long double modfl(long double value, long double *iptr);
+        long double modfl(long double value, long double *iptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The modf functions break the argument value into integral and fractional parts, each of
+ which has the same type and sign as the argument. They store the integral part (in
+ floating-point format) in the object pointed to by iptr.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The modf functions return the signed fractional part of value.
+<!--page 240 indent 4-->
+
+<a name="7.12.6.13" href="#7.12.6.13"><h5>7.12.6.13 The scalbn and scalbln functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double scalbn(double x, int n);
         float scalbnf(float x, int n);
         long double scalbnl(long double x, int n);
         double scalbln(double x, long int n);
         float scalblnf(float x, long int n);
-        long double scalblnl(long double x, long int n);
+        long double scalblnl(long double x, long int n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The scalbn and scalbln functions compute x x FLT_RADIXn efficiently, not
+ normally by computing FLT_RADIXn explicitly. A range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The scalbn and scalbln functions return x x FLT_RADIXn .
+
+<a name="7.12.7" href="#7.12.7"><h4>7.12.7 Power and absolute-value functions</h4></a>
+
+<a name="7.12.7.1" href="#7.12.7.1"><h5>7.12.7.1 The cbrt functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double cbrt(double x);
         float cbrtf(float x);
-        long double cbrtl(long double x);
+        long double cbrtl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cbrt functions compute the real cube root of x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cbrt functions return x1/3 .
+
+<a name="7.12.7.2" href="#7.12.7.2"><h5>7.12.7.2 The fabs functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double fabs(double x);
         float fabsf(float x);
-        long double fabsl(long double x);
+        long double fabsl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fabs functions compute the absolute value of a floating-point number x.
+<!--page 241 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fabs functions return | x |.
+
+<a name="7.12.7.3" href="#7.12.7.3"><h5>7.12.7.3 The hypot functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double hypot(double x, double y);
         float hypotf(float x, float y);
-
-[<a name="p425" href="#p425">page 425</a>] (<a href="#Contents">Contents</a>)
-
-      long double hypotl(long double x, long double y);
-      double pow(double x, double y);
-      float powf(float x, float y);
-      long double powl(long double x, long double y);
-      double sqrt(double x);
-      float sqrtf(float x);
-      long double sqrtl(long double x);
-      double erf(double x);
-      float erff(float x);
-      long double erfl(long double x);
-      double erfc(double x);
-      float erfcf(float x);
-      long double erfcl(long double x);
-      double lgamma(double x);
-      float lgammaf(float x);
-      long double lgammal(long double x);
-      double tgamma(double x);
-      float tgammaf(float x);
-      long double tgammal(long double x);
-      double ceil(double x);
-      float ceilf(float x);
-      long double ceill(long double x);
-      double floor(double x);
-      float floorf(float x);
-      long double floorl(long double x);
-      double nearbyint(double x);
-      float nearbyintf(float x);
-      long double nearbyintl(long double x);
-      double rint(double x);
-      float rintf(float x);
-      long double rintl(long double x);
-      long int lrint(double x);
-      long int lrintf(float x);
-      long int lrintl(long double x);
-      long long int llrint(double x);
-      long long int llrintf(float x);
-      long long int llrintl(long double x);
-      double round(double x);
-      float roundf(float x);
-      long double roundl(long double x);
-      long int lround(double x);
-
-[<a name="p426" href="#p426">page 426</a>] (<a href="#Contents">Contents</a>)
-
+        long double hypotl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The hypot functions compute the square root of the sum of the squares of x and y,
+ without undue overflow or underflow. A range error may occur.
+<p><!--para 3-->
+<h6>Returns</h6>
+<p><!--para 4-->
+ The hypot functions return (sqrt)x2 + y2 .
+<pre>
+                            ???
+                            ???????????????</pre>
+
+<a name="7.12.7.4" href="#7.12.7.4"><h5>7.12.7.4 The pow functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double pow(double x, double y);
+        float powf(float x, float y);
+        long double powl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The pow functions compute x raised to the power y. A domain error occurs if x is finite
+ and negative and y is finite and not an integer value. A range error may occur. A domain
+ error may occur if x is zero and y is zero. A domain error or range error may occur if x
+ is zero and y is less than zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The pow functions return xy .
+
+<a name="7.12.7.5" href="#7.12.7.5"><h5>7.12.7.5 The sqrt functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 242 indent 4-->
+<pre>
+        #include &lt;math.h&gt;
+        double sqrt(double x);
+        float sqrtf(float x);
+        long double sqrtl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sqrt functions compute the nonnegative square root of x. A domain error occurs if
+ the argument is less than zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sqrt functions return (sqrt)x.
+<pre>
+                           ???
+                           ???</pre>
+
+<a name="7.12.8" href="#7.12.8"><h4>7.12.8 Error and gamma functions</h4></a>
+
+<a name="7.12.8.1" href="#7.12.8.1"><h5>7.12.8.1 The erf functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double erf(double x);
+        float erff(float x);
+        long double erfl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The erf functions compute the error function of x.
+<h6>Returns</h6>
+<pre>
+                                    2        x
+                                         (integral)</pre>
+ 
+ The erf functions return erf x =                e-t dt.
+<pre>
+                                                   2</pre>
+ 
+ 
+<pre>
+                                    (sqrt)pi
+                                    ???
+                                    ???    0</pre>
+ 
+
+<a name="7.12.8.2" href="#7.12.8.2"><h5>7.12.8.2 The erfc functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double erfc(double x);
+        float erfcf(float x);
+        long double erfcl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The erfc functions compute the complementary error function of x. A range error
+ occurs if x is too large.
+<h6>Returns</h6>
+<pre>
+                                                           2        (inf)
+                                                                (integral)</pre>
+ 
+ The erfc functions return erfc x = 1 - erf x =                         e-t dt.
+<pre>
+                                                                          2</pre>
+ 
+ 
+<!--page 243 indent 4-->
+<pre>
+                                                           (sqrt)pi
+                                                           ???
+                                                           ???    x</pre>
+
+<a name="7.12.8.3" href="#7.12.8.3"><h5>7.12.8.3 The lgamma functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double lgamma(double x);
+        float lgammaf(float x);
+        long double lgammal(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The lgamma functions compute the natural logarithm of the absolute value of gamma of
+ x. A range error occurs if x is too large. A range error may occur if x is a negative
+ integer or zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The lgamma functions return loge | (Gamma)(x) |.
+
+<a name="7.12.8.4" href="#7.12.8.4"><h5>7.12.8.4 The tgamma functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double tgamma(double x);
+        float tgammaf(float x);
+        long double tgammal(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tgamma functions compute the gamma function of x. A domain error or range error
+ may occur if x is a negative integer or zero. A range error may occur if the magnitude of
+ x is too large or too small.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tgamma functions return (Gamma)(x).
+
+<a name="7.12.9" href="#7.12.9"><h4>7.12.9 Nearest integer functions</h4></a>
+
+<a name="7.12.9.1" href="#7.12.9.1"><h5>7.12.9.1 The ceil functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double ceil(double x);
+        float ceilf(float x);
+        long double ceill(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ceil functions compute the smallest integer value not less than x.
+<!--page 244 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ceil functions return ???x???, expressed as a floating-point number.
+
+<a name="7.12.9.2" href="#7.12.9.2"><h5>7.12.9.2 The floor functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double floor(double x);
+        float floorf(float x);
+        long double floorl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The floor functions compute the largest integer value not greater than x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The floor functions return ???x???, expressed as a floating-point number.
+
+<a name="7.12.9.3" href="#7.12.9.3"><h5>7.12.9.3 The nearbyint functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double nearbyint(double x);
+        float nearbyintf(float x);
+        long double nearbyintl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The nearbyint functions round their argument to an integer value in floating-point
+ format, using the current rounding direction and without raising the ''inexact'' floating-
+ point exception.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The nearbyint functions return the rounded integer value.
+
+<a name="7.12.9.4" href="#7.12.9.4"><h5>7.12.9.4 The rint functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double rint(double x);
+        float rintf(float x);
+        long double rintl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rint functions differ from the nearbyint functions (<a href="#7.12.9.3">7.12.9.3</a>) only in that the
+ rint functions may raise the ''inexact'' floating-point exception if the result differs in
+ value from the argument.
+<!--page 245 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The rint functions return the rounded integer value.
+
+<a name="7.12.9.5" href="#7.12.9.5"><h5>7.12.9.5 The lrint and llrint functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        long int lrint(double x);
+        long int lrintf(float x);
+        long int lrintl(long double x);
+        long long int llrint(double x);
+        long long int llrintf(float x);
+        long long int llrintl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The lrint and llrint functions round their argument to the nearest integer value,
+ rounding according to the current rounding direction. If the rounded value is outside the
+ range of the return type, the numeric result is unspecified and a domain error or range
+ error may occur.                                                                          *
+<h6>Returns</h6>
+<p><!--para 3-->
+ The lrint and llrint functions return the rounded integer value.
+
+<a name="7.12.9.6" href="#7.12.9.6"><h5>7.12.9.6 The round functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double round(double x);
+        float roundf(float x);
+        long double roundl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The round functions round their argument to the nearest integer value in floating-point
+ format, rounding halfway cases away from zero, regardless of the current rounding
+ direction.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The round functions return the rounded integer value.
+<!--page 246 indent 4-->
+
+<a name="7.12.9.7" href="#7.12.9.7"><h5>7.12.9.7 The lround and llround functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        long int lround(double x);
         long int lroundf(float x);
         long int lroundl(long double x);
         long long int llround(double x);
         long long int llroundf(float x);
-        long long int llroundl(long double x);
+        long long int llroundl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The lround and llround functions round their argument to the nearest integer value,
+ rounding halfway cases away from zero, regardless of the current rounding direction. If
+ the rounded value is outside the range of the return type, the numeric result is unspecified
+ and a domain error or range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The lround and llround functions return the rounded integer value.
+
+<a name="7.12.9.8" href="#7.12.9.8"><h5>7.12.9.8 The trunc functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double trunc(double x);
         float truncf(float x);
-        long double truncl(long double x);
-        double fmod(double x, double y);
-        float fmodf(float x, float y);
-        long double fmodl(long double x, long double y);
-        double remainder(double x, double y);
-        float remainderf(float x, float y);
-        long double remainderl(long double x, long double y);
+        long double truncl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The trunc functions round their argument to the integer value, in floating format,
+ nearest to but no larger in magnitude than the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The trunc functions return the truncated integer value.
+<!--page 247 indent 4-->
+
+<a name="7.12.10" href="#7.12.10"><h4>7.12.10 Remainder functions</h4></a>
+
+<a name="7.12.10.1" href="#7.12.10.1"><h5>7.12.10.1 The fmod functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          double fmod(double x, double y);
+          float fmodf(float x, float y);
+          long double fmodl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fmod functions compute the floating-point remainder of x/y.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fmod functions return the value x - ny, for some integer n such that, if y is nonzero,
+ the result has the same sign as x and magnitude less than the magnitude of y. If y is zero,
+ whether a domain error occurs or the fmod functions return zero is implementation-
+ defined.
+
+<a name="7.12.10.2" href="#7.12.10.2"><h5>7.12.10.2 The remainder functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          double remainder(double x, double y);
+          float remainderf(float x, float y);
+          long double remainderl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The remainder functions compute the remainder x REM y required by IEC 60559.<sup><a href="#note210"><b>210)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The remainder functions return x REM y. If y is zero, whether a domain error occurs
+ or the functions return zero is implementation defined.
+ 
+ 
+ 
+ 
+<!--page 248 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note210">210)</a> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
+ mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
+ | n - x/y | = 1/2, then n is even. Thus, the remainder is always exact. If r = 0, its sign shall be that of
+ x.'' This definition is applicable for all implementations.
+
+
+<a name="7.12.10.3" href="#7.12.10.3"><h5>7.12.10.3 The remquo functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double remquo(double x, double y, int *quo);
         float remquof(float x, float y, int *quo);
         long double remquol(long double x, long double y,
-             int *quo);
+             int *quo);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The remquo functions compute the same remainder as the remainder functions. In
+ the object pointed to by quo they store a value whose sign is the sign of x/y and whose
+ magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where
+ n is an implementation-defined integer greater than or equal to 3.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The remquo functions return x REM y. If y is zero, the value stored in the object
+ pointed to by quo is unspecified and whether a domain error occurs or the functions
+ return zero is implementation defined.
+
+<a name="7.12.11" href="#7.12.11"><h4>7.12.11 Manipulation functions</h4></a>
+
+<a name="7.12.11.1" href="#7.12.11.1"><h5>7.12.11.1 The copysign functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double copysign(double x, double y);
         float copysignf(float x, float y);
-        long double copysignl(long double x, long double y);
-        double nan(const char *tagp);
-        float nanf(const char *tagp);
-        long double nanl(const char *tagp);
-        double nextafter(double x, double y);
-        float nextafterf(float x, float y);
-        long double nextafterl(long double x, long double y);
-        double nexttoward(double x, long double y);
-        float nexttowardf(float x, long double y);
-        long double nexttowardl(long double x, long double y);
-        double fdim(double x, double y);
-        float fdimf(float x, float y);
-        long double fdiml(long double x, long double y);
-        double fmax(double x, double y);
-        float fmaxf(float x, float y);
-        long double fmaxl(long double x, long double y);
-        double fmin(double x, double y);
-        float fminf(float x, float y);
-        long double fminl(long double x, long double y);
-        double fma(double x, double y, double z);
-        float fmaf(float x, float y, float z);
-
-[<a name="p427" href="#p427">page 427</a>] (<a href="#Contents">Contents</a>)
-
-      long double fmal(long double x, long double y,
-           long double z);
-      int isgreater(real-floating x, real-floating y);
-      int isgreaterequal(real-floating x, real-floating y);
-      int isless(real-floating x, real-floating y);
-      int islessequal(real-floating x, real-floating y);
-      int islessgreater(real-floating x, real-floating y);
-      int isunordered(real-floating x, real-floating y);
-<a name="B.12" href="#B.12"><b>B.12 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
-      jmp_buf
-      int setjmp(jmp_buf env);
-      void longjmp(jmp_buf env, int val);
-<a name="B.13" href="#B.13"><b>B.13 Signal handling &lt;signal.h&gt;</b></a>
-      sig_atomic_t   SIG_IGN            SIGILL            SIGTERM
-      SIG_DFL        SIGABRT            SIGINT
-      SIG_ERR        SIGFPE             SIGSEGV
-      void (*signal(int sig, void (*func)(int)))(int);
-      int raise(int sig);
-<a name="B.14" href="#B.14"><b>B.14 Variable arguments &lt;stdarg.h&gt;</b></a>
-      va_list
-      type va_arg(va_list ap, type);
-      void va_copy(va_list dest, va_list src);
-      void va_end(va_list ap);
-      void va_start(va_list ap, parmN);
-<a name="B.15" href="#B.15"><b>B.15 Boolean type and values &lt;stdbool.h&gt;</b></a>
-      bool
-      true
-      false
-      __bool_true_false_are_defined
-
-[<a name="p428" href="#p428">page 428</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.16" href="#B.16"><b>B.16 Common definitions &lt;stddef.h&gt;</b></a>
-        ptrdiff_t       size_t            wchar_t           NULL
-        offsetof(type, member-designator)
-<a name="B.17" href="#B.17"><b>B.17 Integer types &lt;stdint.h&gt;</b></a>
-        intN_t                INT_LEASTN_MIN          PTRDIFF_MAX
-        uintN_t               INT_LEASTN_MAX          SIG_ATOMIC_MIN
-        int_leastN_t          UINT_LEASTN_MAX         SIG_ATOMIC_MAX
-        uint_leastN_t         INT_FASTN_MIN           SIZE_MAX
-        int_fastN_t           INT_FASTN_MAX           WCHAR_MIN
-        uint_fastN_t          UINT_FASTN_MAX          WCHAR_MAX
-        intptr_t              INTPTR_MIN              WINT_MIN
-        uintptr_t             INTPTR_MAX              WINT_MAX
-        intmax_t              UINTPTR_MAX             INTN_C(value)
-        uintmax_t             INTMAX_MIN              UINTN_C(value)
-        INTN_MIN              INTMAX_MAX              INTMAX_C(value)
-        INTN_MAX              UINTMAX_MAX             UINTMAX_C(value)
-        UINTN_MAX             PTRDIFF_MIN
-<a name="B.18" href="#B.18"><b>B.18 Input/output &lt;stdio.h&gt;</b></a>
-        size_t          _IOLBF            FILENAME_MAX      TMP_MAX
-        FILE            _IONBF            L_tmpnam          stderr
-        fpos_t          BUFSIZ            SEEK_CUR          stdin
-        NULL            EOF               SEEK_END          stdout
-        _IOFBF          FOPEN_MAX         SEEK_SET
-        int remove(const char *filename);
-        int rename(const char *old, const char *new);
-        FILE *tmpfile(void);
-        char *tmpnam(char *s);
-        int fclose(FILE *stream);
-        int fflush(FILE *stream);
-        FILE *fopen(const char * restrict filename,
-             const char * restrict mode);
+        long double copysignl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The copysign functions produce a value with the magnitude of x and the sign of y.
+ They produce a NaN (with the sign of y) if x is a NaN. On implementations that
+ represent a signed zero but do not treat negative zero consistently in arithmetic
+ operations, the copysign functions regard the sign of zero as positive.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The copysign functions return a value with the magnitude of x and the sign of y.
+<!--page 249 indent 4-->
+
+<a name="7.12.11.2" href="#7.12.11.2"><h5>7.12.11.2 The nan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double nan(const char *tagp);
+         float nanf(const char *tagp);
+         long double nanl(const char *tagp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The call nan("n-char-sequence") is equivalent to strtod("NAN(n-char-
+ sequence)",     (char**)       NULL); the call nan("") is equivalent to
+ strtod("NAN()", (char**) NULL). If tagp does not point to an n-char
+ sequence or an empty string, the call is equivalent to strtod("NAN", (char**)
+ NULL). Calls to nanf and nanl are equivalent to the corresponding calls to strtof
+ and strtold.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The nan functions return a quiet NaN, if available, with content indicated through tagp.
+ If the implementation does not support quiet NaNs, the functions return zero.
+ Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>).
+
+<a name="7.12.11.3" href="#7.12.11.3"><h5>7.12.11.3 The nextafter functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double nextafter(double x, double y);
+         float nextafterf(float x, float y);
+         long double nextafterl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The nextafter functions determine the next representable value, in the type of the
+ function, after x in the direction of y, where x and y are first converted to the type of the
+ function.<sup><a href="#note211"><b>211)</b></a></sup> The nextafter functions return y if x equals y. A range error may occur
+ if the magnitude of x is the largest finite value representable in the type and the result is
+ infinite or not representable in the type.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The nextafter functions return the next representable value in the specified format
+ after x in the direction of y.
+ 
+ 
+<!--page 250 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note211">211)</a> The argument values are converted to the type of the function, even by a macro implementation of the
+ function.
+
+
+<a name="7.12.11.4" href="#7.12.11.4"><h5>7.12.11.4 The nexttoward functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double nexttoward(double x, long double y);
+         float nexttowardf(float x, long double y);
+         long double nexttowardl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The nexttoward functions are equivalent to the nextafter functions except that the
+ second parameter has type long double and the functions return y converted to the
+ type of the function if x equals y.<sup><a href="#note212"><b>212)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note212">212)</a> The result of the nexttoward functions is determined in the type of the function, without loss of
+ range or precision in a floating second argument.
+
+
+<a name="7.12.12" href="#7.12.12"><h4>7.12.12 Maximum, minimum, and positive difference functions</h4></a>
+
+<a name="7.12.12.1" href="#7.12.12.1"><h5>7.12.12.1 The fdim functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fdim(double x, double y);
+         float fdimf(float x, float y);
+         long double fdiml(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fdim functions determine the positive difference between their arguments:
+<pre>
+       ???x - y if x &gt; y
+       ???
+       ???+0     if x &lt;= y</pre>
+ A range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fdim functions return the positive difference value.
+
+<a name="7.12.12.2" href="#7.12.12.2"><h5>7.12.12.2 The fmax functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fmax(double x, double y);
+         float fmaxf(float x, float y);
+         long double fmaxl(long double x, long double y);</pre>
+ 
+ 
+ 
+<!--page 251 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The fmax functions determine the maximum numeric value of their arguments.<sup><a href="#note213"><b>213)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fmax functions return the maximum numeric value of their arguments.
+
+<h6>footnotes</h6>
+<p><a name="note213">213)</a> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
+ fmax functions choose the numeric value. See <a href="#F.9.9.2">F.9.9.2</a>.
+
+
+<a name="7.12.12.3" href="#7.12.12.3"><h5>7.12.12.3 The fmin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fmin(double x, double y);
+         float fminf(float x, float y);
+         long double fminl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fmin functions determine the minimum numeric value of their arguments.<sup><a href="#note214"><b>214)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fmin functions return the minimum numeric value of their arguments.
+
+<h6>footnotes</h6>
+<p><a name="note214">214)</a> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
+
+
+<a name="7.12.13" href="#7.12.13"><h4>7.12.13 Floating multiply-add</h4></a>
+
+<a name="7.12.13.1" href="#7.12.13.1"><h5>7.12.13.1 The fma functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fma(double x, double y, double z);
+         float fmaf(float x, float y, float z);
+         long double fmal(long double x, long double y,
+              long double z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fma functions compute (x x y) + z, rounded as one ternary operation: they compute
+ the value (as if) to infinite precision and round once to the result format, according to the
+ current rounding mode. A range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fma functions return (x x y) + z, rounded as one ternary operation.
+ 
+ 
+ 
+ 
+<!--page 252 indent 4-->
+
+<a name="7.12.14" href="#7.12.14"><h4>7.12.14 Comparison macros</h4></a>
+<p><!--para 1-->
+ The relational and equality operators support the usual mathematical relationships
+ between numeric values. For any ordered pair of numeric values exactly one of the
+ relationships -- less, greater, and equal -- is true. Relational operators may raise the
+ ''invalid'' floating-point exception when argument values are NaNs. For a NaN and a
+ numeric value, or for two NaNs, just the unordered relationship is true.<sup><a href="#note215"><b>215)</b></a></sup> The following
+ subclauses provide macros that are quiet (non floating-point exception raising) versions
+ of the relational operators, and other comparison macros that facilitate writing efficient
+ code that accounts for NaNs without suffering the ''invalid'' floating-point exception. In
+ the synopses in this subclause, real-floating indicates that the argument shall be an
+ expression of real floating type.
+
+<h6>footnotes</h6>
+<p><a name="note215">215)</a> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
+ the operands compare unordered, as an error indicator for programs written without consideration of
+ NaNs; the result in these cases is false.
+
+
+<a name="7.12.14.1" href="#7.12.14.1"><h5>7.12.14.1 The isgreater macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          int isgreater(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isgreater macro determines whether its first argument is greater than its second
+ argument. The value of isgreater(x, y) is always equal to (x) &gt; (y); however,
+ unlike (x) &gt; (y), isgreater(x, y) does not raise the ''invalid'' floating-point
+ exception when x and y are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isgreater macro returns the value of (x) &gt; (y).
+
+<a name="7.12.14.2" href="#7.12.14.2"><h5>7.12.14.2 The isgreaterequal macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          int isgreaterequal(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isgreaterequal macro determines whether its first argument is greater than or
+ equal to its second argument. The value of isgreaterequal(x, y) is always equal
+ to (x) &gt;= (y); however, unlike (x) &gt;= (y), isgreaterequal(x, y) does
+ not raise the ''invalid'' floating-point exception when x and y are unordered.
+ 
+ 
+ 
+<!--page 253 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isgreaterequal macro returns the value of (x) &gt;= (y).
+
+<a name="7.12.14.3" href="#7.12.14.3"><h5>7.12.14.3 The isless macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        int isless(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isless macro determines whether its first argument is less than its second
+ argument. The value of isless(x, y) is always equal to (x) &lt; (y); however,
+ unlike (x) &lt; (y), isless(x, y) does not raise the ''invalid'' floating-point
+ exception when x and y are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isless macro returns the value of (x) &lt; (y).
+
+<a name="7.12.14.4" href="#7.12.14.4"><h5>7.12.14.4 The islessequal macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        int islessequal(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The islessequal macro determines whether its first argument is less than or equal to
+ its second argument. The value of islessequal(x, y) is always equal to
+ (x) &lt;= (y); however, unlike (x) &lt;= (y), islessequal(x, y) does not raise
+ the ''invalid'' floating-point exception when x and y are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The islessequal macro returns the value of (x) &lt;= (y).
+
+<a name="7.12.14.5" href="#7.12.14.5"><h5>7.12.14.5 The islessgreater macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        int islessgreater(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The islessgreater macro determines whether its first argument is less than or
+ greater than its second argument. The islessgreater(x, y) macro is similar to
+ (x) &lt; (y) || (x) &gt; (y); however, islessgreater(x, y) does not raise
+ the ''invalid'' floating-point exception when x and y are unordered (nor does it evaluate x
+ and y twice).
+<!--page 254 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The islessgreater macro returns the value of (x) &lt; (y) || (x) &gt; (y).
+
+<a name="7.12.14.6" href="#7.12.14.6"><h5>7.12.14.6 The isunordered macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+       #include &lt;math.h&gt;
+       int isunordered(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isunordered macro determines whether its arguments are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isunordered macro returns 1 if its arguments are unordered and 0 otherwise.
+<!--page 255 indent 4-->
+
+<a name="7.13" href="#7.13"><h3>7.13 Nonlocal jumps <setjmp.h></h3></a>
+<p><!--para 1-->
+ The header &lt;setjmp.h&gt; defines the macro setjmp, and declares one function and
+ one type, for bypassing the normal function call and return discipline.<sup><a href="#note216"><b>216)</b></a></sup>
+<p><!--para 2-->
+ The type declared is
+<pre>
+         jmp_buf</pre>
+ which is an array type suitable for holding the information needed to restore a calling
+ environment. The environment of a call to the setjmp macro consists of information
+ sufficient for a call to the longjmp function to return execution to the correct block and
+ invocation of that block, were it called recursively. It does not include the state of the
+ floating-point status flags, of open files, or of any other component of the abstract
+ machine.
+<p><!--para 3-->
+ It is unspecified whether setjmp is a macro or an identifier declared with external
+ linkage. If a macro definition is suppressed in order to access an actual function, or a
+ program defines an external identifier with the name setjmp, the behavior is undefined.
+
+<h6>footnotes</h6>
+<p><a name="note216">216)</a> These functions are useful for dealing with unusual conditions encountered in a low-level function of
+ a program.
+
+
+<a name="7.13.1" href="#7.13.1"><h4>7.13.1 Save calling environment</h4></a>
+
+<a name="7.13.1.1" href="#7.13.1.1"><h5>7.13.1.1 The setjmp macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;setjmp.h&gt;
+         int setjmp(jmp_buf env);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The setjmp macro saves its calling environment in its jmp_buf argument for later use
+ by the longjmp function.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the return is from a direct invocation, the setjmp macro returns the value zero. If the
+ return is from a call to the longjmp function, the setjmp macro returns a nonzero
+ value.
+ Environmental limits
+<p><!--para 4-->
+ An invocation of the setjmp macro shall appear only in one of the following contexts:
+<ul>
+<li>  the entire controlling expression of a selection or iteration statement;
+<li>  one operand of a relational or equality operator with the other operand an integer
+ constant expression, with the resulting expression being the entire controlling
+ 
+ 
+<!--page 256 indent 4-->
+   expression of a selection or iteration statement;
+<li>  the operand of a unary ! operator with the resulting expression being the entire
+ controlling expression of a selection or iteration statement; or
+<li>  the entire expression of an expression statement (possibly cast to void).
+</ul>
+<p><!--para 5-->
+ If the invocation appears in any other context, the behavior is undefined.
+
+<a name="7.13.2" href="#7.13.2"><h4>7.13.2 Restore calling environment</h4></a>
+
+<a name="7.13.2.1" href="#7.13.2.1"><h5>7.13.2.1 The longjmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;setjmp.h&gt;
+          void longjmp(jmp_buf env, int val);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The longjmp function restores the environment saved by the most recent invocation of
+ the setjmp macro in the same invocation of the program with the corresponding
+ jmp_buf argument. If there has been no such invocation, or if the function containing
+ the invocation of the setjmp macro has terminated execution<sup><a href="#note217"><b>217)</b></a></sup> in the interim, or if the
+ invocation of the setjmp macro was within the scope of an identifier with variably
+ modified type and execution has left that scope in the interim, the behavior is undefined.
+<p><!--para 3-->
+ All accessible objects have values, and all other components of the abstract machine<sup><a href="#note218"><b>218)</b></a></sup>
+ have state, as of the time the longjmp function was called, except that the values of
+ objects of automatic storage duration that are local to the function containing the
+ invocation of the corresponding setjmp macro that do not have volatile-qualified type
+ and have been changed between the setjmp invocation and longjmp call are
+ indeterminate.
+<h6>Returns</h6>
+<p><!--para 4-->
+ After longjmp is completed, program execution continues as if the corresponding
+ invocation of the setjmp macro had just returned the value specified by val. The
+ longjmp function cannot cause the setjmp macro to return the value 0; if val is 0,
+ the setjmp macro returns the value 1.
+<p><!--para 5-->
+ EXAMPLE The longjmp function that returns control back to the point of the setjmp invocation
+ might cause memory associated with a variable length array object to be squandered.
+ 
+ 
+ 
+ 
+<!--page 257 indent -1-->
+<!--page 258 indent 4-->
+<pre>
+        #include &lt;setjmp.h&gt;
+        jmp_buf buf;
+        void g(int n);
+        void h(int n);
+        int n = 6;
+        void f(void)
+        {
+              int x[n];          // valid: f is not terminated
+              setjmp(buf);
+              g(n);
+        }
+        void g(int n)
+        {
+              int a[n];          // a may remain allocated
+              h(n);
+        }
+        void h(int n)
+        {
+              int b[n];          // b may remain allocated
+              longjmp(buf, 2);   // might cause memory loss
+        }</pre>
+
+<h6>footnotes</h6>
+<p><a name="note217">217)</a> For example, by executing a return statement or because another longjmp call has caused a
+ transfer to a setjmp invocation in a function earlier in the set of nested calls.
+
+<p><a name="note218">218)</a> This includes, but is not limited to, the floating-point status flags and the state of open files.
+
+
+<a name="7.14" href="#7.14"><h3>7.14 Signal handling <signal.h></h3></a>
+<p><!--para 1-->
+ The header &lt;signal.h&gt; declares a type and two functions and defines several macros,
+ for handling various signals (conditions that may be reported during program execution).
+<p><!--para 2-->
+ The type defined is
+<pre>
+         sig_atomic_t</pre>
+ which is the (possibly volatile-qualified) integer type of an object that can be accessed as
+ an atomic entity, even in the presence of asynchronous interrupts.
+<p><!--para 3-->
+ The macros defined are
+<pre>
+         SIG_DFL
+         SIG_ERR
+         SIG_IGN</pre>
+ which expand to constant expressions with distinct values that have type compatible with
+ the second argument to, and the return value of, the signal function, and whose values
+ compare unequal to the address of any declarable function; and the following, which
+ expand to positive integer constant expressions with type int and distinct values that are
+ the signal numbers, each corresponding to the specified condition:
+<p><!--para 4-->
+<pre>
+         SIGABRT abnormal termination, such as is initiated by the abort function
+         SIGFPE         an erroneous arithmetic operation, such as zero divide or an operation
+                        resulting in overflow
+         SIGILL         detection of an invalid function image, such as an invalid instruction
+         SIGINT         receipt of an interactive attention signal
+         SIGSEGV an invalid access to storage
+         SIGTERM a termination request sent to the program</pre>
+ An implementation need not generate any of these signals, except as a result of explicit
+ calls to the raise function. Additional signals and pointers to undeclarable functions,
+ with macro definitions beginning, respectively, with the letters SIG and an uppercase
+ letter or with SIG_ and an uppercase letter,<sup><a href="#note219"><b>219)</b></a></sup> may also be specified by the
+ implementation. The complete set of signals, their semantics, and their default handling
+ is implementation-defined; all signal numbers shall be positive.
+ 
+ 
+ 
+ 
+<!--page 259 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note219">219)</a> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>). The names of the signal numbers reflect the following terms
+ (respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
+ and termination.
+
+
+<a name="7.14.1" href="#7.14.1"><h4>7.14.1 Specify signal handling</h4></a>
+
+<a name="7.14.1.1" href="#7.14.1.1"><h5>7.14.1.1 The signal function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;signal.h&gt;
+         void (*signal(int sig, void (*func)(int)))(int);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The signal function chooses one of three ways in which receipt of the signal number
+ sig is to be subsequently handled. If the value of func is SIG_DFL, default handling
+ for that signal will occur. If the value of func is SIG_IGN, the signal will be ignored.
+ Otherwise, func shall point to a function to be called when that signal occurs. An
+ invocation of such a function because of a signal, or (recursively) of any further functions
+ called by that invocation (other than functions in the standard library), is called a signal
+ handler.
+<p><!--para 3-->
+ When a signal occurs and func points to a function, it is implementation-defined
+ whether the equivalent of signal(sig, SIG_DFL); is executed or the
+ implementation prevents some implementation-defined set of signals (at least including
+ sig) from occurring until the current signal handling has completed; in the case of
+ SIGILL, the implementation may alternatively define that no action is taken. Then the
+ equivalent of (*func)(sig); is executed. If and when the function returns, if the
+ value of sig is SIGFPE, SIGILL, SIGSEGV, or any other implementation-defined
+ value corresponding to a computational exception, the behavior is undefined; otherwise
+ the program will resume execution at the point it was interrupted.
+<p><!--para 4-->
+ If the signal occurs as the result of calling the abort or raise function, the signal
+ handler shall not call the raise function.
+<p><!--para 5-->
+ If the signal occurs other than as the result of calling the abort or raise function, the
+ behavior is undefined if the signal handler refers to any object with static storage duration
+ other than by assigning a value to an object declared as volatile sig_atomic_t, or
+ the signal handler calls any function in the standard library other than the abort
+ function, the _Exit function, or the signal function with the first argument equal to
+ the signal number corresponding to the signal that caused the invocation of the handler.
+ Furthermore, if such a call to the signal function results in a SIG_ERR return, the
+ value of errno is indeterminate.<sup><a href="#note220"><b>220)</b></a></sup>
+<p><!--para 6-->
+ At program startup, the equivalent of
+<pre>
+         signal(sig, SIG_IGN);</pre>
+ 
+ 
+<!--page 260 indent 4-->
+ may be executed for some signals selected in an implementation-defined manner; the
+ equivalent of
+<pre>
+        signal(sig, SIG_DFL);</pre>
+ is executed for all other signals defined by the implementation.
+<p><!--para 7-->
+ The implementation shall behave as if no library function calls the signal function.
+<h6>Returns</h6>
+<p><!--para 8-->
+ If the request can be honored, the signal function returns the value of func for the
+ most recent successful call to signal for the specified signal sig. Otherwise, a value of
+ SIG_ERR is returned and a positive value is stored in errno.
+ Forward references: the abort function (<a href="#7.20.4.1">7.20.4.1</a>), the exit function (<a href="#7.20.4.3">7.20.4.3</a>), the
+ _Exit function (<a href="#7.20.4.4">7.20.4.4</a>).
+
+<h6>footnotes</h6>
+<p><a name="note220">220)</a> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
+
+
+<a name="7.14.2" href="#7.14.2"><h4>7.14.2 Send signal</h4></a>
+
+<a name="7.14.2.1" href="#7.14.2.1"><h5>7.14.2.1 The raise function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;signal.h&gt;
+        int raise(int sig);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The raise function carries out the actions described in <a href="#7.14.1.1">7.14.1.1</a> for the signal sig. If a
+ signal handler is called, the raise function shall not return until after the signal handler
+ does.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The raise function returns zero if successful, nonzero if unsuccessful.
+<!--page 261 indent 4-->
+
+<a name="7.15" href="#7.15"><h3>7.15 Variable arguments <stdarg.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdarg.h&gt; declares a type and defines four macros, for advancing
+ through a list of arguments whose number and types are not known to the called function
+ when it is translated.
+<p><!--para 2-->
+ A function may be called with a variable number of arguments of varying types. As
+ described in <a href="#6.9.1">6.9.1</a>, its parameter list contains one or more parameters. The rightmost
+ parameter plays a special role in the access mechanism, and will be designated parmN in
+ this description.
+<p><!--para 3-->
+ The type declared is
+<pre>
+         va_list</pre>
+ which is an object type suitable for holding information needed by the macros
+ va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
+ desired, the called function shall declare an object (generally referred to as ap in this
+ subclause) having type va_list. The object ap may be passed as an argument to
+ another function; if that function invokes the va_arg macro with parameter ap, the
+ value of ap in the calling function is indeterminate and shall be passed to the va_end
+ macro prior to any further reference to ap.<sup><a href="#note221"><b>221)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note221">221)</a> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
+ case the original function may make further use of the original list after the other function returns.
+
+
+<a name="7.15.1" href="#7.15.1"><h4>7.15.1 Variable argument list access macros</h4></a>
+<p><!--para 1-->
+ The va_start and va_arg macros described in this subclause shall be implemented
+ as macros, not functions. It is unspecified whether va_copy and va_end are macros or
+ identifiers declared with external linkage. If a macro definition is suppressed in order to
+ access an actual function, or a program defines an external identifier with the same name,
+ the behavior is undefined. Each invocation of the va_start and va_copy macros
+ shall be matched by a corresponding invocation of the va_end macro in the same
+ function.
+
+<a name="7.15.1.1" href="#7.15.1.1"><h5>7.15.1.1 The va_arg macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         type va_arg(va_list ap, type);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_arg macro expands to an expression that has the specified type and the value of
+ the next argument in the call. The parameter ap shall have been initialized by the
+ va_start or va_copy macro (without an intervening invocation of the va_end
+ 
+<!--page 262 indent 4-->
+ macro for the same ap). Each invocation of the va_arg macro modifies ap so that the
+ values of successive arguments are returned in turn. The parameter type shall be a type
+ name specified such that the type of a pointer to an object that has the specified type can
+ be obtained simply by postfixing a * to type. If there is no actual next argument, or if
+ type is not compatible with the type of the actual next argument (as promoted according
+ to the default argument promotions), the behavior is undefined, except for the following
+ cases:
+<ul>
+<li>  one type is a signed integer type, the other type is the corresponding unsigned integer
+ type, and the value is representable in both types;
+<li>  one type is pointer to void and the other is a pointer to a character type.
+</ul>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The first invocation of the va_arg macro after that of the va_start macro returns the
+ value of the argument after that specified by parmN . Successive invocations return the
+ values of the remaining arguments in succession.
+
+<a name="7.15.1.2" href="#7.15.1.2"><h5>7.15.1.2 The va_copy macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        void va_copy(va_list dest, va_list src);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_copy macro initializes dest as a copy of src, as if the va_start macro had
+ been applied to dest followed by the same sequence of uses of the va_arg macro as
+ had previously been used to reach the present state of src. Neither the va_copy nor
+ va_start macro shall be invoked to reinitialize dest without an intervening
+ invocation of the va_end macro for the same dest.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The va_copy macro returns no value.
+
+<a name="7.15.1.3" href="#7.15.1.3"><h5>7.15.1.3 The va_end macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        void va_end(va_list ap);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_end macro facilitates a normal return from the function whose variable
+ argument list was referred to by the expansion of the va_start macro, or the function
+ containing the expansion of the va_copy macro, that initialized the va_list ap. The
+ va_end macro may modify ap so that it is no longer usable (without being reinitialized
+<!--page 263 indent 4-->
+ by the va_start or va_copy macro). If there is no corresponding invocation of the
+ va_start or va_copy macro, or if the va_end macro is not invoked before the
+ return, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The va_end macro returns no value.
+
+<a name="7.15.1.4" href="#7.15.1.4"><h5>7.15.1.4 The va_start macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         void va_start(va_list ap, parmN);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_start macro shall be invoked before any access to the unnamed arguments.
+<p><!--para 3-->
+ The va_start macro initializes ap for subsequent use by the va_arg and va_end
+ macros. Neither the va_start nor va_copy macro shall be invoked to reinitialize ap
+ without an intervening invocation of the va_end macro for the same ap.
+<p><!--para 4-->
+ The parameter parmN is the identifier of the rightmost parameter in the variable
+ parameter list in the function definition (the one just before the , ...). If the parameter
+ parmN is declared with the register storage class, with a function or array type, or
+ with a type that is not compatible with the type that results after application of the default
+ argument promotions, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The va_start macro returns no value.
+<p><!--para 6-->
+ EXAMPLE 1 The function f1 gathers into an array a list of arguments that are pointers to strings (but not
+ more than MAXARGS arguments), then passes the array as a single argument to function f2. The number of
+ pointers is specified by the first argument to f1.
+<!--page 264 indent 4-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #define MAXARGS   31
+         void f1(int n_ptrs, ...)
+         {
+               va_list ap;
+               char *array[MAXARGS];
+               int ptr_no = 0;
+                   if (n_ptrs &gt; MAXARGS)
+                         n_ptrs = MAXARGS;
+                   va_start(ap, n_ptrs);
+                   while (ptr_no &lt; n_ptrs)
+                         array[ptr_no++] = va_arg(ap, char *);
+                   va_end(ap);
+                   f2(n_ptrs, array);
+          }</pre>
+ Each call to f1 is required to have visible the definition of the function or a declaration such as
+<pre>
+          void f1(int, ...);</pre>
+ 
+<p><!--para 7-->
+ EXAMPLE 2 The function f3 is similar, but saves the status of the variable argument list after the
+ indicated number of arguments; after f2 has been called once with the whole list, the trailing part of the list
+ is gathered again and passed to function f4.
+<!--page 265 indent 4-->
+<pre>
+          #include &lt;stdarg.h&gt;
+          #define MAXARGS 31
+          void f3(int n_ptrs, int f4_after, ...)
+          {
+                va_list ap, ap_save;
+                char *array[MAXARGS];
+                int ptr_no = 0;
+                if (n_ptrs &gt; MAXARGS)
+                      n_ptrs = MAXARGS;
+                va_start(ap, f4_after);
+                while (ptr_no &lt; n_ptrs) {
+                      array[ptr_no++] = va_arg(ap, char *);
+                      if (ptr_no == f4_after)
+                            va_copy(ap_save, ap);
+                }
+                va_end(ap);
+                f2(n_ptrs, array);
+                   // Now process the saved copy.
+                   n_ptrs -= f4_after;
+                   ptr_no = 0;
+                   while (ptr_no &lt; n_ptrs)
+                         array[ptr_no++] = va_arg(ap_save, char *);
+                   va_end(ap_save);
+                   f4(n_ptrs, array);
+          }</pre>
+
+<a name="7.16" href="#7.16"><h3>7.16 Boolean type and values <stdbool.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdbool.h&gt; defines four macros.
+<p><!--para 2-->
+ The macro
+<pre>
+          bool</pre>
+ expands to _Bool.
+<p><!--para 3-->
+ The remaining three macros are suitable for use in #if preprocessing directives. They
+ are
+<pre>
+          true</pre>
+ which expands to the integer constant 1,
+<pre>
+          false</pre>
+ which expands to the integer constant 0, and
+<pre>
+          __bool_true_false_are_defined</pre>
+ which expands to the integer constant 1.
+<p><!--para 4-->
+ Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+ redefine the macros bool, true, and false.<sup><a href="#note222"><b>222)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 266 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note222">222)</a> See ''future library directions'' (<a href="#7.26.7">7.26.7</a>).
+
+
+<a name="7.17" href="#7.17"><h3>7.17 Common definitions <stddef.h></h3></a>
+<p><!--para 1-->
+ The following types and macros are defined in the standard header &lt;stddef.h&gt;. Some
+ are also defined in other headers, as noted in their respective subclauses.
+<p><!--para 2-->
+ The types are
+<pre>
+        ptrdiff_t</pre>
+ which is the signed integer type of the result of subtracting two pointers;
+<pre>
+        size_t</pre>
+ which is the unsigned integer type of the result of the sizeof operator; and
+<pre>
+        wchar_t</pre>
+ which is an integer type whose range of values can represent distinct codes for all
+ members of the largest extended character set specified among the supported locales; the
+ null character shall have the code value zero. Each member of the basic character set
+ shall have a code value equal to its value when used as the lone character in an integer
+ character      constant     if     an      implementation      does      not      define
+ __STDC_MB_MIGHT_NEQ_WC__.
+<p><!--para 3-->
+ The macros are
+<pre>
+        NULL</pre>
+ which expands to an implementation-defined null pointer constant; and
+<pre>
+        offsetof(type, member-designator)</pre>
+ which expands to an integer constant expression that has type size_t, the value of
+ which is the offset in bytes, to the structure member (designated by member-designator),
+ from the beginning of its structure (designated by type). The type and member designator
+ shall be such that given
+<pre>
+        static type t;</pre>
+ then the expression &amp;(t.member-designator) evaluates to an address constant. (If the
+ specified member is a bit-field, the behavior is undefined.)
+ Recommended practice
+<p><!--para 4-->
+ The types used for size_t and ptrdiff_t should not have an integer conversion rank
+ greater than that of signed long int unless the implementation supports objects
+ large enough to make this necessary.
+ Forward references: localization (<a href="#7.11">7.11</a>).
+<!--page 267 indent 4-->
+
+<a name="7.18" href="#7.18"><h3>7.18 Integer types <stdint.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdint.h&gt; declares sets of integer types having specified widths, and
+ defines corresponding sets of macros.<sup><a href="#note223"><b>223)</b></a></sup> It also defines macros that specify limits of
+ integer types corresponding to types defined in other standard headers.
+<p><!--para 2-->
+ Types are defined in the following categories:
+<ul>
+<li>  integer types having certain exact widths;
+<li>  integer types having at least certain specified widths;
+<li>  fastest integer types having at least certain specified widths;
+<li>  integer types wide enough to hold pointers to objects;
+<li>  integer types having greatest width.
+</ul>
+ (Some of these types may denote the same type.)
+<p><!--para 3-->
+ Corresponding macros specify limits of the declared types and construct suitable
+ constants.
+<p><!--para 4-->
+ For each type described herein that the implementation provides,<sup><a href="#note224"><b>224)</b></a></sup> &lt;stdint.h&gt; shall
+ declare that typedef name and define the associated macros. Conversely, for each type
+ described herein that the implementation does not provide, &lt;stdint.h&gt; shall not
+ declare that typedef name nor shall it define the associated macros. An implementation
+ shall provide those types described as ''required'', but need not provide any of the others
+ (described as ''optional'').
+
+<h6>footnotes</h6>
+<p><a name="note223">223)</a> See ''future library directions'' (<a href="#7.26.8">7.26.8</a>).
+
+<p><a name="note224">224)</a> Some of these types may denote implementation-defined extended integer types.
+
+
+<a name="7.18.1" href="#7.18.1"><h4>7.18.1 Integer types</h4></a>
+<p><!--para 1-->
+ When typedef names differing only in the absence or presence of the initial u are defined,
+ they shall denote corresponding signed and unsigned types as described in <a href="#6.2.5">6.2.5</a>; an
+ implementation providing one of these corresponding types shall also provide the other.
+<p><!--para 2-->
+ In the following descriptions, the symbol N represents an unsigned decimal integer with
+ no leading zeros (e.g., 8 or 24, but not 04 or 048).
+ 
+ 
+ 
+ 
+<!--page 268 indent 4-->
+
+<a name="7.18.1.1" href="#7.18.1.1"><h5>7.18.1.1 Exact-width integer types</h5></a>
+<p><!--para 1-->
+ The typedef name intN_t designates a signed integer type with width N , no padding
+ bits, and a two's complement representation. Thus, int8_t denotes a signed integer
+ type with a width of exactly 8 bits.
+<p><!--para 2-->
+ The typedef name uintN_t designates an unsigned integer type with width N . Thus,
+ uint24_t denotes an unsigned integer type with a width of exactly 24 bits.
+<p><!--para 3-->
+ These types are optional. However, if an implementation provides integer types with
+ widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a
+ two's complement representation, it shall define the corresponding typedef names.
+
+<a name="7.18.1.2" href="#7.18.1.2"><h5>7.18.1.2 Minimum-width integer types</h5></a>
+<p><!--para 1-->
+ The typedef name int_leastN_t designates a signed integer type with a width of at
+ least N , such that no signed integer type with lesser size has at least the specified width.
+ Thus, int_least32_t denotes a signed integer type with a width of at least 32 bits.
+<p><!--para 2-->
+ The typedef name uint_leastN_t designates an unsigned integer type with a width
+ of at least N , such that no unsigned integer type with lesser size has at least the specified
+ width. Thus, uint_least16_t denotes an unsigned integer type with a width of at
+ least 16 bits.
+<p><!--para 3-->
+ The following types are required:
+<pre>
+          int_least8_t                                      uint_least8_t
+          int_least16_t                                     uint_least16_t
+          int_least32_t                                     uint_least32_t
+          int_least64_t                                     uint_least64_t</pre>
+ All other types of this form are optional.
+
+<a name="7.18.1.3" href="#7.18.1.3"><h5>7.18.1.3 Fastest minimum-width integer types</h5></a>
+<p><!--para 1-->
+ Each of the following types designates an integer type that is usually fastest<sup><a href="#note225"><b>225)</b></a></sup> to operate
+ with among all integer types that have at least the specified width.
+<p><!--para 2-->
+ The typedef name int_fastN_t designates the fastest signed integer type with a width
+ of at least N . The typedef name uint_fastN_t designates the fastest unsigned integer
+ type with a width of at least N .
+ 
+ 
+ 
+ 
+<!--page 269 indent 4-->
+<p><!--para 3-->
+ The following types are required:
+<pre>
+        int_fast8_t                                 uint_fast8_t
+        int_fast16_t                                uint_fast16_t
+        int_fast32_t                                uint_fast32_t
+        int_fast64_t                                uint_fast64_t</pre>
+ All other types of this form are optional.
+
+<h6>footnotes</h6>
+<p><a name="note225">225)</a> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
+ grounds for choosing one type over another, it will simply pick some integer type satisfying the
+ signedness and width requirements.
+
+
+<a name="7.18.1.4" href="#7.18.1.4"><h5>7.18.1.4 Integer types capable of holding object pointers</h5></a>
+<p><!--para 1-->
+ The following type designates a signed integer type with the property that any valid
+ pointer to void can be converted to this type, then converted back to pointer to void,
+ and the result will compare equal to the original pointer:
+<pre>
+        intptr_t</pre>
+ The following type designates an unsigned integer type with the property that any valid
+ pointer to void can be converted to this type, then converted back to pointer to void,
+ and the result will compare equal to the original pointer:
+<pre>
+        uintptr_t</pre>
+ These types are optional.
+
+<a name="7.18.1.5" href="#7.18.1.5"><h5>7.18.1.5 Greatest-width integer types</h5></a>
+<p><!--para 1-->
+ The following type designates a signed integer type capable of representing any value of
+ any signed integer type:
+<pre>
+        intmax_t</pre>
+ The following type designates an unsigned integer type capable of representing any value
+ of any unsigned integer type:
+<pre>
+        uintmax_t</pre>
+ These types are required.
+
+<a name="7.18.2" href="#7.18.2"><h4>7.18.2 Limits of specified-width integer types</h4></a>
+<p><!--para 1-->
+ The following object-like macros<sup><a href="#note226"><b>226)</b></a></sup> specify the minimum and maximum limits of the
+ types declared in &lt;stdint.h&gt;. Each macro name corresponds to a similar type name in
+ <a href="#7.18.1">7.18.1</a>.
+<p><!--para 2-->
+ Each instance of any defined macro shall be replaced by a constant expression suitable
+ for use in #if preprocessing directives, and this expression shall have the same type as
+ would an expression that is an object of the corresponding type converted according to
+ 
+<!--page 270 indent 4-->
+ the integer promotions. Its implementation-defined value shall be equal to or greater in
+ magnitude (absolute value) than the corresponding value given below, with the same sign,
+ except where stated to be exactly the given value.
+
+<h6>footnotes</h6>
+<p><a name="note226">226)</a> C++ implementations should define these macros only when __STDC_LIMIT_MACROS is defined
+ before &lt;stdint.h&gt; is included.
+
+
+<a name="7.18.2.1" href="#7.18.2.1"><h5>7.18.2.1 Limits of exact-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum values of exact-width signed integer types
+  INTN_MIN                                    exactly -(2 N -1 )
+<li>  maximum values of exact-width signed integer types
+  INTN_MAX                                    exactly 2 N -1 - 1
+<li>  maximum values of exact-width unsigned integer types
+  UINTN_MAX                                   exactly 2 N - 1
+</ul>
+
+<a name="7.18.2.2" href="#7.18.2.2"><h5>7.18.2.2 Limits of minimum-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum values of minimum-width signed integer types
+  INT_LEASTN_MIN                                      -(2 N -1 - 1)
+<li>  maximum values of minimum-width signed integer types
+  INT_LEASTN_MAX                                      2 N -1 - 1
+<li>  maximum values of minimum-width unsigned integer types
+  UINT_LEASTN_MAX                                     2N - 1
+</ul>
+
+<a name="7.18.2.3" href="#7.18.2.3"><h5>7.18.2.3 Limits of fastest minimum-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum values of fastest minimum-width signed integer types
+  INT_FASTN_MIN                                       -(2 N -1 - 1)
+<li>  maximum values of fastest minimum-width signed integer types
+  INT_FASTN_MAX                                       2 N -1 - 1
+<li>  maximum values of fastest minimum-width unsigned integer types
+  UINT_FASTN_MAX                                      2N - 1
+</ul>
+
+<a name="7.18.2.4" href="#7.18.2.4"><h5>7.18.2.4 Limits of integer types capable of holding object pointers</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum value of pointer-holding signed integer type
+<pre>
+     INTPTR_MIN                                       -(215 - 1)</pre>
+<li>  maximum value of pointer-holding signed integer type
+<!--page 271 indent 4-->
+<pre>
+     INTPTR_MAX                                       215 - 1</pre>
+<li>  maximum value of pointer-holding unsigned integer type
+   UINTPTR_MAX                                                   216 - 1
+</ul>
+
+<a name="7.18.2.5" href="#7.18.2.5"><h5>7.18.2.5 Limits of greatest-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum value of greatest-width signed integer type
+   INTMAX_MIN                                                    -(263 - 1)
+<li>  maximum value of greatest-width signed integer type
+   INTMAX_MAX                                                    263 - 1
+<li>  maximum value of greatest-width unsigned integer type
+   UINTMAX_MAX                                                   264 - 1
+</ul>
+
+<a name="7.18.3" href="#7.18.3"><h4>7.18.3 Limits of other integer types</h4></a>
+<p><!--para 1-->
+ The following object-like macros<sup><a href="#note227"><b>227)</b></a></sup> specify the minimum and maximum limits of
+ integer types corresponding to types defined in other standard headers.
+<p><!--para 2-->
+ Each instance of these macros shall be replaced by a constant expression suitable for use
+ in #if preprocessing directives, and this expression shall have the same type as would an
+ expression that is an object of the corresponding type converted according to the integer
+ promotions. Its implementation-defined value shall be equal to or greater in magnitude
+ (absolute value) than the corresponding value given below, with the same sign. An
+ implementation shall define only the macros corresponding to those typedef names it
+ actually provides.<sup><a href="#note228"><b>228)</b></a></sup>
+<ul>
+<li>  limits of ptrdiff_t
+   PTRDIFF_MIN                                                 -65535
+   PTRDIFF_MAX                                                 +65535
+<li>  limits of sig_atomic_t
+   SIG_ATOMIC_MIN                                              see below
+   SIG_ATOMIC_MAX                                              see below
+<li>  limit of size_t
+   SIZE_MAX                                                      65535
+<li>  limits of wchar_t
+ 
+ 
+ 
+<!--page 272 indent 4-->
+  WCHAR_MIN                                              see below
+  WCHAR_MAX                                              see below
+<li>  limits of wint_t
+  WINT_MIN                                               see below
+  WINT_MAX                                               see below
+</ul>
+<p><!--para 3-->
+ If sig_atomic_t (see <a href="#7.14">7.14</a>) is defined as a signed integer type, the value of
+ SIG_ATOMIC_MIN shall be no greater than -127 and the value of SIG_ATOMIC_MAX
+ shall be no less than 127; otherwise, sig_atomic_t is defined as an unsigned integer
+ type, and the value of SIG_ATOMIC_MIN shall be 0 and the value of
+ SIG_ATOMIC_MAX shall be no less than 255.
+<p><!--para 4-->
+ If wchar_t (see <a href="#7.17">7.17</a>) is defined as a signed integer type, the value of WCHAR_MIN
+ shall be no greater than -127 and the value of WCHAR_MAX shall be no less than 127;
+ otherwise, wchar_t is defined as an unsigned integer type, and the value of
+ WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.<sup><a href="#note229"><b>229)</b></a></sup>
+<p><!--para 5-->
+ If wint_t (see <a href="#7.24">7.24</a>) is defined as a signed integer type, the value of WINT_MIN shall
+ be no greater than -32767 and the value of WINT_MAX shall be no less than 32767;
+ otherwise, wint_t is defined as an unsigned integer type, and the value of WINT_MIN
+ shall be 0 and the value of WINT_MAX shall be no less than 65535.
+
+<h6>footnotes</h6>
+<p><a name="note227">227)</a> C++ implementations should define these macros only when __STDC_LIMIT_MACROS is defined
+ before &lt;stdint.h&gt; is included.
+
+<p><a name="note228">228)</a> A freestanding implementation need not provide all of these types.
+
+<p><a name="note229">229)</a> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
+ character set.
+
+
+<a name="7.18.4" href="#7.18.4"><h4>7.18.4 Macros for integer constants</h4></a>
+<p><!--para 1-->
+ The following function-like macros<sup><a href="#note230"><b>230)</b></a></sup> expand to integer constants suitable for
+ initializing objects that have integer types corresponding to types defined in
+ &lt;stdint.h&gt;. Each macro name corresponds to a similar type name in <a href="#7.18.1.2">7.18.1.2</a> or
+ <a href="#7.18.1.5">7.18.1.5</a>.
+<p><!--para 2-->
+ The argument in any instance of these macros shall be an unsuffixed integer constant (as
+ defined in <a href="#6.4.4.1">6.4.4.1</a>) with a value that does not exceed the limits for the corresponding type.
+<p><!--para 3-->
+ Each invocation of one of these macros shall expand to an integer constant expression
+ suitable for use in #if preprocessing directives. The type of the expression shall have
+ the same type as would an expression of the corresponding type converted according to
+ the integer promotions. The value of the expression shall be that of the argument.
+ 
+ 
+ 
+ 
+<!--page 273 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note230">230)</a> C++ implementations should define these macros only when __STDC_CONSTANT_MACROS is
+ defined before &lt;stdint.h&gt; is included.
+
+
+<a name="7.18.4.1" href="#7.18.4.1"><h5>7.18.4.1 Macros for minimum-width integer constants</h5></a>
+<p><!--para 1-->
+ The macro INTN_C(value) shall expand to an integer constant expression
+ corresponding to the type int_leastN_t. The macro UINTN_C(value) shall expand
+ to an integer constant expression corresponding to the type uint_leastN_t. For
+ example, if uint_least64_t is a name for the type unsigned long long int,
+ then UINT64_C(0x123) might expand to the integer constant 0x123ULL.
+
+<a name="7.18.4.2" href="#7.18.4.2"><h5>7.18.4.2 Macros for greatest-width integer constants</h5></a>
+<p><!--para 1-->
+ The following macro expands to an integer constant expression having the value specified
+ by its argument and the type intmax_t:
+<pre>
+        INTMAX_C(value)</pre>
+ The following macro expands to an integer constant expression having the value specified
+ by its argument and the type uintmax_t:
+<!--page 274 indent 4-->
+<pre>
+        UINTMAX_C(value)</pre>
+
+<a name="7.19" href="#7.19"><h3>7.19 Input/output <stdio.h></h3></a>
+
+<a name="7.19.1" href="#7.19.1"><h4>7.19.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;stdio.h&gt; declares three types, several macros, and many functions for
+ performing input and output.
+<p><!--para 2-->
+ The types declared are size_t (described in <a href="#7.17">7.17</a>);
+<pre>
+        FILE</pre>
+ which is an object type capable of recording all the information needed to control a
+ stream, including its file position indicator, a pointer to its associated buffer (if any), an
+ error indicator that records whether a read/write error has occurred, and an end-of-file
+ indicator that records whether the end of the file has been reached; and
+<pre>
+        fpos_t</pre>
+ which is an object type other than an array type capable of recording all the information
+ needed to specify uniquely every position within a file.
+<p><!--para 3-->
+ The macros are NULL (described in <a href="#7.17">7.17</a>);
+<pre>
+        _IOFBF
+        _IOLBF
+        _IONBF</pre>
+ which expand to integer constant expressions with distinct values, suitable for use as the
+ third argument to the setvbuf function;
+<pre>
+        BUFSIZ</pre>
+ which expands to an integer constant expression that is the size of the buffer used by the
+ setbuf function;
+<pre>
+        EOF</pre>
+ which expands to an integer constant expression, with type int and a negative value, that
+ is returned by several functions to indicate end-of-file, that is, no more input from a
+ stream;
+<pre>
+        FOPEN_MAX</pre>
+ which expands to an integer constant expression that is the minimum number of files that
+ the implementation guarantees can be open simultaneously;
+<pre>
+        FILENAME_MAX</pre>
+ which expands to an integer constant expression that is the size needed for an array of
+ char large enough to hold the longest file name string that the implementation
+<!--page 275 indent 4-->
+ guarantees can be opened;<sup><a href="#note231"><b>231)</b></a></sup>
+<pre>
+         L_tmpnam</pre>
+ which expands to an integer constant expression that is the size needed for an array of
+ char large enough to hold a temporary file name string generated by the tmpnam
+ function;
+<pre>
+         SEEK_CUR
+         SEEK_END
+         SEEK_SET</pre>
+ which expand to integer constant expressions with distinct values, suitable for use as the
+ third argument to the fseek function;
+<pre>
+         TMP_MAX</pre>
+ which expands to an integer constant expression that is the maximum number of unique
+ file names that can be generated by the tmpnam function;
+<pre>
+         stderr
+         stdin
+         stdout</pre>
+ which are expressions of type ''pointer to FILE'' that point to the FILE objects
+ associated, respectively, with the standard error, input, and output streams.
+<p><!--para 4-->
+ The header &lt;wchar.h&gt; declares a number of functions useful for wide character input
+ and output. The wide character input/output functions described in that subclause
+ provide operations analogous to most of those described here, except that the
+ fundamental units internal to the program are wide characters. The external
+ representation (in the file) is a sequence of ''generalized'' multibyte characters, as
+ described further in <a href="#7.19.3">7.19.3</a>.
+<p><!--para 5-->
+ The input/output functions are given the following collective terms:
+<ul>
+<li>  The wide character input functions -- those functions described in <a href="#7.24">7.24</a> that perform
+ input into wide characters and wide strings: fgetwc, fgetws, getwc, getwchar,
+ fwscanf, wscanf, vfwscanf, and vwscanf.
+<li>  The wide character output functions -- those functions described in <a href="#7.24">7.24</a> that perform
+ output from wide characters and wide strings: fputwc, fputws, putwc,
+ putwchar, fwprintf, wprintf, vfwprintf, and vwprintf.
+ 
+ 
+<!--page 276 indent 4-->
+<li>  The wide character input/output functions -- the union of the ungetwc function, the
+ wide character input functions, and the wide character output functions.
+<li>  The byte input/output functions -- those functions described in this subclause that
+ perform input/output: fgetc, fgets, fprintf, fputc, fputs, fread,
+ fscanf, fwrite, getc, getchar, gets, printf, putc, putchar, puts,
+ scanf, ungetc, vfprintf, vfscanf, vprintf, and vscanf.
+</ul>
+ Forward references: files (<a href="#7.19.3">7.19.3</a>), the fseek function (<a href="#7.19.9.2">7.19.9.2</a>), streams (<a href="#7.19.2">7.19.2</a>), the
+ tmpnam function (<a href="#7.19.4.4">7.19.4.4</a>), &lt;wchar.h&gt; (<a href="#7.24">7.24</a>).
+
+<h6>footnotes</h6>
+<p><a name="note231">231)</a> If the implementation imposes no practical limit on the length of file name strings, the value of
+ FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
+ string. Of course, file name string contents are subject to other system-specific constraints; therefore
+ all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
+
+
+<a name="7.19.2" href="#7.19.2"><h4>7.19.2 Streams</h4></a>
+<p><!--para 1-->
+ Input and output, whether to or from physical devices such as terminals and tape drives,
+ or whether to or from files supported on structured storage devices, are mapped into
+ logical data streams, whose properties are more uniform than their various inputs and
+ outputs. Two forms of mapping are supported, for text streams and for binary
+ streams.<sup><a href="#note232"><b>232)</b></a></sup>
+<p><!--para 2-->
+ A text stream is an ordered sequence of characters composed into lines, each line
+ consisting of zero or more characters plus a terminating new-line character. Whether the
+ last line requires a terminating new-line character is implementation-defined. Characters
+ may have to be added, altered, or deleted on input and output to conform to differing
+ conventions for representing text in the host environment. Thus, there need not be a one-
+ to-one correspondence between the characters in a stream and those in the external
+ representation. Data read in from a text stream will necessarily compare equal to the data
+ that were earlier written out to that stream only if: the data consist only of printing
+ characters and the control characters horizontal tab and new-line; no new-line character is
+ immediately preceded by space characters; and the last character is a new-line character.
+ Whether space characters that are written out immediately before a new-line character
+ appear when read in is implementation-defined.
+<p><!--para 3-->
+ A binary stream is an ordered sequence of characters that can transparently record
+ internal data. Data read in from a binary stream shall compare equal to the data that were
+ earlier written out to that stream, under the same implementation. Such a stream may,
+ however, have an implementation-defined number of null characters appended to the end
+ of the stream.
+<p><!--para 4-->
+ Each stream has an orientation. After a stream is associated with an external file, but
+ before any operations are performed on it, the stream is without orientation. Once a wide
+ character input/output function has been applied to a stream without orientation, the
+ 
+ 
+<!--page 277 indent 4-->
+ stream becomes a wide-oriented stream. Similarly, once a byte input/output function has
+ been applied to a stream without orientation, the stream becomes a byte-oriented stream.
+ Only a call to the freopen function or the fwide function can otherwise alter the
+ orientation of a stream. (A successful call to freopen removes any orientation.)<sup><a href="#note233"><b>233)</b></a></sup>
+<p><!--para 5-->
+ Byte input/output functions shall not be applied to a wide-oriented stream and wide
+ character input/output functions shall not be applied to a byte-oriented stream. The
+ remaining stream operations do not affect, and are not affected by, a stream's orientation,
+ except for the following additional restrictions:
+<ul>
+<li>  Binary wide-oriented streams have the file-positioning restrictions ascribed to both
+ text and binary streams.
+<li>  For wide-oriented streams, after a successful call to a file-positioning function that
+ leaves the file position indicator prior to the end-of-file, a wide character output
+ function can overwrite a partial multibyte character; any file contents beyond the
+ byte(s) written are henceforth indeterminate.
+</ul>
+<p><!--para 6-->
+ Each wide-oriented stream has an associated mbstate_t object that stores the current
+ parse state of the stream. A successful call to fgetpos stores a representation of the
+ value of this mbstate_t object as part of the value of the fpos_t object. A later
+ successful call to fsetpos using the same stored fpos_t value restores the value of
+ the associated mbstate_t object as well as the position within the controlled stream.
+ Environmental limits
+<p><!--para 7-->
+ An implementation shall support text files with lines containing at least 254 characters,
+ including the terminating new-line character. The value of the macro BUFSIZ shall be at
+ least 256.
+ Forward references: the freopen function (<a href="#7.19.5.4">7.19.5.4</a>), the fwide function (<a href="#7.24.3.5">7.24.3.5</a>),
+ mbstate_t (<a href="#7.25.1">7.25.1</a>), the fgetpos function (<a href="#7.19.9.1">7.19.9.1</a>), the fsetpos function
+ (<a href="#7.19.9.3">7.19.9.3</a>).
+ 
+ 
+ 
+ 
+<!--page 278 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note232">232)</a> An implementation need not distinguish between text streams and binary streams. In such an
+ implementation, there need be no new-line characters in a text stream nor any limit to the length of a
+ line.
+
+<p><a name="note233">233)</a> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
+
+
+<a name="7.19.3" href="#7.19.3"><h4>7.19.3 Files</h4></a>
+<p><!--para 1-->
+ A stream is associated with an external file (which may be a physical device) by opening
+ a file, which may involve creating a new file. Creating an existing file causes its former
+ contents to be discarded, if necessary. If a file can support positioning requests (such as a
+ disk file, as opposed to a terminal), then a file position indicator associated with the
+ stream is positioned at the start (character number zero) of the file, unless the file is
+ opened with append mode in which case it is implementation-defined whether the file
+ position indicator is initially positioned at the beginning or the end of the file. The file
+ position indicator is maintained by subsequent reads, writes, and positioning requests, to
+ facilitate an orderly progression through the file.
+<p><!--para 2-->
+ Binary files are not truncated, except as defined in <a href="#7.19.5.3">7.19.5.3</a>. Whether a write on a text
+ stream causes the associated file to be truncated beyond that point is implementation-
+ defined.
+<p><!--para 3-->
+ When a stream is unbuffered, characters are intended to appear from the source or at the
+ destination as soon as possible. Otherwise characters may be accumulated and
+ transmitted to or from the host environment as a block. When a stream is fully buffered,
+ characters are intended to be transmitted to or from the host environment as a block when
+ a buffer is filled. When a stream is line buffered, characters are intended to be
+ transmitted to or from the host environment as a block when a new-line character is
+ encountered. Furthermore, characters are intended to be transmitted as a block to the host
+ environment when a buffer is filled, when input is requested on an unbuffered stream, or
+ when input is requested on a line buffered stream that requires the transmission of
+ characters from the host environment. Support for these characteristics is
+ implementation-defined, and may be affected via the setbuf and setvbuf functions.
+<p><!--para 4-->
+ A file may be disassociated from a controlling stream by closing the file. Output streams
+ are flushed (any unwritten buffer contents are transmitted to the host environment) before
+ the stream is disassociated from the file. The value of a pointer to a FILE object is
+ indeterminate after the associated file is closed (including the standard text streams).
+ Whether a file of zero length (on which no characters have been written by an output
+ stream) actually exists is implementation-defined.
+<p><!--para 5-->
+ The file may be subsequently reopened, by the same or another program execution, and
+ its contents reclaimed or modified (if it can be repositioned at its start). If the main
+ function returns to its original caller, or if the exit function is called, all open files are
+ closed (hence all output streams are flushed) before program termination. Other paths to
+ program termination, such as calling the abort function, need not close all files
+ properly.
+<p><!--para 6-->
+ The address of the FILE object used to control a stream may be significant; a copy of a
+ FILE object need not serve in place of the original.
+<!--page 279 indent 5-->
+<p><!--para 7-->
+ At program startup, three text streams are predefined and need not be opened explicitly
+<ul>
+<li>  standard input (for reading conventional input), standard output (for writing
+</ul>
+ conventional output), and standard error (for writing diagnostic output). As initially
+ opened, the standard error stream is not fully buffered; the standard input and standard
+ output streams are fully buffered if and only if the stream can be determined not to refer
+ to an interactive device.
+<p><!--para 8-->
+ Functions that open additional (nontemporary) files require a file name, which is a string.
+ The rules for composing valid file names are implementation-defined. Whether the same
+ file can be simultaneously open multiple times is also implementation-defined.
+<p><!--para 9-->
+ Although both text and binary wide-oriented streams are conceptually sequences of wide
+ characters, the external file associated with a wide-oriented stream is a sequence of
+ multibyte characters, generalized as follows:
+<ul>
+<li>  Multibyte encodings within files may contain embedded null bytes (unlike multibyte
+ encodings valid for use internal to the program).
+<li>  A file need not begin nor end in the initial shift state.<sup><a href="#note234"><b>234)</b></a></sup>
+</ul>
+<p><!--para 10-->
+ Moreover, the encodings used for multibyte characters may differ among files. Both the
+ nature and choice of such encodings are implementation-defined.
+<p><!--para 11-->
+ The wide character input functions read multibyte characters from the stream and convert
+ them to wide characters as if they were read by successive calls to the fgetwc function.
+ Each conversion occurs as if by a call to the mbrtowc function, with the conversion state
+ described by the stream's own mbstate_t object. The byte input functions read
+ characters from the stream as if by successive calls to the fgetc function.
+<p><!--para 12-->
+ The wide character output functions convert wide characters to multibyte characters and
+ write them to the stream as if they were written by successive calls to the fputwc
+ function. Each conversion occurs as if by a call to the wcrtomb function, with the
+ conversion state described by the stream's own mbstate_t object. The byte output
+ functions write characters to the stream as if by successive calls to the fputc function.
+<p><!--para 13-->
+ In some cases, some of the byte input/output functions also perform conversions between
+ multibyte characters and wide characters. These conversions also occur as if by calls to
+ the mbrtowc and wcrtomb functions.
+<p><!--para 14-->
+ An encoding error occurs if the character sequence presented to the underlying
+ mbrtowc function does not form a valid (generalized) multibyte character, or if the code
+ value passed to the underlying wcrtomb does not correspond to a valid (generalized)
+ 
+ 
+<!--page 280 indent 5-->
+ multibyte character. The wide character input/output functions and the byte input/output
+ functions store the value of the macro EILSEQ in errno if and only if an encoding error
+ occurs.
+ Environmental limits
+<p><!--para 15-->
+ The value of FOPEN_MAX shall be at least eight, including the three standard text
+ streams.
+ Forward references: the exit function (<a href="#7.20.4.3">7.20.4.3</a>), the fgetc function (<a href="#7.19.7.1">7.19.7.1</a>), the
+ fopen function (<a href="#7.19.5.3">7.19.5.3</a>), the fputc function (<a href="#7.19.7.3">7.19.7.3</a>), the setbuf function
+ (<a href="#7.19.5.5">7.19.5.5</a>), the setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>), the fgetwc function (<a href="#7.24.3.1">7.24.3.1</a>), the
+ fputwc function (<a href="#7.24.3.3">7.24.3.3</a>), conversion state (<a href="#7.24.6">7.24.6</a>), the mbrtowc function
+ (<a href="#7.24.6.3.2">7.24.6.3.2</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note234">234)</a> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
+ undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
+ with state-dependent encoding that does not assuredly end in the initial shift state.
+
+
+<a name="7.19.4" href="#7.19.4"><h4>7.19.4 Operations on files</h4></a>
+
+<a name="7.19.4.1" href="#7.19.4.1"><h5>7.19.4.1 The remove function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int remove(const char *filename);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The remove function causes the file whose name is the string pointed to by filename
+ to be no longer accessible by that name. A subsequent attempt to open that file using that
+ name will fail, unless it is created anew. If the file is open, the behavior of the remove
+ function is implementation-defined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The remove function returns zero if the operation succeeds, nonzero if it fails.
+
+<a name="7.19.4.2" href="#7.19.4.2"><h5>7.19.4.2 The rename function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int rename(const char *old, const char *new);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rename function causes the file whose name is the string pointed to by old to be
+ henceforth known by the name given by the string pointed to by new. The file named
+ old is no longer accessible by that name. If a file named by the string pointed to by new
+ exists prior to the call to the rename function, the behavior is implementation-defined.
+<!--page 281 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The rename function returns zero if the operation succeeds, nonzero if it fails,<sup><a href="#note235"><b>235)</b></a></sup> in
+ which case if the file existed previously it is still known by its original name.
+
+<h6>footnotes</h6>
+<p><a name="note235">235)</a> Among the reasons the implementation may cause the rename function to fail are that the file is open
+ or that it is necessary to copy its contents to effectuate its renaming.
+
+
+<a name="7.19.4.3" href="#7.19.4.3"><h5>7.19.4.3 The tmpfile function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         FILE *tmpfile(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tmpfile function creates a temporary binary file that is different from any other
+ existing file and that will automatically be removed when it is closed or at program
+ termination. If the program terminates abnormally, whether an open temporary file is
+ removed is implementation-defined. The file is opened for update with "wb+" mode.
+ Recommended practice
+<p><!--para 3-->
+ It should be possible to open at least TMP_MAX temporary files during the lifetime of the
+ program (this limit may be shared with tmpnam) and there should be no limit on the
+ number simultaneously open other than this limit and any limit on the number of open
+ files (FOPEN_MAX).
+<h6>Returns</h6>
+<p><!--para 4-->
+ The tmpfile function returns a pointer to the stream of the file that it created. If the file
+ cannot be created, the tmpfile function returns a null pointer.
+ Forward references: the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
+
+<a name="7.19.4.4" href="#7.19.4.4"><h5>7.19.4.4 The tmpnam function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         char *tmpnam(char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tmpnam function generates a string that is a valid file name and that is not the same
+ as the name of an existing file.<sup><a href="#note236"><b>236)</b></a></sup> The function is potentially capable of generating
+ 
+ 
+<!--page 282 indent 4-->
+ TMP_MAX different strings, but any or all of them may already be in use by existing files
+ and thus not be suitable return values.
+<p><!--para 3-->
+ The tmpnam function generates a different string each time it is called.
+<p><!--para 4-->
+ The implementation shall behave as if no library function calls the tmpnam function.
+<h6>Returns</h6>
+<p><!--para 5-->
+ If no suitable string can be generated, the tmpnam function returns a null pointer.
+ Otherwise, if the argument is a null pointer, the tmpnam function leaves its result in an
+ internal static object and returns a pointer to that object (subsequent calls to the tmpnam
+ function may modify the same object). If the argument is not a null pointer, it is assumed
+ to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
+ in that array and returns the argument as its value.
+ Environmental limits
+<p><!--para 6-->
+ The value of the macro TMP_MAX shall be at least 25.
+
+<h6>footnotes</h6>
+<p><a name="note236">236)</a> Files created using strings generated by the tmpnam function are temporary only in the sense that
+ their names should not collide with those generated by conventional naming rules for the
+ implementation. It is still necessary to use the remove function to remove such files when their use
+ is ended, and before program termination.
+
+
+<a name="7.19.5" href="#7.19.5"><h4>7.19.5 File access functions</h4></a>
+
+<a name="7.19.5.1" href="#7.19.5.1"><h5>7.19.5.1 The fclose function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fclose(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A successful call to the fclose function causes the stream pointed to by stream to be
+ flushed and the associated file to be closed. Any unwritten buffered data for the stream
+ are delivered to the host environment to be written to the file; any unread buffered data
+ are discarded. Whether or not the call succeeds, the stream is disassociated from the file
+ and any buffer set by the setbuf or setvbuf function is disassociated from the stream
+ (and deallocated if it was automatically allocated).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fclose function returns zero if the stream was successfully closed, or EOF if any
+ errors were detected.
+
+<a name="7.19.5.2" href="#7.19.5.2"><h5>7.19.5.2 The fflush function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 283 indent 4-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fflush(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If stream points to an output stream or an update stream in which the most recent
+ operation was not input, the fflush function causes any unwritten data for that stream
+ to be delivered to the host environment to be written to the file; otherwise, the behavior is
+ undefined.
+<p><!--para 3-->
+ If stream is a null pointer, the fflush function performs this flushing action on all
+ streams for which the behavior is defined above.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The fflush function sets the error indicator for the stream and returns EOF if a write
+ error occurs, otherwise it returns zero.
+ Forward references: the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
+
+<a name="7.19.5.3" href="#7.19.5.3"><h5>7.19.5.3 The fopen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         FILE *fopen(const char * restrict filename,
+              const char * restrict mode);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fopen function opens the file whose name is the string pointed to by filename,
+ and associates a stream with it.
+<p><!--para 3-->
+ The argument mode points to a string. If the string is one of the following, the file is
+ open in the indicated mode. Otherwise, the behavior is undefined.<sup><a href="#note237"><b>237)</b></a></sup>
+ r                open text file for reading
+ w                truncate to zero length or create text file for writing
+ a                append; open or create text file for writing at end-of-file
+ rb               open binary file for reading
+ wb               truncate to zero length or create binary file for writing
+ ab               append; open or create binary file for writing at end-of-file
+ r+               open text file for update (reading and writing)
+ w+               truncate to zero length or create text file for update
+ a+               append; open or create text file for update, writing at end-of-file
+ 
+ 
+ 
+ 
+<!--page 284 indent 4-->
+ r+b or rb+ open binary file for update (reading and writing)
+ w+b or wb+ truncate to zero length or create binary file for update
+ a+b or ab+ append; open or create binary file for update, writing at end-of-file
+<p><!--para 4-->
+ Opening a file with read mode ('r' as the first character in the mode argument) fails if
+ the file does not exist or cannot be read.
+<p><!--para 5-->
+ Opening a file with append mode ('a' as the first character in the mode argument)
+ causes all subsequent writes to the file to be forced to the then current end-of-file,
+ regardless of intervening calls to the fseek function. In some implementations, opening
+ a binary file with append mode ('b' as the second or third character in the above list of
+ mode argument values) may initially position the file position indicator for the stream
+ beyond the last data written, because of null character padding.
+<p><!--para 6-->
+ When a file is opened with update mode ('+' as the second or third character in the
+ above list of mode argument values), both input and output may be performed on the
+ associated stream. However, output shall not be directly followed by input without an
+ intervening call to the fflush function or to a file positioning function (fseek,
+ fsetpos, or rewind), and input shall not be directly followed by output without an
+ intervening call to a file positioning function, unless the input operation encounters end-
+ of-file. Opening (or creating) a text file with update mode may instead open (or create) a
+ binary stream in some implementations.
+<p><!--para 7-->
+ When opened, a stream is fully buffered if and only if it can be determined not to refer to
+ an interactive device. The error and end-of-file indicators for the stream are cleared.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The fopen function returns a pointer to the object controlling the stream. If the open
+ operation fails, fopen returns a null pointer.
+ Forward references: file positioning functions (<a href="#7.19.9">7.19.9</a>).
+
+<h6>footnotes</h6>
+<p><a name="note237">237)</a> If the string begins with one of the above sequences, the implementation might choose to ignore the
+ remaining characters, or it might use them to select different kinds of a file (some of which might not
+ conform to the properties in <a href="#7.19.2">7.19.2</a>).
+
+
+<a name="7.19.5.4" href="#7.19.5.4"><h5>7.19.5.4 The freopen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
         FILE *freopen(const char * restrict filename,
              const char * restrict mode,
-             FILE * restrict stream);
-        void setbuf(FILE * restrict stream,
-             char * restrict buf);
-
-[<a name="p429" href="#p429">page 429</a>] (<a href="#Contents">Contents</a>)
-
-      int setvbuf(FILE * restrict stream,
-           char * restrict buf,
-           int mode, size_t size);
-      int fprintf(FILE * restrict stream,
-           const char * restrict format, ...);
-      int fscanf(FILE * restrict stream,
-           const char * restrict format, ...);
-      int printf(const char * restrict format, ...);
-      int scanf(const char * restrict format, ...);
-      int snprintf(char * restrict s, size_t n,
-           const char * restrict format, ...);
-      int sprintf(char * restrict s,
-           const char * restrict format, ...);
-      int sscanf(const char * restrict s,
-           const char * restrict format, ...);
-      int vfprintf(FILE * restrict stream,
-           const char * restrict format, va_list arg);
-      int vfscanf(FILE * restrict stream,
-           const char * restrict format, va_list arg);
-      int vprintf(const char * restrict format, va_list arg);
-      int vscanf(const char * restrict format, va_list arg);
-      int vsnprintf(char * restrict s, size_t n,
-           const char * restrict format, va_list arg);
-      int vsprintf(char * restrict s,
-           const char * restrict format, va_list arg);
-      int vsscanf(const char * restrict s,
-           const char * restrict format, va_list arg);
-      int fgetc(FILE *stream);
-      char *fgets(char * restrict s, int n,
-           FILE * restrict stream);
-      int fputc(int c, FILE *stream);
-      int fputs(const char * restrict s,
-           FILE * restrict stream);
-      int getc(FILE *stream);
-      int getchar(void);
-      char *gets(char *s);
-      int putc(int c, FILE *stream);
-      int putchar(int c);
-      int puts(const char *s);
-      int ungetc(int c, FILE *stream);
-
-[<a name="p430" href="#p430">page 430</a>] (<a href="#Contents">Contents</a>)
-
+             FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The freopen function opens the file whose name is the string pointed to by filename
+ and associates the stream pointed to by stream with it. The mode argument is used just
+<!--page 285 indent 4-->
+ as in the fopen function.<sup><a href="#note238"><b>238)</b></a></sup>
+<p><!--para 3-->
+ If filename is a null pointer, the freopen function attempts to change the mode of
+ the stream to that specified by mode, as if the name of the file currently associated with
+ the stream had been used. It is implementation-defined which changes of mode are
+ permitted (if any), and under what circumstances.
+<p><!--para 4-->
+ The freopen function first attempts to close any file that is associated with the specified
+ stream. Failure to close the file is ignored. The error and end-of-file indicators for the
+ stream are cleared.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The freopen function returns a null pointer if the open operation fails. Otherwise,
+ freopen returns the value of stream.
+
+<h6>footnotes</h6>
+<p><a name="note238">238)</a> The primary use of the freopen function is to change the file associated with a standard text stream
+ (stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
+ returned by the fopen function may be assigned.
+
+
+<a name="7.19.5.5" href="#7.19.5.5"><h5>7.19.5.5 The setbuf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         void setbuf(FILE * restrict stream,
+              char * restrict buf);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ Except that it returns no value, the setbuf function is equivalent to the setvbuf
+ function invoked with the values _IOFBF for mode and BUFSIZ for size, or (if buf
+ is a null pointer), with the value _IONBF for mode.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The setbuf function returns no value.
+ Forward references: the setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>).
+
+<a name="7.19.5.6" href="#7.19.5.6"><h5>7.19.5.6 The setvbuf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int setvbuf(FILE * restrict stream,
+              char * restrict buf,
+              int mode, size_t size);</pre>
+ 
+ 
+ 
+ 
+<!--page 286 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The setvbuf function may be used only after the stream pointed to by stream has
+ been associated with an open file and before any other operation (other than an
+ unsuccessful call to setvbuf) is performed on the stream. The argument mode
+ determines how stream will be buffered, as follows: _IOFBF causes input/output to be
+ fully buffered; _IOLBF causes input/output to be line buffered; _IONBF causes
+ input/output to be unbuffered. If buf is not a null pointer, the array it points to may be
+ used instead of a buffer allocated by the setvbuf function<sup><a href="#note239"><b>239)</b></a></sup> and the argument size
+ specifies the size of the array; otherwise, size may determine the size of a buffer
+ allocated by the setvbuf function. The contents of the array at any time are
+ indeterminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The setvbuf function returns zero on success, or nonzero if an invalid value is given
+ for mode or if the request cannot be honored.
+
+<h6>footnotes</h6>
+<p><a name="note239">239)</a> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
+ before a buffer that has automatic storage duration is deallocated upon block exit.
+
+
+<a name="7.19.6" href="#7.19.6"><h4>7.19.6 Formatted input/output functions</h4></a>
+<p><!--para 1-->
+ The formatted input/output functions shall behave as if there is a sequence point after the
+ actions associated with each specifier.<sup><a href="#note240"><b>240)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note240">240)</a> The fprintf functions perform writes to memory for the %n specifier.
+
+
+<a name="7.19.6.1" href="#7.19.6.1"><h5>7.19.6.1 The fprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fprintf(FILE * restrict stream,
+              const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fprintf function writes output to the stream pointed to by stream, under control
+ of the string pointed to by format that specifies how subsequent arguments are
+ converted for output. If there are insufficient arguments for the format, the behavior is
+ undefined. If the format is exhausted while arguments remain, the excess arguments are
+ evaluated (as always) but are otherwise ignored. The fprintf function returns when
+ the end of the format string is encountered.
+<p><!--para 3-->
+ The format shall be a multibyte character sequence, beginning and ending in its initial
+ shift state. The format is composed of zero or more directives: ordinary multibyte
+ characters (not %), which are copied unchanged to the output stream; and conversion
+ 
+ 
+<!--page 287 indent 4-->
+ specifications, each of which results in fetching zero or more subsequent arguments,
+ converting them, if applicable, according to the corresponding conversion specifier, and
+ then writing the result to the output stream.
+<p><!--para 4-->
+ Each conversion specification is introduced by the character %. After the %, the following
+ appear in sequence:
+<ul>
+<li>  Zero or more flags (in any order) that modify the meaning of the conversion
+ specification.
+<li>  An optional minimum field width. If the converted value has fewer characters than the
+ field width, it is padded with spaces (by default) on the left (or right, if the left
+ adjustment flag, described later, has been given) to the field width. The field width
+ takes the form of an asterisk * (described later) or a nonnegative decimal integer.<sup><a href="#note241"><b>241)</b></a></sup>
+<li>  An optional precision that gives the minimum number of digits to appear for the d, i,
+ o, u, x, and X conversions, the number of digits to appear after the decimal-point
+ character for a, A, e, E, f, and F conversions, the maximum number of significant
+ digits for the g and G conversions, or the maximum number of bytes to be written for
+ s conversions. The precision takes the form of a period (.) followed either by an
+ asterisk * (described later) or by an optional decimal integer; if only the period is
+ specified, the precision is taken as zero. If a precision appears with any other
+ conversion specifier, the behavior is undefined.
+<li>  An optional length modifier that specifies the size of the argument.
+<li>  A conversion specifier character that specifies the type of conversion to be applied.
+</ul>
+<p><!--para 5-->
+ As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+ this case, an int argument supplies the field width or precision. The arguments
+ specifying field width, or precision, or both, shall appear (in that order) before the
+ argument (if any) to be converted. A negative field width argument is taken as a - flag
+ followed by a positive field width. A negative precision argument is taken as if the
+ precision were omitted.
+<p><!--para 6-->
+ The flag characters and their meanings are:
+ -        The result of the conversion is left-justified within the field. (It is right-justified if
+<pre>
+          this flag is not specified.)</pre>
+ +        The result of a signed conversion always begins with a plus or minus sign. (It
+<pre>
+          begins with a sign only when a negative value is converted if this flag is not</pre>
+ 
+ 
+ 
+ 
+<!--page 288 indent 4-->
+<pre>
+           specified.)<sup><a href="#note242"><b>242)</b></a></sup></pre>
+ space If the first character of a signed conversion is not a sign, or if a signed conversion
+<pre>
+       results in no characters, a space is prefixed to the result. If the space and + flags
+       both appear, the space flag is ignored.</pre>
+ #         The result is converted to an ''alternative form''. For o conversion, it increases
+<pre>
+           the precision, if and only if necessary, to force the first digit of the result to be a
+           zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+           conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
+           and G conversions, the result of converting a floating-point number always
+           contains a decimal-point character, even if no digits follow it. (Normally, a
+           decimal-point character appears in the result of these conversions only if a digit
+           follows it.) For g and G conversions, trailing zeros are not removed from the
+           result. For other conversions, the behavior is undefined.</pre>
+ 0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+<p><!--para 7-->
+<pre>
+           (following any indication of sign or base) are used to pad to the field width rather
+           than performing space padding, except when converting an infinity or NaN. If the
+           0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
+           conversions, if a precision is specified, the 0 flag is ignored. For other
+           conversions, the behavior is undefined.</pre>
+ The length modifiers and their meanings are:
+ hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                signed char or unsigned char argument (the argument will have
+                been promoted according to the integer promotions, but its value shall be
+                converted to signed char or unsigned char before printing); or that
+                a following n conversion specifier applies to a pointer to a signed char
+                argument.</pre>
+ h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                short int or unsigned short int argument (the argument will
+                have been promoted according to the integer promotions, but its value shall
+                be converted to short int or unsigned short int before printing);
+                or that a following n conversion specifier applies to a pointer to a short
+                int argument.</pre>
+ l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                long int or unsigned long int argument; that a following n
+                conversion specifier applies to a pointer to a long int argument; that a</pre>
+ 
+<!--page 289 indent 4-->
+<pre>
+              following c conversion specifier applies to a wint_t argument; that a
+              following s conversion specifier applies to a pointer to a wchar_t
+              argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+              specifier.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              long long int or unsigned long long int argument; or that a
+              following n conversion specifier applies to a pointer to a long long int
+              argument.</pre>
+ j            Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+<pre>
+              an intmax_t or uintmax_t argument; or that a following n conversion
+              specifier applies to a pointer to an intmax_t argument.</pre>
+ z            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              size_t or the corresponding signed integer type argument; or that a
+              following n conversion specifier applies to a pointer to a signed integer type
+              corresponding to size_t argument.</pre>
+ t            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              ptrdiff_t or the corresponding unsigned integer type argument; or that a
+              following n conversion specifier applies to a pointer to a ptrdiff_t
+              argument.</pre>
+ L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+              applies to a long double argument.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 8-->
+ The conversion specifiers and their meanings are:
+ d,i         The int argument is converted to signed decimal in the style [-]dddd. The
+<pre>
+             precision specifies the minimum number of digits to appear; if the value
+             being converted can be represented in fewer digits, it is expanded with
+             leading zeros. The default precision is 1. The result of converting a zero
+             value with a precision of zero is no characters.</pre>
+ o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+<!--page 290 indent 0-->
+<pre>
+         decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+         letters abcdef are used for x conversion and the letters ABCDEF for X
+         conversion. The precision specifies the minimum number of digits to appear;
+         if the value being converted can be represented in fewer digits, it is expanded
+         with leading zeros. The default precision is 1. The result of converting a
+         zero value with a precision of zero is no characters.</pre>
+ f,F          A double argument representing a floating-point number is converted to
+<pre>
+              decimal notation in the style [-]ddd.ddd, where the number of digits after
+              the decimal-point character is equal to the precision specification. If the
+              precision is missing, it is taken as 6; if the precision is zero and the # flag is
+              not specified, no decimal-point character appears. If a decimal-point
+              character appears, at least one digit appears before it. The value is rounded to
+              the appropriate number of digits.
+              A double argument representing an infinity is converted in one of the styles
+              [-]inf or [-]infinity -- which style is implementation-defined. A
+              double argument representing a NaN is converted in one of the styles
+              [-]nan or [-]nan(n-char-sequence) -- which style, and the meaning of
+              any n-char-sequence, is implementation-defined. The F conversion specifier
+              produces INF, INFINITY, or NAN instead of inf, infinity, or nan,
+              respectively.<sup><a href="#note243"><b>243)</b></a></sup></pre>
+ e,E          A double argument representing a floating-point number is converted in the
+<pre>
+              style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+              argument is nonzero) before the decimal-point character and the number of
+              digits after it is equal to the precision; if the precision is missing, it is taken as
+              6; if the precision is zero and the # flag is not specified, no decimal-point
+              character appears. The value is rounded to the appropriate number of digits.
+              The E conversion specifier produces a number with E instead of e
+              introducing the exponent. The exponent always contains at least two digits,
+              and only as many more digits as necessary to represent the exponent. If the
+              value is zero, the exponent is zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.</pre>
+ g,G          A double argument representing a floating-point number is converted in
+<pre>
+              style f or e (or in style F or E in the case of a G conversion specifier),
+              depending on the value converted and the precision. Let P equal the
+              precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+              Then, if a conversion with style E would have an exponent of X :
+              -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+                P - (X + 1).
+              -- otherwise, the conversion is with style e (or E) and precision P - 1.
+              Finally, unless the # flag is used, any trailing zeros are removed from the</pre>
+ 
+<!--page 291 indent 0-->
+<pre>
+               fractional portion of the result and the decimal-point character is removed if
+               there is no fractional portion remaining.
+               A double argument representing an infinity or NaN is converted in the style
+               of an f or F conversion specifier.</pre>
+ a,A           A double argument representing a floating-point number is converted in the
+<pre>
+               style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+               nonzero if the argument is a normalized floating-point number and is
+               otherwise unspecified) before the decimal-point character<sup><a href="#note244"><b>244)</b></a></sup> and the number
+               of hexadecimal digits after it is equal to the precision; if the precision is
+               missing and FLT_RADIX is a power of 2, then the precision is sufficient for
+               an exact representation of the value; if the precision is missing and
+               FLT_RADIX is not a power of 2, then the precision is sufficient to
+               distinguish<sup><a href="#note245"><b>245)</b></a></sup> values of type double, except that trailing zeros may be
+               omitted; if the precision is zero and the # flag is not specified, no decimal-
+               point character appears. The letters abcdef are used for a conversion and
+               the letters ABCDEF for A conversion. The A conversion specifier produces a
+               number with X and P instead of x and p. The exponent always contains at
+               least one digit, and only as many more digits as necessary to represent the
+               decimal exponent of 2. If the value is zero, the exponent is zero.
+               A double argument representing an infinity or NaN is converted in the style
+               of an f or F conversion specifier.</pre>
+ c             If no l length modifier is present, the int argument is converted to an
+<pre>
+               unsigned char, and the resulting character is written.
+               If an l length modifier is present, the wint_t argument is converted as if by
+               an ls conversion specification with no precision and an argument that points
+               to the initial element of a two-element array of wchar_t, the first element
+               containing the wint_t argument to the lc conversion specification and the
+               second a null wide character.</pre>
+ s             If no l length modifier is present, the argument shall be a pointer to the initial
+<pre>
+               element of an array of character type.<sup><a href="#note246"><b>246)</b></a></sup> Characters from the array are</pre>
+ 
+ 
+<!--page 292 indent 5-->
+<pre>
+                written up to (but not including) the terminating null character. If the
+                precision is specified, no more than that many bytes are written. If the
+                precision is not specified or is greater than the size of the array, the array shall
+                contain a null character.
+                If an l length modifier is present, the argument shall be a pointer to the initial
+                element of an array of wchar_t type. Wide characters from the array are
+                converted to multibyte characters (each as if by a call to the wcrtomb
+                function, with the conversion state described by an mbstate_t object
+                initialized to zero before the first wide character is converted) up to and
+                including a terminating null wide character. The resulting multibyte
+                characters are written up to (but not including) the terminating null character
+                (byte). If no precision is specified, the array shall contain a null wide
+                character. If a precision is specified, no more than that many bytes are
+                written (including shift sequences, if any), and the array shall contain a null
+                wide character if, to equal the multibyte character sequence length given by
+                the precision, the function would need to access a wide character one past the
+                end of the array. In no case is a partial multibyte character written.<sup><a href="#note247"><b>247)</b></a></sup></pre>
+ p              The argument shall be a pointer to void. The value of the pointer is
+<pre>
+                converted to a sequence of printing characters, in an implementation-defined
+                manner.</pre>
+ n              The argument shall be a pointer to signed integer into which is written the
+<pre>
+                number of characters written to the output stream so far by this call to
+                fprintf. No argument is converted, but one is consumed. If the conversion
+                specification includes any flags, a field width, or a precision, the behavior is
+                undefined.</pre>
+ %              A % character is written. No argument is converted. The complete
+<p><!--para 9-->
+<pre>
+                conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note248"><b>248)</b></a></sup> If any argument is
+ not the correct type for the corresponding conversion specification, the behavior is
+ undefined.
+<p><!--para 10-->
+ In no case does a nonexistent or small field width cause truncation of a field; if the result
+ of a conversion is wider than the field width, the field is expanded to contain the
+ conversion result.
+ 
+ 
+ 
+ 
+<!--page 293 indent 5-->
+<p><!--para 11-->
+ For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+ to a hexadecimal floating number with the given precision.
+ Recommended practice
+<p><!--para 12-->
+ For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+ representable in the given precision, the result should be one of the two adjacent numbers
+ in hexadecimal floating style with the given precision, with the extra stipulation that the
+ error should have a correct sign for the current rounding direction.
+<p><!--para 13-->
+ For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+ DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note249"><b>249)</b></a></sup> If the number of
+ significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+ representable with DECIMAL_DIG digits, then the result should be an exact
+ representation with trailing zeros. Otherwise, the source value is bounded by two
+ adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+ of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+ the error should have a correct sign for the current rounding direction.
+<h6>Returns</h6>
+<p><!--para 14-->
+ The fprintf function returns the number of characters transmitted, or a negative value
+ if an output or encoding error occurred.
+ Environmental limits
+<p><!--para 15-->
+ The number of characters that can be produced by any single conversion shall be at least
+ 4095.
+<p><!--para 16-->
+ EXAMPLE 1 To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+ places:
+<pre>
+         #include &lt;math.h&gt;
+         #include &lt;stdio.h&gt;
+         /* ... */
+         char *weekday, *month;      // pointers to strings
+         int day, hour, min;
+         fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
+                 weekday, month, day, hour, min);
+         fprintf(stdout, "pi = %.5f\n", 4 * atan(1.0));</pre>
+ 
+<p><!--para 17-->
+ EXAMPLE 2 In this example, multibyte characters do not have a state-dependent encoding, and the
+ members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+ the first of which is denoted here by a and the second by an uppercase letter.
+ 
+ 
+ 
+ 
+<!--page 294 indent 5-->
+<p><!--para 18-->
+ Given the following wide string with length seven,
+<pre>
+          static wchar_t wstr[] = L" X Yabc Z W";</pre>
+ the seven calls
+<pre>
+          fprintf(stdout,          "|1234567890123|\n");
+          fprintf(stdout,          "|%13ls|\n", wstr);
+          fprintf(stdout,          "|%-13.9ls|\n", wstr);
+          fprintf(stdout,          "|%13.10ls|\n", wstr);
+          fprintf(stdout,          "|%13.11ls|\n", wstr);
+          fprintf(stdout,          "|%13.15ls|\n", &amp;wstr[2]);
+          fprintf(stdout,          "|%13lc|\n", (wint_t) wstr[5]);</pre>
+ will print the following seven lines:
+<pre>
+          |1234567890123|
+          |   X Yabc Z W|
+          | X Yabc Z    |
+          |     X Yabc Z|
+          |   X Yabc Z W|
+          |      abc Z W|
+          |            Z|</pre>
+ 
+ Forward references: conversion state (<a href="#7.24.6">7.24.6</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note241">241)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
+
+<p><a name="note242">242)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+ include a minus sign.
+
+<p><a name="note243">243)</a> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
+ the # and 0 flag characters have no effect.
+
+<p><a name="note244">244)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
+ that subsequent digits align to nibble (4-bit) boundaries.
+
+<p><a name="note245">245)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+ FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+ might suffice depending on the implementation's scheme for determining the digit to the left of the
+ decimal-point character.
+
+<p><a name="note246">246)</a> No special provisions are made for multibyte characters.
+
+<p><a name="note247">247)</a> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
+
+<p><a name="note248">248)</a> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
+
+<p><a name="note249">249)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+ given format specifier. The number of significant digits is determined by the format specifier, and in
+ the case of fixed-point conversion by the source value as well.
+
+
+<a name="7.19.6.2" href="#7.19.6.2"><h5>7.19.6.2 The fscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdio.h&gt;
+          int fscanf(FILE * restrict stream,
+               const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fscanf function reads input from the stream pointed to by stream, under control
+ of the string pointed to by format that specifies the admissible input sequences and how
+ they are to be converted for assignment, using subsequent arguments as pointers to the
+ objects to receive the converted input. If there are insufficient arguments for the format,
+ the behavior is undefined. If the format is exhausted while arguments remain, the excess
+ arguments are evaluated (as always) but are otherwise ignored.
+<p><!--para 3-->
+ The format shall be a multibyte character sequence, beginning and ending in its initial
+ shift state. The format is composed of zero or more directives: one or more white-space
+ characters, an ordinary multibyte character (neither % nor a white-space character), or a
+ conversion specification. Each conversion specification is introduced by the character %.
+ After the %, the following appear in sequence:
+<ul>
+<li>  An optional assignment-suppressing character *.
+<li>  An optional decimal integer greater than zero that specifies the maximum field width
+ (in characters).
+<!--page 295 indent 5-->
+<li>  An optional length modifier that specifies the size of the receiving object.
+<li>  A conversion specifier character that specifies the type of conversion to be applied.
+</ul>
+<p><!--para 4-->
+ The fscanf function executes each directive of the format in turn. If a directive fails, as
+ detailed below, the function returns. Failures are described as input failures (due to the
+ occurrence of an encoding error or the unavailability of input characters), or matching
+ failures (due to inappropriate input).
+<p><!--para 5-->
+ A directive composed of white-space character(s) is executed by reading input up to the
+ first non-white-space character (which remains unread), or until no more characters can
+ be read.
+<p><!--para 6-->
+ A directive that is an ordinary multibyte character is executed by reading the next
+ characters of the stream. If any of those characters differ from the ones composing the
+ directive, the directive fails and the differing and subsequent characters remain unread.
+ Similarly, if end-of-file, an encoding error, or a read error prevents a character from being
+ read, the directive fails.
+<p><!--para 7-->
+ A directive that is a conversion specification defines a set of matching input sequences, as
+ described below for each specifier. A conversion specification is executed in the
+ following steps:
+<p><!--para 8-->
+ Input white-space characters (as specified by the isspace function) are skipped, unless
+ the specification includes a [, c, or n specifier.<sup><a href="#note250"><b>250)</b></a></sup>
+<p><!--para 9-->
+ An input item is read from the stream, unless the specification includes an n specifier. An
+ input item is defined as the longest sequence of input characters which does not exceed
+ any specified field width and which is, or is a prefix of, a matching input sequence.<sup><a href="#note251"><b>251)</b></a></sup>
+ The first character, if any, after the input item remains unread. If the length of the input
+ item is zero, the execution of the directive fails; this condition is a matching failure unless
+ end-of-file, an encoding error, or a read error prevented input from the stream, in which
+ case it is an input failure.
+<p><!--para 10-->
+ Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+ count of input characters) is converted to a type appropriate to the conversion specifier. If
+ the input item is not a matching sequence, the execution of the directive fails: this
+ condition is a matching failure. Unless assignment suppression was indicated by a *, the
+ result of the conversion is placed in the object pointed to by the first argument following
+ the format argument that has not already received a conversion result. If this object
+ does not have an appropriate type, or if the result of the conversion cannot be represented
+ 
+ 
+<!--page 296 indent 5-->
+ in the object, the behavior is undefined.
+<p><!--para 11-->
+ The length modifiers and their meanings are:
+ hh           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to signed char or unsigned char.</pre>
+ h            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to short int or unsigned short
+              int.</pre>
+ l (ell)      Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to long int or unsigned long
+              int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+              an argument with type pointer to double; or that a following c, s, or [
+              conversion specifier applies to an argument with type pointer to wchar_t.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to long long int or unsigned
+              long long int.</pre>
+ j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to intmax_t or uintmax_t.</pre>
+ z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to size_t or the corresponding signed
+              integer type.</pre>
+ t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to ptrdiff_t or the corresponding
+              unsigned integer type.</pre>
+ L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+              applies to an argument with type pointer to long double.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 12-->
+ The conversion specifiers and their meanings are:
+ d           Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+             expected for the subject sequence of the strtol function with the value 10
+             for the base argument. The corresponding argument shall be a pointer to
+             signed integer.</pre>
+ i           Matches an optionally signed integer, whose format is the same as expected
+<!--page 297 indent 0-->
+<pre>
+             for the subject sequence of the strtol function with the value 0 for the
+             base argument. The corresponding argument shall be a pointer to signed
+             integer.</pre>
+ o             Matches an optionally signed octal integer, whose format is the same as
+<pre>
+               expected for the subject sequence of the strtoul function with the value 8
+               for the base argument. The corresponding argument shall be a pointer to
+               unsigned integer.</pre>
+ u             Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+               expected for the subject sequence of the strtoul function with the value 10
+               for the base argument. The corresponding argument shall be a pointer to
+               unsigned integer.</pre>
+ x             Matches an optionally signed hexadecimal integer, whose format is the same
+<pre>
+               as expected for the subject sequence of the strtoul function with the value
+               16 for the base argument. The corresponding argument shall be a pointer to
+               unsigned integer.</pre>
+ a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+<pre>
+         format is the same as expected for the subject sequence of the strtod
+         function. The corresponding argument shall be a pointer to floating.</pre>
+ c             Matches a sequence of characters of exactly the number specified by the field
+<pre>
+               width (1 if no field width is present in the directive).<sup><a href="#note252"><b>252)</b></a></sup>
+               If no l length modifier is present, the corresponding argument shall be a
+               pointer to the initial element of a character array large enough to accept the
+               sequence. No null character is added.
+               If an l length modifier is present, the input shall be a sequence of multibyte
+               characters that begins in the initial shift state. Each multibyte character in the
+               sequence is converted to a wide character as if by a call to the mbrtowc
+               function, with the conversion state described by an mbstate_t object
+               initialized to zero before the first multibyte character is converted. The
+               corresponding argument shall be a pointer to the initial element of an array of
+               wchar_t large enough to accept the resulting sequence of wide characters.
+               No null wide character is added.</pre>
+ s             Matches a sequence of non-white-space characters.252)
+<pre>
+               If no l length modifier is present, the corresponding argument shall be a
+               pointer to the initial element of a character array large enough to accept the
+               sequence and a terminating null character, which will be added automatically.
+               If an l length modifier is present, the input shall be a sequence of multibyte</pre>
+ 
+ 
+<!--page 298 indent 0-->
+<pre>
+          characters that begins in the initial shift state. Each multibyte character is
+          converted to a wide character as if by a call to the mbrtowc function, with
+          the conversion state described by an mbstate_t object initialized to zero
+          before the first multibyte character is converted. The corresponding argument
+          shall be a pointer to the initial element of an array of wchar_t large enough
+          to accept the sequence and the terminating null wide character, which will be
+          added automatically.</pre>
+ [        Matches a nonempty sequence of characters from a set of expected characters
+<pre>
+          (the scanset).252)
+          If no l length modifier is present, the corresponding argument shall be a
+          pointer to the initial element of a character array large enough to accept the
+          sequence and a terminating null character, which will be added automatically.
+          If an l length modifier is present, the input shall be a sequence of multibyte
+          characters that begins in the initial shift state. Each multibyte character is
+          converted to a wide character as if by a call to the mbrtowc function, with
+          the conversion state described by an mbstate_t object initialized to zero
+          before the first multibyte character is converted. The corresponding argument
+          shall be a pointer to the initial element of an array of wchar_t large enough
+          to accept the sequence and the terminating null wide character, which will be
+          added automatically.
+          The conversion specifier includes all subsequent characters in the format
+          string, up to and including the matching right bracket (]). The characters
+          between the brackets (the scanlist) compose the scanset, unless the character
+          after the left bracket is a circumflex (^), in which case the scanset contains all
+          characters that do not appear in the scanlist between the circumflex and the
+          right bracket. If the conversion specifier begins with [] or [^], the right
+          bracket character is in the scanlist and the next following right bracket
+          character is the matching right bracket that ends the specification; otherwise
+          the first following right bracket character is the one that ends the
+          specification. If a - character is in the scanlist and is not the first, nor the
+          second where the first character is a ^, nor the last character, the behavior is
+          implementation-defined.</pre>
+ p        Matches an implementation-defined set of sequences, which should be the
+<!--page 299 indent 5-->
+<pre>
+          same as the set of sequences that may be produced by the %p conversion of
+          the fprintf function. The corresponding argument shall be a pointer to a
+          pointer to void. The input item is converted to a pointer value in an
+          implementation-defined manner. If the input item is a value converted earlier
+          during the same program execution, the pointer that results shall compare
+          equal to that value; otherwise the behavior of the %p conversion is undefined.</pre>
+ n              No input is consumed. The corresponding argument shall be a pointer to
+<pre>
+                signed integer into which is to be written the number of characters read from
+                the input stream so far by this call to the fscanf function. Execution of a
+                %n directive does not increment the assignment count returned at the
+                completion of execution of the fscanf function. No argument is converted,
+                but one is consumed. If the conversion specification includes an assignment-
+                suppressing character or a field width, the behavior is undefined.</pre>
+ %              Matches a single % character; no conversion or assignment occurs. The
+<p><!--para 13-->
+<pre>
+                complete conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note253"><b>253)</b></a></sup>
+<p><!--para 14-->
+ The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+ respectively, a, e, f, g, and x.
+<p><!--para 15-->
+ Trailing white space (including new-line characters) is left unread unless matched by a
+ directive. The success of literal matches and suppressed assignments is not directly
+ determinable other than via the %n directive.
+<h6>Returns</h6>
+<p><!--para 16-->
+ The fscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the function returns the number of input items
+ assigned, which can be fewer than provided for, or even zero, in the event of an early
+ matching failure.
+<p><!--para 17-->
+ EXAMPLE 1        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int n, i; float x; char name[50];
+          n = fscanf(stdin, "%d%f%s", &amp;i, &amp;x, name);</pre>
+ with the input line:
+<pre>
+          25 54.32E-1 thompson</pre>
+ will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+ thompson\0.
+ 
+<p><!--para 18-->
+ EXAMPLE 2        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int i; float x; char name[50];
+          fscanf(stdin, "%2d%f%*d %[0123456789]", &amp;i, &amp;x, name);</pre>
+ with input:
+ 
+ 
+ 
+<!--page 300 indent 5-->
+<pre>
+          56789 0123 56a72</pre>
+ will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
+ sequence 56\0. The next character read from the input stream will be a.
+ 
+<p><!--para 19-->
+ EXAMPLE 3         To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
+<p><!--para 20-->
+<pre>
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int count; float quant; char units[21], item[21];
+          do {
+                  count = fscanf(stdin, "%f%20s of %20s", &amp;quant, units, item);
+                  fscanf(stdin,"%*[^\n]");
+          } while (!feof(stdin) &amp;&amp; !ferror(stdin));</pre>
+ If the stdin stream contains the following lines:
+<pre>
+          2 quarts of oil
+          -12.8degrees Celsius
+          lots of luck
+          10.0LBS      of
+          dirt
+          100ergs of energy</pre>
+ the execution of the above example will be analogous to the following assignments:
+<pre>
+          quant     =    2; strcpy(units, "quarts"); strcpy(item, "oil");
+          count     =    3;
+          quant     =    -12.8; strcpy(units, "degrees");
+          count     =    2; // "C" fails to match "o"
+          count     =    0; // "l" fails to match "%f"
+          quant     =    10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
+          count     =    3;
+          count     =    0; // "100e" fails to match "%f"
+          count     =    EOF;</pre>
+ 
+<p><!--para 21-->
+ EXAMPLE 4         In:
+<pre>
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int d1, d2, n1, n2, i;
+          i = sscanf("123", "%d%n%n%d", &amp;d1, &amp;n1, &amp;n2, &amp;d2);</pre>
+ the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
+ of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
+ 
+<p><!--para 22-->
+ EXAMPLE 5 In these examples, multibyte characters do have a state-dependent encoding, and the
+ members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+ the first of which is denoted here by a and the second by an uppercase letter, but are only recognized as
+ such when in the alternate shift state. The shift sequences are denoted by (uparrow) and (downarrow), in which the first causes
+ entry into the alternate shift state.
+<p><!--para 23-->
+ After the call:
+<!--page 301 indent 5-->
+<pre>
+           #include &lt;stdio.h&gt;
+           /* ... */
+           char str[50];
+           fscanf(stdin, "a%s", str);</pre>
+ with the input line:
+<pre>
+           a(uparrow) X Y(downarrow) bc</pre>
+ str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
+ characters, in the more general case) appears to be a single-byte white-space character.
+<p><!--para 24-->
+ In contrast, after the call:
+<pre>
+           #include &lt;stdio.h&gt;
+           #include &lt;stddef.h&gt;
+           /* ... */
+           wchar_t wstr[50];
+           fscanf(stdin, "a%ls", wstr);</pre>
+ with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
+ terminating null wide character.
+<p><!--para 25-->
+ However, the call:
+<pre>
+           #include &lt;stdio.h&gt;
+           #include &lt;stddef.h&gt;
+           /* ... */
+           wchar_t wstr[50];
+           fscanf(stdin, "a(uparrow) X(downarrow)%ls", wstr);</pre>
+ with the same input line will return zero due to a matching failure against the (downarrow) sequence in the format
+ string.
+<p><!--para 26-->
+ Assuming that the first byte of the multibyte character X is the same as the first byte of the multibyte
+ character Y, after the call:
+<pre>
+           #include &lt;stdio.h&gt;
+           #include &lt;stddef.h&gt;
+           /* ... */
+           wchar_t wstr[50];
+           fscanf(stdin, "a(uparrow) Y(downarrow)%ls", wstr);</pre>
+ with the same input line, zero will again be returned, but stdin will be left with a partially consumed
+ multibyte character.
+ 
+ Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>), the
+ strtol, strtoll, strtoul, and strtoull functions (<a href="#7.20.1.4">7.20.1.4</a>), conversion state
+ (<a href="#7.24.6">7.24.6</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+<!--page 302 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note250">250)</a> These white-space characters are not counted against a specified field width.
+
+<p><a name="note251">251)</a> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
+ that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
+
+<p><a name="note252">252)</a> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
+ conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
+ resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
+
+<p><a name="note253">253)</a> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
+
+
+<a name="7.19.6.3" href="#7.19.6.3"><h5>7.19.6.3 The printf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int printf(const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The printf function is equivalent to fprintf with the argument stdout interposed
+ before the arguments to printf.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The printf function returns the number of characters transmitted, or a negative value if
+ an output or encoding error occurred.
+
+<a name="7.19.6.4" href="#7.19.6.4"><h5>7.19.6.4 The scanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int scanf(const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The scanf function is equivalent to fscanf with the argument stdin interposed
+ before the arguments to scanf.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The scanf function returns the value of the macro EOF if an input failure occurs before
+ any conversion. Otherwise, the scanf function returns the number of input items
+ assigned, which can be fewer than provided for, or even zero, in the event of an early
+ matching failure.
+
+<a name="7.19.6.5" href="#7.19.6.5"><h5>7.19.6.5 The snprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int snprintf(char * restrict s, size_t n,
+             const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The snprintf function is equivalent to fprintf, except that the output is written into
+ an array (specified by argument s) rather than to a stream. If n is zero, nothing is written,
+ and s may be a null pointer. Otherwise, output characters beyond the n-1st are
+ discarded rather than being written to the array, and a null character is written at the end
+ of the characters actually written into the array. If copying takes place between objects
+ that overlap, the behavior is undefined.
+<!--page 303 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The snprintf function returns the number of characters that would have been written
+ had n been sufficiently large, not counting the terminating null character, or a negative
+ value if an encoding error occurred. Thus, the null-terminated output has been
+ completely written if and only if the returned value is nonnegative and less than n.
+
+<a name="7.19.6.6" href="#7.19.6.6"><h5>7.19.6.6 The sprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int sprintf(char * restrict s,
+             const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sprintf function is equivalent to fprintf, except that the output is written into
+ an array (specified by the argument s) rather than to a stream. A null character is written
+ at the end of the characters written; it is not counted as part of the returned value. If
+ copying takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sprintf function returns the number of characters written in the array, not
+ counting the terminating null character, or a negative value if an encoding error occurred.
+
+<a name="7.19.6.7" href="#7.19.6.7"><h5>7.19.6.7 The sscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int sscanf(const char * restrict s,
+             const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sscanf function is equivalent to fscanf, except that input is obtained from a
+ string (specified by the argument s) rather than from a stream. Reaching the end of the
+ string is equivalent to encountering end-of-file for the fscanf function. If copying
+ takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the sscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+<!--page 304 indent 4-->
+
+<a name="7.19.6.8" href="#7.19.6.8"><h5>7.19.6.8 The vfprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vfprintf(FILE * restrict stream,
+             const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfprintf function is equivalent to fprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfprintf function does not invoke the
+ va_end macro.<sup><a href="#note254"><b>254)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfprintf function returns the number of characters transmitted, or a negative
+ value if an output or encoding error occurred.
+<p><!--para 4-->
+ EXAMPLE       The following shows the use of the vfprintf function in a general error-reporting routine.
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        void error(char *function_name, char *format, ...)
+        {
+              va_list args;
+                 va_start(args, format);
+                 // print out name of function causing error
+                 fprintf(stderr, "ERROR in %s: ", function_name);
+                 // print out remainder of message
+                 vfprintf(stderr, format, args);
+                 va_end(args);
+        }</pre>
+ 
+ 
+ 
+ 
+<!--page 305 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note254">254)</a> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
+ vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+
+<a name="7.19.6.9" href="#7.19.6.9"><h5>7.19.6.9 The vfscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vfscanf(FILE * restrict stream,
+             const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfscanf function is equivalent to fscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfscanf function does not invoke the
+ va_end macro.254)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the vfscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+
+<a name="7.19.6.10" href="#7.19.6.10"><h5>7.19.6.10 The vprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vprintf(const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vprintf function is equivalent to printf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vprintf function does not invoke the
+ va_end macro.254)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vprintf function returns the number of characters transmitted, or a negative value
+ if an output or encoding error occurred.
+<!--page 306 indent 4-->
+
+<a name="7.19.6.11" href="#7.19.6.11"><h5>7.19.6.11 The vscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vscanf(const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vscanf function is equivalent to scanf, with the variable argument list replaced
+ by arg, which shall have been initialized by the va_start macro (and possibly
+ subsequent va_arg calls). The vscanf function does not invoke the va_end
+ macro.254)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the vscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+
+<a name="7.19.6.12" href="#7.19.6.12"><h5>7.19.6.12 The vsnprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vsnprintf(char * restrict s, size_t n,
+             const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vsnprintf function is equivalent to snprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vsnprintf function does not invoke the
+ va_end macro.254) If copying takes place between objects that overlap, the behavior is
+ undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vsnprintf function returns the number of characters that would have been written
+ had n been sufficiently large, not counting the terminating null character, or a negative
+ value if an encoding error occurred. Thus, the null-terminated output has been
+ completely written if and only if the returned value is nonnegative and less than n.
+<!--page 307 indent 4-->
+
+<a name="7.19.6.13" href="#7.19.6.13"><h5>7.19.6.13 The vsprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vsprintf(char * restrict s,
+             const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vsprintf function is equivalent to sprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vsprintf function does not invoke the
+ va_end macro.254) If copying takes place between objects that overlap, the behavior is
+ undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vsprintf function returns the number of characters written in the array, not
+ counting the terminating null character, or a negative value if an encoding error occurred.
+
+<a name="7.19.6.14" href="#7.19.6.14"><h5>7.19.6.14 The vsscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vsscanf(const char * restrict s,
+             const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vsscanf function is equivalent to sscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vsscanf function does not invoke the
+ va_end macro.254)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vsscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the vsscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+<!--page 308 indent 4-->
+
+<a name="7.19.7" href="#7.19.7"><h4>7.19.7 Character input/output functions</h4></a>
+
+<a name="7.19.7.1" href="#7.19.7.1"><h5>7.19.7.1 The fgetc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fgetc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If the end-of-file indicator for the input stream pointed to by stream is not set and a
+ next character is present, the fgetc function obtains that character as an unsigned
+ char converted to an int and advances the associated file position indicator for the
+ stream (if defined).
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+ of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the
+ fgetc function returns the next character from the input stream pointed to by stream.
+ If a read error occurs, the error indicator for the stream is set and the fgetc function
+ returns EOF.<sup><a href="#note255"><b>255)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note255">255)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+
+
+<a name="7.19.7.2" href="#7.19.7.2"><h5>7.19.7.2 The fgets function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         char *fgets(char * restrict s, int n,
+              FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fgets function reads at most one less than the number of characters specified by n
+ from the stream pointed to by stream into the array pointed to by s. No additional
+ characters are read after a new-line character (which is retained) or after end-of-file. A
+ null character is written immediately after the last character read into the array.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fgets function returns s if successful. If end-of-file is encountered and no
+ characters have been read into the array, the contents of the array remain unchanged and a
+ null pointer is returned. If a read error occurs during the operation, the array contents are
+ indeterminate and a null pointer is returned.
+ 
+ 
+ 
+ 
+<!--page 309 indent 4-->
+
+<a name="7.19.7.3" href="#7.19.7.3"><h5>7.19.7.3 The fputc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fputc(int c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputc function writes the character specified by c (converted to an unsigned
+ char) to the output stream pointed to by stream, at the position indicated by the
+ associated file position indicator for the stream (if defined), and advances the indicator
+ appropriately. If the file cannot support positioning requests, or if the stream was opened
+ with append mode, the character is appended to the output stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputc function returns the character written. If a write error occurs, the error
+ indicator for the stream is set and fputc returns EOF.
+
+<a name="7.19.7.4" href="#7.19.7.4"><h5>7.19.7.4 The fputs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fputs(const char * restrict s,
+             FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputs function writes the string pointed to by s to the stream pointed to by
+ stream. The terminating null character is not written.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputs function returns EOF if a write error occurs; otherwise it returns a
+ nonnegative value.
+
+<a name="7.19.7.5" href="#7.19.7.5"><h5>7.19.7.5 The getc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int getc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getc function is equivalent to fgetc, except that if it is implemented as a macro, it
+ may evaluate stream more than once, so the argument should never be an expression
+ with side effects.
+<!--page 310 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getc function returns the next character from the input stream pointed to by
+ stream. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+ getc returns EOF. If a read error occurs, the error indicator for the stream is set and
+ getc returns EOF.
+
+<a name="7.19.7.6" href="#7.19.7.6"><h5>7.19.7.6 The getchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int getchar(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getchar function is equivalent to getc with the argument stdin.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getchar function returns the next character from the input stream pointed to by
+ stdin. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+ getchar returns EOF. If a read error occurs, the error indicator for the stream is set and
+ getchar returns EOF.
+
+<a name="7.19.7.7" href="#7.19.7.7"><h5>7.19.7.7 The gets function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        char *gets(char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The gets function reads characters from the input stream pointed to by stdin, into the
+ array pointed to by s, until end-of-file is encountered or a new-line character is read.
+ Any new-line character is discarded, and a null character is written immediately after the
+ last character read into the array.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The gets function returns s if successful. If end-of-file is encountered and no
+ characters have been read into the array, the contents of the array remain unchanged and a
+ null pointer is returned. If a read error occurs during the operation, the array contents are
+ indeterminate and a null pointer is returned.
+ Forward references: future library directions (<a href="#7.26.9">7.26.9</a>).
+<!--page 311 indent 4-->
+
+<a name="7.19.7.8" href="#7.19.7.8"><h5>7.19.7.8 The putc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int putc(int c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putc function is equivalent to fputc, except that if it is implemented as a macro, it
+ may evaluate stream more than once, so that argument should never be an expression
+ with side effects.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putc function returns the character written. If a write error occurs, the error
+ indicator for the stream is set and putc returns EOF.
+
+<a name="7.19.7.9" href="#7.19.7.9"><h5>7.19.7.9 The putchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int putchar(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putchar function is equivalent to putc with the second argument stdout.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putchar function returns the character written. If a write error occurs, the error
+ indicator for the stream is set and putchar returns EOF.
+
+<a name="7.19.7.10" href="#7.19.7.10"><h5>7.19.7.10 The puts function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int puts(const char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The puts function writes the string pointed to by s to the stream pointed to by stdout,
+ and appends a new-line character to the output. The terminating null character is not
+ written.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The puts function returns EOF if a write error occurs; otherwise it returns a nonnegative
+ value.
+<!--page 312 indent 4-->
+
+<a name="7.19.7.11" href="#7.19.7.11"><h5>7.19.7.11 The ungetc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdio.h&gt;
+          int ungetc(int c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ungetc function pushes the character specified by c (converted to an unsigned
+ char) back onto the input stream pointed to by stream. Pushed-back characters will be
+ returned by subsequent reads on that stream in the reverse order of their pushing. A
+ successful intervening call (with the stream pointed to by stream) to a file positioning
+ function (fseek, fsetpos, or rewind) discards any pushed-back characters for the
+ stream. The external storage corresponding to the stream is unchanged.
+<p><!--para 3-->
+ One character of pushback is guaranteed. If the ungetc function is called too many
+ times on the same stream without an intervening read or file positioning operation on that
+ stream, the operation may fail.
+<p><!--para 4-->
+ If the value of c equals that of the macro EOF, the operation fails and the input stream is
+ unchanged.
+<p><!--para 5-->
+ A successful call to the ungetc function clears the end-of-file indicator for the stream.
+ The value of the file position indicator for the stream after reading or discarding all
+ pushed-back characters shall be the same as it was before the characters were pushed
+ back. For a text stream, the value of its file position indicator after a successful call to the
+ ungetc function is unspecified until all pushed-back characters are read or discarded.
+ For a binary stream, its file position indicator is decremented by each successful call to
+ the ungetc function; if its value was zero before a call, it is indeterminate after the
+ call.<sup><a href="#note256"><b>256)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 6-->
+ The ungetc function returns the character pushed back after conversion, or EOF if the
+ operation fails.
+ Forward references: file positioning functions (<a href="#7.19.9">7.19.9</a>).
+ 
+ 
+ 
+ 
+<!--page 313 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note256">256)</a> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
+
+
+<a name="7.19.8" href="#7.19.8"><h4>7.19.8 Direct input/output functions</h4></a>
+
+<a name="7.19.8.1" href="#7.19.8.1"><h5>7.19.8.1 The fread function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
         size_t fread(void * restrict ptr,
              size_t size, size_t nmemb,
-             FILE * restrict stream);
+             FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fread function reads, into the array pointed to by ptr, up to nmemb elements
+ whose size is specified by size, from the stream pointed to by stream. For each
+ object, size calls are made to the fgetc function and the results stored, in the order
+ read, in an array of unsigned char exactly overlaying the object. The file position
+ indicator for the stream (if defined) is advanced by the number of characters successfully
+ read. If an error occurs, the resulting value of the file position indicator for the stream is
+ indeterminate. If a partial element is read, its value is indeterminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fread function returns the number of elements successfully read, which may be
+ less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero,
+ fread returns zero and the contents of the array and the state of the stream remain
+ unchanged.
+
+<a name="7.19.8.2" href="#7.19.8.2"><h5>7.19.8.2 The fwrite function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
         size_t fwrite(const void * restrict ptr,
              size_t size, size_t nmemb,
-             FILE * restrict stream);
+             FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwrite function writes, from the array pointed to by ptr, up to nmemb elements
+ whose size is specified by size, to the stream pointed to by stream. For each object,
+ size calls are made to the fputc function, taking the values (in order) from an array of
+ unsigned char exactly overlaying the object. The file position indicator for the
+ stream (if defined) is advanced by the number of characters successfully written. If an
+ error occurs, the resulting value of the file position indicator for the stream is
+ indeterminate.
+<!--page 314 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fwrite function returns the number of elements successfully written, which will be
+ less than nmemb only if a write error is encountered. If size or nmemb is zero,
+ fwrite returns zero and the state of the stream remains unchanged.
+
+<a name="7.19.9" href="#7.19.9"><h4>7.19.9 File positioning functions</h4></a>
+
+<a name="7.19.9.1" href="#7.19.9.1"><h5>7.19.9.1 The fgetpos function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
         int fgetpos(FILE * restrict stream,
-             fpos_t * restrict pos);
-        int fseek(FILE *stream, long int offset, int whence);
-        int fsetpos(FILE *stream, const fpos_t *pos);
-        long int ftell(FILE *stream);
-        void rewind(FILE *stream);
-        void clearerr(FILE *stream);
-        int feof(FILE *stream);
-        int ferror(FILE *stream);
-        void perror(const char *s);
-<a name="B.19" href="#B.19"><b>B.19 General utilities &lt;stdlib.h&gt;</b></a>
-        size_t       ldiv_t             EXIT_FAILURE      MB_CUR_MAX
-        wchar_t      lldiv_t            EXIT_SUCCESS
-        div_t        NULL               RAND_MAX
-        double atof(const char *nptr);
+             fpos_t * restrict pos);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fgetpos function stores the current values of the parse state (if any) and file
+ position indicator for the stream pointed to by stream in the object pointed to by pos.
+ The values stored contain unspecified information usable by the fsetpos function for
+ repositioning the stream to its position at the time of the call to the fgetpos function.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If successful, the fgetpos function returns zero; on failure, the fgetpos function
+ returns nonzero and stores an implementation-defined positive value in errno.
+ Forward references: the fsetpos function (<a href="#7.19.9.3">7.19.9.3</a>).
+
+<a name="7.19.9.2" href="#7.19.9.2"><h5>7.19.9.2 The fseek function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fseek(FILE *stream, long int offset, int whence);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fseek function sets the file position indicator for the stream pointed to by stream.
+ If a read or write error occurs, the error indicator for the stream is set and fseek fails.
+<p><!--para 3-->
+ For a binary stream, the new position, measured in characters from the beginning of the
+ file, is obtained by adding offset to the position specified by whence. The specified
+ position is the beginning of the file if whence is SEEK_SET, the current value of the file
+ position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
+ meaningfully support fseek calls with a whence value of SEEK_END.
+<p><!--para 4-->
+ For a text stream, either offset shall be zero, or offset shall be a value returned by
+ an earlier successful call to the ftell function on a stream associated with the same file
+ and whence shall be SEEK_SET.
+<!--page 315 indent 4-->
+<p><!--para 5-->
+ After determining the new position, a successful call to the fseek function undoes any
+ effects of the ungetc function on the stream, clears the end-of-file indicator for the
+ stream, and then establishes the new position. After a successful fseek call, the next
+ operation on an update stream may be either input or output.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The fseek function returns nonzero only for a request that cannot be satisfied.
+ Forward references: the ftell function (<a href="#7.19.9.4">7.19.9.4</a>).
+
+<a name="7.19.9.3" href="#7.19.9.3"><h5>7.19.9.3 The fsetpos function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fsetpos(FILE *stream, const fpos_t *pos);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fsetpos function sets the mbstate_t object (if any) and file position indicator
+ for the stream pointed to by stream according to the value of the object pointed to by
+ pos, which shall be a value obtained from an earlier successful call to the fgetpos
+ function on a stream associated with the same file. If a read or write error occurs, the
+ error indicator for the stream is set and fsetpos fails.
+<p><!--para 3-->
+ A successful call to the fsetpos function undoes any effects of the ungetc function
+ on the stream, clears the end-of-file indicator for the stream, and then establishes the new
+ parse state and position. After a successful fsetpos call, the next operation on an
+ update stream may be either input or output.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If successful, the fsetpos function returns zero; on failure, the fsetpos function
+ returns nonzero and stores an implementation-defined positive value in errno.
+
+<a name="7.19.9.4" href="#7.19.9.4"><h5>7.19.9.4 The ftell function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        long int ftell(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ftell function obtains the current value of the file position indicator for the stream
+ pointed to by stream. For a binary stream, the value is the number of characters from
+ the beginning of the file. For a text stream, its file position indicator contains unspecified
+ information, usable by the fseek function for returning the file position indicator for the
+ stream to its position at the time of the ftell call; the difference between two such
+ return values is not necessarily a meaningful measure of the number of characters written
+<!--page 316 indent 4-->
+ or read.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If successful, the ftell function returns the current value of the file position indicator
+ for the stream. On failure, the ftell function returns -1L and stores an
+ implementation-defined positive value in errno.
+
+<a name="7.19.9.5" href="#7.19.9.5"><h5>7.19.9.5 The rewind function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        void rewind(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rewind function sets the file position indicator for the stream pointed to by
+ stream to the beginning of the file. It is equivalent to
+<pre>
+        (void)fseek(stream, 0L, SEEK_SET)</pre>
+ except that the error indicator for the stream is also cleared.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The rewind function returns no value.
+
+<a name="7.19.10" href="#7.19.10"><h4>7.19.10 Error-handling functions</h4></a>
+
+<a name="7.19.10.1" href="#7.19.10.1"><h5>7.19.10.1 The clearerr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        void clearerr(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The clearerr function clears the end-of-file and error indicators for the stream pointed
+ to by stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The clearerr function returns no value.
+<!--page 317 indent 4-->
+
+<a name="7.19.10.2" href="#7.19.10.2"><h5>7.19.10.2 The feof function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int feof(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feof function tests the end-of-file indicator for the stream pointed to by stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feof function returns nonzero if and only if the end-of-file indicator is set for
+ stream.
+
+<a name="7.19.10.3" href="#7.19.10.3"><h5>7.19.10.3 The ferror function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int ferror(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ferror function tests the error indicator for the stream pointed to by stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ferror function returns nonzero if and only if the error indicator is set for
+ stream.
+
+<a name="7.19.10.4" href="#7.19.10.4"><h5>7.19.10.4 The perror function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        void perror(const char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The perror function maps the error number in the integer expression errno to an
+ error message. It writes a sequence of characters to the standard error stream thus: first
+ (if s is not a null pointer and the character pointed to by s is not the null character), the
+ string pointed to by s followed by a colon (:) and a space; then an appropriate error
+ message string followed by a new-line character. The contents of the error message
+ strings are the same as those returned by the strerror function with argument errno.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The perror function returns no value.
+ Forward references: the strerror function (<a href="#7.21.6.2">7.21.6.2</a>).
+<!--page 318 indent 4-->
+
+<a name="7.20" href="#7.20"><h3>7.20 General utilities <stdlib.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdlib.h&gt; declares five types and several functions of general utility, and
+ defines several macros.<sup><a href="#note257"><b>257)</b></a></sup>
+<p><!--para 2-->
+ The types declared are size_t and wchar_t (both described in <a href="#7.17">7.17</a>),
+<pre>
+          div_t</pre>
+ which is a structure type that is the type of the value returned by the div function,
+<pre>
+          ldiv_t</pre>
+ which is a structure type that is the type of the value returned by the ldiv function, and
+<pre>
+          lldiv_t</pre>
+ which is a structure type that is the type of the value returned by the lldiv function.
+<p><!--para 3-->
+ The macros defined are NULL (described in <a href="#7.17">7.17</a>);
+<pre>
+          EXIT_FAILURE</pre>
+ and
+<pre>
+          EXIT_SUCCESS</pre>
+ which expand to integer constant expressions that can be used as the argument to the
+ exit function to return unsuccessful or successful termination status, respectively, to the
+ host environment;
+<pre>
+          RAND_MAX</pre>
+ which expands to an integer constant expression that is the maximum value returned by
+ the rand function; and
+<pre>
+          MB_CUR_MAX</pre>
+ which expands to a positive integer expression with type size_t that is the maximum
+ number of bytes in a multibyte character for the extended character set specified by the
+ current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
+ 
+ 
+ 
+ 
+<!--page 319 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note257">257)</a> See ''future library directions'' (<a href="#7.26.10">7.26.10</a>).
+
+
+<a name="7.20.1" href="#7.20.1"><h4>7.20.1 Numeric conversion functions</h4></a>
+<p><!--para 1-->
+ The functions atof, atoi, atol, and atoll need not affect the value of the integer
+ expression errno on an error. If the value of the result cannot be represented, the
+ behavior is undefined.
+
+<a name="7.20.1.1" href="#7.20.1.1"><h5>7.20.1.1 The atof function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        double atof(const char *nptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atof function converts the initial portion of the string pointed to by nptr to
+ double representation. Except for the behavior on error, it is equivalent to
+<pre>
+        strtod(nptr, (char **)NULL)</pre>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atof function returns the converted value.
+ Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>).
+
+<a name="7.20.1.2" href="#7.20.1.2"><h5>7.20.1.2 The atoi, atol, and atoll functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
         int atoi(const char *nptr);
         long int atol(const char *nptr);
-        long long int atoll(const char *nptr);
+        long long int atoll(const char *nptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atoi, atol, and atoll functions convert the initial portion of the string pointed
+ to by nptr to int, long int, and long long int representation, respectively.
+ Except for the behavior on error, they are equivalent to
+<pre>
+        atoi: (int)strtol(nptr, (char **)NULL, 10)
+        atol: strtol(nptr, (char **)NULL, 10)
+        atoll: strtoll(nptr, (char **)NULL, 10)</pre>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atoi, atol, and atoll functions return the converted value.
+ Forward references: the strtol, strtoll, strtoul, and strtoull functions
+ (<a href="#7.20.1.4">7.20.1.4</a>).
+<!--page 320 indent 4-->
+
+<a name="7.20.1.3" href="#7.20.1.3"><h5>7.20.1.3 The strtod, strtof, and strtold functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
         double strtod(const char * restrict nptr,
              char ** restrict endptr);
         float strtof(const char * restrict nptr,
              char ** restrict endptr);
         long double strtold(const char * restrict nptr,
-             char ** restrict endptr);
-        long int strtol(const char * restrict nptr,
-             char ** restrict endptr, int base);
-        long long int strtoll(const char * restrict nptr,
-             char ** restrict endptr, int base);
-        unsigned long int strtoul(
-             const char * restrict nptr,
-             char ** restrict endptr, int base);
-
-[<a name="p431" href="#p431">page 431</a>] (<a href="#Contents">Contents</a>)
-
-      unsigned long long int strtoull(
-           const char * restrict nptr,
-           char ** restrict endptr, int base);
-      int rand(void);
-      void srand(unsigned int seed);
-      void *calloc(size_t nmemb, size_t size);
-      void free(void *ptr);
-      void *malloc(size_t size);
-      void *realloc(void *ptr, size_t size);
-      void abort(void);
-      int atexit(void (*func)(void));
-      void exit(int status);
-      void _Exit(int status);
-      char *getenv(const char *name);
-      int system(const char *string);
-      void *bsearch(const void *key, const void *base,
-           size_t nmemb, size_t size,
-           int (*compar)(const void *, const void *));
-      void qsort(void *base, size_t nmemb, size_t size,
-           int (*compar)(const void *, const void *));
-      int abs(int j);
-      long int labs(long int j);
-      long long int llabs(long long int j);
-      div_t div(int numer, int denom);
-      ldiv_t ldiv(long int numer, long int denom);
-      lldiv_t lldiv(long long int numer,
-           long long int denom);
-      int mblen(const char *s, size_t n);
-      int mbtowc(wchar_t * restrict pwc,
-           const char * restrict s, size_t n);
-      int wctomb(char *s, wchar_t wchar);
-      size_t mbstowcs(wchar_t * restrict pwcs,
-           const char * restrict s, size_t n);
-      size_t wcstombs(char * restrict s,
-           const wchar_t * restrict pwcs, size_t n);
-
-[<a name="p432" href="#p432">page 432</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.20" href="#B.20"><b>B.20 String handling &lt;string.h&gt;</b></a>
-        size_t
-        NULL
-        void *memcpy(void * restrict s1,
-             const void * restrict s2, size_t n);
-        void *memmove(void *s1, const void *s2, size_t n);
+             char ** restrict endptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strtod, strtof, and strtold functions convert the initial portion of the string
+ pointed to by nptr to double, float, and long double representation,
+ respectively. First, they decompose the input string into three parts: an initial, possibly
+ empty, sequence of white-space characters (as specified by the isspace function), a
+ subject sequence resembling a floating-point constant or representing an infinity or NaN;
+ and a final string of one or more unrecognized characters, including the terminating null
+ character of the input string. Then, they attempt to convert the subject sequence to a
+ floating-point number, and return the result.
+<p><!--para 3-->
+ The expected form of the subject sequence is an optional plus or minus sign, then one of
+ the following:
+<ul>
+<li>  a nonempty sequence of decimal digits optionally containing a decimal-point
+ character, then an optional exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+ decimal-point character, then an optional binary exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  INF or INFINITY, ignoring case
+<li>  NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part, where:
+<pre>
+          n-char-sequence:
+                 digit
+                 nondigit
+                 n-char-sequence digit
+                 n-char-sequence nondigit</pre>
+</ul>
+ The subject sequence is defined as the longest initial subsequence of the input string,
+ starting with the first non-white-space character, that is of the expected form. The subject
+ sequence contains no characters if the input string is not of the expected form.
+<p><!--para 4-->
+ If the subject sequence has the expected form for a floating-point number, the sequence of
+ characters starting with the first digit or the decimal-point character (whichever occurs
+ first) is interpreted as a floating constant according to the rules of <a href="#6.4.4.2">6.4.4.2</a>, except that the
+<!--page 321 indent 4-->
+ decimal-point character is used in place of a period, and that if neither an exponent part
+ nor a decimal-point character appears in a decimal floating point number, or if a binary
+ exponent part does not appear in a hexadecimal floating point number, an exponent part
+ of the appropriate type with value zero is assumed to follow the last digit in the string. If
+ the subject sequence begins with a minus sign, the sequence is interpreted as negated.<sup><a href="#note258"><b>258)</b></a></sup>
+ A character sequence INF or INFINITY is interpreted as an infinity, if representable in
+ the return type, else like a floating constant that is too large for the range of the return
+ type. A character sequence NAN or NAN(n-char-sequenceopt), is interpreted as a quiet
+ NaN, if supported in the return type, else like a subject sequence part that does not have
+ the expected form; the meaning of the n-char sequences is implementation-defined.<sup><a href="#note259"><b>259)</b></a></sup> A
+ pointer to the final string is stored in the object pointed to by endptr, provided that
+ endptr is not a null pointer.
+<p><!--para 5-->
+ If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+ value resulting from the conversion is correctly rounded.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+ Recommended practice
+<p><!--para 8-->
+ If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+ the result is not exactly representable, the result should be one of the two numbers in the
+ appropriate internal format that are adjacent to the hexadecimal floating source value,
+ with the extra stipulation that the error should have a correct sign for the current rounding
+ direction.
+<p><!--para 9-->
+ If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+ &lt;float.h&gt;) significant digits, the result should be correctly rounded. If the subject
+ sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+ consider the two bounding, adjacent decimal strings L and U, both having
+ DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+ The result should be one of the (equal or adjacent) values that would be obtained by
+ correctly rounding L and U according to the current rounding direction, with the extra
+ 
+<!--page 322 indent 5-->
+ stipulation that the error with respect to D should have a correct sign for the current
+ rounding direction.<sup><a href="#note260"><b>260)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 10-->
+ The functions return the converted value, if any. If no conversion could be performed,
+ zero is returned. If the correct value is outside the range of representable values, plus or
+ minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the return
+ type and sign of the value), and the value of the macro ERANGE is stored in errno. If
+ the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is no greater
+ than the smallest normalized positive number in the return type; whether errno acquires
+ the value ERANGE is implementation-defined.
+
+<h6>footnotes</h6>
+<p><a name="note258">258)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+ negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+ methods may yield different results if rounding is toward positive or negative infinity. In either case,
+ the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+
+<p><a name="note259">259)</a> An implementation may use the n-char sequence to determine extra information to be represented in
+ the NaN's significand.
+
+<p><a name="note260">260)</a> DECIMAL_DIG, defined in &lt;float.h&gt;, should be sufficiently large that L and U will usually round
+ to the same internal floating value, but if not will round to adjacent values.
+
+
+<a name="7.20.1.4" href="#7.20.1.4"><h5>7.20.1.4 The strtol, strtoll, strtoul, and strtoull functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         long int strtol(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);
+         long long int strtoll(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);
+         unsigned long int strtoul(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);
+         unsigned long long int strtoull(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strtol, strtoll, strtoul, and strtoull functions convert the initial
+ portion of the string pointed to by nptr to long int, long long int, unsigned
+ long int, and unsigned long long int representation, respectively. First,
+ they decompose the input string into three parts: an initial, possibly empty, sequence of
+ white-space characters (as specified by the isspace function), a subject sequence
+ 
+ 
+<!--page 323 indent 4-->
+ resembling an integer represented in some radix determined by the value of base, and a
+ final string of one or more unrecognized characters, including the terminating null
+ character of the input string. Then, they attempt to convert the subject sequence to an
+ integer, and return the result.
+<p><!--para 3-->
+ If the value of base is zero, the expected form of the subject sequence is that of an
+ integer constant as described in <a href="#6.4.4.1">6.4.4.1</a>, optionally preceded by a plus or minus sign, but
+ not including an integer suffix. If the value of base is between 2 and 36 (inclusive), the
+ expected form of the subject sequence is a sequence of letters and digits representing an
+ integer with the radix specified by base, optionally preceded by a plus or minus sign,
+ but not including an integer suffix. The letters from a (or A) through z (or Z) are
+ ascribed the values 10 through 35; only letters and digits whose ascribed values are less
+ than that of base are permitted. If the value of base is 16, the characters 0x or 0X may
+ optionally precede the sequence of letters and digits, following the sign if present.
+<p><!--para 4-->
+ The subject sequence is defined as the longest initial subsequence of the input string,
+ starting with the first non-white-space character, that is of the expected form. The subject
+ sequence contains no characters if the input string is empty or consists entirely of white
+ space, or if the first non-white-space character is other than a sign or a permissible letter
+ or digit.
+<p><!--para 5-->
+ If the subject sequence has the expected form and the value of base is zero, the sequence
+ of characters starting with the first digit is interpreted as an integer constant according to
+ the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the value of base
+ is between 2 and 36, it is used as the base for conversion, ascribing to each letter its value
+ as given above. If the subject sequence begins with a minus sign, the value resulting from
+ the conversion is negated (in the return type). A pointer to the final string is stored in the
+ object pointed to by endptr, provided that endptr is not a null pointer.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The strtol, strtoll, strtoul, and strtoull functions return the converted
+ value, if any. If no conversion could be performed, zero is returned. If the correct value
+ is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+ LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+ and sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+<!--page 324 indent 4-->
+
+<a name="7.20.2" href="#7.20.2"><h4>7.20.2 Pseudo-random sequence generation functions</h4></a>
+
+<a name="7.20.2.1" href="#7.20.2.1"><h5>7.20.2.1 The rand function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int rand(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rand function computes a sequence of pseudo-random integers in the range 0 to
+ RAND_MAX.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the rand function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The rand function returns a pseudo-random integer.
+ Environmental limits
+<p><!--para 5-->
+ The value of the RAND_MAX macro shall be at least 32767.
+
+<a name="7.20.2.2" href="#7.20.2.2"><h5>7.20.2.2 The srand function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        void srand(unsigned int seed);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The srand function uses the argument as a seed for a new sequence of pseudo-random
+ numbers to be returned by subsequent calls to rand. If srand is then called with the
+ same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is
+ called before any calls to srand have been made, the same sequence shall be generated
+ as when srand is first called with a seed value of 1.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the srand function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The srand function returns no value.
+<p><!--para 5-->
+ EXAMPLE       The following functions define a portable implementation of rand and srand.
+<!--page 325 indent 4-->
+<pre>
+        static unsigned long int next = 1;
+        int rand(void)   // RAND_MAX assumed to be 32767
+        {
+              next = next * 1103515245 + 12345;
+              return (unsigned int)(next/65536) % 32768;
+        }
+         void srand(unsigned int seed)
+         {
+               next = seed;
+         }</pre>
+ 
+
+<a name="7.20.3" href="#7.20.3"><h4>7.20.3 Memory management functions</h4></a>
+<p><!--para 1-->
+ The order and contiguity of storage allocated by successive calls to the calloc,
+ malloc, and realloc functions is unspecified. The pointer returned if the allocation
+ succeeds is suitably aligned so that it may be assigned to a pointer to any type of object
+ and then used to access such an object or an array of such objects in the space allocated
+ (until the space is explicitly deallocated). The lifetime of an allocated object extends
+ from the allocation until the deallocation. Each such allocation shall yield a pointer to an
+ object disjoint from any other object. The pointer returned points to the start (lowest byte
+ address) of the allocated space. If the space cannot be allocated, a null pointer is
+ returned. If the size of the space requested is zero, the behavior is implementation-
+ defined: either a null pointer is returned, or the behavior is as if the size were some
+ nonzero value, except that the returned pointer shall not be used to access an object.
+
+<a name="7.20.3.1" href="#7.20.3.1"><h5>7.20.3.1 The calloc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void *calloc(size_t nmemb, size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The calloc function allocates space for an array of nmemb objects, each of whose size
+ is size. The space is initialized to all bits zero.<sup><a href="#note261"><b>261)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The calloc function returns either a null pointer or a pointer to the allocated space.
+
+<h6>footnotes</h6>
+<p><a name="note261">261)</a> Note that this need not be the same as the representation of floating-point zero or a null pointer
+ constant.
+
+
+<a name="7.20.3.2" href="#7.20.3.2"><h5>7.20.3.2 The free function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void free(void *ptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The free function causes the space pointed to by ptr to be deallocated, that is, made
+ available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if
+ the argument does not match a pointer earlier returned by the calloc, malloc, or
+ 
+ 
+<!--page 326 indent 4-->
+ realloc function, or if the space has been deallocated by a call to free or realloc,
+ the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The free function returns no value.
+
+<a name="7.20.3.3" href="#7.20.3.3"><h5>7.20.3.3 The malloc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        void *malloc(size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The malloc function allocates space for an object whose size is specified by size and
+ whose value is indeterminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The malloc function returns either a null pointer or a pointer to the allocated space.
+
+<a name="7.20.3.4" href="#7.20.3.4"><h5>7.20.3.4 The realloc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        void *realloc(void *ptr, size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The realloc function deallocates the old object pointed to by ptr and returns a
+ pointer to a new object that has the size specified by size. The contents of the new
+ object shall be the same as that of the old object prior to deallocation, up to the lesser of
+ the new and old sizes. Any bytes in the new object beyond the size of the old object have
+ indeterminate values.
+<p><!--para 3-->
+ If ptr is a null pointer, the realloc function behaves like the malloc function for the
+ specified size. Otherwise, if ptr does not match a pointer earlier returned by the
+ calloc, malloc, or realloc function, or if the space has been deallocated by a call
+ to the free or realloc function, the behavior is undefined. If memory for the new
+ object cannot be allocated, the old object is not deallocated and its value is unchanged.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The realloc function returns a pointer to the new object (which may have the same
+ value as a pointer to the old object), or a null pointer if the new object could not be
+ allocated.
+<!--page 327 indent 4-->
+
+<a name="7.20.4" href="#7.20.4"><h4>7.20.4 Communication with the environment</h4></a>
+
+<a name="7.20.4.1" href="#7.20.4.1"><h5>7.20.4.1 The abort function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        void abort(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The abort function causes abnormal program termination to occur, unless the signal
+ SIGABRT is being caught and the signal handler does not return. Whether open streams
+ with unwritten buffered data are flushed, open streams are closed, or temporary files are
+ removed is implementation-defined. An implementation-defined form of the status
+ unsuccessful termination is returned to the host environment by means of the function
+ call raise(SIGABRT).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The abort function does not return to its caller.
+
+<a name="7.20.4.2" href="#7.20.4.2"><h5>7.20.4.2 The atexit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int atexit(void (*func)(void));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atexit function registers the function pointed to by func, to be called without
+ arguments at normal program termination.
+ Environmental limits
+<p><!--para 3-->
+ The implementation shall support the registration of at least 32 functions.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The atexit function returns zero if the registration succeeds, nonzero if it fails.
+ Forward references: the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+
+<a name="7.20.4.3" href="#7.20.4.3"><h5>7.20.4.3 The exit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        void exit(int status);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The exit function causes normal program termination to occur. If more than one call to
+ the exit function is executed by a program, the behavior is undefined.
+<!--page 328 indent 4-->
+<p><!--para 3-->
+ First, all functions registered by the atexit function are called, in the reverse order of
+ their registration,<sup><a href="#note262"><b>262)</b></a></sup> except that a function is called after any previously registered
+ functions that had already been called at the time it was registered. If, during the call to
+ any such function, a call to the longjmp function is made that would terminate the call
+ to the registered function, the behavior is undefined.
+<p><!--para 4-->
+ Next, all open streams with unwritten buffered data are flushed, all open streams are
+ closed, and all files created by the tmpfile function are removed.
+<p><!--para 5-->
+ Finally, control is returned to the host environment. If the value of status is zero or
+ EXIT_SUCCESS, an implementation-defined form of the status successful termination is
+ returned. If the value of status is EXIT_FAILURE, an implementation-defined form
+ of the status unsuccessful termination is returned. Otherwise the status returned is
+ implementation-defined.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The exit function cannot return to its caller.
+
+<h6>footnotes</h6>
+<p><a name="note262">262)</a> Each function is called as many times as it was registered, and in the correct order with respect to
+ other registered functions.
+
+
+<a name="7.20.4.4" href="#7.20.4.4"><h5>7.20.4.4 The _Exit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void _Exit(int status);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The _Exit function causes normal program termination to occur and control to be
+ returned to the host environment. No functions registered by the atexit function or
+ signal handlers registered by the signal function are called. The status returned to the
+ host environment is determined in the same way as for the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+ Whether open streams with unwritten buffered data are flushed, open streams are closed,
+ or temporary files are removed is implementation-defined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The _Exit function cannot return to its caller.
+ 
+ 
+ 
+ 
+<!--page 329 indent 4-->
+
+<a name="7.20.4.5" href="#7.20.4.5"><h5>7.20.4.5 The getenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        char *getenv(const char *name);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getenv function searches an environment list, provided by the host environment,
+ for a string that matches the string pointed to by name. The set of environment names
+ and the method for altering the environment list are implementation-defined.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the getenv function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The getenv function returns a pointer to a string associated with the matched list
+ member. The string pointed to shall not be modified by the program, but may be
+ overwritten by a subsequent call to the getenv function. If the specified name cannot
+ be found, a null pointer is returned.
+
+<a name="7.20.4.6" href="#7.20.4.6"><h5>7.20.4.6 The system function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int system(const char *string);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If string is a null pointer, the system function determines whether the host
+ environment has a command processor. If string is not a null pointer, the system
+ function passes the string pointed to by string to that command processor to be
+ executed in a manner which the implementation shall document; this might then cause the
+ program calling system to behave in a non-conforming manner or to terminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a null pointer, the system function returns nonzero only if a
+ command processor is available. If the argument is not a null pointer, and the system
+ function does return, it returns an implementation-defined value.
+<!--page 330 indent 4-->
+
+<a name="7.20.5" href="#7.20.5"><h4>7.20.5 Searching and sorting utilities</h4></a>
+<p><!--para 1-->
+ These utilities make use of a comparison function to search or sort arrays of unspecified
+ type. Where an argument declared as size_t nmemb specifies the length of the array
+ for a function, nmemb can have the value zero on a call to that function; the comparison
+ function is not called, a search finds no matching element, and sorting performs no
+ rearrangement. Pointer arguments on such a call shall still have valid values, as described
+ in <a href="#7.1.4">7.1.4</a>.
+<p><!--para 2-->
+ The implementation shall ensure that the second argument of the comparison function
+ (when called from bsearch), or both arguments (when called from qsort), are
+ pointers to elements of the array.<sup><a href="#note263"><b>263)</b></a></sup> The first argument when called from bsearch
+ shall equal key.
+<p><!--para 3-->
+ The comparison function shall not alter the contents of the array. The implementation
+ may reorder elements of the array between calls to the comparison function, but shall not
+ alter the contents of any individual element.
+<p><!--para 4-->
+ When the same objects (consisting of size bytes, irrespective of their current positions
+ in the array) are passed more than once to the comparison function, the results shall be
+ consistent with one another. That is, for qsort they shall define a total ordering on the
+ array, and for bsearch the same object shall always compare the same way with the
+ key.
+<p><!--para 5-->
+ A sequence point occurs immediately before and immediately after each call to the
+ comparison function, and also between any call to the comparison function and any
+ movement of the objects passed as arguments to that call.
+
+<h6>footnotes</h6>
+<p><a name="note263">263)</a> That is, if the value passed is p, then the following expressions are always nonzero:
+
+<pre>
+          ((char *)p - (char *)base) % size == 0
+          (char *)p &gt;= (char *)base
+          (char *)p &lt; (char *)base + nmemb * size</pre>
+
+
+<a name="7.20.5.1" href="#7.20.5.1"><h5>7.20.5.1 The bsearch function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          void *bsearch(const void *key, const void *base,
+               size_t nmemb, size_t size,
+               int (*compar)(const void *, const void *));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The bsearch function searches an array of nmemb objects, the initial element of which
+ is pointed to by base, for an element that matches the object pointed to by key. The
+ 
+ 
+<!--page 331 indent 4-->
+ size of each element of the array is specified by size.
+<p><!--para 3-->
+ The comparison function pointed to by compar is called with two arguments that point
+ to the key object and to an array element, in that order. The function shall return an
+ integer less than, equal to, or greater than zero if the key object is considered,
+ respectively, to be less than, to match, or to be greater than the array element. The array
+ shall consist of: all the elements that compare less than, all the elements that compare
+ equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note264"><b>264)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The bsearch function returns a pointer to a matching element of the array, or a null
+ pointer if no match is found. If two elements compare as equal, which element is
+ matched is unspecified.
+
+<h6>footnotes</h6>
+<p><a name="note264">264)</a> In practice, the entire array is sorted according to the comparison function.
+
+
+<a name="7.20.5.2" href="#7.20.5.2"><h5>7.20.5.2 The qsort function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          void qsort(void *base, size_t nmemb, size_t size,
+               int (*compar)(const void *, const void *));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The qsort function sorts an array of nmemb objects, the initial element of which is
+ pointed to by base. The size of each object is specified by size.
+<p><!--para 3-->
+ The contents of the array are sorted into ascending order according to a comparison
+ function pointed to by compar, which is called with two arguments that point to the
+ objects being compared. The function shall return an integer less than, equal to, or
+ greater than zero if the first argument is considered to be respectively less than, equal to,
+ or greater than the second.
+<p><!--para 4-->
+ If two elements compare as equal, their order in the resulting sorted array is unspecified.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The qsort function returns no value.
+ 
+ 
+ 
+ 
+<!--page 332 indent 4-->
+
+<a name="7.20.6" href="#7.20.6"><h4>7.20.6 Integer arithmetic functions</h4></a>
+
+<a name="7.20.6.1" href="#7.20.6.1"><h5>7.20.6.1 The abs, labs and llabs functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         int abs(int j);
+         long int labs(long int j);
+         long long int llabs(long long int j);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The abs, labs, and llabs functions compute the absolute value of an integer j. If the
+ result cannot be represented, the behavior is undefined.<sup><a href="#note265"><b>265)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The abs, labs, and llabs, functions return the absolute value.
+
+<h6>footnotes</h6>
+<p><a name="note265">265)</a> The absolute value of the most negative number cannot be represented in two's complement.
+
+
+<a name="7.20.6.2" href="#7.20.6.2"><h5>7.20.6.2 The div, ldiv, and lldiv functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         div_t div(int numer, int denom);
+         ldiv_t ldiv(long int numer, long int denom);
+         lldiv_t lldiv(long long int numer, long long int denom);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The div, ldiv, and lldiv, functions compute numer / denom and numer %
+ denom in a single operation.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The div, ldiv, and lldiv functions return a structure of type div_t, ldiv_t, and
+ lldiv_t, respectively, comprising both the quotient and the remainder. The structures
+ shall contain (in either order) the members quot (the quotient) and rem (the remainder),
+ each of which has the same type as the arguments numer and denom. If either part of
+ the result cannot be represented, the behavior is undefined.
+ 
+ 
+ 
+ 
+<!--page 333 indent 4-->
+
+<a name="7.20.7" href="#7.20.7"><h4>7.20.7 Multibyte/wide character conversion functions</h4></a>
+<p><!--para 1-->
+ The behavior of the multibyte character functions is affected by the LC_CTYPE category
+ of the current locale. For a state-dependent encoding, each function is placed into its
+ initial conversion state by a call for which its character pointer argument, s, is a null
+ pointer. Subsequent calls with s as other than a null pointer cause the internal conversion
+ state of the function to be altered as necessary. A call with s as a null pointer causes
+ these functions to return a nonzero value if encodings have state dependency, and zero
+ otherwise.<sup><a href="#note266"><b>266)</b></a></sup> Changing the LC_CTYPE category causes the conversion state of these
+ functions to be indeterminate.
+
+<h6>footnotes</h6>
+<p><a name="note266">266)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+ character codes, but are grouped with an adjacent multibyte character.
+
+
+<a name="7.20.7.1" href="#7.20.7.1"><h5>7.20.7.1 The mblen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         int mblen(const char *s, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is not a null pointer, the mblen function determines the number of bytes contained
+ in the multibyte character pointed to by s. Except that the conversion state of the
+ mbtowc function is not affected, it is equivalent to
+<p><!--para 3-->
+<pre>
+         mbtowc((wchar_t *)0, s, n);</pre>
+ The implementation shall behave as if no library function calls the mblen function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If s is a null pointer, the mblen function returns a nonzero or zero value, if multibyte
+ character encodings, respectively, do or do not have state-dependent encodings. If s is
+ not a null pointer, the mblen function either returns 0 (if s points to the null character),
+ or returns the number of bytes that are contained in the multibyte character (if the next n
+ or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
+ multibyte character).
+ Forward references: the mbtowc function (<a href="#7.20.7.2">7.20.7.2</a>).
+ 
+ 
+ 
+ 
+<!--page 334 indent 4-->
+
+<a name="7.20.7.2" href="#7.20.7.2"><h5>7.20.7.2 The mbtowc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int mbtowc(wchar_t * restrict pwc,
+             const char * restrict s,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is not a null pointer, the mbtowc function inspects at most n bytes beginning with
+ the byte pointed to by s to determine the number of bytes needed to complete the next
+ multibyte character (including any shift sequences). If the function determines that the
+ next multibyte character is complete and valid, it determines the value of the
+ corresponding wide character and then, if pwc is not a null pointer, stores that value in
+ the object pointed to by pwc. If the corresponding wide character is the null wide
+ character, the function is left in the initial conversion state.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the mbtowc function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If s is a null pointer, the mbtowc function returns a nonzero or zero value, if multibyte
+ character encodings, respectively, do or do not have state-dependent encodings. If s is
+ not a null pointer, the mbtowc function either returns 0 (if s points to the null character),
+ or returns the number of bytes that are contained in the converted multibyte character (if
+ the next n or fewer bytes form a valid multibyte character), or returns -1 (if they do not
+ form a valid multibyte character).
+<p><!--para 5-->
+ In no case will the value returned be greater than n or the value of the MB_CUR_MAX
+ macro.
+
+<a name="7.20.7.3" href="#7.20.7.3"><h5>7.20.7.3 The wctomb function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int wctomb(char *s, wchar_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctomb function determines the number of bytes needed to represent the multibyte
+ character corresponding to the wide character given by wc (including any shift
+ sequences), and stores the multibyte character representation in the array whose first
+ element is pointed to by s (if s is not a null pointer). At most MB_CUR_MAX characters
+ are stored. If wc is a null wide character, a null byte is stored, preceded by any shift
+ sequence needed to restore the initial shift state, and the function is left in the initial
+ conversion state.
+<!--page 335 indent 4-->
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the wctomb function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If s is a null pointer, the wctomb function returns a nonzero or zero value, if multibyte
+ character encodings, respectively, do or do not have state-dependent encodings. If s is
+ not a null pointer, the wctomb function returns -1 if the value of wc does not correspond
+ to a valid multibyte character, or returns the number of bytes that are contained in the
+ multibyte character corresponding to the value of wc.
+<p><!--para 5-->
+ In no case will the value returned be greater than the value of the MB_CUR_MAX macro.
+
+<a name="7.20.8" href="#7.20.8"><h4>7.20.8 Multibyte/wide string conversion functions</h4></a>
+<p><!--para 1-->
+ The behavior of the multibyte string functions is affected by the LC_CTYPE category of
+ the current locale.
+
+<a name="7.20.8.1" href="#7.20.8.1"><h5>7.20.8.1 The mbstowcs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          size_t mbstowcs(wchar_t * restrict pwcs,
+               const char * restrict s,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mbstowcs function converts a sequence of multibyte characters that begins in the
+ initial shift state from the array pointed to by s into a sequence of corresponding wide
+ characters and stores not more than n wide characters into the array pointed to by pwcs.
+ No multibyte characters that follow a null character (which is converted into a null wide
+ character) will be examined or converted. Each multibyte character is converted as if by
+ a call to the mbtowc function, except that the conversion state of the mbtowc function is
+ not affected.
+<p><!--para 3-->
+ No more than n elements will be modified in the array pointed to by pwcs. If copying
+ takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If an invalid multibyte character is encountered, the mbstowcs function returns
+ (size_t)(-1). Otherwise, the mbstowcs function returns the number of array
+ elements modified, not including a terminating null wide character, if any.<sup><a href="#note267"><b>267)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 336 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note267">267)</a> The array will not be null-terminated if the value returned is n.
+
+
+<a name="7.20.8.2" href="#7.20.8.2"><h5>7.20.8.2 The wcstombs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        size_t wcstombs(char * restrict s,
+             const wchar_t * restrict pwcs,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstombs function converts a sequence of wide characters from the array pointed
+ to by pwcs into a sequence of corresponding multibyte characters that begins in the
+ initial shift state, and stores these multibyte characters into the array pointed to by s,
+ stopping if a multibyte character would exceed the limit of n total bytes or if a null
+ character is stored. Each wide character is converted as if by a call to the wctomb
+ function, except that the conversion state of the wctomb function is not affected.
+<p><!--para 3-->
+ No more than n bytes will be modified in the array pointed to by s. If copying takes place
+ between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If a wide character is encountered that does not correspond to a valid multibyte character,
+ the wcstombs function returns (size_t)(-1). Otherwise, the wcstombs function
+ returns the number of bytes modified, not including a terminating null character, if
+ any.267)
+<!--page 337 indent 4-->
+
+<a name="7.21" href="#7.21"><h3>7.21 String handling <string.h></h3></a>
+
+<a name="7.21.1" href="#7.21.1"><h4>7.21.1 String function conventions</h4></a>
+<p><!--para 1-->
+ The header &lt;string.h&gt; declares one type and several functions, and defines one
+ macro useful for manipulating arrays of character type and other objects treated as arrays
+ of character type.<sup><a href="#note268"><b>268)</b></a></sup> The type is size_t and the macro is NULL (both described in
+ <a href="#7.17">7.17</a>). Various methods are used for determining the lengths of the arrays, but in all cases
+ a char * or void * argument points to the initial (lowest addressed) character of the
+ array. If an array is accessed beyond the end of an object, the behavior is undefined.
+<p><!--para 2-->
+ Where an argument declared as size_t n specifies the length of the array for a
+ function, n can have the value zero on a call to that function. Unless explicitly stated
+ otherwise in the description of a particular function in this subclause, pointer arguments
+ on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+ function that locates a character finds no occurrence, a function that compares two
+ character sequences returns zero, and a function that copies characters copies zero
+ characters.
+<p><!--para 3-->
+ For all functions in this subclause, each character shall be interpreted as if it had the type
+ unsigned char (and therefore every possible object representation is valid and has a
+ different value).
+
+<h6>footnotes</h6>
+<p><a name="note268">268)</a> See ''future library directions'' (<a href="#7.26.11">7.26.11</a>).
+
+
+<a name="7.21.2" href="#7.21.2"><h4>7.21.2 Copying functions</h4></a>
+
+<a name="7.21.2.1" href="#7.21.2.1"><h5>7.21.2.1 The memcpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;string.h&gt;
+          void *memcpy(void * restrict s1,
+               const void * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memcpy function copies n characters from the object pointed to by s2 into the
+ object pointed to by s1. If copying takes place between objects that overlap, the behavior
+ is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memcpy function returns the value of s1.
+ 
+ 
+ 
+ 
+<!--page 338 indent 4-->
+
+<a name="7.21.2.2" href="#7.21.2.2"><h5>7.21.2.2 The memmove function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        void *memmove(void *s1, const void *s2, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memmove function copies n characters from the object pointed to by s2 into the
+ object pointed to by s1. Copying takes place as if the n characters from the object
+ pointed to by s2 are first copied into a temporary array of n characters that does not
+ overlap the objects pointed to by s1 and s2, and then the n characters from the
+ temporary array are copied into the object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memmove function returns the value of s1.
+
+<a name="7.21.2.3" href="#7.21.2.3"><h5>7.21.2.3 The strcpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
         char *strcpy(char * restrict s1,
-             const char * restrict s2);
+             const char * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcpy function copies the string pointed to by s2 (including the terminating null
+ character) into the array pointed to by s1. If copying takes place between objects that
+ overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcpy function returns the value of s1.
+
+<a name="7.21.2.4" href="#7.21.2.4"><h5>7.21.2.4 The strncpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
         char *strncpy(char * restrict s1,
-             const char * restrict s2, size_t n);
-        char *strcat(char * restrict s1,
-             const char * restrict s2);
-        char *strncat(char * restrict s1,
-             const char * restrict s2, size_t n);
-        int memcmp(const void *s1, const void *s2, size_t n);
-        int strcmp(const char *s1, const char *s2);
-        int strcoll(const char *s1, const char *s2);
-        int strncmp(const char *s1, const char *s2, size_t n);
+             const char * restrict s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strncpy function copies not more than n characters (characters that follow a null
+ character are not copied) from the array pointed to by s2 to the array pointed to by
+<!--page 339 indent 4-->
+ s1.<sup><a href="#note269"><b>269)</b></a></sup> If copying takes place between objects that overlap, the behavior is undefined.
+<p><!--para 3-->
+ If the array pointed to by s2 is a string that is shorter than n characters, null characters
+ are appended to the copy in the array pointed to by s1, until n characters in all have been
+ written.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The strncpy function returns the value of s1.
+
+<h6>footnotes</h6>
+<p><a name="note269">269)</a> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
+ not be null-terminated.
+
+
+<a name="7.21.3" href="#7.21.3"><h4>7.21.3 Concatenation functions</h4></a>
+
+<a name="7.21.3.1" href="#7.21.3.1"><h5>7.21.3.1 The strcat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;string.h&gt;
+          char *strcat(char * restrict s1,
+               const char * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcat function appends a copy of the string pointed to by s2 (including the
+ terminating null character) to the end of the string pointed to by s1. The initial character
+ of s2 overwrites the null character at the end of s1. If copying takes place between
+ objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcat function returns the value of s1.
+
+<a name="7.21.3.2" href="#7.21.3.2"><h5>7.21.3.2 The strncat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;string.h&gt;
+          char *strncat(char * restrict s1,
+               const char * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strncat function appends not more than n characters (a null character and
+ characters that follow it are not appended) from the array pointed to by s2 to the end of
+ the string pointed to by s1. The initial character of s2 overwrites the null character at the
+ end of s1. A terminating null character is always appended to the result.<sup><a href="#note270"><b>270)</b></a></sup> If copying
+ 
+<!--page 340 indent 4-->
+ takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strncat function returns the value of s1.
+ Forward references: the strlen function (<a href="#7.21.6.3">7.21.6.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note270">270)</a> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
+ strlen(s1)+n+1.
+
+
+<a name="7.21.4" href="#7.21.4"><h4>7.21.4 Comparison functions</h4></a>
+<p><!--para 1-->
+ The sign of a nonzero value returned by the comparison functions memcmp, strcmp,
+ and strncmp is determined by the sign of the difference between the values of the first
+ pair of characters (both interpreted as unsigned char) that differ in the objects being
+ compared.
+
+<a name="7.21.4.1" href="#7.21.4.1"><h5>7.21.4.1 The memcmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         int memcmp(const void *s1, const void *s2, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memcmp function compares the first n characters of the object pointed to by s1 to
+ the first n characters of the object pointed to by s2.<sup><a href="#note271"><b>271)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memcmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+ pointed to by s2.
+
+<h6>footnotes</h6>
+<p><a name="note271">271)</a> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
+ indeterminate. Strings shorter than their allocated space and unions may also cause problems in
+ comparison.
+
+
+<a name="7.21.4.2" href="#7.21.4.2"><h5>7.21.4.2 The strcmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         int strcmp(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcmp function compares the string pointed to by s1 to the string pointed to by
+ s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+ 
+<!--page 341 indent 4-->
+ pointed to by s2.
+
+<a name="7.21.4.3" href="#7.21.4.3"><h5>7.21.4.3 The strcoll function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        int strcoll(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcoll function compares the string pointed to by s1 to the string pointed to by
+ s2, both interpreted as appropriate to the LC_COLLATE category of the current locale.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcoll function returns an integer greater than, equal to, or less than zero,
+ accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+ pointed to by s2 when both are interpreted as appropriate to the current locale.
+
+<a name="7.21.4.4" href="#7.21.4.4"><h5>7.21.4.4 The strncmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        int strncmp(const char *s1, const char *s2, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strncmp function compares not more than n characters (characters that follow a
+ null character are not compared) from the array pointed to by s1 to the array pointed to
+ by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strncmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+ to, or less than the possibly null-terminated array pointed to by s2.
+
+<a name="7.21.4.5" href="#7.21.4.5"><h5>7.21.4.5 The strxfrm function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
         size_t strxfrm(char * restrict s1,
-             const char * restrict s2, size_t n);
-        void *memchr(const void *s, int c, size_t n);
-        char *strchr(const char *s, int c);
-        size_t strcspn(const char *s1, const char *s2);
-        char *strpbrk(const char *s1, const char *s2);
-        char *strrchr(const char *s, int c);
-        size_t strspn(const char *s1, const char *s2);
-        char *strstr(const char *s1, const char *s2);
+             const char * restrict s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strxfrm function transforms the string pointed to by s2 and places the resulting
+ string into the array pointed to by s1. The transformation is such that if the strcmp
+ function is applied to two transformed strings, it returns a value greater than, equal to, or
+<!--page 342 indent 4-->
+ less than zero, corresponding to the result of the strcoll function applied to the same
+ two original strings. No more than n characters are placed into the resulting array
+ pointed to by s1, including the terminating null character. If n is zero, s1 is permitted to
+ be a null pointer. If copying takes place between objects that overlap, the behavior is
+ undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strxfrm function returns the length of the transformed string (not including the
+ terminating null character). If the value returned is n or more, the contents of the array
+ pointed to by s1 are indeterminate.
+<p><!--para 4-->
+ EXAMPLE The value of the following expression is the size of the array needed to hold the
+ transformation of the string pointed to by s.
+<pre>
+        1 + strxfrm(NULL, s, 0)</pre>
+ 
+
+<a name="7.21.5" href="#7.21.5"><h4>7.21.5 Search functions</h4></a>
+
+<a name="7.21.5.1" href="#7.21.5.1"><h5>7.21.5.1 The memchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        void *memchr(const void *s, int c, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memchr function locates the first occurrence of c (converted to an unsigned
+ char) in the initial n characters (each interpreted as unsigned char) of the object
+ pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memchr function returns a pointer to the located character, or a null pointer if the
+ character does not occur in the object.
+
+<a name="7.21.5.2" href="#7.21.5.2"><h5>7.21.5.2 The strchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        char *strchr(const char *s, int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strchr function locates the first occurrence of c (converted to a char) in the
+ string pointed to by s. The terminating null character is considered to be part of the
+ string.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strchr function returns a pointer to the located character, or a null pointer if the
+ character does not occur in the string.
+<!--page 343 indent 4-->
+
+<a name="7.21.5.3" href="#7.21.5.3"><h5>7.21.5.3 The strcspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        size_t strcspn(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcspn function computes the length of the maximum initial segment of the string
+ pointed to by s1 which consists entirely of characters not from the string pointed to by
+ s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcspn function returns the length of the segment.
+
+<a name="7.21.5.4" href="#7.21.5.4"><h5>7.21.5.4 The strpbrk function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        char *strpbrk(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strpbrk function locates the first occurrence in the string pointed to by s1 of any
+ character from the string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strpbrk function returns a pointer to the character, or a null pointer if no character
+ from s2 occurs in s1.
+
+<a name="7.21.5.5" href="#7.21.5.5"><h5>7.21.5.5 The strrchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        char *strrchr(const char *s, int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strrchr function locates the last occurrence of c (converted to a char) in the
+ string pointed to by s. The terminating null character is considered to be part of the
+ string.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strrchr function returns a pointer to the character, or a null pointer if c does not
+ occur in the string.
+<!--page 344 indent 4-->
+
+<a name="7.21.5.6" href="#7.21.5.6"><h5>7.21.5.6 The strspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        size_t strspn(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strspn function computes the length of the maximum initial segment of the string
+ pointed to by s1 which consists entirely of characters from the string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strspn function returns the length of the segment.
+
+<a name="7.21.5.7" href="#7.21.5.7"><h5>7.21.5.7 The strstr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        char *strstr(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strstr function locates the first occurrence in the string pointed to by s1 of the
+ sequence of characters (excluding the terminating null character) in the string pointed to
+ by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strstr function returns a pointer to the located string, or a null pointer if the string
+ is not found. If s2 points to a string with zero length, the function returns s1.
+
+<a name="7.21.5.8" href="#7.21.5.8"><h5>7.21.5.8 The strtok function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
         char *strtok(char * restrict s1,
-             const char * restrict s2);
-        void *memset(void *s, int c, size_t n);
-        char *strerror(int errnum);
-        size_t strlen(const char *s);
-
-[<a name="p433" href="#p433">page 433</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.21" href="#B.21"><b>B.21 Type-generic math &lt;tgmath.h&gt;</b></a>
-      acos           sqrt               fmod              nextafter
-      asin           fabs               frexp             nexttoward
-      atan           atan2              hypot             remainder
-      acosh          cbrt               ilogb             remquo
-      asinh          ceil               ldexp             rint
-      atanh          copysign           lgamma            round
-      cos            erf                llrint            scalbn
-      sin            erfc               llround           scalbln
-      tan            exp2               log10             tgamma
-      cosh           expm1              log1p             trunc
-      sinh           fdim               log2              carg
-      tanh           floor              logb              cimag
-      exp            fma                lrint             conj
-      log            fmax               lround            cproj
-      pow            fmin               nearbyint         creal
-<a name="B.22" href="#B.22"><b>B.22 Date and time &lt;time.h&gt;</b></a>
-      NULL                  size_t                  time_t
-      CLOCKS_PER_SEC        clock_t                 struct tm
-      clock_t clock(void);
-      double difftime(time_t time1, time_t time0);
-      time_t mktime(struct tm *timeptr);
-      time_t time(time_t *timer);
-      char *asctime(const struct tm *timeptr);
-      char *ctime(const time_t *timer);
-      struct tm *gmtime(const time_t *timer);
-      struct tm *localtime(const time_t *timer);
-      size_t strftime(char * restrict s,
-           size_t maxsize,
-           const char * restrict format,
-           const struct tm * restrict timeptr);
-
-[<a name="p434" href="#p434">page 434</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.23" href="#B.23"><b>B.23 Extended multibyte/wide character utilities &lt;wchar.h&gt;</b></a>
-        wchar_t       wint_t             WCHAR_MAX
-        size_t        struct tm          WCHAR_MIN
-        mbstate_t     NULL               WEOF
-        int fwprintf(FILE * restrict stream,
-             const wchar_t * restrict format, ...);
+             const char * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A sequence of calls to the strtok function breaks the string pointed to by s1 into a
+ sequence of tokens, each of which is delimited by a character from the string pointed to
+ by s2. The first call in the sequence has a non-null first argument; subsequent calls in the
+ sequence have a null first argument. The separator string pointed to by s2 may be
+ different from call to call.
+<p><!--para 3-->
+ The first call in the sequence searches the string pointed to by s1 for the first character
+ that is not contained in the current separator string pointed to by s2. If no such character
+ is found, then there are no tokens in the string pointed to by s1 and the strtok function
+<!--page 345 indent 4-->
+ returns a null pointer. If such a character is found, it is the start of the first token.
+<p><!--para 4-->
+ The strtok function then searches from there for a character that is contained in the
+ current separator string. If no such character is found, the current token extends to the
+ end of the string pointed to by s1, and subsequent searches for a token will return a null
+ pointer. If such a character is found, it is overwritten by a null character, which
+ terminates the current token. The strtok function saves a pointer to the following
+ character, from which the next search for a token will start.
+<p><!--para 5-->
+ Each subsequent call, with a null pointer as the value of the first argument, starts
+ searching from the saved pointer and behaves as described above.
+<p><!--para 6-->
+ The implementation shall behave as if no library function calls the strtok function.
+<h6>Returns</h6>
+<p><!--para 7-->
+ The strtok function returns a pointer to the first character of a token, or a null pointer
+ if there is no token.
+<p><!--para 8-->
+ EXAMPLE
+<pre>
+         #include &lt;string.h&gt;
+         static char str[] = "?a???b,,,#c";
+         char *t;
+         t   =   strtok(str, "?");       //   t   points to the token "a"
+         t   =   strtok(NULL, ",");      //   t   points to the token "??b"
+         t   =   strtok(NULL, "#,");     //   t   points to the token "c"
+         t   =   strtok(NULL, "?");      //   t   is a null pointer</pre>
+ 
+
+<a name="7.21.6" href="#7.21.6"><h4>7.21.6 Miscellaneous functions</h4></a>
+
+<a name="7.21.6.1" href="#7.21.6.1"><h5>7.21.6.1 The memset function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         void *memset(void *s, int c, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memset function copies the value of c (converted to an unsigned char) into
+ each of the first n characters of the object pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memset function returns the value of s.
+<!--page 346 indent 4-->
+
+<a name="7.21.6.2" href="#7.21.6.2"><h5>7.21.6.2 The strerror function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        char *strerror(int errnum);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strerror function maps the number in errnum to a message string. Typically,
+ the values for errnum come from errno, but strerror shall map any value of type
+ int to a message.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the strerror function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The strerror function returns a pointer to the string, the contents of which are locale-
+ specific. The array pointed to shall not be modified by the program, but may be
+ overwritten by a subsequent call to the strerror function.
+
+<a name="7.21.6.3" href="#7.21.6.3"><h5>7.21.6.3 The strlen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        size_t strlen(const char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strlen function computes the length of the string pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strlen function returns the number of characters that precede the terminating null
+ character.
+<!--page 347 indent 4-->
+
+<a name="7.22" href="#7.22"><h3>7.22 Type-generic math <tgmath.h></h3></a>
+<p><!--para 1-->
+ The header &lt;tgmath.h&gt; includes the headers &lt;math.h&gt; and &lt;complex.h&gt; and
+ defines several type-generic macros.
+<p><!--para 2-->
+ Of the &lt;math.h&gt; and &lt;complex.h&gt; functions without an f (float) or l (long
+ double) suffix, several have one or more parameters whose corresponding real type is
+ double. For each such function, except modf, there is a corresponding type-generic
+ macro.<sup><a href="#note272"><b>272)</b></a></sup> The parameters whose corresponding real type is double in the function
+ synopsis are generic parameters. Use of the macro invokes a function whose
+ corresponding real type and type domain are determined by the arguments for the generic
+ parameters.<sup><a href="#note273"><b>273)</b></a></sup>
+<p><!--para 3-->
+ Use of the macro invokes a function whose generic parameters have the corresponding
+ real type determined as follows:
+<ul>
+<li>  First, if any argument for generic parameters has type long double, the type
+ determined is long double.
+<li>  Otherwise, if any argument for generic parameters has type double or is of integer
+ type, the type determined is double.
+<li>  Otherwise, the type determined is float.
+</ul>
+<p><!--para 4-->
+ For each unsuffixed function in &lt;math.h&gt; for which there is a function in
+ &lt;complex.h&gt; with the same name except for a c prefix, the corresponding type-
+ generic macro (for both functions) has the same name as the function in &lt;math.h&gt;. The
+ corresponding type-generic macro for fabs and cabs is fabs.
+ 
+ 
+ 
+ 
+<!--page 348 indent 4-->
+<pre>
+         &lt;math.h&gt;          &lt;complex.h&gt;           type-generic
+          function            function              macro
+           acos               cacos                acos
+           asin               casin                asin
+           atan               catan                atan
+           acosh              cacosh               acosh
+           asinh              casinh               asinh
+           atanh              catanh               atanh
+           cos                ccos                 cos
+           sin                csin                 sin
+           tan                ctan                 tan
+           cosh               ccosh                cosh
+           sinh               csinh                sinh
+           tanh               ctanh                tanh
+           exp                cexp                 exp
+           log                clog                 log
+           pow                cpow                 pow
+           sqrt               csqrt                sqrt
+           fabs               cabs                 fabs</pre>
+ If at least one argument for a generic parameter is complex, then use of the macro invokes
+ a complex function; otherwise, use of the macro invokes a real function.
+<p><!--para 5-->
+ For each unsuffixed function in &lt;math.h&gt; without a c-prefixed counterpart in
+ &lt;complex.h&gt; (except modf), the corresponding type-generic macro has the same
+ name as the function. These type-generic macros are:
+<pre>
+       atan2                fma                  llround              remainder
+       cbrt                 fmax                 log10                remquo
+       ceil                 fmin                 log1p                rint
+       copysign             fmod                 log2                 round
+       erf                  frexp                logb                 scalbn
+       erfc                 hypot                lrint                scalbln
+       exp2                 ilogb                lround               tgamma
+       expm1                ldexp                nearbyint            trunc
+       fdim                 lgamma               nextafter
+       floor                llrint               nexttoward</pre>
+ If all arguments for generic parameters are real, then use of the macro invokes a real
+ function; otherwise, use of the macro results in undefined behavior.
+<p><!--para 6-->
+ For each unsuffixed function in &lt;complex.h&gt; that is not a c-prefixed counterpart to a
+ function in &lt;math.h&gt;, the corresponding type-generic macro has the same name as the
+ function. These type-generic macros are:
+<!--page 349 indent 4-->
+<pre>
+         carg                    conj                     creal
+         cimag                   cproj</pre>
+ Use of the macro with any real or complex argument invokes a complex function.
+<p><!--para 7-->
+ EXAMPLE       With the declarations
+<pre>
+         #include &lt;tgmath.h&gt;
+         int n;
+         float f;
+         double d;
+         long double ld;
+         float complex fc;
+         double complex dc;
+         long double complex ldc;</pre>
+ functions invoked by use of type-generic macros are shown in the following table:
+<!--page 350 indent 4-->
+<pre>
+                  macro use                                  invokes
+             exp(n)                              exp(n), the function
+             acosh(f)                            acoshf(f)
+             sin(d)                              sin(d), the function
+             atan(ld)                            atanl(ld)
+             log(fc)                             clogf(fc)
+             sqrt(dc)                            csqrt(dc)
+             pow(ldc, f)                         cpowl(ldc, f)
+             remainder(n, n)                     remainder(n, n), the function
+             nextafter(d, f)                     nextafter(d, f), the function
+             nexttoward(f, ld)                   nexttowardf(f, ld)
+             copysign(n, ld)                     copysignl(n, ld)
+             ceil(fc)                            undefined behavior
+             rint(dc)                            undefined behavior
+             fmax(ldc, ld)                       undefined behavior
+             carg(n)                             carg(n), the function
+             cproj(f)                            cprojf(f)
+             creal(d)                            creal(d), the function
+             cimag(ld)                           cimagl(ld)
+             fabs(fc)                            cabsf(fc)
+             carg(dc)                            carg(dc), the function
+             cproj(ldc)                          cprojl(ldc)</pre>
+
+<h6>footnotes</h6>
+<p><a name="note272">272)</a> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
+ make available the corresponding ordinary function.
+
+<p><a name="note273">273)</a> If the type of the argument is not compatible with the type of the parameter for the selected function,
+ the behavior is undefined.
+
+
+<a name="7.23" href="#7.23"><h3>7.23 Date and time <time.h></h3></a>
+
+<a name="7.23.1" href="#7.23.1"><h4>7.23.1 Components of time</h4></a>
+<p><!--para 1-->
+ The header &lt;time.h&gt; defines two macros, and declares several types and functions for
+ manipulating time. Many functions deal with a calendar time that represents the current
+ date (according to the Gregorian calendar) and time. Some functions deal with local
+ time, which is the calendar time expressed for some specific time zone, and with Daylight
+ Saving Time, which is a temporary change in the algorithm for determining local time.
+ The local time zone and Daylight Saving Time are implementation-defined.
+<p><!--para 2-->
+ The macros defined are NULL (described in <a href="#7.17">7.17</a>); and
+<pre>
+         CLOCKS_PER_SEC</pre>
+ which expands to an expression with type clock_t (described below) that is the
+ number per second of the value returned by the clock function.
+<p><!--para 3-->
+ The types declared are size_t (described in <a href="#7.17">7.17</a>);
+<pre>
+         clock_t</pre>
+ and
+<pre>
+         time_t</pre>
+ which are arithmetic types capable of representing times; and
+<pre>
+         struct tm</pre>
+ which holds the components of a calendar time, called the broken-down time.
+<p><!--para 4-->
+ The range and precision of times representable in clock_t and time_t are
+ implementation-defined. The tm structure shall contain at least the following members,
+ in any order. The semantics of the members and their normal ranges are expressed in the
+ comments.<sup><a href="#note274"><b>274)</b></a></sup>
+<pre>
+         int    tm_sec;           //   seconds after the minute -- [0, 60]
+         int    tm_min;           //   minutes after the hour -- [0, 59]
+         int    tm_hour;          //   hours since midnight -- [0, 23]
+         int    tm_mday;          //   day of the month -- [1, 31]
+         int    tm_mon;           //   months since January -- [0, 11]
+         int    tm_year;          //   years since 1900
+         int    tm_wday;          //   days since Sunday -- [0, 6]
+         int    tm_yday;          //   days since January 1 -- [0, 365]
+         int    tm_isdst;         //   Daylight Saving Time flag</pre>
+ 
+ 
+ 
+<!--page 351 indent 4-->
+ The value of tm_isdst is positive if Daylight Saving Time is in effect, zero if Daylight
+ Saving Time is not in effect, and negative if the information is not available.
+
+<h6>footnotes</h6>
+<p><a name="note274">274)</a> The range [0, 60] for tm_sec allows for a positive leap second.
+
+
+<a name="7.23.2" href="#7.23.2"><h4>7.23.2 Time manipulation functions</h4></a>
+
+<a name="7.23.2.1" href="#7.23.2.1"><h5>7.23.2.1 The clock function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;time.h&gt;
+         clock_t clock(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The clock function determines the processor time used.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The clock function returns the implementation's best approximation to the processor
+ time used by the program since the beginning of an implementation-defined era related
+ only to the program invocation. To determine the time in seconds, the value returned by
+ the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
+ the processor time used is not available or its value cannot be represented, the function
+ returns the value (clock_t)(-1).<sup><a href="#note275"><b>275)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note275">275)</a> In order to measure the time spent in a program, the clock function should be called at the start of
+ the program and its return value subtracted from the value returned by subsequent calls.
+
+
+<a name="7.23.2.2" href="#7.23.2.2"><h5>7.23.2.2 The difftime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;time.h&gt;
+         double difftime(time_t time1, time_t time0);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The difftime function computes the difference between two calendar times: time1 -
+ time0.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The difftime function returns the difference expressed in seconds as a double.
+ 
+ 
+ 
+ 
+<!--page 352 indent 4-->
+
+<a name="7.23.2.3" href="#7.23.2.3"><h5>7.23.2.3 The mktime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;time.h&gt;
+         time_t mktime(struct tm *timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mktime function converts the broken-down time, expressed as local time, in the
+ structure pointed to by timeptr into a calendar time value with the same encoding as
+ that of the values returned by the time function. The original values of the tm_wday
+ and tm_yday components of the structure are ignored, and the original values of the
+ other components are not restricted to the ranges indicated above.<sup><a href="#note276"><b>276)</b></a></sup> On successful
+ completion, the values of the tm_wday and tm_yday components of the structure are
+ set appropriately, and the other components are set to represent the specified calendar
+ time, but with their values forced to the ranges indicated above; the final value of
+ tm_mday is not set until tm_mon and tm_year are determined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mktime function returns the specified calendar time encoded as a value of type
+ time_t. If the calendar time cannot be represented, the function returns the value
+ (time_t)(-1).
+<p><!--para 4-->
+ EXAMPLE       What day of the week is July 4, 2001?
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;time.h&gt;
+         static const char *const wday[] = {
+                 "Sunday", "Monday", "Tuesday", "Wednesday",
+                 "Thursday", "Friday", "Saturday", "-unknown-"
+         };
+         struct tm time_str;
+         /* ... */</pre>
+ 
+ 
+ 
+ 
+<!--page 353 indent 4-->
+<pre>
+        time_str.tm_year   = 2001 - 1900;
+        time_str.tm_mon    = 7 - 1;
+        time_str.tm_mday   = 4;
+        time_str.tm_hour   = 0;
+        time_str.tm_min    = 0;
+        time_str.tm_sec    = 1;
+        time_str.tm_isdst = -1;
+        if (mktime(&amp;time_str) == (time_t)(-1))
+              time_str.tm_wday = 7;
+        printf("%s\n", wday[time_str.tm_wday]);</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note276">276)</a> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
+ Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
+ causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
+
+
+<a name="7.23.2.4" href="#7.23.2.4"><h5>7.23.2.4 The time function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        time_t time(time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The time function determines the current calendar time. The encoding of the value is
+ unspecified.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The time function returns the implementation's best approximation to the current
+ calendar time. The value (time_t)(-1) is returned if the calendar time is not
+ available. If timer is not a null pointer, the return value is also assigned to the object it
+ points to.
+
+<a name="7.23.3" href="#7.23.3"><h4>7.23.3 Time conversion functions</h4></a>
+<p><!--para 1-->
+ Except for the strftime function, these functions each return a pointer to one of two
+ types of static objects: a broken-down time structure or an array of char. Execution of
+ any of the functions that return a pointer to one of these object types may overwrite the
+ information in any object of the same type pointed to by the value returned from any
+ previous call to any of them. The implementation shall behave as if no other library
+ functions call these functions.
+
+<a name="7.23.3.1" href="#7.23.3.1"><h5>7.23.3.1 The asctime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        char *asctime(const struct tm *timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The asctime function converts the broken-down time in the structure pointed to by
+ timeptr into a string in the form
+<!--page 354 indent 4-->
+<pre>
+        Sun Sep 16 01:03:52 1973\n\0</pre>
+ using the equivalent of the following algorithm.
+ char *asctime(const struct tm *timeptr)
+ {
+<pre>
+      static const char wday_name[7][3] = {
+           "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+      };
+      static const char mon_name[12][3] = {
+           "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+      };
+      static char result[26];
+        sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
+             wday_name[timeptr-&gt;tm_wday],
+             mon_name[timeptr-&gt;tm_mon],
+             timeptr-&gt;tm_mday, timeptr-&gt;tm_hour,
+             timeptr-&gt;tm_min, timeptr-&gt;tm_sec,
+             1900 + timeptr-&gt;tm_year);
+        return result;</pre>
+ }
+<h6>Returns</h6>
+<p><!--para 3-->
+ The asctime function returns a pointer to the string.
+
+<a name="7.23.3.2" href="#7.23.3.2"><h5>7.23.3.2 The ctime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        char *ctime(const time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ctime function converts the calendar time pointed to by timer to local time in the
+ form of a string. It is equivalent to
+<pre>
+        asctime(localtime(timer))</pre>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ctime function returns the pointer returned by the asctime function with that
+ broken-down time as argument.
+ Forward references: the localtime function (<a href="#7.23.3.4">7.23.3.4</a>).
+<!--page 355 indent 4-->
+
+<a name="7.23.3.3" href="#7.23.3.3"><h5>7.23.3.3 The gmtime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        struct tm *gmtime(const time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The gmtime function converts the calendar time pointed to by timer into a broken-
+ down time, expressed as UTC.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The gmtime function returns a pointer to the broken-down time, or a null pointer if the
+ specified time cannot be converted to UTC.
+
+<a name="7.23.3.4" href="#7.23.3.4"><h5>7.23.3.4 The localtime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        struct tm *localtime(const time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The localtime function converts the calendar time pointed to by timer into a
+ broken-down time, expressed as local time.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The localtime function returns a pointer to the broken-down time, or a null pointer if
+ the specified time cannot be converted to local time.
+
+<a name="7.23.3.5" href="#7.23.3.5"><h5>7.23.3.5 The strftime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        size_t strftime(char * restrict s,
+             size_t maxsize,
+             const char * restrict format,
+             const struct tm * restrict timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strftime function places characters into the array pointed to by s as controlled by
+ the string pointed to by format. The format shall be a multibyte character sequence,
+ beginning and ending in its initial shift state. The format string consists of zero or
+ more conversion specifiers and ordinary multibyte characters. A conversion specifier
+ consists of a % character, possibly followed by an E or O modifier character (described
+ below), followed by a character that determines the behavior of the conversion specifier.
+ All ordinary multibyte characters (including the terminating null character) are copied
+<!--page 356 indent 4-->
+ unchanged into the array. If copying takes place between objects that overlap, the
+ behavior is undefined. No more than maxsize characters are placed into the array.
+<p><!--para 3-->
+ Each conversion specifier is replaced by appropriate characters as described in the
+ following list. The appropriate characters are determined using the LC_TIME category
+ of the current locale and by the values of zero or more members of the broken-down time
+ structure pointed to by timeptr, as specified in brackets in the description. If any of
+ the specified values is outside the normal range, the characters stored are unspecified.
+ %a    is replaced by the locale's abbreviated weekday name. [tm_wday]
+ %A    is replaced by the locale's full weekday name. [tm_wday]
+ %b    is replaced by the locale's abbreviated month name. [tm_mon]
+ %B    is replaced by the locale's full month name. [tm_mon]
+ %c    is replaced by the locale's appropriate date and time representation. [all specified
+<pre>
+       in <a href="#7.23.1">7.23.1</a>]</pre>
+ %C    is replaced by the year divided by 100 and truncated to an integer, as a decimal
+<pre>
+       number (00-99). [tm_year]</pre>
+ %d    is replaced by the day of the month as a decimal number (01-31). [tm_mday]
+ %D    is equivalent to ''%m/%d/%y''. [tm_mon, tm_mday, tm_year]
+ %e    is replaced by the day of the month as a decimal number (1-31); a single digit is
+<pre>
+       preceded by a space. [tm_mday]</pre>
+ %F    is equivalent to ''%Y-%m-%d'' (the ISO 8601 date format). [tm_year, tm_mon,
+<pre>
+       tm_mday]</pre>
+ %g    is replaced by the last 2 digits of the week-based year (see below) as a decimal
+<pre>
+       number (00-99). [tm_year, tm_wday, tm_yday]</pre>
+ %G    is replaced by the week-based year (see below) as a decimal number (e.g., 1997).
+<pre>
+       [tm_year, tm_wday, tm_yday]</pre>
+ %h    is equivalent to ''%b''. [tm_mon]
+ %H    is replaced by the hour (24-hour clock) as a decimal number (00-23). [tm_hour]
+ %I    is replaced by the hour (12-hour clock) as a decimal number (01-12). [tm_hour]
+ %j    is replaced by the day of the year as a decimal number (001-366). [tm_yday]
+ %m    is replaced by the month as a decimal number (01-12). [tm_mon]
+ %M    is replaced by the minute as a decimal number (00-59). [tm_min]
+ %n    is replaced by a new-line character.
+ %p    is replaced by the locale's equivalent of the AM/PM designations associated with a
+<pre>
+       12-hour clock. [tm_hour]</pre>
+ %r    is replaced by the locale's 12-hour clock time. [tm_hour, tm_min, tm_sec]
+ %R    is equivalent to ''%H:%M''. [tm_hour, tm_min]
+ %S    is replaced by the second as a decimal number (00-60). [tm_sec]
+ %t    is replaced by a horizontal-tab character.
+ %T    is equivalent to ''%H:%M:%S'' (the ISO 8601 time format). [tm_hour, tm_min,
+<!--page 357 indent 4-->
+<pre>
+       tm_sec]</pre>
+ %u   is replaced by the ISO 8601 weekday as a decimal number (1-7), where Monday
+<pre>
+      is 1. [tm_wday]</pre>
+ %U   is replaced by the week number of the year (the first Sunday as the first day of week
+<pre>
+      1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]</pre>
+ %V   is replaced by the ISO 8601 week number (see below) as a decimal number
+<pre>
+      (01-53). [tm_year, tm_wday, tm_yday]</pre>
+ %w   is replaced by the weekday as a decimal number (0-6), where Sunday is 0.
+<pre>
+      [tm_wday]</pre>
+ %W   is replaced by the week number of the year (the first Monday as the first day of
+<pre>
+      week 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]</pre>
+ %x   is replaced by the locale's appropriate date representation. [all specified in <a href="#7.23.1">7.23.1</a>]
+ %X   is replaced by the locale's appropriate time representation. [all specified in <a href="#7.23.1">7.23.1</a>]
+ %y   is replaced by the last 2 digits of the year as a decimal number (00-99).
+<pre>
+      [tm_year]</pre>
+ %Y   is replaced by the year as a decimal number (e.g., 1997). [tm_year]
+ %z   is replaced by the offset from UTC in the ISO 8601 format ''-0430'' (meaning 4
+<pre>
+      hours 30 minutes behind UTC, west of Greenwich), or by no characters if no time
+      zone is determinable. [tm_isdst]</pre>
+ %Z   is replaced by the locale's time zone name or abbreviation, or by no characters if no
+<pre>
+      time zone is determinable. [tm_isdst]</pre>
+ %%   is replaced by %.
+<p><!--para 4-->
+ Some conversion specifiers can be modified by the inclusion of an E or O modifier
+ character to indicate an alternative format or specification. If the alternative format or
+ specification does not exist for the current locale, the modifier is ignored.
+ %Ec is replaced by the locale's alternative date and time representation.
+ %EC is replaced by the name of the base year (period) in the locale's alternative
+<pre>
+     representation.</pre>
+ %Ex is replaced by the locale's alternative date representation.
+ %EX is replaced by the locale's alternative time representation.
+ %Ey is replaced by the offset from %EC (year only) in the locale's alternative
+<pre>
+     representation.</pre>
+ %EY is replaced by the locale's full alternative year representation.
+ %Od is replaced by the day of the month, using the locale's alternative numeric symbols
+<pre>
+     (filled as needed with leading zeros, or with leading spaces if there is no alternative
+     symbol for zero).</pre>
+ %Oe is replaced by the day of the month, using the locale's alternative numeric symbols
+<pre>
+     (filled as needed with leading spaces).</pre>
+ %OH is replaced by the hour (24-hour clock), using the locale's alternative numeric
+<!--page 358 indent 4-->
+<pre>
+     symbols.</pre>
+ %OI is replaced by the hour (12-hour clock), using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %Om is replaced by the month, using the locale's alternative numeric symbols.
+ %OM is replaced by the minutes, using the locale's alternative numeric symbols.
+ %OS is replaced by the seconds, using the locale's alternative numeric symbols.
+ %Ou is replaced by the ISO 8601 weekday as a number in the locale's alternative
+<pre>
+     representation, where Monday is 1.</pre>
+ %OU is replaced by the week number, using the locale's alternative numeric symbols.
+ %OV is replaced by the ISO 8601 week number, using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %Ow is replaced by the weekday as a number, using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %OW is replaced by the week number of the year, using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %Oy is replaced by the last 2 digits of the year, using the locale's alternative numeric
+<p><!--para 5-->
+<pre>
+     symbols.</pre>
+ %g, %G, and %V give values according to the ISO 8601 week-based year. In this system,
+ weeks begin on a Monday and week 1 of the year is the week that includes January 4th,
+ which is also the week that includes the first Thursday of the year, and is also the first
+ week that contains at least four days in the year. If the first Monday of January is the
+ 2nd, 3rd, or 4th, the preceding days are part of the last week of the preceding year; thus,
+ for Saturday 2nd January 1999, %G is replaced by 1998 and %V is replaced by 53. If
+ December 29th, 30th, or 31st is a Monday, it and any following days are part of week 1 of
+ the following year. Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and
+ %V is replaced by 01.
+<p><!--para 6-->
+ If a conversion specifier is not one of the above, the behavior is undefined.
+<p><!--para 7-->
+ In the "C" locale, the E and O modifiers are ignored and the replacement strings for the
+ following specifiers are:
+ %a    the first three characters of %A.
+ %A    one of ''Sunday'', ''Monday'', ... , ''Saturday''.
+ %b    the first three characters of %B.
+ %B    one of ''January'', ''February'', ... , ''December''.
+ %c    equivalent to ''%a %b %e %T %Y''.
+ %p    one of ''AM'' or ''PM''.
+ %r    equivalent to ''%I:%M:%S %p''.
+ %x    equivalent to ''%m/%d/%y''.
+ %X    equivalent to %T.
+ %Z    implementation-defined.
+<!--page 359 indent 4-->
+<h6>Returns</h6>
+<p><!--para 8-->
+ If the total number of resulting characters including the terminating null character is not
+ more than maxsize, the strftime function returns the number of characters placed
+ into the array pointed to by s not including the terminating null character. Otherwise,
+ zero is returned and the contents of the array are indeterminate.
+<!--page 360 indent 4-->
+
+<a name="7.24" href="#7.24"><h3>7.24 Extended multibyte and wide character utilities <wchar.h></h3></a>
+
+<a name="7.24.1" href="#7.24.1"><h4>7.24.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;wchar.h&gt; declares four data types, one tag, four macros, and many
+ functions.<sup><a href="#note277"><b>277)</b></a></sup>
+<p><!--para 2-->
+ The types declared are wchar_t and size_t (both described in <a href="#7.17">7.17</a>);
+<pre>
+          mbstate_t</pre>
+ which is an object type other than an array type that can hold the conversion state
+ information necessary to convert between sequences of multibyte characters and wide
+ characters;
+<pre>
+          wint_t</pre>
+ which is an integer type unchanged by default argument promotions that can hold any
+ value corresponding to members of the extended character set, as well as at least one
+ value that does not correspond to any member of the extended character set (see WEOF
+ below);<sup><a href="#note278"><b>278)</b></a></sup> and
+<pre>
+          struct tm</pre>
+ which is declared as an incomplete structure type (the contents are described in <a href="#7.23.1">7.23.1</a>).
+<p><!--para 3-->
+ The macros defined are NULL (described in <a href="#7.17">7.17</a>); WCHAR_MIN and WCHAR_MAX
+ (described in <a href="#7.18.3">7.18.3</a>); and
+<pre>
+          WEOF</pre>
+ which expands to a constant expression of type wint_t whose value does not
+ correspond to any member of the extended character set.<sup><a href="#note279"><b>279)</b></a></sup> It is accepted (and returned)
+ by several functions in this subclause to indicate end-of-file, that is, no more input from a
+ stream. It is also used as a wide character value that does not correspond to any member
+ of the extended character set.
+<p><!--para 4-->
+ The functions declared are grouped as follows:
+<ul>
+<li>  Functions that perform input and output of wide characters, or multibyte characters,
+ or both;
+<li>  Functions that provide wide string numeric conversion;
+<li>  Functions that perform general wide string manipulation;
+ 
+ 
+<!--page 361 indent 4-->
+<li>  Functions for wide string date and time conversion; and
+<li>  Functions that provide extended capabilities for conversion between multibyte and
+ wide character sequences.
+</ul>
+<p><!--para 5-->
+ Unless explicitly stated otherwise, if the execution of a function described in this
+ subclause causes copying to take place between objects that overlap, the behavior is
+ undefined.
+
+<h6>footnotes</h6>
+<p><a name="note277">277)</a> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
+
+<p><a name="note278">278)</a> wchar_t and wint_t can be the same integer type.
+
+<p><a name="note279">279)</a> The value of the macro WEOF may differ from that of EOF and need not be negative.
+
+
+<a name="7.24.2" href="#7.24.2"><h4>7.24.2 Formatted wide character input/output functions</h4></a>
+<p><!--para 1-->
+ The formatted wide character input/output functions shall behave as if there is a sequence
+ point after the actions associated with each specifier.<sup><a href="#note280"><b>280)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note280">280)</a> The fwprintf functions perform writes to memory for the %n specifier.
+
+
+<a name="7.24.2.1" href="#7.24.2.1"><h5>7.24.2.1 The fwprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int fwprintf(FILE * restrict stream,
+              const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwprintf function writes output to the stream pointed to by stream, under
+ control of the wide string pointed to by format that specifies how subsequent arguments
+ are converted for output. If there are insufficient arguments for the format, the behavior
+ is undefined. If the format is exhausted while arguments remain, the excess arguments
+ are evaluated (as always) but are otherwise ignored. The fwprintf function returns
+ when the end of the format string is encountered.
+<p><!--para 3-->
+ The format is composed of zero or more directives: ordinary wide characters (not %),
+ which are copied unchanged to the output stream; and conversion specifications, each of
+ which results in fetching zero or more subsequent arguments, converting them, if
+ applicable, according to the corresponding conversion specifier, and then writing the
+ result to the output stream.
+<p><!--para 4-->
+ Each conversion specification is introduced by the wide character %. After the %, the
+ following appear in sequence:
+<ul>
+<li>  Zero or more flags (in any order) that modify the meaning of the conversion
+ specification.
+<li>  An optional minimum field width. If the converted value has fewer wide characters
+ than the field width, it is padded with spaces (by default) on the left (or right, if the
+ 
+ 
+<!--page 362 indent 4-->
+   left adjustment flag, described later, has been given) to the field width. The field
+   width takes the form of an asterisk * (described later) or a nonnegative decimal
+   integer.<sup><a href="#note281"><b>281)</b></a></sup>
+<li>  An optional precision that gives the minimum number of digits to appear for the d, i,
+ o, u, x, and X conversions, the number of digits to appear after the decimal-point
+ wide character for a, A, e, E, f, and F conversions, the maximum number of
+ significant digits for the g and G conversions, or the maximum number of wide
+ characters to be written for s conversions. The precision takes the form of a period
+ (.) followed either by an asterisk * (described later) or by an optional decimal
+ integer; if only the period is specified, the precision is taken as zero. If a precision
+ appears with any other conversion specifier, the behavior is undefined.
+<li>  An optional length modifier that specifies the size of the argument.
+<li>  A conversion specifier wide character that specifies the type of conversion to be
+ applied.
+</ul>
+<p><!--para 5-->
+ As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+ this case, an int argument supplies the field width or precision. The arguments
+ specifying field width, or precision, or both, shall appear (in that order) before the
+ argument (if any) to be converted. A negative field width argument is taken as a - flag
+ followed by a positive field width. A negative precision argument is taken as if the
+ precision were omitted.
+<p><!--para 6-->
+ The flag wide characters and their meanings are:
+ -        The result of the conversion is left-justified within the field. (It is right-justified if
+<pre>
+          this flag is not specified.)</pre>
+ +        The result of a signed conversion always begins with a plus or minus sign. (It
+<pre>
+          begins with a sign only when a negative value is converted if this flag is not
+          specified.)<sup><a href="#note282"><b>282)</b></a></sup></pre>
+ space If the first wide character of a signed conversion is not a sign, or if a signed
+<pre>
+       conversion results in no wide characters, a space is prefixed to the result. If the
+       space and + flags both appear, the space flag is ignored.</pre>
+ #        The result is converted to an ''alternative form''. For o conversion, it increases
+<pre>
+          the precision, if and only if necessary, to force the first digit of the result to be a
+          zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+          conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,</pre>
+ 
+<!--page 363 indent 4-->
+<pre>
+           and G conversions, the result of converting a floating-point number always
+           contains a decimal-point wide character, even if no digits follow it. (Normally, a
+           decimal-point wide character appears in the result of these conversions only if a
+           digit follows it.) For g and G conversions, trailing zeros are not removed from the
+           result. For other conversions, the behavior is undefined.</pre>
+ 0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+<p><!--para 7-->
+<pre>
+           (following any indication of sign or base) are used to pad to the field width rather
+           than performing space padding, except when converting an infinity or NaN. If the
+           0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
+           conversions, if a precision is specified, the 0 flag is ignored. For other
+           conversions, the behavior is undefined.</pre>
+ The length modifiers and their meanings are:
+ hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                signed char or unsigned char argument (the argument will have
+                been promoted according to the integer promotions, but its value shall be
+                converted to signed char or unsigned char before printing); or that
+                a following n conversion specifier applies to a pointer to a signed char
+                argument.</pre>
+ h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                short int or unsigned short int argument (the argument will
+                have been promoted according to the integer promotions, but its value shall
+                be converted to short int or unsigned short int before printing);
+                or that a following n conversion specifier applies to a pointer to a short
+                int argument.</pre>
+ l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                long int or unsigned long int argument; that a following n
+                conversion specifier applies to a pointer to a long int argument; that a
+                following c conversion specifier applies to a wint_t argument; that a
+                following s conversion specifier applies to a pointer to a wchar_t
+                argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+                specifier.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              long long int or unsigned long long int argument; or that a
+              following n conversion specifier applies to a pointer to a long long int
+              argument.</pre>
+ j              Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+<!--page 364 indent 4-->
+<pre>
+                an intmax_t or uintmax_t argument; or that a following n conversion
+                specifier applies to a pointer to an intmax_t argument.</pre>
+ z           Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+             size_t or the corresponding signed integer type argument; or that a
+             following n conversion specifier applies to a pointer to a signed integer type
+             corresponding to size_t argument.</pre>
+ t           Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+             ptrdiff_t or the corresponding unsigned integer type argument; or that a
+             following n conversion specifier applies to a pointer to a ptrdiff_t
+             argument.</pre>
+ L           Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+             applies to a long double argument.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 8-->
+ The conversion specifiers and their meanings are:
+ d,i        The int argument is converted to signed decimal in the style [-]dddd. The
+<pre>
+            precision specifies the minimum number of digits to appear; if the value
+            being converted can be represented in fewer digits, it is expanded with
+            leading zeros. The default precision is 1. The result of converting a zero
+            value with a precision of zero is no wide characters.</pre>
+ o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+<pre>
+         decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+         letters abcdef are used for x conversion and the letters ABCDEF for X
+         conversion. The precision specifies the minimum number of digits to appear;
+         if the value being converted can be represented in fewer digits, it is expanded
+         with leading zeros. The default precision is 1. The result of converting a
+         zero value with a precision of zero is no wide characters.</pre>
+ f,F        A double argument representing a floating-point number is converted to
+<!--page 365 indent 0-->
+<pre>
+            decimal notation in the style [-]ddd.ddd, where the number of digits after
+            the decimal-point wide character is equal to the precision specification. If the
+            precision is missing, it is taken as 6; if the precision is zero and the # flag is
+            not specified, no decimal-point wide character appears. If a decimal-point
+            wide character appears, at least one digit appears before it. The value is
+            rounded to the appropriate number of digits.
+            A double argument representing an infinity is converted in one of the styles
+            [-]inf or [-]infinity -- which style is implementation-defined. A
+            double argument representing a NaN is converted in one of the styles
+            [-]nan or [-]nan(n-wchar-sequence) -- which style, and the meaning of
+            any n-wchar-sequence, is implementation-defined. The F conversion
+            specifier produces INF, INFINITY, or NAN instead of inf, infinity, or
+              nan, respectively.<sup><a href="#note283"><b>283)</b></a></sup></pre>
+ e,E          A double argument representing a floating-point number is converted in the
+<pre>
+              style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+              argument is nonzero) before the decimal-point wide character and the number
+              of digits after it is equal to the precision; if the precision is missing, it is taken
+              as 6; if the precision is zero and the # flag is not specified, no decimal-point
+              wide character appears. The value is rounded to the appropriate number of
+              digits. The E conversion specifier produces a number with E instead of e
+              introducing the exponent. The exponent always contains at least two digits,
+              and only as many more digits as necessary to represent the exponent. If the
+              value is zero, the exponent is zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.</pre>
+ g,G          A double argument representing a floating-point number is converted in
+<pre>
+              style f or e (or in style F or E in the case of a G conversion specifier),
+              depending on the value converted and the precision. Let P equal the
+              precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+              Then, if a conversion with style E would have an exponent of X :
+              -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+                P - (X + 1).
+              -- otherwise, the conversion is with style e (or E) and precision P - 1.
+              Finally, unless the # flag is used, any trailing zeros are removed from the
+              fractional portion of the result and the decimal-point wide character is
+              removed if there is no fractional portion remaining.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.</pre>
+ a,A          A double argument representing a floating-point number is converted in the
+<pre>
+              style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+              nonzero if the argument is a normalized floating-point number and is
+              otherwise unspecified) before the decimal-point wide character<sup><a href="#note284"><b>284)</b></a></sup> and the
+              number of hexadecimal digits after it is equal to the precision; if the precision
+              is missing and FLT_RADIX is a power of 2, then the precision is sufficient</pre>
+ 
+ 
+<!--page 366 indent 0-->
+<pre>
+              for an exact representation of the value; if the precision is missing and
+              FLT_RADIX is not a power of 2, then the precision is sufficient to
+              distinguish<sup><a href="#note285"><b>285)</b></a></sup> values of type double, except that trailing zeros may be
+              omitted; if the precision is zero and the # flag is not specified, no decimal-
+              point wide character appears. The letters abcdef are used for a conversion
+              and the letters ABCDEF for A conversion. The A conversion specifier
+              produces a number with X and P instead of x and p. The exponent always
+              contains at least one digit, and only as many more digits as necessary to
+              represent the decimal exponent of 2. If the value is zero, the exponent is
+              zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.</pre>
+ c            If no l length modifier is present, the int argument is converted to a wide
+<pre>
+              character as if by calling btowc and the resulting wide character is written.
+              If an l length modifier is present, the wint_t argument is converted to
+              wchar_t and written.</pre>
+ s            If no l length modifier is present, the argument shall be a pointer to the initial
+<pre>
+              element of a character array containing a multibyte character sequence
+              beginning in the initial shift state. Characters from the array are converted as
+              if by repeated calls to the mbrtowc function, with the conversion state
+              described by an mbstate_t object initialized to zero before the first
+              multibyte character is converted, and written up to (but not including) the
+              terminating null wide character. If the precision is specified, no more than
+              that many wide characters are written. If the precision is not specified or is
+              greater than the size of the converted array, the converted array shall contain a
+              null wide character.
+              If an l length modifier is present, the argument shall be a pointer to the initial
+              element of an array of wchar_t type. Wide characters from the array are
+              written up to (but not including) a terminating null wide character. If the
+              precision is specified, no more than that many wide characters are written. If
+              the precision is not specified or is greater than the size of the array, the array
+              shall contain a null wide character.</pre>
+ p            The argument shall be a pointer to void. The value of the pointer is
+<pre>
+              converted to a sequence of printing wide characters, in an implementation-</pre>
+ 
+<!--page 367 indent 5-->
+<pre>
+                defined manner.</pre>
+ n              The argument shall be a pointer to signed integer into which is written the
+<pre>
+                number of wide characters written to the output stream so far by this call to
+                fwprintf. No argument is converted, but one is consumed. If the
+                conversion specification includes any flags, a field width, or a precision, the
+                behavior is undefined.</pre>
+ %              A % wide character is written. No argument is converted. The complete
+<p><!--para 9-->
+<pre>
+                conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note286"><b>286)</b></a></sup> If any argument is
+ not the correct type for the corresponding conversion specification, the behavior is
+ undefined.
+<p><!--para 10-->
+ In no case does a nonexistent or small field width cause truncation of a field; if the result
+ of a conversion is wider than the field width, the field is expanded to contain the
+ conversion result.
+<p><!--para 11-->
+ For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+ to a hexadecimal floating number with the given precision.
+ Recommended practice
+<p><!--para 12-->
+ For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+ representable in the given precision, the result should be one of the two adjacent numbers
+ in hexadecimal floating style with the given precision, with the extra stipulation that the
+ error should have a correct sign for the current rounding direction.
+<p><!--para 13-->
+ For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+ DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note287"><b>287)</b></a></sup> If the number of
+ significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+ representable with DECIMAL_DIG digits, then the result should be an exact
+ representation with trailing zeros. Otherwise, the source value is bounded by two
+ adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+ of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+ the error should have a correct sign for the current rounding direction.
+<h6>Returns</h6>
+<p><!--para 14-->
+ The fwprintf function returns the number of wide characters transmitted, or a negative
+ value if an output or encoding error occurred.
+ 
+<!--page 368 indent 5-->
+ Environmental limits
+<p><!--para 15-->
+ The number of wide characters that can be produced by any single conversion shall be at
+ least 4095.
+<p><!--para 16-->
+ EXAMPLE       To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+ places:
+<pre>
+        #include &lt;math.h&gt;
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        /* ... */
+        wchar_t *weekday, *month; // pointers to wide strings
+        int day, hour, min;
+        fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
+                weekday, month, day, hour, min);
+        fwprintf(stdout, L"pi = %.5f\n", 4 * atan(1.0));</pre>
+ 
+ Forward references:          the btowc function (<a href="#7.24.6.1.1">7.24.6.1.1</a>), the mbrtowc function
+ (<a href="#7.24.6.3.2">7.24.6.3.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note281">281)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
+
+<p><a name="note282">282)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+ include a minus sign.
+
+<p><a name="note283">283)</a> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
+ meaning; the # and 0 flag wide characters have no effect.
+
+<p><a name="note284">284)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
+ character so that subsequent digits align to nibble (4-bit) boundaries.
+
+<p><a name="note285">285)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+ FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+ might suffice depending on the implementation's scheme for determining the digit to the left of the
+ decimal-point wide character.
+
+<p><a name="note286">286)</a> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
+
+<p><a name="note287">287)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+ given format specifier. The number of significant digits is determined by the format specifier, and in
+ the case of fixed-point conversion by the source value as well.
+
+
+<a name="7.24.2.2" href="#7.24.2.2"><h5>7.24.2.2 The fwscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
         int fwscanf(FILE * restrict stream,
-             const wchar_t * restrict format, ...);
-        int swprintf(wchar_t * restrict s, size_t n,
-             const wchar_t * restrict format, ...);
+             const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwscanf function reads input from the stream pointed to by stream, under
+ control of the wide string pointed to by format that specifies the admissible input
+ sequences and how they are to be converted for assignment, using subsequent arguments
+ as pointers to the objects to receive the converted input. If there are insufficient
+ arguments for the format, the behavior is undefined. If the format is exhausted while
+ arguments remain, the excess arguments are evaluated (as always) but are otherwise
+ ignored.
+<p><!--para 3-->
+ The format is composed of zero or more directives: one or more white-space wide
+ characters, an ordinary wide character (neither % nor a white-space wide character), or a
+ conversion specification. Each conversion specification is introduced by the wide
+ character %. After the %, the following appear in sequence:
+<ul>
+<li>  An optional assignment-suppressing wide character *.
+<li>  An optional decimal integer greater than zero that specifies the maximum field width
+ (in wide characters).
+<!--page 369 indent 5-->
+<li>  An optional length modifier that specifies the size of the receiving object.
+<li>  A conversion specifier wide character that specifies the type of conversion to be
+ applied.
+</ul>
+<p><!--para 4-->
+ The fwscanf function executes each directive of the format in turn. If a directive fails,
+ as detailed below, the function returns. Failures are described as input failures (due to the
+ occurrence of an encoding error or the unavailability of input characters), or matching
+ failures (due to inappropriate input).
+<p><!--para 5-->
+ A directive composed of white-space wide character(s) is executed by reading input up to
+ the first non-white-space wide character (which remains unread), or until no more wide
+ characters can be read.
+<p><!--para 6-->
+ A directive that is an ordinary wide character is executed by reading the next wide
+ character of the stream. If that wide character differs from the directive, the directive
+ fails and the differing and subsequent wide characters remain unread. Similarly, if end-
+ of-file, an encoding error, or a read error prevents a wide character from being read, the
+ directive fails.
+<p><!--para 7-->
+ A directive that is a conversion specification defines a set of matching input sequences, as
+ described below for each specifier. A conversion specification is executed in the
+ following steps:
+<p><!--para 8-->
+ Input white-space wide characters (as specified by the iswspace function) are skipped,
+ unless the specification includes a [, c, or n specifier.<sup><a href="#note288"><b>288)</b></a></sup>
+<p><!--para 9-->
+ An input item is read from the stream, unless the specification includes an n specifier. An
+ input item is defined as the longest sequence of input wide characters which does not
+ exceed any specified field width and which is, or is a prefix of, a matching input
+ sequence.<sup><a href="#note289"><b>289)</b></a></sup> The first wide character, if any, after the input item remains unread. If the
+ length of the input item is zero, the execution of the directive fails; this condition is a
+ matching failure unless end-of-file, an encoding error, or a read error prevented input
+ from the stream, in which case it is an input failure.
+<p><!--para 10-->
+ Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+ count of input wide characters) is converted to a type appropriate to the conversion
+ specifier. If the input item is not a matching sequence, the execution of the directive fails:
+ this condition is a matching failure. Unless assignment suppression was indicated by a *,
+ the result of the conversion is placed in the object pointed to by the first argument
+ following the format argument that has not already received a conversion result. If this
+ 
+ 
+<!--page 370 indent 5-->
+ object does not have an appropriate type, or if the result of the conversion cannot be
+ represented in the object, the behavior is undefined.
+<p><!--para 11-->
+ The length modifiers and their meanings are:
+ hh          Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+             to an argument with type pointer to signed char or unsigned char.</pre>
+ h           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+             to an argument with type pointer to short int or unsigned short
+             int.</pre>
+ l (ell)     Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+             to an argument with type pointer to long int or unsigned long
+             int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+             an argument with type pointer to double; or that a following c, s, or [
+             conversion specifier applies to an argument with type pointer to wchar_t.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to long long int or unsigned
+              long long int.</pre>
+ j           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+             to an argument with type pointer to intmax_t or uintmax_t.</pre>
+ z           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+             to an argument with type pointer to size_t or the corresponding signed
+             integer type.</pre>
+ t           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+             to an argument with type pointer to ptrdiff_t or the corresponding
+             unsigned integer type.</pre>
+ L           Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+             applies to an argument with type pointer to long double.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 12-->
+ The conversion specifiers and their meanings are:
+ d          Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+            expected for the subject sequence of the wcstol function with the value 10
+            for the base argument. The corresponding argument shall be a pointer to
+            signed integer.</pre>
+ i          Matches an optionally signed integer, whose format is the same as expected
+<!--page 371 indent 0-->
+<pre>
+            for the subject sequence of the wcstol function with the value 0 for the
+            base argument. The corresponding argument shall be a pointer to signed
+             integer.</pre>
+ o           Matches an optionally signed octal integer, whose format is the same as
+<pre>
+             expected for the subject sequence of the wcstoul function with the value 8
+             for the base argument. The corresponding argument shall be a pointer to
+             unsigned integer.</pre>
+ u           Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+             expected for the subject sequence of the wcstoul function with the value 10
+             for the base argument. The corresponding argument shall be a pointer to
+             unsigned integer.</pre>
+ x           Matches an optionally signed hexadecimal integer, whose format is the same
+<pre>
+             as expected for the subject sequence of the wcstoul function with the value
+             16 for the base argument. The corresponding argument shall be a pointer to
+             unsigned integer.</pre>
+ a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+<pre>
+         format is the same as expected for the subject sequence of the wcstod
+         function. The corresponding argument shall be a pointer to floating.</pre>
+ c           Matches a sequence of wide characters of exactly the number specified by the
+<pre>
+             field width (1 if no field width is present in the directive).
+             If no l length modifier is present, characters from the input field are
+             converted as if by repeated calls to the wcrtomb function, with the
+             conversion state described by an mbstate_t object initialized to zero
+             before the first wide character is converted. The corresponding argument
+             shall be a pointer to the initial element of a character array large enough to
+             accept the sequence. No null character is added.
+             If an l length modifier is present, the corresponding argument shall be a
+             pointer to the initial element of an array of wchar_t large enough to accept
+             the sequence. No null wide character is added.</pre>
+ s           Matches a sequence of non-white-space wide characters.
+<!--page 372 indent 0-->
+<pre>
+             If no l length modifier is present, characters from the input field are
+             converted as if by repeated calls to the wcrtomb function, with the
+             conversion state described by an mbstate_t object initialized to zero
+             before the first wide character is converted. The corresponding argument
+             shall be a pointer to the initial element of a character array large enough to
+             accept the sequence and a terminating null character, which will be added
+             automatically.
+             If an l length modifier is present, the corresponding argument shall be a
+             pointer to the initial element of an array of wchar_t large enough to accept
+          the sequence and the terminating null wide character, which will be added
+          automatically.</pre>
+ [        Matches a nonempty sequence of wide characters from a set of expected
+<pre>
+          characters (the scanset).
+          If no l length modifier is present, characters from the input field are
+          converted as if by repeated calls to the wcrtomb function, with the
+          conversion state described by an mbstate_t object initialized to zero
+          before the first wide character is converted. The corresponding argument
+          shall be a pointer to the initial element of a character array large enough to
+          accept the sequence and a terminating null character, which will be added
+          automatically.
+          If an l length modifier is present, the corresponding argument shall be a
+          pointer to the initial element of an array of wchar_t large enough to accept
+          the sequence and the terminating null wide character, which will be added
+          automatically.
+          The conversion specifier includes all subsequent wide characters in the
+          format string, up to and including the matching right bracket (]). The wide
+          characters between the brackets (the scanlist) compose the scanset, unless the
+          wide character after the left bracket is a circumflex (^), in which case the
+          scanset contains all wide characters that do not appear in the scanlist between
+          the circumflex and the right bracket. If the conversion specifier begins with
+          [] or [^], the right bracket wide character is in the scanlist and the next
+          following right bracket wide character is the matching right bracket that ends
+          the specification; otherwise the first following right bracket wide character is
+          the one that ends the specification. If a - wide character is in the scanlist and
+          is not the first, nor the second where the first wide character is a ^, nor the
+          last character, the behavior is implementation-defined.</pre>
+ p        Matches an implementation-defined set of sequences, which should be the
+<pre>
+          same as the set of sequences that may be produced by the %p conversion of
+          the fwprintf function. The corresponding argument shall be a pointer to a
+          pointer to void. The input item is converted to a pointer value in an
+          implementation-defined manner. If the input item is a value converted earlier
+          during the same program execution, the pointer that results shall compare
+          equal to that value; otherwise the behavior of the %p conversion is undefined.</pre>
+ n        No input is consumed. The corresponding argument shall be a pointer to
+<!--page 373 indent 5-->
+<pre>
+          signed integer into which is to be written the number of wide characters read
+          from the input stream so far by this call to the fwscanf function. Execution
+          of a %n directive does not increment the assignment count returned at the
+          completion of execution of the fwscanf function. No argument is
+                converted, but one is consumed. If the conversion specification includes an
+                assignment-suppressing wide character or a field width, the behavior is
+                undefined.</pre>
+ %              Matches a single % wide character; no conversion or assignment occurs. The
+<p><!--para 13-->
+<pre>
+                complete conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note290"><b>290)</b></a></sup>
+<p><!--para 14-->
+ The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+ respectively, a, e, f, g, and x.
+<p><!--para 15-->
+ Trailing white space (including new-line wide characters) is left unread unless matched
+ by a directive. The success of literal matches and suppressed assignments is not directly
+ determinable other than via the %n directive.
+<h6>Returns</h6>
+<p><!--para 16-->
+ The fwscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the function returns the number of input items
+ assigned, which can be fewer than provided for, or even zero, in the event of an early
+ matching failure.
+<p><!--para 17-->
+ EXAMPLE 1        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          #include &lt;wchar.h&gt;
+          /* ... */
+          int n, i; float x; wchar_t name[50];
+          n = fwscanf(stdin, L"%d%f%ls", &amp;i, &amp;x, name);</pre>
+ with the input line:
+<pre>
+          25 54.32E-1 thompson</pre>
+ will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+ thompson\0.
+ 
+<p><!--para 18-->
+ EXAMPLE 2        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          #include &lt;wchar.h&gt;
+          /* ... */
+          int i; float x; double y;
+          fwscanf(stdin, L"%2d%f%*d %lf", &amp;i, &amp;x, &amp;y);</pre>
+ with input:
+<pre>
+          56789 0123 56a72</pre>
+ will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
+ 56.0. The next wide character read from the input stream will be a.
+ 
+ 
+<!--page 374 indent 4-->
+ Forward references: the wcstod, wcstof, and wcstold functions (<a href="#7.24.4.1.1">7.24.4.1.1</a>), the
+ wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.24.4.1.2">7.24.4.1.2</a>), the wcrtomb
+ function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note288">288)</a> These white-space wide characters are not counted against a specified field width.
+
+<p><a name="note289">289)</a> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
+ sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
+
+<p><a name="note290">290)</a> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
+
+
+<a name="7.24.2.3" href="#7.24.2.3"><h5>7.24.2.3 The swprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        int swprintf(wchar_t * restrict s,
+             size_t n,
+             const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The swprintf function is equivalent to fwprintf, except that the argument s
+ specifies an array of wide characters into which the generated output is to be written,
+ rather than written to a stream. No more than n wide characters are written, including a
+ terminating null wide character, which is always added (unless n is zero).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The swprintf function returns the number of wide characters written in the array, not
+ counting the terminating null wide character, or a negative value if an encoding error
+ occurred or if n or more wide characters were requested to be written.
+
+<a name="7.24.2.4" href="#7.24.2.4"><h5>7.24.2.4 The swscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
         int swscanf(const wchar_t * restrict s,
-             const wchar_t * restrict format, ...);
+             const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The swscanf function is equivalent to fwscanf, except that the argument s specifies a
+ wide string from which the input is to be obtained, rather than from a stream. Reaching
+ the end of the wide string is equivalent to encountering end-of-file for the fwscanf
+ function.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The swscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the swscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+<!--page 375 indent 4-->
+
+<a name="7.24.2.5" href="#7.24.2.5"><h5>7.24.2.5 The vfwprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
         int vfwprintf(FILE * restrict stream,
-             const wchar_t * restrict format, va_list arg);
+             const wchar_t * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfwprintf function is equivalent to fwprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfwprintf function does not invoke the
+ va_end macro.<sup><a href="#note291"><b>291)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfwprintf function returns the number of wide characters transmitted, or a
+ negative value if an output or encoding error occurred.
+<p><!--para 4-->
+ EXAMPLE       The following shows the use of the vfwprintf function in a general error-reporting
+ routine.
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        void error(char *function_name, wchar_t *format, ...)
+        {
+              va_list args;
+                 va_start(args, format);
+                 // print out name of function causing error
+                 fwprintf(stderr, L"ERROR in %s: ", function_name);
+                 // print out remainder of message
+                 vfwprintf(stderr, format, args);
+                 va_end(args);
+        }</pre>
+ 
+ 
+ 
+ 
+<!--page 376 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note291">291)</a> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
+ invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+
+<a name="7.24.2.6" href="#7.24.2.6"><h5>7.24.2.6 The vfwscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
         int vfwscanf(FILE * restrict stream,
-             const wchar_t * restrict format, va_list arg);
-        int vswprintf(wchar_t * restrict s, size_t n,
-             const wchar_t * restrict format, va_list arg);
+             const wchar_t * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfwscanf function is equivalent to fwscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfwscanf function does not invoke the
+ va_end macro.291)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfwscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the vfwscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+
+<a name="7.24.2.7" href="#7.24.2.7"><h5>7.24.2.7 The vswprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;wchar.h&gt;
+        int vswprintf(wchar_t * restrict s,
+             size_t n,
+             const wchar_t * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vswprintf function is equivalent to swprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vswprintf function does not invoke the
+ va_end macro.291)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vswprintf function returns the number of wide characters written in the array, not
+ counting the terminating null wide character, or a negative value if an encoding error
+ occurred or if n or more wide characters were requested to be generated.
+<!--page 377 indent 4-->
+
+<a name="7.24.2.8" href="#7.24.2.8"><h5>7.24.2.8 The vswscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;wchar.h&gt;
         int vswscanf(const wchar_t * restrict s,
-             const wchar_t * restrict format, va_list arg);
+             const wchar_t * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vswscanf function is equivalent to swscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vswscanf function does not invoke the
+ va_end macro.291)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vswscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the vswscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+
+<a name="7.24.2.9" href="#7.24.2.9"><h5>7.24.2.9 The vwprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;wchar.h&gt;
         int vwprintf(const wchar_t * restrict format,
-             va_list arg);
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vwprintf function is equivalent to wprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vwprintf function does not invoke the
+ va_end macro.291)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vwprintf function returns the number of wide characters transmitted, or a negative
+ value if an output or encoding error occurred.
+<!--page 378 indent 4-->
+
+<a name="7.24.2.10" href="#7.24.2.10"><h5>7.24.2.10 The vwscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;wchar.h&gt;
         int vwscanf(const wchar_t * restrict format,
-             va_list arg);
-        int wprintf(const wchar_t * restrict format, ...);
-        int wscanf(const wchar_t * restrict format, ...);
-        wint_t fgetwc(FILE *stream);
-        wchar_t *fgetws(wchar_t * restrict s, int n,
-             FILE * restrict stream);
-        wint_t fputwc(wchar_t c, FILE *stream);
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vwscanf function is equivalent to wscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vwscanf function does not invoke the
+ va_end macro.291)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vwscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the vwscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+
+<a name="7.24.2.11" href="#7.24.2.11"><h5>7.24.2.11 The wprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        int wprintf(const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wprintf function is equivalent to fwprintf with the argument stdout
+ interposed before the arguments to wprintf.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wprintf function returns the number of wide characters transmitted, or a negative
+ value if an output or encoding error occurred.
+
+<a name="7.24.2.12" href="#7.24.2.12"><h5>7.24.2.12 The wscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        int wscanf(const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wscanf function is equivalent to fwscanf with the argument stdin interposed
+ before the arguments to wscanf.
+<!--page 379 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wscanf function returns the value of the macro EOF if an input failure occurs
+ before any conversion. Otherwise, the wscanf function returns the number of input
+ items assigned, which can be fewer than provided for, or even zero, in the event of an
+ early matching failure.
+
+<a name="7.24.3" href="#7.24.3"><h4>7.24.3 Wide character input/output functions</h4></a>
+
+<a name="7.24.3.1" href="#7.24.3.1"><h5>7.24.3.1 The fgetwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wint_t fgetwc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If the end-of-file indicator for the input stream pointed to by stream is not set and a
+ next wide character is present, the fgetwc function obtains that wide character as a
+ wchar_t converted to a wint_t and advances the associated file position indicator for
+ the stream (if defined).
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+ of-file indicator for the stream is set and the fgetwc function returns WEOF. Otherwise,
+ the fgetwc function returns the next wide character from the input stream pointed to by
+ stream. If a read error occurs, the error indicator for the stream is set and the fgetwc
+ function returns WEOF. If an encoding error occurs (including too few bytes), the value of
+ the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note292"><b>292)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note292">292)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+ Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
+
+
+<a name="7.24.3.2" href="#7.24.3.2"><h5>7.24.3.2 The fgetws function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wchar_t *fgetws(wchar_t * restrict s,
+              int n, FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fgetws function reads at most one less than the number of wide characters
+ specified by n from the stream pointed to by stream into the array pointed to by s. No
+ 
+ 
+<!--page 380 indent 4-->
+ additional wide characters are read after a new-line wide character (which is retained) or
+ after end-of-file. A null wide character is written immediately after the last wide
+ character read into the array.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fgetws function returns s if successful. If end-of-file is encountered and no
+ characters have been read into the array, the contents of the array remain unchanged and a
+ null pointer is returned. If a read or encoding error occurs during the operation, the array
+ contents are indeterminate and a null pointer is returned.
+
+<a name="7.24.3.3" href="#7.24.3.3"><h5>7.24.3.3 The fputwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        wint_t fputwc(wchar_t c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputwc function writes the wide character specified by c to the output stream
+ pointed to by stream, at the position indicated by the associated file position indicator
+ for the stream (if defined), and advances the indicator appropriately. If the file cannot
+ support positioning requests, or if the stream was opened with append mode, the
+ character is appended to the output stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputwc function returns the wide character written. If a write error occurs, the
+ error indicator for the stream is set and fputwc returns WEOF. If an encoding error
+ occurs, the value of the macro EILSEQ is stored in errno and fputwc returns WEOF.
+
+<a name="7.24.3.4" href="#7.24.3.4"><h5>7.24.3.4 The fputws function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
         int fputws(const wchar_t * restrict s,
-             FILE * restrict stream);
-        int fwide(FILE *stream, int mode);
-        wint_t getwc(FILE *stream);
-        wint_t getwchar(void);
-        wint_t putwc(wchar_t c, FILE *stream);
-        wint_t putwchar(wchar_t c);
-        wint_t ungetwc(wint_t c, FILE *stream);
-
-[<a name="p435" href="#p435">page 435</a>] (<a href="#Contents">Contents</a>)
-
-      double wcstod(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr);
-      float wcstof(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr);
-      long double wcstold(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr);
-      long int wcstol(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      long long int wcstoll(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      unsigned long int wcstoul(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      unsigned long long int wcstoull(
-           const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      wchar_t *wcscpy(wchar_t * restrict s1,
-           const wchar_t * restrict s2);
-      wchar_t *wcsncpy(wchar_t * restrict s1,
-           const wchar_t * restrict s2, size_t n);
-      wchar_t *wmemcpy(wchar_t * restrict s1,
-           const wchar_t * restrict s2, size_t n);
-      wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
-           size_t n);
-      wchar_t *wcscat(wchar_t * restrict s1,
-           const wchar_t * restrict s2);
-      wchar_t *wcsncat(wchar_t * restrict s1,
-           const wchar_t * restrict s2, size_t n);
-      int wcscmp(const wchar_t *s1, const wchar_t *s2);
-      int wcscoll(const wchar_t *s1, const wchar_t *s2);
-      int wcsncmp(const wchar_t *s1, const wchar_t *s2,
-           size_t n);
-      size_t wcsxfrm(wchar_t * restrict s1,
-           const wchar_t * restrict s2, size_t n);
-      int wmemcmp(const wchar_t *s1, const wchar_t *s2,
-           size_t n);
-      wchar_t *wcschr(const wchar_t *s, wchar_t c);
-      size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
-      wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2); *
-      wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
-      size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
-      wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
-
-[<a name="p436" href="#p436">page 436</a>] (<a href="#Contents">Contents</a>)
-
+             FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputws function writes the wide string pointed to by s to the stream pointed to by
+ stream. The terminating null wide character is not written.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputws function returns EOF if a write or encoding error occurs; otherwise, it
+ returns a nonnegative value.
+<!--page 381 indent 4-->
+
+<a name="7.24.3.5" href="#7.24.3.5"><h5>7.24.3.5 The fwide function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int fwide(FILE *stream, int mode);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwide function determines the orientation of the stream pointed to by stream. If
+ mode is greater than zero, the function first attempts to make the stream wide oriented. If
+ mode is less than zero, the function first attempts to make the stream byte oriented.<sup><a href="#note293"><b>293)</b></a></sup>
+ Otherwise, mode is zero and the function does not alter the orientation of the stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fwide function returns a value greater than zero if, after the call, the stream has
+ wide orientation, a value less than zero if the stream has byte orientation, or zero if the
+ stream has no orientation.
+
+<h6>footnotes</h6>
+<p><a name="note293">293)</a> If the orientation of the stream has already been determined, fwide does not change it.
+
+
+<a name="7.24.3.6" href="#7.24.3.6"><h5>7.24.3.6 The getwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wint_t getwc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getwc function is equivalent to fgetwc, except that if it is implemented as a
+ macro, it may evaluate stream more than once, so the argument should never be an
+ expression with side effects.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getwc function returns the next wide character from the input stream pointed to by
+ stream, or WEOF.
+
+<a name="7.24.3.7" href="#7.24.3.7"><h5>7.24.3.7 The getwchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wint_t getwchar(void);</pre>
+ 
+ 
+ 
+ 
+<!--page 382 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The getwchar function is equivalent to getwc with the argument stdin.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getwchar function returns the next wide character from the input stream pointed to
+ by stdin, or WEOF.
+
+<a name="7.24.3.8" href="#7.24.3.8"><h5>7.24.3.8 The putwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        wint_t putwc(wchar_t c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putwc function is equivalent to fputwc, except that if it is implemented as a
+ macro, it may evaluate stream more than once, so that argument should never be an
+ expression with side effects.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putwc function returns the wide character written, or WEOF.
+
+<a name="7.24.3.9" href="#7.24.3.9"><h5>7.24.3.9 The putwchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wint_t putwchar(wchar_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putwchar function is equivalent to putwc with the second argument stdout.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putwchar function returns the character written, or WEOF.
+
+<a name="7.24.3.10" href="#7.24.3.10"><h5>7.24.3.10 The ungetwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        wint_t ungetwc(wint_t c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ungetwc function pushes the wide character specified by c back onto the input
+ stream pointed to by stream. Pushed-back wide characters will be returned by
+ subsequent reads on that stream in the reverse order of their pushing. A successful
+<!--page 383 indent 4-->
+ intervening call (with the stream pointed to by stream) to a file positioning function
+ (fseek, fsetpos, or rewind) discards any pushed-back wide characters for the
+ stream. The external storage corresponding to the stream is unchanged.
+<p><!--para 3-->
+ One wide character of pushback is guaranteed, even if the call to the ungetwc function
+ follows just after a call to a formatted wide character input function fwscanf,
+ vfwscanf, vwscanf, or wscanf. If the ungetwc function is called too many times
+ on the same stream without an intervening read or file positioning operation on that
+ stream, the operation may fail.
+<p><!--para 4-->
+ If the value of c equals that of the macro WEOF, the operation fails and the input stream is
+ unchanged.
+<p><!--para 5-->
+ A successful call to the ungetwc function clears the end-of-file indicator for the stream.
+ The value of the file position indicator for the stream after reading or discarding all
+ pushed-back wide characters is the same as it was before the wide characters were pushed
+ back. For a text or binary stream, the value of its file position indicator after a successful
+ call to the ungetwc function is unspecified until all pushed-back wide characters are
+ read or discarded.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The ungetwc function returns the wide character pushed back, or WEOF if the operation
+ fails.
+
+<a name="7.24.4" href="#7.24.4"><h4>7.24.4 General wide string utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wchar.h&gt; declares a number of functions useful for wide string
+ manipulation. Various methods are used for determining the lengths of the arrays, but in
+ all cases a wchar_t * argument points to the initial (lowest addressed) element of the
+ array. If an array is accessed beyond the end of an object, the behavior is undefined.
+<p><!--para 2-->
+ Where an argument declared as size_t n determines the length of the array for a
+ function, n can have the value zero on a call to that function. Unless explicitly stated
+ otherwise in the description of a particular function in this subclause, pointer arguments
+ on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+ function that locates a wide character finds no occurrence, a function that compares two
+ wide character sequences returns zero, and a function that copies wide characters copies
+ zero wide characters.
+<!--page 384 indent 4-->
+
+<a name="7.24.4.1" href="#7.24.4.1"><h5>7.24.4.1 Wide string numeric conversion functions</h5></a>
+
+<a name="7.24.4.1.1" href="#7.24.4.1.1"><h5>7.24.4.1.1 The wcstod, wcstof, and wcstold functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        double wcstod(const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr);
+        float wcstof(const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr);
+        long double wcstold(const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstod, wcstof, and wcstold functions convert the initial portion of the wide
+ string pointed to by nptr to double, float, and long double representation,
+ respectively. First, they decompose the input string into three parts: an initial, possibly
+ empty, sequence of white-space wide characters (as specified by the iswspace
+ function), a subject sequence resembling a floating-point constant or representing an
+ infinity or NaN; and a final wide string of one or more unrecognized wide characters,
+ including the terminating null wide character of the input wide string. Then, they attempt
+ to convert the subject sequence to a floating-point number, and return the result.
+<p><!--para 3-->
+ The expected form of the subject sequence is an optional plus or minus sign, then one of
+ the following:
+<ul>
+<li>  a nonempty sequence of decimal digits optionally containing a decimal-point wide
+ character, then an optional exponent part as defined for the corresponding single-byte
+ characters in <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+ decimal-point wide character, then an optional binary exponent part as defined in
+ <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  INF or INFINITY, or any other wide string equivalent except for case
+<li>  NAN or NAN(n-wchar-sequenceopt), or any other wide string equivalent except for
+ case in the NAN part, where:
+<pre>
+          n-wchar-sequence:
+                digit
+                nondigit
+                n-wchar-sequence digit
+                n-wchar-sequence nondigit</pre>
+</ul>
+ The subject sequence is defined as the longest initial subsequence of the input wide
+ string, starting with the first non-white-space wide character, that is of the expected form.
+<!--page 385 indent 4-->
+ The subject sequence contains no wide characters if the input wide string is not of the
+ expected form.
+<p><!--para 4-->
+ If the subject sequence has the expected form for a floating-point number, the sequence of
+ wide characters starting with the first digit or the decimal-point wide character
+ (whichever occurs first) is interpreted as a floating constant according to the rules of
+ <a href="#6.4.4.2">6.4.4.2</a>, except that the decimal-point wide character is used in place of a period, and that
+ if neither an exponent part nor a decimal-point wide character appears in a decimal
+ floating point number, or if a binary exponent part does not appear in a hexadecimal
+ floating point number, an exponent part of the appropriate type with value zero is
+ assumed to follow the last digit in the string. If the subject sequence begins with a minus
+ sign, the sequence is interpreted as negated.<sup><a href="#note294"><b>294)</b></a></sup> A wide character sequence INF or
+ INFINITY is interpreted as an infinity, if representable in the return type, else like a
+ floating constant that is too large for the range of the return type. A wide character
+ sequence NAN or NAN(n-wchar-sequenceopt) is interpreted as a quiet NaN, if supported
+ in the return type, else like a subject sequence part that does not have the expected form;
+ the meaning of the n-wchar sequences is implementation-defined.<sup><a href="#note295"><b>295)</b></a></sup> A pointer to the
+ final wide string is stored in the object pointed to by endptr, provided that endptr is
+ not a null pointer.
+<p><!--para 5-->
+ If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+ value resulting from the conversion is correctly rounded.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+ Recommended practice
+<p><!--para 8-->
+ If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+ the result is not exactly representable, the result should be one of the two numbers in the
+ appropriate internal format that are adjacent to the hexadecimal floating source value,
+ with the extra stipulation that the error should have a correct sign for the current rounding
+ direction.
+ 
+ 
+ 
+<!--page 386 indent 5-->
+<p><!--para 9-->
+ If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+ &lt;float.h&gt;) significant digits, the result should be correctly rounded. If the subject
+ sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+ consider the two bounding, adjacent decimal strings L and U, both having
+ DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+ The result should be one of the (equal or adjacent) values that would be obtained by
+ correctly rounding L and U according to the current rounding direction, with the extra
+ stipulation that the error with respect to D should have a correct sign for the current
+ rounding direction.<sup><a href="#note296"><b>296)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 10-->
+ The functions return the converted value, if any. If no conversion could be performed,
+ zero is returned. If the correct value is outside the range of representable values, plus or
+ minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the return
+ type and sign of the value), and the value of the macro ERANGE is stored in errno. If
+ the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is no greater
+ than the smallest normalized positive number in the return type; whether errno acquires
+ the value ERANGE is implementation-defined.
+ 
+ 
+ 
+ 
+<!--page 387 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note294">294)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+ negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+ methods may yield different results if rounding is toward positive or negative infinity. In either case,
+ the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+
+<p><a name="note295">295)</a> An implementation may use the n-wchar sequence to determine extra information to be represented in
+ the NaN's significand.
+
+<p><a name="note296">296)</a> DECIMAL_DIG, defined in &lt;float.h&gt;, should be sufficiently large that L and U will usually round
+ to the same internal floating value, but if not will round to adjacent values.
+
+
+<a name="7.24.4.1.2" href="#7.24.4.1.2"><h5>7.24.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        long int wcstol(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);
+        long long int wcstoll(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);
+        unsigned long int wcstoul(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);
+        unsigned long long int wcstoull(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
+ portion of the wide string pointed to by nptr to long int, long long int,
+ unsigned long int, and unsigned long long int representation,
+ respectively. First, they decompose the input string into three parts: an initial, possibly
+ empty, sequence of white-space wide characters (as specified by the iswspace
+ function), a subject sequence resembling an integer represented in some radix determined
+ by the value of base, and a final wide string of one or more unrecognized wide
+ characters, including the terminating null wide character of the input wide string. Then,
+ they attempt to convert the subject sequence to an integer, and return the result.
+<p><!--para 3-->
+ If the value of base is zero, the expected form of the subject sequence is that of an
+ integer constant as described for the corresponding single-byte characters in <a href="#6.4.4.1">6.4.4.1</a>,
+ optionally preceded by a plus or minus sign, but not including an integer suffix. If the
+ value of base is between 2 and 36 (inclusive), the expected form of the subject sequence
+ is a sequence of letters and digits representing an integer with the radix specified by
+ base, optionally preceded by a plus or minus sign, but not including an integer suffix.
+ The letters from a (or A) through z (or Z) are ascribed the values 10 through 35; only
+ letters and digits whose ascribed values are less than that of base are permitted. If the
+ value of base is 16, the wide characters 0x or 0X may optionally precede the sequence
+ of letters and digits, following the sign if present.
+<!--page 388 indent 4-->
+<p><!--para 4-->
+ The subject sequence is defined as the longest initial subsequence of the input wide
+ string, starting with the first non-white-space wide character, that is of the expected form.
+ The subject sequence contains no wide characters if the input wide string is empty or
+ consists entirely of white space, or if the first non-white-space wide character is other
+ than a sign or a permissible letter or digit.
+<p><!--para 5-->
+ If the subject sequence has the expected form and the value of base is zero, the sequence
+ of wide characters starting with the first digit is interpreted as an integer constant
+ according to the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the
+ value of base is between 2 and 36, it is used as the base for conversion, ascribing to each
+ letter its value as given above. If the subject sequence begins with a minus sign, the value
+ resulting from the conversion is negated (in the return type). A pointer to the final wide
+ string is stored in the object pointed to by endptr, provided that endptr is not a null
+ pointer.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The wcstol, wcstoll, wcstoul, and wcstoull functions return the converted
+ value, if any. If no conversion could be performed, zero is returned. If the correct value
+ is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+ LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+ sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+
+<a name="7.24.4.2" href="#7.24.4.2"><h5>7.24.4.2 Wide string copying functions</h5></a>
+
+<a name="7.24.4.2.1" href="#7.24.4.2.1"><h5>7.24.4.2.1 The wcscpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcscpy(wchar_t * restrict s1,
+             const wchar_t * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscpy function copies the wide string pointed to by s2 (including the terminating
+ null wide character) into the array pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscpy function returns the value of s1.
+<!--page 389 indent 4-->
+
+<a name="7.24.4.2.2" href="#7.24.4.2.2"><h5>7.24.4.2.2 The wcsncpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;wchar.h&gt;
+          wchar_t *wcsncpy(wchar_t * restrict s1,
+               const wchar_t * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsncpy function copies not more than n wide characters (those that follow a null
+ wide character are not copied) from the array pointed to by s2 to the array pointed to by
+ s1.<sup><a href="#note297"><b>297)</b></a></sup>
+<p><!--para 3-->
+ If the array pointed to by s2 is a wide string that is shorter than n wide characters, null
+ wide characters are appended to the copy in the array pointed to by s1, until n wide
+ characters in all have been written.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The wcsncpy function returns the value of s1.
+
+<h6>footnotes</h6>
+<p><a name="note297">297)</a> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
+ result will not be null-terminated.
+
+
+<a name="7.24.4.2.3" href="#7.24.4.2.3"><h5>7.24.4.2.3 The wmemcpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;wchar.h&gt;
+          wchar_t *wmemcpy(wchar_t * restrict s1,
+               const wchar_t * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemcpy function copies n wide characters from the object pointed to by s2 to the
+ object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemcpy function returns the value of s1.
+ 
+ 
+ 
+ 
+<!--page 390 indent 4-->
+
+<a name="7.24.4.2.4" href="#7.24.4.2.4"><h5>7.24.4.2.4 The wmemmove function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemmove function copies n wide characters from the object pointed to by s2 to
+ the object pointed to by s1. Copying takes place as if the n wide characters from the
+ object pointed to by s2 are first copied into a temporary array of n wide characters that
+ does not overlap the objects pointed to by s1 or s2, and then the n wide characters from
+ the temporary array are copied into the object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemmove function returns the value of s1.
+
+<a name="7.24.4.3" href="#7.24.4.3"><h5>7.24.4.3 Wide string concatenation functions</h5></a>
+
+<a name="7.24.4.3.1" href="#7.24.4.3.1"><h5>7.24.4.3.1 The wcscat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcscat(wchar_t * restrict s1,
+             const wchar_t * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscat function appends a copy of the wide string pointed to by s2 (including the
+ terminating null wide character) to the end of the wide string pointed to by s1. The initial
+ wide character of s2 overwrites the null wide character at the end of s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscat function returns the value of s1.
+
+<a name="7.24.4.3.2" href="#7.24.4.3.2"><h5>7.24.4.3.2 The wcsncat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcsncat(wchar_t * restrict s1,
+             const wchar_t * restrict s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsncat function appends not more than n wide characters (a null wide character
+ and those that follow it are not appended) from the array pointed to by s2 to the end of
+<!--page 391 indent 4-->
+ the wide string pointed to by s1. The initial wide character of s2 overwrites the null
+ wide character at the end of s1. A terminating null wide character is always appended to
+ the result.<sup><a href="#note298"><b>298)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsncat function returns the value of s1.
+
+<h6>footnotes</h6>
+<p><a name="note298">298)</a> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
+ wcslen(s1)+n+1.
+
+
+<a name="7.24.4.4" href="#7.24.4.4"><h5>7.24.4.4 Wide string comparison functions</h5></a>
+<p><!--para 1-->
+ Unless explicitly stated otherwise, the functions described in this subclause order two
+ wide characters the same way as two integers of the underlying integer type designated
+ by wchar_t.
+
+<a name="7.24.4.4.1" href="#7.24.4.4.1"><h5>7.24.4.4.1 The wcscmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int wcscmp(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscmp function compares the wide string pointed to by s1 to the wide string
+ pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+ wide string pointed to by s2.
+
+<a name="7.24.4.4.2" href="#7.24.4.4.2"><h5>7.24.4.4.2 The wcscoll function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int wcscoll(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscoll function compares the wide string pointed to by s1 to the wide string
+ pointed to by s2, both interpreted as appropriate to the LC_COLLATE category of the
+ current locale.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscoll function returns an integer greater than, equal to, or less than zero,
+ accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+ 
+ 
+<!--page 392 indent 4-->
+ wide string pointed to by s2 when both are interpreted as appropriate to the current
+ locale.
+
+<a name="7.24.4.4.3" href="#7.24.4.4.3"><h5>7.24.4.4.3 The wcsncmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsncmp function compares not more than n wide characters (those that follow a
+ null wide character are not compared) from the array pointed to by s1 to the array
+ pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsncmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+ to, or less than the possibly null-terminated array pointed to by s2.
+
+<a name="7.24.4.4.4" href="#7.24.4.4.4"><h5>7.24.4.4.4 The wcsxfrm function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        size_t wcsxfrm(wchar_t * restrict s1,
+             const wchar_t * restrict s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsxfrm function transforms the wide string pointed to by s2 and places the
+ resulting wide string into the array pointed to by s1. The transformation is such that if
+ the wcscmp function is applied to two transformed wide strings, it returns a value greater
+ than, equal to, or less than zero, corresponding to the result of the wcscoll function
+ applied to the same two original wide strings. No more than n wide characters are placed
+ into the resulting array pointed to by s1, including the terminating null wide character. If
+ n is zero, s1 is permitted to be a null pointer.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsxfrm function returns the length of the transformed wide string (not including
+ the terminating null wide character). If the value returned is n or greater, the contents of
+ the array pointed to by s1 are indeterminate.
+<p><!--para 4-->
+ EXAMPLE The value of the following expression is the length of the array needed to hold the
+ transformation of the wide string pointed to by s:
+<!--page 393 indent 4-->
+<pre>
+        1 + wcsxfrm(NULL, s, 0)</pre>
+ 
+
+<a name="7.24.4.4.5" href="#7.24.4.4.5"><h5>7.24.4.4.5 The wmemcmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        int wmemcmp(const wchar_t *s1, const wchar_t *s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemcmp function compares the first n wide characters of the object pointed to by
+ s1 to the first n wide characters of the object pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemcmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+ pointed to by s2.
+
+<a name="7.24.4.5" href="#7.24.4.5"><h5>7.24.4.5 Wide string search functions</h5></a>
+
+<a name="7.24.4.5.1" href="#7.24.4.5.1"><h5>7.24.4.5.1 The wcschr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcschr(const wchar_t *s, wchar_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcschr function locates the first occurrence of c in the wide string pointed to by s.
+ The terminating null wide character is considered to be part of the wide string.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcschr function returns a pointer to the located wide character, or a null pointer if
+ the wide character does not occur in the wide string.
+
+<a name="7.24.4.5.2" href="#7.24.4.5.2"><h5>7.24.4.5.2 The wcscspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        size_t wcscspn(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscspn function computes the length of the maximum initial segment of the wide
+ string pointed to by s1 which consists entirely of wide characters not from the wide
+ string pointed to by s2.
+<!--page 394 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscspn function returns the length of the segment.
+
+<a name="7.24.4.5.3" href="#7.24.4.5.3"><h5>7.24.4.5.3 The wcspbrk function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcspbrk function locates the first occurrence in the wide string pointed to by s1 of
+ any wide character from the wide string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcspbrk function returns a pointer to the wide character in s1, or a null pointer if
+ no wide character from s2 occurs in s1.
+
+<a name="7.24.4.5.4" href="#7.24.4.5.4"><h5>7.24.4.5.4 The wcsrchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcsrchr(const wchar_t *s, wchar_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsrchr function locates the last occurrence of c in the wide string pointed to by
+ s. The terminating null wide character is considered to be part of the wide string.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsrchr function returns a pointer to the wide character, or a null pointer if c does
+ not occur in the wide string.
+
+<a name="7.24.4.5.5" href="#7.24.4.5.5"><h5>7.24.4.5.5 The wcsspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        size_t wcsspn(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsspn function computes the length of the maximum initial segment of the wide
+ string pointed to by s1 which consists entirely of wide characters from the wide string
+ pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsspn function returns the length of the segment.
+<!--page 395 indent 4-->
+
+<a name="7.24.4.5.6" href="#7.24.4.5.6"><h5>7.24.4.5.6 The wcsstr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsstr function locates the first occurrence in the wide string pointed to by s1 of
+ the sequence of wide characters (excluding the terminating null wide character) in the
+ wide string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsstr function returns a pointer to the located wide string, or a null pointer if the
+ wide string is not found. If s2 points to a wide string with zero length, the function
+ returns s1.
+
+<a name="7.24.4.5.7" href="#7.24.4.5.7"><h5>7.24.4.5.7 The wcstok function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
         wchar_t *wcstok(wchar_t * restrict s1,
              const wchar_t * restrict s2,
-             wchar_t ** restrict ptr);
-        wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
-        size_t wcslen(const wchar_t *s);
-        wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
-        size_t wcsftime(wchar_t * restrict s, size_t maxsize,
+             wchar_t ** restrict ptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A sequence of calls to the wcstok function breaks the wide string pointed to by s1 into
+ a sequence of tokens, each of which is delimited by a wide character from the wide string
+ pointed to by s2. The third argument points to a caller-provided wchar_t pointer into
+ which the wcstok function stores information necessary for it to continue scanning the
+ same wide string.
+<p><!--para 3-->
+ The first call in a sequence has a non-null first argument and stores an initial value in the
+ object pointed to by ptr. Subsequent calls in the sequence have a null first argument and
+ the object pointed to by ptr is required to have the value stored by the previous call in
+ the sequence, which is then updated. The separator wide string pointed to by s2 may be
+ different from call to call.
+<p><!--para 4-->
+ The first call in the sequence searches the wide string pointed to by s1 for the first wide
+ character that is not contained in the current separator wide string pointed to by s2. If no
+ such wide character is found, then there are no tokens in the wide string pointed to by s1
+ and the wcstok function returns a null pointer. If such a wide character is found, it is
+ the start of the first token.
+<p><!--para 5-->
+ The wcstok function then searches from there for a wide character that is contained in
+ the current separator wide string. If no such wide character is found, the current token
+<!--page 396 indent 4-->
+ extends to the end of the wide string pointed to by s1, and subsequent searches in the
+ same wide string for a token return a null pointer. If such a wide character is found, it is
+ overwritten by a null wide character, which terminates the current token.
+<p><!--para 6-->
+ In all cases, the wcstok function stores sufficient information in the pointer pointed to
+ by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+ value for ptr, shall start searching just past the element overwritten by a null wide
+ character (if any).
+<h6>Returns</h6>
+<p><!--para 7-->
+ The wcstok function returns a pointer to the first wide character of a token, or a null
+ pointer if there is no token.
+<p><!--para 8-->
+ EXAMPLE
+<pre>
+        #include &lt;wchar.h&gt;
+        static wchar_t str1[] = L"?a???b,,,#c";
+        static wchar_t str2[] = L"\t \t";
+        wchar_t *t, *ptr1, *ptr2;
+        t   =   wcstok(str1,   L"?", &amp;ptr1);          //   t   points to the token L"a"
+        t   =   wcstok(NULL,   L",", &amp;ptr1);          //   t   points to the token L"??b"
+        t   =   wcstok(str2,   L" \t", &amp;ptr2);        //   t   is a null pointer
+        t   =   wcstok(NULL,   L"#,", &amp;ptr1);         //   t   points to the token L"c"
+        t   =   wcstok(NULL,   L"?", &amp;ptr1);          //   t   is a null pointer</pre>
+ 
+
+<a name="7.24.4.5.8" href="#7.24.4.5.8"><h5>7.24.4.5.8 The wmemchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wmemchr(const wchar_t *s, wchar_t c,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemchr function locates the first occurrence of c in the initial n wide characters of
+ the object pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemchr function returns a pointer to the located wide character, or a null pointer if
+ the wide character does not occur in the object.
+<!--page 397 indent 4-->
+
+<a name="7.24.4.6" href="#7.24.4.6"><h5>7.24.4.6 Miscellaneous functions</h5></a>
+
+<a name="7.24.4.6.1" href="#7.24.4.6.1"><h5>7.24.4.6.1 The wcslen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        size_t wcslen(const wchar_t *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcslen function computes the length of the wide string pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcslen function returns the number of wide characters that precede the terminating
+ null wide character.
+
+<a name="7.24.4.6.2" href="#7.24.4.6.2"><h5>7.24.4.6.2 The wmemset function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemset function copies the value of c into each of the first n wide characters of
+ the object pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemset function returns the value of s.
+
+<a name="7.24.5" href="#7.24.5"><h4>7.24.5 Wide character time conversion functions</h4></a>
+
+<a name="7.24.5.1" href="#7.24.5.1"><h5>7.24.5.1 The wcsftime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        #include &lt;wchar.h&gt;
+        size_t wcsftime(wchar_t * restrict s,
+             size_t maxsize,
              const wchar_t * restrict format,
-             const struct tm * restrict timeptr);
-        wint_t btowc(int c);
-        int wctob(wint_t c);
-        int mbsinit(const mbstate_t *ps);
-        size_t mbrlen(const char * restrict s, size_t n,
-             mbstate_t * restrict ps);
-        size_t mbrtowc(wchar_t * restrict pwc,
-             const char * restrict s, size_t n,
-             mbstate_t * restrict ps);
-        size_t wcrtomb(char * restrict s, wchar_t wc,
-             mbstate_t * restrict ps);
-        size_t mbsrtowcs(wchar_t * restrict dst,
-             const char ** restrict src, size_t len,
-             mbstate_t * restrict ps);
-        size_t wcsrtombs(char * restrict dst,
-             const wchar_t ** restrict src, size_t len,
-             mbstate_t * restrict ps);
-<a name="B.24" href="#B.24"><b>B.24 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
-        wint_t         wctrans_t          wctype_t          WEOF
-        int   iswalnum(wint_t wc);
-        int   iswalpha(wint_t wc);
-        int   iswblank(wint_t wc);
-        int   iswcntrl(wint_t wc);
-        int   iswdigit(wint_t wc);
-        int   iswgraph(wint_t wc);
-        int   iswlower(wint_t wc);
-        int   iswprint(wint_t wc);
-        int   iswpunct(wint_t wc);
-        int   iswspace(wint_t wc);
-        int   iswupper(wint_t wc);
-        int   iswxdigit(wint_t wc);
-        int   iswctype(wint_t wc, wctype_t desc);
-
-[<a name="p437" href="#p437">page 437</a>] (<a href="#Contents">Contents</a>)
-
-      wctype_t wctype(const char *property);
-      wint_t towlower(wint_t wc);
-      wint_t towupper(wint_t wc);
-      wint_t towctrans(wint_t wc, wctrans_t desc);
-      wctrans_t wctrans(const char *property);
-
-[<a name="p438" href="#p438">page 438</a>] (<a href="#Contents">Contents</a>)
-
-<a name="C" href="#C"><b>                                          Annex C</b></a>
-                                        (informative)
-                                      Sequence points
-1   The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
-    -- The call to a function, after the arguments have been evaluated (<a href="#6.5.2.2">6.5.2.2</a>).
-    -- The end of the first operand of the following operators: logical AND &amp;&amp; (<a href="#6.5.13">6.5.13</a>);
-      logical OR || (<a href="#6.5.14">6.5.14</a>); conditional ? (<a href="#6.5.15">6.5.15</a>); comma , (<a href="#6.5.17">6.5.17</a>).
-    -- The end of a full declarator: declarators (<a href="#6.7.5">6.7.5</a>);
-    -- The end of a full expression: an initializer (<a href="#6.7.8">6.7.8</a>); the expression in an expression
-      statement (<a href="#6.8.3">6.8.3</a>); the controlling expression of a selection statement (if or switch)
-      (<a href="#6.8.4">6.8.4</a>); the controlling expression of a while or do statement (<a href="#6.8.5">6.8.5</a>); each of the
-      expressions of a for statement (<a href="#6.8.5.3">6.8.5.3</a>); the expression in a return statement
-      (<a href="#6.8.6.4">6.8.6.4</a>).
-    -- Immediately before a library function returns (<a href="#7.1.4">7.1.4</a>).
-    -- After the actions associated with each formatted input/output function conversion
-      specifier (<a href="#7.19.6">7.19.6</a>, <a href="#7.24.2">7.24.2</a>).
-    -- Immediately before and immediately after each call to a comparison function, and
-      also between any call to a comparison function and any movement of the objects
-      passed as arguments to that call (<a href="#7.20.5">7.20.5</a>).
-
-[<a name="p439" href="#p439">page 439</a>] (<a href="#Contents">Contents</a>)
-
-<a name="D" href="#D"><b>                                         Annex D</b></a>
-                                        (normative)
-                   Universal character names for identifiers
-1   This clause lists the hexadecimal code values that are valid in universal character names
-    in identifiers.
-2   This table is reproduced unchanged from ISO/IEC TR 10176:1998, produced by ISO/IEC
-    JTC 1/SC 22/WG 20, except for the omission of ranges that are part of the basic character
-    sets.
-    Latin:            00AA, 00BA, 00C0-00D6, 00D8-00F6, 00F8-01F5, 01FA-0217,
-                      0250-02A8, 1E00-1E9B, 1EA0-1EF9, 207F
-    Greek:            0386, 0388-038A, 038C, 038E-03A1, 03A3-03CE, 03D0-03D6,
-                      03DA, 03DC, 03DE, 03E0, 03E2-03F3, 1F00-1F15, 1F18-1F1D,
-                      1F20-1F45, 1F48-1F4D, 1F50-1F57, 1F59, 1F5B, 1F5D,
-                      1F5F-1F7D, 1F80-1FB4, 1FB6-1FBC, 1FC2-1FC4, 1FC6-1FCC,
-                      1FD0-1FD3, 1FD6-1FDB, 1FE0-1FEC, 1FF2-1FF4, 1FF6-1FFC
-    Cyrillic:         0401-040C, 040E-044F, 0451-045C, 045E-0481, 0490-04C4,
-                      04C7-04C8, 04CB-04CC, 04D0-04EB, 04EE-04F5, 04F8-04F9
-    Armenian:         0531-0556, 0561-0587
-    Hebrew:           05B0-05B9,      05BB-05BD,       05BF,   05C1-05C2,      05D0-05EA,
-                      05F0-05F2
-    Arabic:           0621-063A, 0640-0652, 0670-06B7, 06BA-06BE, 06C0-06CE,
-                      06D0-06DC, 06E5-06E8, 06EA-06ED
-    Devanagari:       0901-0903, 0905-0939, 093E-094D, 0950-0952, 0958-0963
-    Bengali:          0981-0983, 0985-098C, 098F-0990, 0993-09A8, 09AA-09B0,
-                      09B2, 09B6-09B9, 09BE-09C4, 09C7-09C8, 09CB-09CD,
-                      09DC-09DD, 09DF-09E3, 09F0-09F1
-    Gurmukhi:         0A02, 0A05-0A0A, 0A0F-0A10, 0A13-0A28, 0A2A-0A30,
-                      0A32-0A33, 0A35-0A36, 0A38-0A39, 0A3E-0A42, 0A47-0A48,
-                      0A4B-0A4D, 0A59-0A5C, 0A5E, 0A74
-    Gujarati:         0A81-0A83, 0A85-0A8B, 0A8D, 0A8F-0A91, 0A93-0AA8,
-                      0AAA-0AB0,    0AB2-0AB3,     0AB5-0AB9, 0ABD-0AC5,
-                      0AC7-0AC9, 0ACB-0ACD, 0AD0, 0AE0
-    Oriya:            0B01-0B03, 0B05-0B0C, 0B0F-0B10, 0B13-0B28, 0B2A-0B30,
-                      0B32-0B33, 0B36-0B39, 0B3E-0B43, 0B47-0B48, 0B4B-0B4D,
-
-[<a name="p440" href="#p440">page 440</a>] (<a href="#Contents">Contents</a>)
-
-                0B5C-0B5D, 0B5F-0B61
-Tamil:          0B82-0B83, 0B85-0B8A, 0B8E-0B90, 0B92-0B95, 0B99-0B9A,
-                0B9C, 0B9E-0B9F, 0BA3-0BA4, 0BA8-0BAA, 0BAE-0BB5,
-                0BB7-0BB9, 0BBE-0BC2, 0BC6-0BC8, 0BCA-0BCD
-Telugu:         0C01-0C03, 0C05-0C0C, 0C0E-0C10, 0C12-0C28, 0C2A-0C33,
-                0C35-0C39, 0C3E-0C44, 0C46-0C48, 0C4A-0C4D, 0C60-0C61
-Kannada:        0C82-0C83, 0C85-0C8C, 0C8E-0C90, 0C92-0CA8, 0CAA-0CB3,
-                0CB5-0CB9, 0CBE-0CC4, 0CC6-0CC8, 0CCA-0CCD, 0CDE,
-                0CE0-0CE1
-Malayalam:      0D02-0D03, 0D05-0D0C, 0D0E-0D10, 0D12-0D28, 0D2A-0D39,
-                0D3E-0D43, 0D46-0D48, 0D4A-0D4D, 0D60-0D61
-Thai:           0E01-0E3A, 0E40-0E5B
-Lao:            0E81-0E82, 0E84, 0E87-0E88, 0E8A, 0E8D, 0E94-0E97,
-                0E99-0E9F,   0EA1-0EA3,  0EA5,  0EA7,  0EAA-0EAB,
-                0EAD-0EAE, 0EB0-0EB9, 0EBB-0EBD, 0EC0-0EC4, 0EC6,
-                0EC8-0ECD, 0EDC-0EDD
-Tibetan:        0F00, 0F18-0F19, 0F35, 0F37, 0F39, 0F3E-0F47, 0F49-0F69,
-                0F71-0F84, 0F86-0F8B, 0F90-0F95, 0F97, 0F99-0FAD,
-                0FB1-0FB7, 0FB9
-Georgian:       10A0-10C5, 10D0-10F6
-Hiragana:       3041-3093, 309B-309C
-Katakana:       30A1-30F6, 30FB-30FC
-Bopomofo:       3105-312C
-CJK Unified Ideographs: 4E00-9FA5
-Hangul:         AC00-D7A3
-Digits:         0660-0669, 06F0-06F9, 0966-096F, 09E6-09EF, 0A66-0A6F,
-                0AE6-0AEF, 0B66-0B6F, 0BE7-0BEF, 0C66-0C6F, 0CE6-0CEF,
-                0D66-0D6F, 0E50-0E59, 0ED0-0ED9, 0F20-0F33
-Special characters: 00B5, 00B7, 02B0-02B8, 02BB, 02BD-02C1, 02D0-02D1,
-                   02E0-02E4, 037A, 0559, 093D, 0B3D, 1FBE, 203F-2040, 2102,
-                   2107, 210A-2113, 2115, 2118-211D, 2124, 2126, 2128, 212A-2131,
-                   2133-2138, 2160-2182, 3005-3007, 3021-3029
-
-[<a name="p441" href="#p441">page 441</a>] (<a href="#Contents">Contents</a>)
-
-<a name="E" href="#E"><b>                                         Annex E</b></a>
-                                       (informative)
-                                Implementation limits
-1   The contents of the header <a href="#7.10">&lt;limits.h&gt;</a> are given below, in alphabetical order. The
-    minimum magnitudes shown shall be replaced by implementation-defined magnitudes
-    with the same sign. The values shall all be constant expressions suitable for use in #if
-    preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
-           #define     CHAR_BIT                               8
-           #define     CHAR_MAX          UCHAR_MAX or SCHAR_MAX
-           #define     CHAR_MIN                  0 or SCHAR_MIN
-           #define     INT_MAX                           +32767
-           #define     INT_MIN                           -32767
-           #define     LONG_MAX                     +2147483647
-           #define     LONG_MIN                     -2147483647
-           #define     LLONG_MAX           +9223372036854775807
-           #define     LLONG_MIN           -9223372036854775807
-           #define     MB_LEN_MAX                             1
-           #define     SCHAR_MAX                           +127
-           #define     SCHAR_MIN                           -127
-           #define     SHRT_MAX                          +32767
-           #define     SHRT_MIN                          -32767
-           #define     UCHAR_MAX                            255
-           #define     USHRT_MAX                          65535
-           #define     UINT_MAX                           65535
-           #define     ULONG_MAX                     4294967295
-           #define     ULLONG_MAX          18446744073709551615
-2   The contents of the header <a href="#7.7">&lt;float.h&gt;</a> are given below. All integer values, except
-    FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
-    directives; all floating values shall be constant expressions. The components are
-    described further in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
-3   The values given in the following list shall be replaced by implementation-defined
-    expressions:
-           #define FLT_EVAL_METHOD
-           #define FLT_ROUNDS
-4   The values given in the following list shall be replaced by implementation-defined
-    constant expressions that are greater or equal in magnitude (absolute value) to those
-    shown, with the same sign:
-
-[<a name="p442" href="#p442">page 442</a>] (<a href="#Contents">Contents</a>)
-
-           #define    DBL_DIG                                        10
-           #define    DBL_MANT_DIG
-           #define    DBL_MAX_10_EXP                               +37
-           #define    DBL_MAX_EXP
-           #define    DBL_MIN_10_EXP                               -37
-           #define    DBL_MIN_EXP
-           #define    DECIMAL_DIG                                    10
-           #define    FLT_DIG                                         6
-           #define    FLT_MANT_DIG
-           #define    FLT_MAX_10_EXP                               +37
-           #define    FLT_MAX_EXP
-           #define    FLT_MIN_10_EXP                               -37
-           #define    FLT_MIN_EXP
-           #define    FLT_RADIX                                       2
-           #define    LDBL_DIG                                       10
-           #define    LDBL_MANT_DIG
-           #define    LDBL_MAX_10_EXP                              +37
-           #define    LDBL_MAX_EXP
-           #define    LDBL_MIN_10_EXP                              -37
-           #define    LDBL_MIN_EXP
-5   The values given in the following list shall be replaced by implementation-defined
-    constant expressions with values that are greater than or equal to those shown:
-           #define DBL_MAX                                      1E+37
-           #define FLT_MAX                                      1E+37
-           #define LDBL_MAX                                     1E+37
-6   The values given in the following list shall be replaced by implementation-defined
-    constant expressions with (positive) values that are less than or equal to those shown:
-           #define    DBL_EPSILON                                1E-9
-           #define    DBL_MIN                                   1E-37
-           #define    FLT_EPSILON                                1E-5
-           #define    FLT_MIN                                   1E-37
-           #define    LDBL_EPSILON                               1E-9
-           #define    LDBL_MIN                                  1E-37
-
-[<a name="p443" href="#p443">page 443</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F" href="#F"><b>                                               Annex F</b></a>
-                                              (normative)
-                          IEC 60559 floating-point arithmetic
-<a name="F.1" href="#F.1"><b>    F.1 Introduction</b></a>
-1   This annex specifies C language support for the IEC 60559 floating-point standard. The
-    IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for
-    microprocessor systems, second edition (IEC 60559:1989), previously designated
-    IEC 559:1989 and as IEEE Standard for Binary Floating-Point Arithmetic
-    (ANSI/IEEE 754-1985). IEEE Standard for Radix-Independent Floating-Point
-    Arithmetic (ANSI/IEEE 854-1987) generalizes the binary standard to remove
-    dependencies on radix and word length. IEC 60559 generally refers to the floating-point
-    standard, as in IEC 60559 operation, IEC 60559 format, etc. An implementation that
-    defines __STDC_IEC_559__ shall conform to the specifications in this annex. Where
-    a binding between the C language and IEC 60559 is indicated, the IEC 60559-specified
-    behavior is adopted by reference, unless stated otherwise.
-<a name="F.2" href="#F.2"><b>    F.2 Types</b></a>
-1   The C floating types match the IEC 60559 formats as follows:
-    -- The float type matches the IEC 60559 single format.
-    -- The double type matches the IEC 60559 double format.
-    -- The long double type matches an IEC 60559 extended format,<sup><a href="#note307"><b>307)</b></a></sup> else a
-      non-IEC 60559 extended format, else the IEC 60559 double format.
-    Any non-IEC 60559 extended format used for the long double type shall have more
-    precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note308"><b>308)</b></a></sup>
-    Recommended practice
-2   The long double type should match an IEC 60559 extended format.
-
-
-
-
-    <sup><a name="note307" href="#note307"><b>307)</b></a></sup> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
-         and quadruple 128-bit IEC 60559 formats.
-    <sup><a name="note308" href="#note308"><b>308)</b></a></sup> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
-         all double values.
-
-[<a name="p444" href="#p444">page 444</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.2.1" href="#F.2.1"><b>    F.2.1 Infinities, signed zeros, and NaNs</b></a>
-1   This specification does not define the behavior of signaling NaNs.<sup><a href="#note309"><b>309)</b></a></sup> It generally uses
-    the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
-    functions in <a href="#7.12">&lt;math.h&gt;</a> provide designations for IEC 60559 NaNs and infinities.
-<a name="F.3" href="#F.3"><b>    F.3 Operators and functions</b></a>
-1   C operators and functions provide IEC 60559 required and recommended facilities as
-    listed below.
-    -- The +, -, *, and / operators provide the IEC 60559 add, subtract, multiply, and
-      divide operations.
-    -- The sqrt functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 square root operation.
-    -- The remainder functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 remainder
-      operation. The remquo functions in <a href="#7.12">&lt;math.h&gt;</a> provide the same operation but
-      with additional information.
-    -- The rint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 operation that rounds a
-      floating-point number to an integer value (in the same precision). The nearbyint
-      functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nearbyinteger function recommended in the
-      Appendix to ANSI/IEEE 854.
-    -- The conversions for floating types provide the IEC 60559 conversions between
-      floating-point precisions.
-    -- The conversions from integer to floating types provide the IEC 60559 conversions
-      from integer to floating point.
-    -- The conversions from floating to integer types provide IEC 60559-like conversions
-      but always round toward zero.
-    -- The lrint and llrint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559
-      conversions, which honor the directed rounding mode, from floating point to the
-      long int and long long int integer formats. The lrint and llrint
-      functions can be used to implement IEC 60559 conversions from floating to other
-      integer formats.
-    -- The translation time conversion of floating constants and the strtod, strtof,
-      strtold, fprintf, fscanf, and related library functions in <a href="#7.20">&lt;stdlib.h&gt;</a>,
-      <a href="#7.19">&lt;stdio.h&gt;</a>, and <a href="#7.24">&lt;wchar.h&gt;</a> provide IEC 60559 binary-decimal conversions. The
-      strtold function in <a href="#7.20">&lt;stdlib.h&gt;</a> provides the conv function recommended in the
-      Appendix to ANSI/IEEE 854.
-
-    <sup><a name="note309" href="#note309"><b>309)</b></a></sup> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
-         sufficient for closure of the arithmetic.
-
-[<a name="p445" href="#p445">page 445</a>] (<a href="#Contents">Contents</a>)
-
--- The relational and equality operators provide IEC 60559 comparisons. IEC 60559
-  identifies a need for additional comparison predicates to facilitate writing code that
-  accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
-  isless, islessequal, islessgreater, and isunordered) in <a href="#7.12">&lt;math.h&gt;</a>
-  supplement the language operators to address this need. The islessgreater and
-  isunordered macros provide respectively a quiet version of the &lt;&gt; predicate and
-  the unordered predicate recommended in the Appendix to IEC 60559.
--- The feclearexcept, feraiseexcept, and fetestexcept functions in
-  <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to test and alter the IEC 60559 floating-point
-  exception status flags. The fegetexceptflag and fesetexceptflag
-  functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to save and restore all five status flags at
-  one time. These functions are used in conjunction with the type fexcept_t and the
-  floating-point     exception      macros      (FE_INEXACT,         FE_DIVBYZERO,
-  FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in <a href="#7.6">&lt;fenv.h&gt;</a>.
--- The fegetround and fesetround functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility
-  to select among the IEC 60559 directed rounding modes represented by the rounding
-  direction macros in <a href="#7.6">&lt;fenv.h&gt;</a> (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
-  FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the
-  IEC 60559 directed rounding modes.
--- The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
-  <a href="#7.6">&lt;fenv.h&gt;</a> provide a facility to manage the floating-point environment, comprising
-  the IEC 60559 status flags and control modes.
--- The copysign functions in <a href="#7.12">&lt;math.h&gt;</a> provide the copysign function
-  recommended in the Appendix to IEC 60559.
--- The unary minus (-) operator provides the minus (-) operation recommended in the
-  Appendix to IEC 60559.
--- The scalbn and scalbln functions in <a href="#7.12">&lt;math.h&gt;</a> provide the scalb function
-  recommended in the Appendix to IEC 60559.
--- The logb functions in <a href="#7.12">&lt;math.h&gt;</a> provide the logb function recommended in the
-  Appendix to IEC 60559, but following the newer specifications in ANSI/IEEE 854.
--- The nextafter and nexttoward functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nextafter
-  function recommended in the Appendix to IEC 60559 (but with a minor change to
-  better handle signed zeros).
--- The isfinite macro in <a href="#7.12">&lt;math.h&gt;</a> provides the finite function recommended in
-  the Appendix to IEC 60559.
--- The isnan macro in <a href="#7.12">&lt;math.h&gt;</a> provides the isnan function recommended in the
-  Appendix to IEC 60559.
-
-[<a name="p446" href="#p446">page 446</a>] (<a href="#Contents">Contents</a>)
-
-    -- The signbit macro and the fpclassify macro in <a href="#7.12">&lt;math.h&gt;</a>, used in
-      conjunction with the number classification macros (FP_NAN, FP_INFINITE,
-      FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
-      function recommended in the Appendix to IEC 60559 (except that the classification
-      macros defined in <a href="#7.12.3">7.12.3</a> do not distinguish signaling from quiet NaNs).
-<a name="F.4" href="#F.4"><b>    F.4 Floating to integer conversion</b></a>
-1   If the floating value is infinite or NaN or if the integral part of the floating value exceeds
-    the range of the integer type, then the ''invalid'' floating-point exception is raised and the
-    resulting value is unspecified. Whether conversion of non-integer floating values whose
-    integral part is within the range of the integer type raises the ''inexact'' floating-point
-    exception is unspecified.<sup><a href="#note310"><b>310)</b></a></sup>
-<a name="F.5" href="#F.5"><b>    F.5 Binary-decimal conversion</b></a>
-1   Conversion from the widest supported IEC 60559 format to decimal with
-    DECIMAL_DIG digits and back is the identity function.<sup><a href="#note311"><b>311)</b></a></sup>
-2   Conversions involving IEC 60559 formats follow all pertinent recommended practice. In
-    particular, conversion between any supported IEC 60559 format and decimal with
-    DECIMAL_DIG or fewer significant digits is correctly rounded (honoring the current
-    rounding mode), which assures that conversion from the widest supported IEC 60559
-    format to decimal with DECIMAL_DIG digits and back is the identity function.
-3   Functions such as strtod that convert character sequences to floating types honor the
-    rounding direction. Hence, if the rounding direction might be upward or downward, the
-    implementation cannot convert a minus-signed sequence by negating the converted
-    unsigned sequence.
-
-
-
-
-    <sup><a name="note310" href="#note310"><b>310)</b></a></sup> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
-         conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
-         cases where it matters, library functions can be used to effect such conversions with or without raising
-         the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
-         <a href="#7.12">&lt;math.h&gt;</a>.
-    <sup><a name="note311" href="#note311"><b>311)</b></a></sup> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
-         DECIMAL_DIG shall be at least 21. If IEC 60559 double (53 bits of precision) is the widest
-         IEC 60559 format supported, then DECIMAL_DIG shall be at least 17. (By contrast, LDBL_DIG and
-         DBL_DIG are 18 and 15, respectively, for these formats.)
-
-[<a name="p447" href="#p447">page 447</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.6" href="#F.6"><b>    F.6 Contracted expressions</b></a>
-1   A contracted expression treats infinities, NaNs, signed zeros, subnormals, and the
-    rounding directions in a manner consistent with the basic arithmetic operations covered
-    by IEC 60559.
-    Recommended practice
-2   A contracted expression should raise floating-point exceptions in a manner generally
-    consistent with the basic arithmetic operations. A contracted expression should deliver
-    the same value as its uncontracted counterpart, else should be correctly rounded (once).
-<a name="F.7" href="#F.7"><b>    F.7 Floating-point environment</b></a>
-1   The floating-point environment defined in <a href="#7.6">&lt;fenv.h&gt;</a> includes the IEC 60559 floating-
-    point exception status flags and directed-rounding control modes. It includes also
-    IEC 60559 dynamic rounding precision and trap enablement modes, if the
-    implementation supports them.<sup><a href="#note312"><b>312)</b></a></sup>
-<a name="F.7.1" href="#F.7.1"><b>    F.7.1 Environment management</b></a>
-1   IEC 60559 requires that floating-point operations implicitly raise floating-point exception
-    status flags, and that rounding control modes can be set explicitly to affect result values of
-    floating-point operations. When the state for the FENV_ACCESS pragma (defined in
-    <a href="#7.6">&lt;fenv.h&gt;</a>) is ''on'', these changes to the floating-point state are treated as side effects
-    which respect sequence points.<sup><a href="#note313"><b>313)</b></a></sup>
-<a name="F.7.2" href="#F.7.2"><b>    F.7.2 Translation</b></a>
-1   During translation the IEC 60559 default modes are in effect:
-    -- The rounding direction mode is rounding to nearest.
-    -- The rounding precision mode (if supported) is set so that results are not shortened.
-    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
-    Recommended practice
-2   The implementation should produce a diagnostic message for each translation-time
-
-
-
-
-    <sup><a name="note312" href="#note312"><b>312)</b></a></sup> This specification does not require dynamic rounding precision nor trap enablement modes.
-    <sup><a name="note313" href="#note313"><b>313)</b></a></sup> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
-         point control modes will be the default ones and the floating-point status flags will not be tested,
-         which allows certain optimizations (see <a href="#F.8">F.8</a>).
-
-[<a name="p448" href="#p448">page 448</a>] (<a href="#Contents">Contents</a>)
-
-    floating-point exception, other than ''inexact'';<sup><a href="#note314"><b>314)</b></a></sup> the implementation should then
-    proceed with the translation of the program.
-<a name="F.7.3" href="#F.7.3"><b>    F.7.3 Execution</b></a>
-1   At program startup the floating-point environment is initialized as prescribed by
-    IEC 60559:
-    -- All floating-point exception status flags are cleared.
-    -- The rounding direction mode is rounding to nearest.
-    -- The dynamic rounding precision mode (if supported) is set so that results are not
-      shortened.
-    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
-<a name="F.7.4" href="#F.7.4"><b>    F.7.4 Constant expressions</b></a>
-1   An arithmetic constant expression of floating type, other than one in an initializer for an
-    object that has static storage duration, is evaluated (as if) during execution; thus, it is
-    affected by any operative floating-point control modes and raises floating-point
-    exceptions as required by IEC 60559 (provided the state for the FENV_ACCESS pragma
-    is ''on'').<sup><a href="#note315"><b>315)</b></a></sup>
-2   EXAMPLE
-             #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             #pragma STDC FENV_ACCESS ON
-             void f(void)
-             {
-                   float w[] = { 0.0/0.0 };                  //   raises an exception
-                   static float x = 0.0/0.0;                 //   does not raise an exception
-                   float y = 0.0/0.0;                        //   raises an exception
-                   double z = 0.0/0.0;                       //   raises an exception
-                   /* ... */
-             }
-3   For the static initialization, the division is done at translation time, raising no (execution-time) floating-
-    point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
-
-
-    <sup><a name="note314" href="#note314"><b>314)</b></a></sup> As floating constants are converted to appropriate internal representations at translation time, their
-         conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
-         (even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
-         strtod, provide execution-time conversion of numeric strings.
-    <sup><a name="note315" href="#note315"><b>315)</b></a></sup> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
-         are affected by rounding modes set at execution time, and expressions such as 0.0/0.0 and
-         1.0/0.0 generate execution-time floating-point exceptions. The programmer can achieve the
-         efficiency of translation-time evaluation through static initialization, such as
-                  const static double one_third = 1.0/3.0;
-
-[<a name="p449" href="#p449">page 449</a>] (<a href="#Contents">Contents</a>)
-
-    execution time.
-
-<a name="F.7.5" href="#F.7.5"><b>    F.7.5 Initialization</b></a>
-1   All computation for automatic initialization is done (as if) at execution time; thus, it is
-    affected by any operative modes and raises floating-point exceptions as required by
-    IEC 60559 (provided the state for the FENV_ACCESS pragma is ''on''). All computation
-    for initialization of objects that have static storage duration is done (as if) at translation
-    time.
-2   EXAMPLE
-             #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             #pragma STDC FENV_ACCESS ON
-             void f(void)
-             {
-                   float u[] = { 1.1e75 };                  //   raises exceptions
-                   static float v = 1.1e75;                 //   does not raise exceptions
-                   float w = 1.1e75;                        //   raises exceptions
-                   double x = 1.1e75;                       //   may raise exceptions
-                   float y = 1.1e75f;                       //   may raise exceptions
-                   long double z = 1.1e75;                  //   does not raise exceptions
-                   /* ... */
-             }
-3   The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
-    done at translation time. The automatic initialization of u and w require an execution-time conversion to
-    float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
-    of x and y entail execution-time conversion; however, in some expression evaluation methods, the
-    conversions is not to a narrower format, in which case no floating-point exception is raised.<sup><a href="#note316"><b>316)</b></a></sup> The
-    automatic initialization of z entails execution-time conversion, but not to a narrower format, so no floating-
-    point exception is raised. Note that the conversions of the floating constants 1.1e75 and 1.1e75f to
-    their internal representations occur at translation time in all cases.
-
-
-
-
-    <sup><a name="note316" href="#note316"><b>316)</b></a></sup> Use of float_t and double_t variables increases the likelihood of translation-time computation.
-         For example, the automatic initialization
-                   double_t x = 1.1e75;
-          could be done at translation time, regardless of the expression evaluation method.
-
-[<a name="p450" href="#p450">page 450</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.7.6" href="#F.7.6"><b>    F.7.6 Changing the environment</b></a>
-1   Operations defined in <a href="#6.5">6.5</a> and functions and macros defined for the standard libraries
-    change floating-point status flags and control modes just as indicated by their
-    specifications (including conformance to IEC 60559). They do not change flags or modes
-    (so as to be detectable by the user) in any other cases.
-2   If the argument to the feraiseexcept function in <a href="#7.6">&lt;fenv.h&gt;</a> represents IEC 60559
-    valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
-    ''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
-    before ''inexact''.
-<a name="F.8" href="#F.8"><b>    F.8 Optimization</b></a>
-1   This section identifies code transformations that might subvert IEC 60559-specified
-    behavior, and others that do not.
-<a name="F.8.1" href="#F.8.1"><b>    F.8.1 Global transformations</b></a>
-1   Floating-point arithmetic operations and external function calls may entail side effects
-    which optimization shall honor, at least where the state of the FENV_ACCESS pragma is
-    ''on''. The flags and modes in the floating-point environment may be regarded as global
-    variables; floating-point operations (+, *, etc.) implicitly read the modes and write the
-    flags.
-2   Concern about side effects may inhibit code motion and removal of seemingly useless
-    code. For example, in
-             #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             #pragma STDC FENV_ACCESS ON
-             void f(double x)
-             {
-                  /* ... */
-                  for (i = 0; i &lt; n; i++) x + 1;
-                  /* ... */
-             }
-    x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
-    body might not execute (maybe 0 &gt;= n), x + 1 cannot be moved out of the loop. (Of
-    course these optimizations are valid if the implementation can rule out the nettlesome
-    cases.)
-3   This specification does not require support for trap handlers that maintain information
-    about the order or count of floating-point exceptions. Therefore, between function calls,
-    floating-point exceptions need not be precise: the actual order and number of occurrences
-    of floating-point exceptions (&gt; 1) may vary from what the source code expresses. Thus,
-    the preceding loop could be treated as
-
-[<a name="p451" href="#p451">page 451</a>] (<a href="#Contents">Contents</a>)
-
-            if (0 &lt; n) x + 1;
-<a name="F.8.2" href="#F.8.2"><b>    F.8.2 Expression transformations</b></a>
-1   x / 2 &lt;-&gt; x * 0.5                         Although similar transformations involving inexact
-                                            constants generally do not yield numerically equivalent
-                                            expressions, if the constants are exact then such
-                                            transformations can be made on IEC 60559 machines
-                                            and others that round perfectly.
-    1 * x and x / 1 -&gt; x                     The expressions 1 * x, x / 1, and x are equivalent
-                                            (on IEC 60559 machines, among others).<sup><a href="#note317"><b>317)</b></a></sup>
-    x / x -&gt; 1.0                             The expressions x / x and 1.0 are not equivalent if x
-                                            can be zero, infinite, or NaN.
-    x - y &lt;-&gt; x + (-y)                        The expressions x - y, x + (-y), and (-y) + x
-                                            are equivalent (on IEC 60559 machines, among others).
-    x - y &lt;-&gt; -(y - x)                        The expressions x - y and -(y - x) are not
-                                            equivalent because 1 - 1 is +0 but -(1 - 1) is -0 (in the
-                                            default rounding direction).<sup><a href="#note318"><b>318)</b></a></sup>
-    x - x -&gt; 0.0                             The expressions x - x and 0.0 are not equivalent if
-                                            x is a NaN or infinite.
-    0 * x -&gt; 0.0                             The expressions 0 * x and 0.0 are not equivalent if
-                                            x is a NaN, infinite, or -0.
-    x + 0-&gt;x                                 The expressions x + 0 and x are not equivalent if x is
-                                            -0, because (-0) + (+0) yields +0 (in the default
-                                            rounding direction), not -0.
-    x - 0-&gt;x                                 (+0) - (+0) yields -0 when rounding is downward
-                                            (toward -(inf)), but +0 otherwise, and (-0) - (+0) always
-                                            yields -0; so, if the state of the FENV_ACCESS pragma
-                                            is ''off'', promising default rounding, then the
-                                            implementation can replace x - 0 by x, even if x
-
-
-    <sup><a name="note317" href="#note317"><b>317)</b></a></sup> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
-         other transformations that remove arithmetic operators.
-    <sup><a name="note318" href="#note318"><b>318)</b></a></sup> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
-         Examples include:
-            1/(1/ (+-) (inf)) is (+-) (inf)
-         and
-            conj(csqrt(z)) is csqrt(conj(z)),
-         for complex z.
-
-[<a name="p452" href="#p452">page 452</a>] (<a href="#Contents">Contents</a>)
-
-                                             might be zero.
-    -x &lt;-&gt; 0 - x                               The expressions -x and 0 - x are not equivalent if x
-                                             is +0, because -(+0) yields -0, but 0 - (+0) yields +0
-                                             (unless rounding is downward).
-<a name="F.8.3" href="#F.8.3"><b>    F.8.3 Relational operators</b></a>
-1   x != x -&gt; false                           The statement x != x is true if x is a NaN.
-    x == x -&gt; true                            The statement x == x is false if x is a NaN.
-    x &lt; y -&gt; isless(x,y)                      (and similarly for &lt;=, &gt;, &gt;=) Though numerically
-                                             equal, these expressions are not equivalent because of
-                                             side effects when x or y is a NaN and the state of the
-                                             FENV_ACCESS pragma is ''on''. This transformation,
-                                             which would be desirable if extra code were required to
-                                             cause the ''invalid'' floating-point exception for
-                                             unordered cases, could be performed provided the state
-                                             of the FENV_ACCESS pragma is ''off''.
-    The sense of relational operators shall be maintained. This includes handling unordered
-    cases as expressed by the source code.
-2   EXAMPLE
-             // calls g and raises ''invalid'' if a and b are unordered
-             if (a &lt; b)
-                     f();
-             else
-                     g();
-    is not equivalent to
-             // calls f and raises ''invalid'' if a and b are unordered
-             if (a &gt;= b)
-                     g();
-             else
-                     f();
-    nor to
-             // calls f without raising ''invalid'' if a and b are unordered
-             if (isgreaterequal(a,b))
-                     g();
-             else
-                     f();
-    nor, unless the state of the FENV_ACCESS pragma is ''off'', to
-
-[<a name="p453" href="#p453">page 453</a>] (<a href="#Contents">Contents</a>)
-
-             // calls g without raising ''invalid'' if a and b are unordered
-             if (isless(a,b))
-                     f();
-             else
-                     g();
-    but is equivalent to
-             if (!(a &lt; b))
-                   g();
-             else
-                   f();
-
-<a name="F.8.4" href="#F.8.4"><b>    F.8.4 Constant arithmetic</b></a>
-1   The implementation shall honor floating-point exceptions raised by execution-time
-    constant arithmetic wherever the state of the FENV_ACCESS pragma is ''on''. (See <a href="#F.7.4">F.7.4</a>
-    and <a href="#F.7.5">F.7.5</a>.) An operation on constants that raises no floating-point exception can be
-    folded during translation, except, if the state of the FENV_ACCESS pragma is ''on'', a
-    further check is required to assure that changing the rounding direction to downward does
-    not alter the sign of the result,<sup><a href="#note319"><b>319)</b></a></sup> and implementations that support dynamic rounding
-    precision modes shall assure further that the result of the operation raises no floating-
-    point exception when converted to the semantic type of the operation.
-<a name="F.9" href="#F.9"><b>    F.9 Mathematics &lt;math.h&gt;</b></a>
-1   This subclause contains specifications of <a href="#7.12">&lt;math.h&gt;</a> facilities that are particularly suited
-    for IEC 60559 implementations.
-2   The Standard C macro HUGE_VAL and its float and long double analogs,
-    HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
-    infinities.
-3   Special cases for functions in <a href="#7.12">&lt;math.h&gt;</a> are covered directly or indirectly by
-    IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
-    other functions in <a href="#7.12">&lt;math.h&gt;</a> treat infinities, NaNs, signed zeros, subnormals, and
-    (provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
-    in a manner consistent with the basic arithmetic operations covered by IEC 60559.
-4   The expression math_errhandling &amp; MATH_ERREXCEPT shall evaluate to a
-    nonzero value.
-5   The ''invalid'' and ''divide-by-zero'' floating-point exceptions are raised as specified in
-    subsequent subclauses of this annex.
-6   The ''overflow'' floating-point exception is raised whenever an infinity -- or, because of
-    rounding direction, a maximal-magnitude finite number -- is returned in lieu of a value
-
-
-    <sup><a name="note319" href="#note319"><b>319)</b></a></sup> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
-
-[<a name="p454" href="#p454">page 454</a>] (<a href="#Contents">Contents</a>)
-
-     whose magnitude is too large.
-7    The ''underflow'' floating-point exception is raised whenever a result is tiny (essentially
-     subnormal or zero) and suffers loss of accuracy.<sup><a href="#note320"><b>320)</b></a></sup>
-8    Whether or when library functions raise the ''inexact'' floating-point exception is
-     unspecified, unless explicitly specified otherwise.
-9    Whether or when library functions raise an undeserved ''underflow'' floating-point
-     exception is unspecified.<sup><a href="#note321"><b>321)</b></a></sup> Otherwise, as implied by <a href="#F.7.6">F.7.6</a>, the <a href="#7.12">&lt;math.h&gt;</a> functions do
-     not raise spurious floating-point exceptions (detectable by the user), other than the
-     ''inexact'' floating-point exception.
-10   Whether the functions honor the rounding direction mode is implementation-defined,
-     unless explicitly specified otherwise.
-11   Functions with a NaN argument return a NaN result and raise no floating-point exception,
-     except where stated otherwise.
-12   The specifications in the following subclauses append to the definitions in <a href="#7.12">&lt;math.h&gt;</a>.
-     For families of functions, the specifications apply to all of the functions even though only
-     the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
-     occurs in both an argument and the result, the result has the same sign as the argument.
-     Recommended practice
-13   If a function with one or more NaN arguments returns a NaN result, the result should be
-     the same as one of the NaN arguments (after possible type conversion), except perhaps
-     for the sign.
-<a name="F.9.1" href="#F.9.1"><b>     F.9.1 Trigonometric functions</b></a>
-<a name="F.9.1.1" href="#F.9.1.1"><b>     F.9.1.1 The acos functions</b></a>
-1    -- acos(1) returns +0.
-     -- acos(x) returns a NaN and raises the ''invalid'' floating-point exception for
-       | x | &gt; 1.
-
-
-
-
-     <sup><a name="note320" href="#note320"><b>320)</b></a></sup> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
-          when the floating-point exception is raised.
-     <sup><a name="note321" href="#note321"><b>321)</b></a></sup> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
-          avoiding them would be too costly.
-
-[<a name="p455" href="#p455">page 455</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.1.2" href="#F.9.1.2"><b>    F.9.1.2 The asin functions</b></a>
-1   -- asin((+-)0) returns (+-)0.
-    -- asin(x) returns a NaN and raises the ''invalid'' floating-point exception for
-      | x | &gt; 1.
-<a name="F.9.1.3" href="#F.9.1.3"><b>    F.9.1.3 The atan functions</b></a>
-1   -- atan((+-)0) returns (+-)0.
-    -- atan((+-)(inf)) returns (+-)pi /2.
-<a name="F.9.1.4" href="#F.9.1.4"><b>    F.9.1.4 The atan2 functions</b></a>
-1   -- atan2((+-)0, -0) returns (+-)pi .<sup><a href="#note322"><b>322)</b></a></sup>
-    -- atan2((+-)0, +0) returns (+-)0.
-    -- atan2((+-)0, x) returns (+-)pi for x &lt; 0.
-    -- atan2((+-)0, x) returns (+-)0 for x &gt; 0.
-    -- atan2(y, (+-)0) returns -pi /2 for y &lt; 0.
-    -- atan2(y, (+-)0) returns pi /2 for y &gt; 0.
-    -- atan2((+-)y, -(inf)) returns (+-)pi for finite y &gt; 0.
-    -- atan2((+-)y, +(inf)) returns (+-)0 for finite y &gt; 0.
-    -- atan2((+-)(inf), x) returns (+-)pi /2 for finite x.
-    -- atan2((+-)(inf), -(inf)) returns (+-)3pi /4.
-    -- atan2((+-)(inf), +(inf)) returns (+-)pi /4.
-<a name="F.9.1.5" href="#F.9.1.5"><b>    F.9.1.5 The cos functions</b></a>
-1   -- cos((+-)0) returns 1.
-    -- cos((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-<a name="F.9.1.6" href="#F.9.1.6"><b>    F.9.1.6 The sin functions</b></a>
-1   -- sin((+-)0) returns (+-)0.
-    -- sin((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-
-
-
-
-    <sup><a name="note322" href="#note322"><b>322)</b></a></sup> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y ,    0) raise
-         the ''divide-by-zero'' floating-point exception.
-
-[<a name="p456" href="#p456">page 456</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.1.7" href="#F.9.1.7"><b>    F.9.1.7 The tan functions</b></a>
-1   -- tan((+-)0) returns (+-)0.
-    -- tan((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-<a name="F.9.2" href="#F.9.2"><b>    F.9.2 Hyperbolic functions</b></a>
-<a name="F.9.2.1" href="#F.9.2.1"><b>    F.9.2.1 The acosh functions</b></a>
-1   -- acosh(1) returns +0.
-    -- acosh(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 1.
-    -- acosh(+(inf)) returns +(inf).
-<a name="F.9.2.2" href="#F.9.2.2"><b>    F.9.2.2 The asinh functions</b></a>
-1   -- asinh((+-)0) returns (+-)0.
-    -- asinh((+-)(inf)) returns (+-)(inf).
-<a name="F.9.2.3" href="#F.9.2.3"><b>    F.9.2.3 The atanh functions</b></a>
-1   -- atanh((+-)0) returns (+-)0.
-    -- atanh((+-)1) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- atanh(x) returns a NaN and raises the ''invalid'' floating-point exception for
-      | x | &gt; 1.
-<a name="F.9.2.4" href="#F.9.2.4"><b>    F.9.2.4 The cosh functions</b></a>
-1   -- cosh((+-)0) returns 1.
-    -- cosh((+-)(inf)) returns +(inf).
-<a name="F.9.2.5" href="#F.9.2.5"><b>    F.9.2.5 The sinh functions</b></a>
-1   -- sinh((+-)0) returns (+-)0.
-    -- sinh((+-)(inf)) returns (+-)(inf).
-<a name="F.9.2.6" href="#F.9.2.6"><b>    F.9.2.6 The tanh functions</b></a>
-1   -- tanh((+-)0) returns (+-)0.
-    -- tanh((+-)(inf)) returns (+-)1.
-
-[<a name="p457" href="#p457">page 457</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.3" href="#F.9.3"><b>    F.9.3 Exponential and logarithmic functions</b></a>
-<a name="F.9.3.1" href="#F.9.3.1"><b>    F.9.3.1 The exp functions</b></a>
-1   -- exp((+-)0) returns 1.
-    -- exp(-(inf)) returns +0.
-    -- exp(+(inf)) returns +(inf).
-<a name="F.9.3.2" href="#F.9.3.2"><b>    F.9.3.2 The exp2 functions</b></a>
-1   -- exp2((+-)0) returns 1.
-    -- exp2(-(inf)) returns +0.
-    -- exp2(+(inf)) returns +(inf).
-<a name="F.9.3.3" href="#F.9.3.3"><b>    F.9.3.3 The expm1 functions</b></a>
-1   -- expm1((+-)0) returns (+-)0.
-    -- expm1(-(inf)) returns -1.
-    -- expm1(+(inf)) returns +(inf).
-<a name="F.9.3.4" href="#F.9.3.4"><b>    F.9.3.4 The frexp functions</b></a>
-1   -- frexp((+-)0, exp) returns (+-)0, and stores 0 in the object pointed to by exp.
-    -- frexp((+-)(inf), exp) returns (+-)(inf), and stores an unspecified value in the object
-      pointed to by exp.
-    -- frexp(NaN, exp) stores an unspecified value in the object pointed to by exp
-      (and returns a NaN).
-2   frexp raises no floating-point exceptions.
-3   On a binary system, the body of the frexp function might be
-           {
-                  *exp = (value == 0) ? 0 : (int)(1 + logb(value));
-                  return scalbn(value, -(*exp));
-           }
-<a name="F.9.3.5" href="#F.9.3.5"><b>    F.9.3.5 The ilogb functions</b></a>
-1   If the correct result is outside the range of the return type, the numeric result is
-    unspecified and the ''invalid'' floating-point exception is raised.
-
-[<a name="p458" href="#p458">page 458</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.3.6" href="#F.9.3.6"><b>    F.9.3.6 The ldexp functions</b></a>
-1   On a binary system, ldexp(x, exp) is equivalent to scalbn(x, exp).
-<a name="F.9.3.7" href="#F.9.3.7"><b>    F.9.3.7 The log functions</b></a>
-1   -- log((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log(1) returns +0.
-    -- log(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
-    -- log(+(inf)) returns +(inf).
-<a name="F.9.3.8" href="#F.9.3.8"><b>    F.9.3.8 The log10 functions</b></a>
-1   -- log10((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log10(1) returns +0.
-    -- log10(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
-    -- log10(+(inf)) returns +(inf).
-<a name="F.9.3.9" href="#F.9.3.9"><b>    F.9.3.9 The log1p functions</b></a>
-1   -- log1p((+-)0) returns (+-)0.
-    -- log1p(-1) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log1p(x) returns a NaN and raises the ''invalid'' floating-point exception for
-      x &lt; -1.
-    -- log1p(+(inf)) returns +(inf).
-<a name="F.9.3.10" href="#F.9.3.10"><b>    F.9.3.10 The log2 functions</b></a>
-1   -- log2((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log2(1) returns +0.
-    -- log2(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
-    -- log2(+(inf)) returns +(inf).
-<a name="F.9.3.11" href="#F.9.3.11"><b>    F.9.3.11 The logb functions</b></a>
-1   -- logb((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- logb((+-)(inf)) returns +(inf).
-
-[<a name="p459" href="#p459">page 459</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.3.12" href="#F.9.3.12"><b>    F.9.3.12 The modf functions</b></a>
-1   -- modf((+-)x, iptr) returns a result with the same sign as x.
-    -- modf((+-)(inf), iptr) returns (+-)0 and stores (+-)(inf) in the object pointed to by iptr.
-    -- modf(NaN, iptr) stores a NaN in the object pointed to by iptr (and returns a
-      NaN).
-2   modf behaves as though implemented by
-          #include <a href="#7.12">&lt;math.h&gt;</a>
-          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             const struct tm * restrict timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsftime function is equivalent to the strftime function, except that:
+<ul>
+<li>  The argument s points to the initial element of an array of wide characters into which
+ the generated output is to be placed.
+<!--page 398 indent 4-->
+<li>  The argument maxsize indicates the limiting number of wide characters.
+<li>  The argument format is a wide string and the conversion specifiers are replaced by
+ corresponding sequences of wide characters.
+<li>  The return value indicates the number of wide characters.
+</ul>
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the total number of resulting wide characters including the terminating null wide
+ character is not more than maxsize, the wcsftime function returns the number of
+ wide characters placed into the array pointed to by s not including the terminating null
+ wide character. Otherwise, zero is returned and the contents of the array are
+ indeterminate.
+
+<a name="7.24.6" href="#7.24.6"><h4>7.24.6 Extended multibyte/wide character conversion utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wchar.h&gt; declares an extended set of functions useful for conversion
+ between multibyte characters and wide characters.
+<p><!--para 2-->
+ Most of the following functions -- those that are listed as ''restartable'', <a href="#7.24.6.3">7.24.6.3</a> and
+ <a href="#7.24.6.4">7.24.6.4</a> -- take as a last argument a pointer to an object of type mbstate_t that is used
+ to describe the current conversion state from a particular multibyte character sequence to
+ a wide character sequence (or the reverse) under the rules of a particular setting for the
+ LC_CTYPE category of the current locale.
+<p><!--para 3-->
+ The initial conversion state corresponds, for a conversion in either direction, to the
+ beginning of a new multibyte character in the initial shift state. A zero-valued
+ mbstate_t object is (at least) one way to describe an initial conversion state. A zero-
+ valued mbstate_t object can be used to initiate conversion involving any multibyte
+ character sequence, in any LC_CTYPE category setting. If an mbstate_t object has
+ been altered by any of the functions described in this subclause, and is then used with a
+ different multibyte character sequence, or in the other conversion direction, or with a
+ different LC_CTYPE category setting than on earlier function calls, the behavior is
+ undefined.<sup><a href="#note299"><b>299)</b></a></sup>
+<p><!--para 4-->
+ On entry, each function takes the described conversion state (either internal or pointed to
+ by an argument) as current. The conversion state described by the pointed-to object is
+ altered as needed to track the shift state, and the position within a multibyte character, for
+ the associated multibyte character sequence.
+ 
+ 
+ 
+ 
+<!--page 399 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note299">299)</a> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
+ mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
+ character string.
+
+
+<a name="7.24.6.1" href="#7.24.6.1"><h5>7.24.6.1 Single-byte/wide character conversion functions</h5></a>
+
+<a name="7.24.6.1.1" href="#7.24.6.1.1"><h5>7.24.6.1.1 The btowc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        wint_t btowc(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The btowc function determines whether c constitutes a valid single-byte character in the
+ initial shift state.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The btowc function returns WEOF if c has the value EOF or if (unsigned char)c
+ does not constitute a valid single-byte character in the initial shift state. Otherwise, it
+ returns the wide character representation of that character.
+
+<a name="7.24.6.1.2" href="#7.24.6.1.2"><h5>7.24.6.1.2 The wctob function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        int wctob(wint_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctob function determines whether c corresponds to a member of the extended
+ character set whose multibyte character representation is a single byte when in the initial
+ shift state.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wctob function returns EOF if c does not correspond to a multibyte character with
+ length one in the initial shift state. Otherwise, it returns the single-byte representation of
+ that character as an unsigned char converted to an int.
+
+<a name="7.24.6.2" href="#7.24.6.2"><h5>7.24.6.2 Conversion state functions</h5></a>
+
+<a name="7.24.6.2.1" href="#7.24.6.2.1"><h5>7.24.6.2.1 The mbsinit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        int mbsinit(const mbstate_t *ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If ps is not a null pointer, the mbsinit function determines whether the pointed-to
+ mbstate_t object describes an initial conversion state.
+<!--page 400 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mbsinit function returns nonzero if ps is a null pointer or if the pointed-to object
+ describes an initial conversion state; otherwise, it returns zero.
+
+<a name="7.24.6.3" href="#7.24.6.3"><h5>7.24.6.3 Restartable multibyte/wide character conversion functions</h5></a>
+<p><!--para 1-->
+ These functions differ from the corresponding multibyte character functions of <a href="#7.20.7">7.20.7</a>
+ (mblen, mbtowc, and wctomb) in that they have an extra parameter, ps, of type
+ pointer to mbstate_t that points to an object that can completely describe the current
+ conversion state of the associated multibyte character sequence. If ps is a null pointer,
+ each function uses its own internal mbstate_t object instead, which is initialized at
+ program startup to the initial conversion state. The implementation behaves as if no
+ library function calls these functions with a null pointer for ps.
+<p><!--para 2-->
+ Also unlike their corresponding functions, the return value does not represent whether the
+ encoding is state-dependent.
+
+<a name="7.24.6.3.1" href="#7.24.6.3.1"><h5>7.24.6.3.1 The mbrlen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        size_t mbrlen(const char * restrict s,
+             size_t n,
+             mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mbrlen function is equivalent to the call:
+<pre>
+        mbrtowc(NULL, s, n, ps != NULL ? ps : &amp;internal)</pre>
+ where internal is the mbstate_t object for the mbrlen function, except that the
+ expression designated by ps is evaluated only once.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
+ or (size_t)(-1).
+ Forward references: the mbrtowc function (<a href="#7.24.6.3.2">7.24.6.3.2</a>).
+<!--page 401 indent 4-->
+
+<a name="7.24.6.3.2" href="#7.24.6.3.2"><h5>7.24.6.3.2 The mbrtowc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t mbrtowc(wchar_t * restrict pwc,
+              const char * restrict s,
+              size_t n,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the mbrtowc function is equivalent to the call:
+<pre>
+                 mbrtowc(NULL, "", 1, ps)</pre>
+ In this case, the values of the parameters pwc and n are ignored.
+<p><!--para 3-->
+ If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
+ the byte pointed to by s to determine the number of bytes needed to complete the next
+ multibyte character (including any shift sequences). If the function determines that the
+ next multibyte character is complete and valid, it determines the value of the
+ corresponding wide character and then, if pwc is not a null pointer, stores that value in
+ the object pointed to by pwc. If the corresponding wide character is the null wide
+ character, the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The mbrtowc function returns the first of the following that applies (given the current
+ conversion state):
+ 0                     if the next n or fewer bytes complete the multibyte character that
+<pre>
+                       corresponds to the null wide character (which is the value stored).</pre>
+ between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+<pre>
+                    character (which is the value stored); the value returned is the number
+                    of bytes that complete the multibyte character.</pre>
+ (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+<pre>
+              multibyte character, and all n bytes have been processed (no value is
+              stored).<sup><a href="#note300"><b>300)</b></a></sup></pre>
+ (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+<pre>
+              do not contribute to a complete and valid multibyte character (no
+              value is stored); the value of the macro EILSEQ is stored in errno,
+              and the conversion state is unspecified.</pre>
+ 
+<!--page 402 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note300">300)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+ sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+
+<a name="7.24.6.3.3" href="#7.24.6.3.3"><h5>7.24.6.3.3 The wcrtomb function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t wcrtomb(char * restrict s,
+              wchar_t wc,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the wcrtomb function is equivalent to the call
+<pre>
+                 wcrtomb(buf, L'\0', ps)</pre>
+ where buf is an internal buffer.
+<p><!--para 3-->
+ If s is not a null pointer, the wcrtomb function determines the number of bytes needed
+ to represent the multibyte character that corresponds to the wide character given by wc
+ (including any shift sequences), and stores the multibyte character representation in the
+ array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+ wc is a null wide character, a null byte is stored, preceded by any shift sequence needed
+ to restore the initial shift state; the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The wcrtomb function returns the number of bytes stored in the array object (including
+ any shift sequences). When wc is not a valid wide character, an encoding error occurs:
+ the function stores the value of the macro EILSEQ in errno and returns
+ (size_t)(-1); the conversion state is unspecified.
+
+<a name="7.24.6.4" href="#7.24.6.4"><h5>7.24.6.4 Restartable multibyte/wide string conversion functions</h5></a>
+<p><!--para 1-->
+ These functions differ from the corresponding multibyte string functions of <a href="#7.20.8">7.20.8</a>
+ (mbstowcs and wcstombs) in that they have an extra parameter, ps, of type pointer to
+ mbstate_t that points to an object that can completely describe the current conversion
+ state of the associated multibyte character sequence. If ps is a null pointer, each function
+ uses its own internal mbstate_t object instead, which is initialized at program startup
+ to the initial conversion state. The implementation behaves as if no library function calls
+ these functions with a null pointer for ps.
+<p><!--para 2-->
+ Also unlike their corresponding functions, the conversion source parameter, src, has a
+ pointer-to-pointer type. When the function is storing the results of conversions (that is,
+ when dst is not a null pointer), the pointer object pointed to by this parameter is updated
+ to reflect the amount of the source processed by that invocation.
+<!--page 403 indent 4-->
+
+<a name="7.24.6.4.1" href="#7.24.6.4.1"><h5>7.24.6.4.1 The mbsrtowcs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;wchar.h&gt;
+          size_t mbsrtowcs(wchar_t * restrict dst,
+               const char ** restrict src,
+               size_t len,
+               mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mbsrtowcs function converts a sequence of multibyte characters that begins in the
+ conversion state described by the object pointed to by ps, from the array indirectly
+ pointed to by src into a sequence of corresponding wide characters. If dst is not a null
+ pointer, the converted characters are stored into the array pointed to by dst. Conversion
+ continues up to and including a terminating null character, which is also stored.
+ Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
+ not form a valid multibyte character, or (if dst is not a null pointer) when len wide
+ characters have been stored into the array pointed to by dst.<sup><a href="#note301"><b>301)</b></a></sup> Each conversion takes
+ place as if by a call to the mbrtowc function.
+<p><!--para 3-->
+ If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+ pointer (if conversion stopped due to reaching a terminating null character) or the address
+ just past the last multibyte character converted (if any). If conversion stopped due to
+ reaching a terminating null character and if dst is not a null pointer, the resulting state
+ described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If the input conversion encounters a sequence of bytes that do not form a valid multibyte
+ character, an encoding error occurs: the mbsrtowcs function stores the value of the
+ macro EILSEQ in errno and returns (size_t)(-1); the conversion state is
+ unspecified. Otherwise, it returns the number of multibyte characters successfully
+ converted, not including the terminating null character (if any).
+ 
+ 
+ 
+ 
+<!--page 404 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note301">301)</a> Thus, the value of len is ignored if dst is a null pointer.
+
+
+<a name="7.24.6.4.2" href="#7.24.6.4.2"><h5>7.24.6.4.2 The wcsrtombs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t wcsrtombs(char * restrict dst,
+              const wchar_t ** restrict src,
+              size_t len,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsrtombs function converts a sequence of wide characters from the array
+ indirectly pointed to by src into a sequence of corresponding multibyte characters that
+ begins in the conversion state described by the object pointed to by ps. If dst is not a
+ null pointer, the converted characters are then stored into the array pointed to by dst.
+ Conversion continues up to and including a terminating null wide character, which is also
+ stored. Conversion stops earlier in two cases: when a wide character is reached that does
+ not correspond to a valid multibyte character, or (if dst is not a null pointer) when the
+ next multibyte character would exceed the limit of len total bytes to be stored into the
+ array pointed to by dst. Each conversion takes place as if by a call to the wcrtomb
+ function.<sup><a href="#note302"><b>302)</b></a></sup>
+<p><!--para 3-->
+ If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+ pointer (if conversion stopped due to reaching a terminating null wide character) or the
+ address just past the last wide character converted (if any). If conversion stopped due to
+ reaching a terminating null wide character, the resulting state described is the initial
+ conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If conversion stops because a wide character is reached that does not correspond to a
+ valid multibyte character, an encoding error occurs: the wcsrtombs function stores the
+ value of the macro EILSEQ in errno and returns (size_t)(-1); the conversion
+ state is unspecified. Otherwise, it returns the number of bytes in the resulting multibyte
+ character sequence, not including the terminating null character (if any).
+ 
+ 
+ 
+ 
+<!--page 405 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note302">302)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
+ include those necessary to reach the initial shift state immediately before the null byte.
+
+
+<a name="7.25" href="#7.25"><h3>7.25 Wide character classification and mapping utilities <wctype.h></h3></a>
+
+<a name="7.25.1" href="#7.25.1"><h4>7.25.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;wctype.h&gt; declares three data types, one macro, and many functions.<sup><a href="#note303"><b>303)</b></a></sup>
+<p><!--para 2-->
+ The types declared are
+<pre>
+          wint_t</pre>
+ described in <a href="#7.24.1">7.24.1</a>;
+<pre>
+          wctrans_t</pre>
+ which is a scalar type that can hold values which represent locale-specific character
+ mappings; and
+<pre>
+          wctype_t</pre>
+ which is a scalar type that can hold values which represent locale-specific character
+ classifications.
+<p><!--para 3-->
+ The macro defined is WEOF (described in <a href="#7.24.1">7.24.1</a>).
+<p><!--para 4-->
+ The functions declared are grouped as follows:
+<ul>
+<li>  Functions that provide wide character classification;
+<li>  Extensible functions that provide wide character classification;
+<li>  Functions that provide wide character case mapping;
+<li>  Extensible functions that provide wide character mapping.
+</ul>
+<p><!--para 5-->
+ For all functions described in this subclause that accept an argument of type wint_t, the
+ value shall be representable as a wchar_t or shall equal the value of the macro WEOF. If
+ this argument has any other value, the behavior is undefined.
+<p><!--para 6-->
+ The behavior of these functions is affected by the LC_CTYPE category of the current
+ locale.
+ 
+ 
+ 
+ 
+<!--page 406 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note303">303)</a> See ''future library directions'' (<a href="#7.26.13">7.26.13</a>).
+
+
+<a name="7.25.2" href="#7.25.2"><h4>7.25.2 Wide character classification utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wctype.h&gt; declares several functions useful for classifying wide
+ characters.
+<p><!--para 2-->
+ The term printing wide character refers to a member of a locale-specific set of wide
+ characters, each of which occupies at least one printing position on a display device. The
+ term control wide character refers to a member of a locale-specific set of wide characters
+ that are not printing wide characters.
+
+<a name="7.25.2.1" href="#7.25.2.1"><h5>7.25.2.1 Wide character classification functions</h5></a>
+<p><!--para 1-->
+ The functions in this subclause return nonzero (true) if and only if the value of the
+ argument wc conforms to that in the description of the function.
+<p><!--para 2-->
+ Each of the following functions returns true for each wide character that corresponds (as
+ if by a call to the wctob function) to a single-byte character for which the corresponding
+ character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
+ iswpunct functions may differ with respect to wide characters other than L' ' that are
+ both printing and white-space wide characters.<sup><a href="#note304"><b>304)</b></a></sup>
+ Forward references: the wctob function (<a href="#7.24.6.1.2">7.24.6.1.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note304">304)</a> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
+ iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
+ (which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
+ &amp;&amp; iswspace(wc) is true, but not both.
+
+
+<a name="7.25.2.1.1" href="#7.25.2.1.1"><h5>7.25.2.1.1 The iswalnum function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswalnum(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswalnum function tests for any wide character for which iswalpha or
+ iswdigit is true.
+
+<a name="7.25.2.1.2" href="#7.25.2.1.2"><h5>7.25.2.1.2 The iswalpha function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswalpha(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswalpha function tests for any wide character for which iswupper or
+ iswlower is true, or any wide character that is one of a locale-specific set of alphabetic
+ 
+<!--page 407 indent 4-->
+ wide characters for which none of iswcntrl, iswdigit, iswpunct, or iswspace
+ is true.<sup><a href="#note305"><b>305)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note305">305)</a> The functions iswlower and iswupper test true or false separately for each of these additional
+ wide characters; all four combinations are possible.
+
+
+<a name="7.25.2.1.3" href="#7.25.2.1.3"><h5>7.25.2.1.3 The iswblank function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswblank(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswblank function tests for any wide character that is a standard blank wide
+ character or is one of a locale-specific set of wide characters for which iswspace is true
+ and that is used to separate words within a line of text. The standard blank wide
+ characters are the following: space (L' '), and horizontal tab (L'\t'). In the "C"
+ locale, iswblank returns true only for the standard blank characters.
+
+<a name="7.25.2.1.4" href="#7.25.2.1.4"><h5>7.25.2.1.4 The iswcntrl function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswcntrl(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswcntrl function tests for any control wide character.
+
+<a name="7.25.2.1.5" href="#7.25.2.1.5"><h5>7.25.2.1.5 The iswdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswdigit(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswdigit function tests for any wide character that corresponds to a decimal-digit
+ character (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.25.2.1.6" href="#7.25.2.1.6"><h5>7.25.2.1.6 The iswgraph function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswgraph(wint_t wc);</pre>
+ 
+ 
+ 
+ 
+<!--page 408 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswgraph function tests for any wide character for which iswprint is true and
+ iswspace is false.<sup><a href="#note306"><b>306)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note306">306)</a> Note that the behavior of the iswgraph and iswpunct functions may differ from their
+ corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
+ characters other than ' '.
+
+
+<a name="7.25.2.1.7" href="#7.25.2.1.7"><h5>7.25.2.1.7 The iswlower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswlower(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswlower function tests for any wide character that corresponds to a lowercase
+ letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+ iswdigit, iswpunct, or iswspace is true.
+
+<a name="7.25.2.1.8" href="#7.25.2.1.8"><h5>7.25.2.1.8 The iswprint function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswprint(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswprint function tests for any printing wide character.
+
+<a name="7.25.2.1.9" href="#7.25.2.1.9"><h5>7.25.2.1.9 The iswpunct function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswpunct(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswpunct function tests for any printing wide character that is one of a locale-
+ specific set of punctuation wide characters for which neither iswspace nor iswalnum
+ is true.306)
+
+<a name="7.25.2.1.10" href="#7.25.2.1.10"><h5>7.25.2.1.10 The iswspace function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswspace(wint_t wc);</pre>
+ 
+ 
+ 
+<!--page 409 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswspace function tests for any wide character that corresponds to a locale-specific
+ set of white-space wide characters for which none of iswalnum, iswgraph, or
+ iswpunct is true.
+
+<a name="7.25.2.1.11" href="#7.25.2.1.11"><h5>7.25.2.1.11 The iswupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswupper(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswupper function tests for any wide character that corresponds to an uppercase
+ letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+ iswdigit, iswpunct, or iswspace is true.
+
+<a name="7.25.2.1.12" href="#7.25.2.1.12"><h5>7.25.2.1.12 The iswxdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswxdigit(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswxdigit function tests for any wide character that corresponds to a
+ hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+
+<a name="7.25.2.2" href="#7.25.2.2"><h5>7.25.2.2 Extensible wide character classification functions</h5></a>
+<p><!--para 1-->
+ The functions wctype and iswctype provide extensible wide character classification
+ as well as testing equivalent to that performed by the functions described in the previous
+ subclause (<a href="#7.25.2.1">7.25.2.1</a>).
+
+<a name="7.25.2.2.1" href="#7.25.2.2.1"><h5>7.25.2.2.1 The iswctype function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswctype(wint_t wc, wctype_t desc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswctype function determines whether the wide character wc has the property
+ described by desc. The current setting of the LC_CTYPE category shall be the same as
+ during the call to wctype that returned the value desc.
+<p><!--para 3-->
+ Each of the following expressions has a truth-value equivalent to the call to the wide
+ character classification function (<a href="#7.25.2.1">7.25.2.1</a>) in the comment that follows the expression:
+<!--page 410 indent 4-->
+<pre>
+        iswctype(wc,       wctype("alnum"))             //   iswalnum(wc)
+        iswctype(wc,       wctype("alpha"))             //   iswalpha(wc)
+        iswctype(wc,       wctype("blank"))             //   iswblank(wc)
+        iswctype(wc,       wctype("cntrl"))             //   iswcntrl(wc)
+        iswctype(wc,       wctype("digit"))             //   iswdigit(wc)
+        iswctype(wc,       wctype("graph"))             //   iswgraph(wc)
+        iswctype(wc,       wctype("lower"))             //   iswlower(wc)
+        iswctype(wc,       wctype("print"))             //   iswprint(wc)
+        iswctype(wc,       wctype("punct"))             //   iswpunct(wc)
+        iswctype(wc,       wctype("space"))             //   iswspace(wc)
+        iswctype(wc,       wctype("upper"))             //   iswupper(wc)
+        iswctype(wc,       wctype("xdigit"))            //   iswxdigit(wc)</pre>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The iswctype function returns nonzero (true) if and only if the value of the wide
+ character wc has the property described by desc.
+ Forward references: the wctype function (<a href="#7.25.2.2.2">7.25.2.2.2</a>).
+
+<a name="7.25.2.2.2" href="#7.25.2.2.2"><h5>7.25.2.2.2 The wctype function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        wctype_t wctype(const char *property);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctype function constructs a value with type wctype_t that describes a class of
+ wide characters identified by the string argument property.
+<p><!--para 3-->
+ The strings listed in the description of the iswctype function shall be valid in all
+ locales as property arguments to the wctype function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If property identifies a valid class of wide characters according to the LC_CTYPE
+ category of the current locale, the wctype function returns a nonzero value that is valid
+ as the second argument to the iswctype function; otherwise, it returns zero.              *
+<!--page 411 indent 4-->
+
+<a name="7.25.3" href="#7.25.3"><h4>7.25.3 Wide character case mapping utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wctype.h&gt; declares several functions useful for mapping wide characters.
+
+<a name="7.25.3.1" href="#7.25.3.1"><h5>7.25.3.1 Wide character case mapping functions</h5></a>
+
+<a name="7.25.3.1.1" href="#7.25.3.1.1"><h5>7.25.3.1.1 The towlower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        wint_t towlower(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The towlower function converts an uppercase letter to a corresponding lowercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a wide character for which iswupper is true and there are one or
+ more corresponding wide characters, as specified by the current locale, for which
+ iswlower is true, the towlower function returns one of the corresponding wide
+ characters (always the same one for any given locale); otherwise, the argument is
+ returned unchanged.
+
+<a name="7.25.3.1.2" href="#7.25.3.1.2"><h5>7.25.3.1.2 The towupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        wint_t towupper(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The towupper function converts a lowercase letter to a corresponding uppercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a wide character for which iswlower is true and there are one or
+ more corresponding wide characters, as specified by the current locale, for which
+ iswupper is true, the towupper function returns one of the corresponding wide
+ characters (always the same one for any given locale); otherwise, the argument is
+ returned unchanged.
+
+<a name="7.25.3.2" href="#7.25.3.2"><h5>7.25.3.2 Extensible wide character case mapping functions</h5></a>
+<p><!--para 1-->
+ The functions wctrans and towctrans provide extensible wide character mapping as
+ well as case mapping equivalent to that performed by the functions described in the
+ previous subclause (<a href="#7.25.3.1">7.25.3.1</a>).
+<!--page 412 indent 4-->
+
+<a name="7.25.3.2.1" href="#7.25.3.2.1"><h5>7.25.3.2.1 The towctrans function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        wint_t towctrans(wint_t wc, wctrans_t desc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The towctrans function maps the wide character wc using the mapping described by
+ desc. The current setting of the LC_CTYPE category shall be the same as during the call
+ to wctrans that returned the value desc.
+<p><!--para 3-->
+ Each of the following expressions behaves the same as the call to the wide character case
+ mapping function (<a href="#7.25.3.1">7.25.3.1</a>) in the comment that follows the expression:
+<pre>
+        towctrans(wc, wctrans("tolower"))                      // towlower(wc)
+        towctrans(wc, wctrans("toupper"))                      // towupper(wc)</pre>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The towctrans function returns the mapped value of wc using the mapping described
+ by desc.
+
+<a name="7.25.3.2.2" href="#7.25.3.2.2"><h5>7.25.3.2.2 The wctrans function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        wctrans_t wctrans(const char *property);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctrans function constructs a value with type wctrans_t that describes a
+ mapping between wide characters identified by the string argument property.
+<p><!--para 3-->
+ The strings listed in the description of the towctrans function shall be valid in all
+ locales as property arguments to the wctrans function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If property identifies a valid mapping of wide characters according to the LC_CTYPE
+ category of the current locale, the wctrans function returns a nonzero value that is valid
+ as the second argument to the towctrans function; otherwise, it returns zero.
+<!--page 413 indent 4-->
+
+<a name="7.26" href="#7.26"><h3>7.26 Future library directions</h3></a>
+<p><!--para 1-->
+ The following names are grouped under individual headers for convenience. All external
+ names described below are reserved no matter what headers are included by the program.
+
+<a name="7.26.1" href="#7.26.1"><h4>7.26.1 Complex arithmetic <complex.h></h4></a>
+<p><!--para 1-->
+ The function names
+<pre>
+      cerf                cexpm1              clog2
+      cerfc               clog10              clgamma
+      cexp2               clog1p              ctgamma</pre>
+ and the same names suffixed with f or l may be added to the declarations in the
+ &lt;complex.h&gt; header.
+
+<a name="7.26.2" href="#7.26.2"><h4>7.26.2 Character handling <ctype.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with either is or to, and a lowercase letter may be added to
+ the declarations in the &lt;ctype.h&gt; header.
+
+<a name="7.26.3" href="#7.26.3"><h4>7.26.3 Errors <errno.h></h4></a>
+<p><!--para 1-->
+ Macros that begin with E and a digit or E and an uppercase letter may be added to the
+ declarations in the &lt;errno.h&gt; header.
+
+<a name="7.26.4" href="#7.26.4"><h4>7.26.4 Format conversion of integer types <inttypes.h></h4></a>
+<p><!--para 1-->
+ Macro names beginning with PRI or SCN followed by any lowercase letter or X may be
+ added to the macros defined in the &lt;inttypes.h&gt; header.
+
+<a name="7.26.5" href="#7.26.5"><h4>7.26.5 Localization <locale.h></h4></a>
+<p><!--para 1-->
+ Macros that begin with LC_ and an uppercase letter may be added to the definitions in
+ the &lt;locale.h&gt; header.
+
+<a name="7.26.6" href="#7.26.6"><h4>7.26.6 Signal handling <signal.h></h4></a>
+<p><!--para 1-->
+ Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
+ letter may be added to the definitions in the &lt;signal.h&gt; header.
+
+<a name="7.26.7" href="#7.26.7"><h4>7.26.7 Boolean type and values <stdbool.h></h4></a>
+<p><!--para 1-->
+ The ability to undefine and perhaps then redefine the macros bool, true, and false is
+ an obsolescent feature.
+
+<a name="7.26.8" href="#7.26.8"><h4>7.26.8 Integer types <stdint.h></h4></a>
+<p><!--para 1-->
+ Typedef names beginning with int or uint and ending with _t may be added to the
+ types defined in the &lt;stdint.h&gt; header. Macro names beginning with INT or UINT
+ and ending with _MAX, _MIN, or _C may be added to the macros defined in the
+ &lt;stdint.h&gt; header.
+<!--page 414 indent 4-->
+
+<a name="7.26.9" href="#7.26.9"><h4>7.26.9 Input/output <stdio.h></h4></a>
+<p><!--para 1-->
+ Lowercase letters may be added to the conversion specifiers and length modifiers in
+ fprintf and fscanf. Other characters may be used in extensions.
+<p><!--para 2-->
+ The gets function is obsolescent, and is deprecated.
+<p><!--para 3-->
+ The use of ungetc on a binary stream where the file position indicator is zero prior to
+ the call is an obsolescent feature.
+
+<a name="7.26.10" href="#7.26.10"><h4>7.26.10 General utilities <stdlib.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with str and a lowercase letter may be added to the
+ declarations in the &lt;stdlib.h&gt; header.
+
+<a name="7.26.11" href="#7.26.11"><h4>7.26.11 String handling <string.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with str, mem, or wcs and a lowercase letter may be added
+ to the declarations in the &lt;string.h&gt; header.
+
+<a name="7.26.12" href="#7.26.12"><h4>7.26.12 Extended multibyte and wide character utilities <wchar.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with wcs and a lowercase letter may be added to the
+ declarations in the &lt;wchar.h&gt; header.
+<p><!--para 2-->
+ Lowercase letters may be added to the conversion specifiers and length modifiers in
+ fwprintf and fwscanf. Other characters may be used in extensions.
+
+<a name="7.26.13" href="#7.26.13"><h4>7.26.13 Wide character classification and mapping utilities</h4></a>
+ &lt;wctype.h&gt;
+<p><!--para 1-->
+ Function names that begin with is or to and a lowercase letter may be added to the
+ declarations in the &lt;wctype.h&gt; header.
+<!--page 415 indent 4-->
+
+<a name="A" href="#A"><h2>Annex A</h2></a>
+<p><!--para 1-->
+<pre>
+                                              (informative)
+                               Language syntax summary</pre>
+ NOTE     The notation is described in <a href="#6.1">6.1</a>.
+ 
+
+<a name="A.1" href="#A.1"><h3>A.1 Lexical grammar</h3></a>
+
+<a name="A.1.1" href="#A.1.1"><h4>A.1.1 Lexical elements</h4></a>
+ (<a href="#6.4">6.4</a>) token:
+<pre>
+                  keyword
+                  identifier
+                  constant
+                  string-literal
+                  punctuator</pre>
+ (<a href="#6.4">6.4</a>) preprocessing-token:
+<pre>
+               header-name
+               identifier
+               pp-number
+               character-constant
+               string-literal
+               punctuator
+               each non-white-space character that cannot be one of the above</pre>
+
+<a name="A.1.2" href="#A.1.2"><h4>A.1.2 Keywords</h4></a>
+ (<a href="#6.4.1">6.4.1</a>) keyword: one of
+<!--page 416 indent 0-->
+<pre>
+               auto                      enum             restrict    unsigned
+               break                     extern           return      void
+               case                      float            short       volatile
+               char                      for              signed      while
+               const                     goto             sizeof      _Bool
+               continue                  if               static      _Complex
+               default                   inline           struct      _Imaginary
+               do                        int              switch
+               double                    long             typedef
+               else                      register         union</pre>
+
+<a name="A.1.3" href="#A.1.3"><h4>A.1.3 Identifiers</h4></a>
+ (<a href="#6.4.2.1">6.4.2.1</a>) identifier:
+<pre>
+                identifier-nondigit
+                identifier identifier-nondigit
+                identifier digit</pre>
+ (<a href="#6.4.2.1">6.4.2.1</a>) identifier-nondigit:
+<pre>
+                nondigit
+                universal-character-name
+                other implementation-defined characters</pre>
+ (<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
+<pre>
+               _ a b          c    d   e   f   g   h     i   j   k   l   m
+                    n o       p    q   r   s   t   u     v   w   x   y   z
+                    A B       C    D   E   F   G   H     I   J   K   L   M
+                    N O       P    Q   R   S   T   U     V   W   X   Y   Z</pre>
+ (<a href="#6.4.2.1">6.4.2.1</a>) digit: one of
+<pre>
+                0 1 2         3    4   5   6   7   8     9</pre>
+
+<a name="A.1.4" href="#A.1.4"><h4>A.1.4 Universal character names</h4></a>
+ (<a href="#6.4.3">6.4.3</a>) universal-character-name:
+<pre>
+               \u hex-quad
+               \U hex-quad hex-quad</pre>
+ (<a href="#6.4.3">6.4.3</a>) hex-quad:
+<pre>
+               hexadecimal-digit hexadecimal-digit
+                            hexadecimal-digit hexadecimal-digit</pre>
+
+<a name="A.1.5" href="#A.1.5"><h4>A.1.5 Constants</h4></a>
+ (<a href="#6.4.4">6.4.4</a>) constant:
+<pre>
+               integer-constant
+               floating-constant
+               enumeration-constant
+               character-constant</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
+<pre>
+                decimal-constant integer-suffixopt
+                octal-constant integer-suffixopt
+                hexadecimal-constant integer-suffixopt</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) decimal-constant:
+<!--page 417 indent 0-->
+<pre>
+               nonzero-digit
+               decimal-constant digit</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) octal-constant:
+<pre>
+                0
+                octal-constant octal-digit</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-constant:
+<pre>
+               hexadecimal-prefix hexadecimal-digit
+               hexadecimal-constant hexadecimal-digit</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-prefix: one of
+<pre>
+               0x 0X</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) nonzero-digit: one of
+<pre>
+               1 2 3 4 5              6      7   8   9</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) octal-digit: one of
+<pre>
+                0 1 2 3           4   5      6   7</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-digit: one of
+<pre>
+               0 1 2 3 4 5                   6   7   8   9
+               a b c d e f
+               A B C D E F</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
+<pre>
+                unsigned-suffix long-suffixopt
+                unsigned-suffix long-long-suffix
+                long-suffix unsigned-suffixopt
+                long-long-suffix unsigned-suffixopt</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) unsigned-suffix: one of
+<pre>
+                u U</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) long-suffix: one of
+<pre>
+                l L</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) long-long-suffix: one of
+<pre>
+                ll LL</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) floating-constant:
+<pre>
+                decimal-floating-constant
+                hexadecimal-floating-constant</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
+<!--page 418 indent 0-->
+<pre>
+               fractional-constant exponent-partopt floating-suffixopt
+               digit-sequence exponent-part floating-suffixopt</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
+<pre>
+               hexadecimal-prefix hexadecimal-fractional-constant
+                             binary-exponent-part floating-suffixopt
+               hexadecimal-prefix hexadecimal-digit-sequence
+                             binary-exponent-part floating-suffixopt</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) fractional-constant:
+<pre>
+                digit-sequenceopt . digit-sequence
+                digit-sequence .</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) exponent-part:
+<pre>
+               e signopt digit-sequence
+               E signopt digit-sequence</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) sign: one of
+<pre>
+                + -</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) digit-sequence:
+<pre>
+                digit
+                digit-sequence digit</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
+<pre>
+               hexadecimal-digit-sequenceopt .
+                              hexadecimal-digit-sequence
+               hexadecimal-digit-sequence .</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) binary-exponent-part:
+<pre>
+                p signopt digit-sequence
+                P signopt digit-sequence</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-digit-sequence:
+<pre>
+               hexadecimal-digit
+               hexadecimal-digit-sequence hexadecimal-digit</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) floating-suffix: one of
+<pre>
+                f l F L</pre>
+ (<a href="#6.4.4.3">6.4.4.3</a>) enumeration-constant:
+<pre>
+               identifier</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) character-constant:
+<!--page 419 indent 0-->
+<pre>
+               ' c-char-sequence '
+               L' c-char-sequence '</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) c-char-sequence:
+<pre>
+                c-char
+                c-char-sequence c-char</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) c-char:
+<pre>
+                any member of the source character set except
+                             the single-quote ', backslash \, or new-line character
+                escape-sequence</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) escape-sequence:
+<pre>
+               simple-escape-sequence
+               octal-escape-sequence
+               hexadecimal-escape-sequence
+               universal-character-name</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) simple-escape-sequence: one of
+<pre>
+               \' \" \? \\
+               \a \b \f \n \r \t                   \v</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) octal-escape-sequence:
+<pre>
+                \ octal-digit
+                \ octal-digit octal-digit
+                \ octal-digit octal-digit octal-digit</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) hexadecimal-escape-sequence:
+<pre>
+               \x hexadecimal-digit
+               hexadecimal-escape-sequence hexadecimal-digit</pre>
+
+<a name="A.1.6" href="#A.1.6"><h4>A.1.6 String literals</h4></a>
+ (<a href="#6.4.5">6.4.5</a>) string-literal:
+<pre>
+                " s-char-sequenceopt "
+                L" s-char-sequenceopt "</pre>
+ (<a href="#6.4.5">6.4.5</a>) s-char-sequence:
+<pre>
+                s-char
+                s-char-sequence s-char</pre>
+ (<a href="#6.4.5">6.4.5</a>) s-char:
+<!--page 420 indent 0-->
+<pre>
+                any member of the source character set except
+                             the double-quote ", backslash \, or new-line character
+                escape-sequence</pre>
+
+<a name="A.1.7" href="#A.1.7"><h4>A.1.7 Punctuators</h4></a>
+ (<a href="#6.4.6">6.4.6</a>) punctuator: one of
+<pre>
+               [ ] ( ) { } . -&gt;
+               ++ -- &amp; * + - ~ !
+               / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                     ==      !=    ^    |    &amp;&amp;   ||
+               ? : ; ...
+               = *= /= %= += -= &lt;&lt;=                    &gt;&gt;=      &amp;=       ^=   |=
+               , # ##
+               &lt;: :&gt; &lt;% %&gt; %: %:%:</pre>
+
+<a name="A.1.8" href="#A.1.8"><h4>A.1.8 Header names</h4></a>
+ (<a href="#6.4.7">6.4.7</a>) header-name:
+<pre>
+               &lt; h-char-sequence &gt;
+               " q-char-sequence "</pre>
+ (<a href="#6.4.7">6.4.7</a>) h-char-sequence:
+<pre>
+               h-char
+               h-char-sequence h-char</pre>
+ (<a href="#6.4.7">6.4.7</a>) h-char:
+<pre>
+               any member of the source character set except
+                            the new-line character and &gt;</pre>
+ (<a href="#6.4.7">6.4.7</a>) q-char-sequence:
+<pre>
+               q-char
+               q-char-sequence q-char</pre>
+ (<a href="#6.4.7">6.4.7</a>) q-char:
+<pre>
+               any member of the source character set except
+                            the new-line character and "</pre>
+
+<a name="A.1.9" href="#A.1.9"><h4>A.1.9 Preprocessing numbers</h4></a>
+ (<a href="#6.4.8">6.4.8</a>) pp-number:
+<!--page 421 indent 0-->
+<pre>
+               digit
+               . digit
+               pp-number   digit
+               pp-number   identifier-nondigit
+               pp-number   e sign
+               pp-number   E sign
+               pp-number   p sign
+               pp-number   P sign
+               pp-number   .</pre>
+
+<a name="A.2" href="#A.2"><h3>A.2 Phrase structure grammar</h3></a>
+
+<a name="A.2.1" href="#A.2.1"><h4>A.2.1 Expressions</h4></a>
+ (<a href="#6.5.1">6.5.1</a>) primary-expression:
+<pre>
+               identifier
+               constant
+               string-literal
+               ( expression )</pre>
+ (<a href="#6.5.2">6.5.2</a>) postfix-expression:
+<pre>
+               primary-expression
+               postfix-expression [ expression ]
+               postfix-expression ( argument-expression-listopt )
+               postfix-expression . identifier
+               postfix-expression -&gt; identifier
+               postfix-expression ++
+               postfix-expression --
+               ( type-name ) { initializer-list }
+               ( type-name ) { initializer-list , }</pre>
+ (<a href="#6.5.2">6.5.2</a>) argument-expression-list:
+<pre>
+              assignment-expression
+              argument-expression-list , assignment-expression</pre>
+ (<a href="#6.5.3">6.5.3</a>) unary-expression:
+<pre>
+               postfix-expression
+               ++ unary-expression
+               -- unary-expression
+               unary-operator cast-expression
+               sizeof unary-expression
+               sizeof ( type-name )</pre>
+ (<a href="#6.5.3">6.5.3</a>) unary-operator: one of
+<pre>
+               &amp; * + - ~             !</pre>
+ (<a href="#6.5.4">6.5.4</a>) cast-expression:
+<pre>
+                unary-expression
+                ( type-name ) cast-expression</pre>
+ (<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
+<!--page 422 indent 0-->
+<pre>
+                cast-expression
+                multiplicative-expression * cast-expression
+                multiplicative-expression / cast-expression
+                multiplicative-expression % cast-expression</pre>
+ (<a href="#6.5.6">6.5.6</a>) additive-expression:
+<pre>
+                multiplicative-expression
+                additive-expression + multiplicative-expression
+                additive-expression - multiplicative-expression</pre>
+ (<a href="#6.5.7">6.5.7</a>) shift-expression:
+<pre>
+                 additive-expression
+                 shift-expression &lt;&lt; additive-expression
+                 shift-expression &gt;&gt; additive-expression</pre>
+ (<a href="#6.5.8">6.5.8</a>) relational-expression:
+<pre>
+                shift-expression
+                relational-expression   &lt;    shift-expression
+                relational-expression   &gt;    shift-expression
+                relational-expression   &lt;=   shift-expression
+                relational-expression   &gt;=   shift-expression</pre>
+ (<a href="#6.5.9">6.5.9</a>) equality-expression:
+<pre>
+                relational-expression
+                equality-expression == relational-expression
+                equality-expression != relational-expression</pre>
+ (<a href="#6.5.10">6.5.10</a>) AND-expression:
+<pre>
+              equality-expression
+              AND-expression &amp; equality-expression</pre>
+ (<a href="#6.5.11">6.5.11</a>) exclusive-OR-expression:
+<pre>
+               AND-expression
+               exclusive-OR-expression ^ AND-expression</pre>
+ (<a href="#6.5.12">6.5.12</a>) inclusive-OR-expression:
+<pre>
+                exclusive-OR-expression
+                inclusive-OR-expression | exclusive-OR-expression</pre>
+ (<a href="#6.5.13">6.5.13</a>) logical-AND-expression:
+<pre>
+               inclusive-OR-expression
+               logical-AND-expression &amp;&amp; inclusive-OR-expression</pre>
+ (<a href="#6.5.14">6.5.14</a>) logical-OR-expression:
+<pre>
+               logical-AND-expression
+               logical-OR-expression || logical-AND-expression</pre>
+ (<a href="#6.5.15">6.5.15</a>) conditional-expression:
+<!--page 423 indent 0-->
+<pre>
+               logical-OR-expression
+               logical-OR-expression ? expression : conditional-expression</pre>
+ (<a href="#6.5.16">6.5.16</a>) assignment-expression:
+<pre>
+               conditional-expression
+               unary-expression assignment-operator assignment-expression</pre>
+ (<a href="#6.5.16">6.5.16</a>) assignment-operator: one of
+<pre>
+               = *= /= %= +=                -=    &lt;&lt;=    &gt;&gt;=      &amp;=   ^=   |=</pre>
+ (<a href="#6.5.17">6.5.17</a>) expression:
+<pre>
+               assignment-expression
+               expression , assignment-expression</pre>
+ (<a href="#6.6">6.6</a>) constant-expression:
+<pre>
+               conditional-expression</pre>
+
+<a name="A.2.2" href="#A.2.2"><h4>A.2.2 Declarations</h4></a>
+ (<a href="#6.7">6.7</a>) declaration:
+<pre>
+                declaration-specifiers init-declarator-listopt ;</pre>
+ (<a href="#6.7">6.7</a>) declaration-specifiers:
+<pre>
+                storage-class-specifier declaration-specifiersopt
+                type-specifier declaration-specifiersopt
+                type-qualifier declaration-specifiersopt
+                function-specifier declaration-specifiersopt</pre>
+ (<a href="#6.7">6.7</a>) init-declarator-list:
+<pre>
+                init-declarator
+                init-declarator-list , init-declarator</pre>
+ (<a href="#6.7">6.7</a>) init-declarator:
+<pre>
+                declarator
+                declarator = initializer</pre>
+ (<a href="#6.7.1">6.7.1</a>) storage-class-specifier:
+<!--page 424 indent 0-->
+<pre>
+               typedef
+               extern
+               static
+               auto
+               register</pre>
+ (<a href="#6.7.2">6.7.2</a>) type-specifier:
+<pre>
+                void
+                char
+                short
+                int
+                long
+                float
+                double
+                signed
+                unsigned
+                _Bool
+                _Complex
+                struct-or-union-specifier                                                 *
+                enum-specifier
+                typedef-name</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
+<pre>
+                struct-or-union identifieropt { struct-declaration-list }
+                struct-or-union identifier</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union:
+<pre>
+                struct
+                union</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration-list:
+<pre>
+                struct-declaration
+                struct-declaration-list struct-declaration</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration:
+<pre>
+                specifier-qualifier-list struct-declarator-list ;</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
+<pre>
+                type-specifier specifier-qualifier-listopt
+                type-qualifier specifier-qualifier-listopt</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator-list:
+<pre>
+                struct-declarator
+                struct-declarator-list , struct-declarator</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator:
+<!--page 425 indent 0-->
+<pre>
+                declarator
+                declaratoropt : constant-expression</pre>
+ (<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
+<pre>
+               enum identifieropt { enumerator-list }
+               enum identifieropt { enumerator-list , }
+               enum identifier</pre>
+ (<a href="#6.7.2.2">6.7.2.2</a>) enumerator-list:
+<pre>
+               enumerator
+               enumerator-list , enumerator</pre>
+ (<a href="#6.7.2.2">6.7.2.2</a>) enumerator:
+<pre>
+               enumeration-constant
+               enumeration-constant = constant-expression</pre>
+ (<a href="#6.7.3">6.7.3</a>) type-qualifier:
+<pre>
+               const
+               restrict
+               volatile</pre>
+ (<a href="#6.7.4">6.7.4</a>) function-specifier:
+<pre>
+                inline</pre>
+ (<a href="#6.7.5">6.7.5</a>) declarator:
+<pre>
+               pointeropt direct-declarator</pre>
+ (<a href="#6.7.5">6.7.5</a>) direct-declarator:
+<pre>
+                identifier
+                ( declarator )
+                direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+                direct-declarator [ static type-qualifier-listopt assignment-expression ]
+                direct-declarator [ type-qualifier-list static assignment-expression ]
+                direct-declarator [ type-qualifier-listopt * ]
+                direct-declarator ( parameter-type-list )
+                direct-declarator ( identifier-listopt )</pre>
+ (<a href="#6.7.5">6.7.5</a>) pointer:
+<pre>
+                * type-qualifier-listopt
+                * type-qualifier-listopt pointer</pre>
+ (<a href="#6.7.5">6.7.5</a>) type-qualifier-list:
+<pre>
+               type-qualifier
+               type-qualifier-list type-qualifier</pre>
+ (<a href="#6.7.5">6.7.5</a>) parameter-type-list:
+<!--page 426 indent 0-->
+<pre>
+              parameter-list
+              parameter-list , ...</pre>
+ (<a href="#6.7.5">6.7.5</a>) parameter-list:
+<pre>
+              parameter-declaration
+              parameter-list , parameter-declaration</pre>
+ (<a href="#6.7.5">6.7.5</a>) parameter-declaration:
+<pre>
+              declaration-specifiers declarator
+              declaration-specifiers abstract-declaratoropt</pre>
+ (<a href="#6.7.5">6.7.5</a>) identifier-list:
+<pre>
+                identifier
+                identifier-list , identifier</pre>
+ (<a href="#6.7.6">6.7.6</a>) type-name:
+<pre>
+               specifier-qualifier-list abstract-declaratoropt</pre>
+ (<a href="#6.7.6">6.7.6</a>) abstract-declarator:
+<pre>
+               pointer
+               pointeropt direct-abstract-declarator</pre>
+ (<a href="#6.7.6">6.7.6</a>) direct-abstract-declarator:
+<pre>
+                ( abstract-declarator )
+                direct-abstract-declaratoropt [ type-qualifier-listopt
+                               assignment-expressionopt ]
+                direct-abstract-declaratoropt [ static type-qualifier-listopt
+                               assignment-expression ]
+                direct-abstract-declaratoropt [ type-qualifier-list static
+                               assignment-expression ]
+                direct-abstract-declaratoropt [ * ]
+                direct-abstract-declaratoropt ( parameter-type-listopt )</pre>
+ (<a href="#6.7.7">6.7.7</a>) typedef-name:
+<pre>
+               identifier</pre>
+ (<a href="#6.7.8">6.7.8</a>) initializer:
+<pre>
+                 assignment-expression
+                 { initializer-list }
+                 { initializer-list , }</pre>
+ (<a href="#6.7.8">6.7.8</a>) initializer-list:
+<pre>
+                 designationopt initializer
+                 initializer-list , designationopt initializer</pre>
+ (<a href="#6.7.8">6.7.8</a>) designation:
+<!--page 427 indent 0-->
+<pre>
+               designator-list =</pre>
+ (<a href="#6.7.8">6.7.8</a>) designator-list:
+<pre>
+               designator
+               designator-list designator</pre>
+ (<a href="#6.7.8">6.7.8</a>) designator:
+<pre>
+               [ constant-expression ]
+               . identifier</pre>
+
+<a name="A.2.3" href="#A.2.3"><h4>A.2.3 Statements</h4></a>
+ (<a href="#6.8">6.8</a>) statement:
+<pre>
+               labeled-statement
+               compound-statement
+               expression-statement
+               selection-statement
+               iteration-statement
+               jump-statement</pre>
+ (<a href="#6.8.1">6.8.1</a>) labeled-statement:
+<pre>
+                identifier : statement
+                case constant-expression : statement
+                default : statement</pre>
+ (<a href="#6.8.2">6.8.2</a>) compound-statement:
+<pre>
+              { block-item-listopt }</pre>
+ (<a href="#6.8.2">6.8.2</a>) block-item-list:
+<pre>
+                block-item
+                block-item-list block-item</pre>
+ (<a href="#6.8.2">6.8.2</a>) block-item:
+<pre>
+                declaration
+                statement</pre>
+ (<a href="#6.8.3">6.8.3</a>) expression-statement:
+<pre>
+               expressionopt ;</pre>
+ (<a href="#6.8.4">6.8.4</a>) selection-statement:
+<!--page 428 indent 0-->
+<pre>
+                if ( expression ) statement
+                if ( expression ) statement else statement
+                switch ( expression ) statement</pre>
+ (<a href="#6.8.5">6.8.5</a>) iteration-statement:
+<pre>
+                 while ( expression ) statement
+                 do statement while ( expression ) ;
+                 for ( expressionopt ; expressionopt ; expressionopt ) statement
+                 for ( declaration expressionopt ; expressionopt ) statement</pre>
+ (<a href="#6.8.6">6.8.6</a>) jump-statement:
+<pre>
+               goto identifier ;
+               continue ;
+               break ;
+               return expressionopt ;</pre>
+
+<a name="A.2.4" href="#A.2.4"><h4>A.2.4 External definitions</h4></a>
+ (<a href="#6.9">6.9</a>) translation-unit:
+<pre>
+                external-declaration
+                translation-unit external-declaration</pre>
+ (<a href="#6.9">6.9</a>) external-declaration:
+<pre>
+                function-definition
+                declaration</pre>
+ (<a href="#6.9.1">6.9.1</a>) function-definition:
+<pre>
+                declaration-specifiers declarator declaration-listopt compound-statement</pre>
+ (<a href="#6.9.1">6.9.1</a>) declaration-list:
+<pre>
+               declaration
+               declaration-list declaration</pre>
+
+<a name="A.3" href="#A.3"><h3>A.3 Preprocessing directives</h3></a>
+ (<a href="#6.10">6.10</a>) preprocessing-file:
+<pre>
+               groupopt</pre>
+ (<a href="#6.10">6.10</a>) group:
+<pre>
+                 group-part
+                 group group-part</pre>
+ (<a href="#6.10">6.10</a>) group-part:
+<pre>
+               if-section
+               control-line
+               text-line
+               # non-directive</pre>
+ (<a href="#6.10">6.10</a>) if-section:
+<!--page 429 indent 0-->
+<pre>
+                 if-group elif-groupsopt else-groupopt endif-line</pre>
+ (<a href="#6.10">6.10</a>) if-group:
+<pre>
+                # if     constant-expression new-line groupopt
+                # ifdef identifier new-line groupopt
+                # ifndef identifier new-line groupopt</pre>
+ (<a href="#6.10">6.10</a>) elif-groups:
+<pre>
+                elif-group
+                elif-groups elif-group</pre>
+ (<a href="#6.10">6.10</a>) elif-group:
+<pre>
+                # elif        constant-expression new-line groupopt</pre>
+ (<a href="#6.10">6.10</a>) else-group:
+<pre>
+                # else        new-line groupopt</pre>
+ (<a href="#6.10">6.10</a>) endif-line:
+<pre>
+                # endif       new-line</pre>
+ (<a href="#6.10">6.10</a>) control-line:
+<pre>
+               # include pp-tokens new-line
+               # define identifier replacement-list new-line
+               # define identifier lparen identifier-listopt )
+                                               replacement-list new-line
+               # define identifier lparen ... ) replacement-list new-line
+               # define identifier lparen identifier-list , ... )
+                                               replacement-list new-line
+               # undef   identifier new-line
+               # line    pp-tokens new-line
+               # error   pp-tokensopt new-line
+               # pragma pp-tokensopt new-line
+               #         new-line</pre>
+ (<a href="#6.10">6.10</a>) text-line:
+<pre>
+                pp-tokensopt new-line</pre>
+ (<a href="#6.10">6.10</a>) non-directive:
+<pre>
+               pp-tokens new-line</pre>
+ (<a href="#6.10">6.10</a>) lparen:
+<pre>
+                  a ( character not immediately preceded by white-space</pre>
+ (<a href="#6.10">6.10</a>) replacement-list:
+<!--page 430 indent 0-->
+<pre>
+               pp-tokensopt</pre>
+ (<a href="#6.10">6.10</a>) pp-tokens:
+<pre>
+               preprocessing-token
+               pp-tokens preprocessing-token</pre>
+ (<a href="#6.10">6.10</a>) new-line:
+<!--page 431 indent 0-->
+<pre>
+               the new-line character</pre>
+
+<a name="B" href="#B"><h2>Annex B</h2></a>
+<pre>
+                               (informative)
+                           Library summary</pre>
+
+<a name="B.1" href="#B.1"><h3>B.1 Diagnostics <assert.h></h3></a>
+<pre>
+        NDEBUG
+        void assert(scalar expression);</pre>
+
+<a name="B.2" href="#B.2"><h3>B.2 Complex <complex.h></h3></a>
+<!--page 432 indent -1-->
+<!--page 433 indent 0-->
+<pre>
+        complex               imaginary               I
+        _Complex_I            _Imaginary_I
+        #pragma STDC CX_LIMITED_RANGE on-off-switch
+        double complex cacos(double complex z);
+        float complex cacosf(float complex z);
+        long double complex cacosl(long double complex z);
+        double complex casin(double complex z);
+        float complex casinf(float complex z);
+        long double complex casinl(long double complex z);
+        double complex catan(double complex z);
+        float complex catanf(float complex z);
+        long double complex catanl(long double complex z);
+        double complex ccos(double complex z);
+        float complex ccosf(float complex z);
+        long double complex ccosl(long double complex z);
+        double complex csin(double complex z);
+        float complex csinf(float complex z);
+        long double complex csinl(long double complex z);
+        double complex ctan(double complex z);
+        float complex ctanf(float complex z);
+        long double complex ctanl(long double complex z);
+        double complex cacosh(double complex z);
+        float complex cacoshf(float complex z);
+        long double complex cacoshl(long double complex z);
+        double complex casinh(double complex z);
+        float complex casinhf(float complex z);
+        long double complex casinhl(long double complex z);
+        double complex catanh(double complex z);
+        float complex catanhf(float complex z);
+        long double complex catanhl(long double complex z);
+       double complex ccosh(double complex z);
+       float complex ccoshf(float complex z);
+       long double complex ccoshl(long double complex z);
+       double complex csinh(double complex z);
+       float complex csinhf(float complex z);
+       long double complex csinhl(long double complex z);
+       double complex ctanh(double complex z);
+       float complex ctanhf(float complex z);
+       long double complex ctanhl(long double complex z);
+       double complex cexp(double complex z);
+       float complex cexpf(float complex z);
+       long double complex cexpl(long double complex z);
+       double complex clog(double complex z);
+       float complex clogf(float complex z);
+       long double complex clogl(long double complex z);
+       double cabs(double complex z);
+       float cabsf(float complex z);
+       long double cabsl(long double complex z);
+       double complex cpow(double complex x, double complex y);
+       float complex cpowf(float complex x, float complex y);
+       long double complex cpowl(long double complex x,
+            long double complex y);
+       double complex csqrt(double complex z);
+       float complex csqrtf(float complex z);
+       long double complex csqrtl(long double complex z);
+       double carg(double complex z);
+       float cargf(float complex z);
+       long double cargl(long double complex z);
+       double cimag(double complex z);
+       float cimagf(float complex z);
+       long double cimagl(long double complex z);
+       double complex conj(double complex z);
+       float complex conjf(float complex z);
+       long double complex conjl(long double complex z);
+       double complex cproj(double complex z);
+       float complex cprojf(float complex z);
+       long double complex cprojl(long double complex z);
+       double creal(double complex z);
+       float crealf(float complex z);
+       long double creall(long double complex z);</pre>
+
+<a name="B.3" href="#B.3"><h3>B.3 Character handling <ctype.h></h3></a>
+<pre>
+        int    isalnum(int c);
+        int    isalpha(int c);
+        int    isblank(int c);
+        int    iscntrl(int c);
+        int    isdigit(int c);
+        int    isgraph(int c);
+        int    islower(int c);
+        int    isprint(int c);
+        int    ispunct(int c);
+        int    isspace(int c);
+        int    isupper(int c);
+        int    isxdigit(int c);
+        int    tolower(int c);
+        int    toupper(int c);</pre>
+
+<a name="B.4" href="#B.4"><h3>B.4 Errors <errno.h></h3></a>
+<pre>
+        EDOM            EILSEQ             ERANGE            errno</pre>
+
+<a name="B.5" href="#B.5"><h3>B.5 Floating-point environment <fenv.h></h3></a>
+<!--page 434 indent 0-->
+<pre>
+        fenv_t                 FE_OVERFLOW             FE_TOWARDZERO
+        fexcept_t              FE_UNDERFLOW            FE_UPWARD
+        FE_DIVBYZERO           FE_ALL_EXCEPT           FE_DFL_ENV
+        FE_INEXACT             FE_DOWNWARD
+        FE_INVALID             FE_TONEAREST
+        #pragma STDC FENV_ACCESS on-off-switch
+        int feclearexcept(int excepts);
+        int fegetexceptflag(fexcept_t *flagp, int excepts);
+        int feraiseexcept(int excepts);
+        int fesetexceptflag(const fexcept_t *flagp,
+             int excepts);
+        int fetestexcept(int excepts);
+        int fegetround(void);
+        int fesetround(int round);
+        int fegetenv(fenv_t *envp);
+        int feholdexcept(fenv_t *envp);
+        int fesetenv(const fenv_t *envp);
+        int feupdateenv(const fenv_t *envp);</pre>
+
+<a name="B.6" href="#B.6"><h3>B.6 Characteristics of floating types <float.h></h3></a>
+<pre>
+       FLT_ROUNDS              DBL_MIN_EXP             FLT_MAX
+       FLT_EVAL_METHOD         LDBL_MIN_EXP            DBL_MAX
+       FLT_RADIX               FLT_MIN_10_EXP          LDBL_MAX
+       FLT_MANT_DIG            DBL_MIN_10_EXP          FLT_EPSILON
+       DBL_MANT_DIG            LDBL_MIN_10_EXP         DBL_EPSILON
+       LDBL_MANT_DIG           FLT_MAX_EXP             LDBL_EPSILON
+       DECIMAL_DIG             DBL_MAX_EXP             FLT_MIN
+       FLT_DIG                 LDBL_MAX_EXP            DBL_MIN
+       DBL_DIG                 FLT_MAX_10_EXP          LDBL_MIN
+       LDBL_DIG                DBL_MAX_10_EXP
+       FLT_MIN_EXP             LDBL_MAX_10_EXP</pre>
+
+<a name="B.7" href="#B.7"><h3>B.7 Format conversion of integer types <inttypes.h></h3></a>
+<!--page 435 indent 0-->
+<pre>
+       imaxdiv_t
+       PRIdN        PRIdLEASTN        PRIdFASTN        PRIdMAX     PRIdPTR
+       PRIiN        PRIiLEASTN        PRIiFASTN        PRIiMAX     PRIiPTR
+       PRIoN        PRIoLEASTN        PRIoFASTN        PRIoMAX     PRIoPTR
+       PRIuN        PRIuLEASTN        PRIuFASTN        PRIuMAX     PRIuPTR
+       PRIxN        PRIxLEASTN        PRIxFASTN        PRIxMAX     PRIxPTR
+       PRIXN        PRIXLEASTN        PRIXFASTN        PRIXMAX     PRIXPTR
+       SCNdN        SCNdLEASTN        SCNdFASTN        SCNdMAX     SCNdPTR
+       SCNiN        SCNiLEASTN        SCNiFASTN        SCNiMAX     SCNiPTR
+       SCNoN        SCNoLEASTN        SCNoFASTN        SCNoMAX     SCNoPTR
+       SCNuN        SCNuLEASTN        SCNuFASTN        SCNuMAX     SCNuPTR
+       SCNxN        SCNxLEASTN        SCNxFASTN        SCNxMAX     SCNxPTR
+       intmax_t imaxabs(intmax_t j);
+       imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+       intmax_t strtoimax(const char * restrict nptr,
+               char ** restrict endptr, int base);
+       uintmax_t strtoumax(const char * restrict nptr,
+               char ** restrict endptr, int base);
+       intmax_t wcstoimax(const wchar_t * restrict nptr,
+               wchar_t ** restrict endptr, int base);
+       uintmax_t wcstoumax(const wchar_t * restrict nptr,
+               wchar_t ** restrict endptr, int base);</pre>
+
+<a name="B.8" href="#B.8"><h3>B.8 Alternative spellings <iso646.h></h3></a>
+<pre>
+      and             bitor             not_eq            xor
+      and_eq          compl             or                xor_eq
+      bitand          not               or_eq</pre>
+
+<a name="B.9" href="#B.9"><h3>B.9 Sizes of integer types <limits.h></h3></a>
+<pre>
+      CHAR_BIT        CHAR_MAX          INT_MIN           ULONG_MAX
+      SCHAR_MIN       MB_LEN_MAX        INT_MAX           LLONG_MIN
+      SCHAR_MAX       SHRT_MIN          UINT_MAX          LLONG_MAX
+      UCHAR_MAX       SHRT_MAX          LONG_MIN          ULLONG_MAX
+      CHAR_MIN        USHRT_MAX         LONG_MAX</pre>
+
+<a name="B.10" href="#B.10"><h3>B.10 Localization <locale.h></h3></a>
+<pre>
+      struct lconv    LC_ALL            LC_CTYPE          LC_NUMERIC
+      NULL            LC_COLLATE        LC_MONETARY       LC_TIME
+      char *setlocale(int category, const char *locale);
+      struct lconv *localeconv(void);</pre>
+
+<a name="B.11" href="#B.11"><h3>B.11 Mathematics <math.h></h3></a>
+<!--page 436 indent -1-->
+<!--page 437 indent -1-->
+<!--page 438 indent -1-->
+<!--page 439 indent -1-->
+<!--page 440 indent 0-->
+<pre>
+      float_t               FP_INFINITE             FP_FAST_FMAL
+      double_t              FP_NAN                  FP_ILOGB0
+      HUGE_VAL              FP_NORMAL               FP_ILOGBNAN
+      HUGE_VALF             FP_SUBNORMAL            MATH_ERRNO
+      HUGE_VALL             FP_ZERO                 MATH_ERREXCEPT
+      INFINITY              FP_FAST_FMA             math_errhandling
+      NAN                   FP_FAST_FMAF
+       #pragma STDC FP_CONTRACT on-off-switch
+       int fpclassify(real-floating x);
+       int isfinite(real-floating x);
+       int isinf(real-floating x);
+       int isnan(real-floating x);
+       int isnormal(real-floating x);
+       int signbit(real-floating x);
+       double acos(double x);
+       float acosf(float x);
+       long double acosl(long double x);
+       double asin(double x);
+       float asinf(float x);
+       long double asinl(long double x);
+       double atan(double x);
+       float atanf(float x);
+       long double atanl(long double x);
+       double atan2(double y, double x);
+       float atan2f(float y, float x);
+       long double atan2l(long double y, long double x);
+       double cos(double x);
+       float cosf(float x);
+       long double cosl(long double x);
+       double sin(double x);
+       float sinf(float x);
+       long double sinl(long double x);
+       double tan(double x);
+       float tanf(float x);
+       long double tanl(long double x);
+       double acosh(double x);
+       float acoshf(float x);
+       long double acoshl(long double x);
+       double asinh(double x);
+       float asinhf(float x);
+       long double asinhl(long double x);
+       double atanh(double x);
+       float atanhf(float x);
+       long double atanhl(long double x);
+       double cosh(double x);
+       float coshf(float x);
+       long double coshl(long double x);
+       double sinh(double x);
+       float sinhf(float x);
+       long double sinhl(long double x);
+       double tanh(double x);
+       float tanhf(float x);
+       long double tanhl(long double x);
+       double exp(double x);
+       float expf(float x);
+       long double expl(long double x);
+       double exp2(double x);
+       float exp2f(float x);
+       long double exp2l(long double x);
+       double expm1(double x);
+       float expm1f(float x);
+       long double expm1l(long double x);
+         double frexp(double value, int *exp);
+         float frexpf(float value, int *exp);
+         long double frexpl(long double value, int *exp);
+         int ilogb(double x);
+         int ilogbf(float x);
+         int ilogbl(long double x);
+         double ldexp(double x, int exp);
+         float ldexpf(float x, int exp);
+         long double ldexpl(long double x, int exp);
+         double log(double x);
+         float logf(float x);
+         long double logl(long double x);
+         double log10(double x);
+         float log10f(float x);
+         long double log10l(long double x);
+         double log1p(double x);
+         float log1pf(float x);
+         long double log1pl(long double x);
+         double log2(double x);
+         float log2f(float x);
+         long double log2l(long double x);
+         double logb(double x);
+         float logbf(float x);
+         long double logbl(long double x);
+         double modf(double value, double *iptr);
+         float modff(float value, float *iptr);
+         long double modfl(long double value, long double *iptr);
+         double scalbn(double x, int n);
+         float scalbnf(float x, int n);
+         long double scalbnl(long double x, int n);
+         double scalbln(double x, long int n);
+         float scalblnf(float x, long int n);
+         long double scalblnl(long double x, long int n);
+         double cbrt(double x);
+         float cbrtf(float x);
+         long double cbrtl(long double x);
+         double fabs(double x);
+         float fabsf(float x);
+         long double fabsl(long double x);
+         double hypot(double x, double y);
+         float hypotf(float x, float y);
+       long double hypotl(long double x, long double y);
+       double pow(double x, double y);
+       float powf(float x, float y);
+       long double powl(long double x, long double y);
+       double sqrt(double x);
+       float sqrtf(float x);
+       long double sqrtl(long double x);
+       double erf(double x);
+       float erff(float x);
+       long double erfl(long double x);
+       double erfc(double x);
+       float erfcf(float x);
+       long double erfcl(long double x);
+       double lgamma(double x);
+       float lgammaf(float x);
+       long double lgammal(long double x);
+       double tgamma(double x);
+       float tgammaf(float x);
+       long double tgammal(long double x);
+       double ceil(double x);
+       float ceilf(float x);
+       long double ceill(long double x);
+       double floor(double x);
+       float floorf(float x);
+       long double floorl(long double x);
+       double nearbyint(double x);
+       float nearbyintf(float x);
+       long double nearbyintl(long double x);
+       double rint(double x);
+       float rintf(float x);
+       long double rintl(long double x);
+       long int lrint(double x);
+       long int lrintf(float x);
+       long int lrintl(long double x);
+       long long int llrint(double x);
+       long long int llrintf(float x);
+       long long int llrintl(long double x);
+       double round(double x);
+       float roundf(float x);
+       long double roundl(long double x);
+       long int lround(double x);
+         long int lroundf(float x);
+         long int lroundl(long double x);
+         long long int llround(double x);
+         long long int llroundf(float x);
+         long long int llroundl(long double x);
+         double trunc(double x);
+         float truncf(float x);
+         long double truncl(long double x);
+         double fmod(double x, double y);
+         float fmodf(float x, float y);
+         long double fmodl(long double x, long double y);
+         double remainder(double x, double y);
+         float remainderf(float x, float y);
+         long double remainderl(long double x, long double y);
+         double remquo(double x, double y, int *quo);
+         float remquof(float x, float y, int *quo);
+         long double remquol(long double x, long double y,
+              int *quo);
+         double copysign(double x, double y);
+         float copysignf(float x, float y);
+         long double copysignl(long double x, long double y);
+         double nan(const char *tagp);
+         float nanf(const char *tagp);
+         long double nanl(const char *tagp);
+         double nextafter(double x, double y);
+         float nextafterf(float x, float y);
+         long double nextafterl(long double x, long double y);
+         double nexttoward(double x, long double y);
+         float nexttowardf(float x, long double y);
+         long double nexttowardl(long double x, long double y);
+         double fdim(double x, double y);
+         float fdimf(float x, float y);
+         long double fdiml(long double x, long double y);
+         double fmax(double x, double y);
+         float fmaxf(float x, float y);
+         long double fmaxl(long double x, long double y);
+         double fmin(double x, double y);
+         float fminf(float x, float y);
+         long double fminl(long double x, long double y);
+         double fma(double x, double y, double z);
+         float fmaf(float x, float y, float z);
+       long double fmal(long double x, long double y,
+            long double z);
+       int isgreater(real-floating x, real-floating y);
+       int isgreaterequal(real-floating x, real-floating y);
+       int isless(real-floating x, real-floating y);
+       int islessequal(real-floating x, real-floating y);
+       int islessgreater(real-floating x, real-floating y);
+       int isunordered(real-floating x, real-floating y);</pre>
+
+<a name="B.12" href="#B.12"><h3>B.12 Nonlocal jumps <setjmp.h></h3></a>
+<pre>
+       jmp_buf
+       int setjmp(jmp_buf env);
+       void longjmp(jmp_buf env, int val);</pre>
+
+<a name="B.13" href="#B.13"><h3>B.13 Signal handling <signal.h></h3></a>
+<pre>
+       sig_atomic_t   SIG_IGN            SIGILL            SIGTERM
+       SIG_DFL        SIGABRT            SIGINT
+       SIG_ERR        SIGFPE             SIGSEGV
+       void (*signal(int sig, void (*func)(int)))(int);
+       int raise(int sig);</pre>
+
+<a name="B.14" href="#B.14"><h3>B.14 Variable arguments <stdarg.h></h3></a>
+<pre>
+       va_list
+       type va_arg(va_list ap, type);
+       void va_copy(va_list dest, va_list src);
+       void va_end(va_list ap);
+       void va_start(va_list ap, parmN);</pre>
+
+<a name="B.15" href="#B.15"><h3>B.15 Boolean type and values <stdbool.h></h3></a>
+<!--page 441 indent 0-->
+<pre>
+       bool
+       true
+       false
+       __bool_true_false_are_defined</pre>
+
+<a name="B.16" href="#B.16"><h3>B.16 Common definitions <stddef.h></h3></a>
+<pre>
+         ptrdiff_t       size_t            wchar_t           NULL
+         offsetof(type, member-designator)</pre>
+
+<a name="B.17" href="#B.17"><h3>B.17 Integer types <stdint.h></h3></a>
+<pre>
+         intN_t                INT_LEASTN_MIN          PTRDIFF_MAX
+         uintN_t               INT_LEASTN_MAX          SIG_ATOMIC_MIN
+         int_leastN_t          UINT_LEASTN_MAX         SIG_ATOMIC_MAX
+         uint_leastN_t         INT_FASTN_MIN           SIZE_MAX
+         int_fastN_t           INT_FASTN_MAX           WCHAR_MIN
+         uint_fastN_t          UINT_FASTN_MAX          WCHAR_MAX
+         intptr_t              INTPTR_MIN              WINT_MIN
+         uintptr_t             INTPTR_MAX              WINT_MAX
+         intmax_t              UINTPTR_MAX             INTN_C(value)
+         uintmax_t             INTMAX_MIN              UINTN_C(value)
+         INTN_MIN              INTMAX_MAX              INTMAX_C(value)
+         INTN_MAX              UINTMAX_MAX             UINTMAX_C(value)
+         UINTN_MAX             PTRDIFF_MIN</pre>
+
+<a name="B.18" href="#B.18"><h3>B.18 Input/output <stdio.h></h3></a>
+<!--page 442 indent -1-->
+<!--page 443 indent 0-->
+<pre>
+         size_t          _IOLBF            FILENAME_MAX      TMP_MAX
+         FILE            _IONBF            L_tmpnam          stderr
+         fpos_t          BUFSIZ            SEEK_CUR          stdin
+         NULL            EOF               SEEK_END          stdout
+         _IOFBF          FOPEN_MAX         SEEK_SET
+         int remove(const char *filename);
+         int rename(const char *old, const char *new);
+         FILE *tmpfile(void);
+         char *tmpnam(char *s);
+         int fclose(FILE *stream);
+         int fflush(FILE *stream);
+         FILE *fopen(const char * restrict filename,
+              const char * restrict mode);
+         FILE *freopen(const char * restrict filename,
+              const char * restrict mode,
+              FILE * restrict stream);
+         void setbuf(FILE * restrict stream,
+              char * restrict buf);
+       int setvbuf(FILE * restrict stream,
+            char * restrict buf,
+            int mode, size_t size);
+       int fprintf(FILE * restrict stream,
+            const char * restrict format, ...);
+       int fscanf(FILE * restrict stream,
+            const char * restrict format, ...);
+       int printf(const char * restrict format, ...);
+       int scanf(const char * restrict format, ...);
+       int snprintf(char * restrict s, size_t n,
+            const char * restrict format, ...);
+       int sprintf(char * restrict s,
+            const char * restrict format, ...);
+       int sscanf(const char * restrict s,
+            const char * restrict format, ...);
+       int vfprintf(FILE * restrict stream,
+            const char * restrict format, va_list arg);
+       int vfscanf(FILE * restrict stream,
+            const char * restrict format, va_list arg);
+       int vprintf(const char * restrict format, va_list arg);
+       int vscanf(const char * restrict format, va_list arg);
+       int vsnprintf(char * restrict s, size_t n,
+            const char * restrict format, va_list arg);
+       int vsprintf(char * restrict s,
+            const char * restrict format, va_list arg);
+       int vsscanf(const char * restrict s,
+            const char * restrict format, va_list arg);
+       int fgetc(FILE *stream);
+       char *fgets(char * restrict s, int n,
+            FILE * restrict stream);
+       int fputc(int c, FILE *stream);
+       int fputs(const char * restrict s,
+            FILE * restrict stream);
+       int getc(FILE *stream);
+       int getchar(void);
+       char *gets(char *s);
+       int putc(int c, FILE *stream);
+       int putchar(int c);
+       int puts(const char *s);
+       int ungetc(int c, FILE *stream);
+         size_t fread(void * restrict ptr,
+              size_t size, size_t nmemb,
+              FILE * restrict stream);
+         size_t fwrite(const void * restrict ptr,
+              size_t size, size_t nmemb,
+              FILE * restrict stream);
+         int fgetpos(FILE * restrict stream,
+              fpos_t * restrict pos);
+         int fseek(FILE *stream, long int offset, int whence);
+         int fsetpos(FILE *stream, const fpos_t *pos);
+         long int ftell(FILE *stream);
+         void rewind(FILE *stream);
+         void clearerr(FILE *stream);
+         int feof(FILE *stream);
+         int ferror(FILE *stream);
+         void perror(const char *s);</pre>
+
+<a name="B.19" href="#B.19"><h3>B.19 General utilities <stdlib.h></h3></a>
+<!--page 444 indent -1-->
+<!--page 445 indent 0-->
+<pre>
+         size_t       ldiv_t             EXIT_FAILURE      MB_CUR_MAX
+         wchar_t      lldiv_t            EXIT_SUCCESS
+         div_t        NULL               RAND_MAX
+         double atof(const char *nptr);
+         int atoi(const char *nptr);
+         long int atol(const char *nptr);
+         long long int atoll(const char *nptr);
+         double strtod(const char * restrict nptr,
+              char ** restrict endptr);
+         float strtof(const char * restrict nptr,
+              char ** restrict endptr);
+         long double strtold(const char * restrict nptr,
+              char ** restrict endptr);
+         long int strtol(const char * restrict nptr,
+              char ** restrict endptr, int base);
+         long long int strtoll(const char * restrict nptr,
+              char ** restrict endptr, int base);
+         unsigned long int strtoul(
+              const char * restrict nptr,
+              char ** restrict endptr, int base);
+       unsigned long long int strtoull(
+            const char * restrict nptr,
+            char ** restrict endptr, int base);
+       int rand(void);
+       void srand(unsigned int seed);
+       void *calloc(size_t nmemb, size_t size);
+       void free(void *ptr);
+       void *malloc(size_t size);
+       void *realloc(void *ptr, size_t size);
+       void abort(void);
+       int atexit(void (*func)(void));
+       void exit(int status);
+       void _Exit(int status);
+       char *getenv(const char *name);
+       int system(const char *string);
+       void *bsearch(const void *key, const void *base,
+            size_t nmemb, size_t size,
+            int (*compar)(const void *, const void *));
+       void qsort(void *base, size_t nmemb, size_t size,
+            int (*compar)(const void *, const void *));
+       int abs(int j);
+       long int labs(long int j);
+       long long int llabs(long long int j);
+       div_t div(int numer, int denom);
+       ldiv_t ldiv(long int numer, long int denom);
+       lldiv_t lldiv(long long int numer,
+            long long int denom);
+       int mblen(const char *s, size_t n);
+       int mbtowc(wchar_t * restrict pwc,
+            const char * restrict s, size_t n);
+       int wctomb(char *s, wchar_t wchar);
+       size_t mbstowcs(wchar_t * restrict pwcs,
+            const char * restrict s, size_t n);
+       size_t wcstombs(char * restrict s,
+            const wchar_t * restrict pwcs, size_t n);</pre>
+
+<a name="B.20" href="#B.20"><h3>B.20 String handling <string.h></h3></a>
+<!--page 446 indent 0-->
+<pre>
+         size_t
+         NULL
+         void *memcpy(void * restrict s1,
+              const void * restrict s2, size_t n);
+         void *memmove(void *s1, const void *s2, size_t n);
+         char *strcpy(char * restrict s1,
+              const char * restrict s2);
+         char *strncpy(char * restrict s1,
+              const char * restrict s2, size_t n);
+         char *strcat(char * restrict s1,
+              const char * restrict s2);
+         char *strncat(char * restrict s1,
+              const char * restrict s2, size_t n);
+         int memcmp(const void *s1, const void *s2, size_t n);
+         int strcmp(const char *s1, const char *s2);
+         int strcoll(const char *s1, const char *s2);
+         int strncmp(const char *s1, const char *s2, size_t n);
+         size_t strxfrm(char * restrict s1,
+              const char * restrict s2, size_t n);
+         void *memchr(const void *s, int c, size_t n);
+         char *strchr(const char *s, int c);
+         size_t strcspn(const char *s1, const char *s2);
+         char *strpbrk(const char *s1, const char *s2);
+         char *strrchr(const char *s, int c);
+         size_t strspn(const char *s1, const char *s2);
+         char *strstr(const char *s1, const char *s2);
+         char *strtok(char * restrict s1,
+              const char * restrict s2);
+         void *memset(void *s, int c, size_t n);
+         char *strerror(int errnum);
+         size_t strlen(const char *s);</pre>
+
+<a name="B.21" href="#B.21"><h3>B.21 Type-generic math <tgmath.h></h3></a>
+<pre>
+       acos           sqrt               fmod              nextafter
+       asin           fabs               frexp             nexttoward
+       atan           atan2              hypot             remainder
+       acosh          cbrt               ilogb             remquo
+       asinh          ceil               ldexp             rint
+       atanh          copysign           lgamma            round
+       cos            erf                llrint            scalbn
+       sin            erfc               llround           scalbln
+       tan            exp2               log10             tgamma
+       cosh           expm1              log1p             trunc
+       sinh           fdim               log2              carg
+       tanh           floor              logb              cimag
+       exp            fma                lrint             conj
+       log            fmax               lround            cproj
+       pow            fmin               nearbyint         creal</pre>
+
+<a name="B.22" href="#B.22"><h3>B.22 Date and time <time.h></h3></a>
+<!--page 447 indent 0-->
+<pre>
+       NULL                  size_t                  time_t
+       CLOCKS_PER_SEC        clock_t                 struct tm
+       clock_t clock(void);
+       double difftime(time_t time1, time_t time0);
+       time_t mktime(struct tm *timeptr);
+       time_t time(time_t *timer);
+       char *asctime(const struct tm *timeptr);
+       char *ctime(const time_t *timer);
+       struct tm *gmtime(const time_t *timer);
+       struct tm *localtime(const time_t *timer);
+       size_t strftime(char * restrict s,
+            size_t maxsize,
+            const char * restrict format,
+            const struct tm * restrict timeptr);</pre>
+
+<a name="B.23" href="#B.23"><h3>B.23 Extended multibyte/wide character utilities <wchar.h></h3></a>
+<!--page 448 indent -1-->
+<!--page 449 indent 0-->
+<pre>
+         wchar_t       wint_t             WCHAR_MAX
+         size_t        struct tm          WCHAR_MIN
+         mbstate_t     NULL               WEOF
+         int fwprintf(FILE * restrict stream,
+              const wchar_t * restrict format, ...);
+         int fwscanf(FILE * restrict stream,
+              const wchar_t * restrict format, ...);
+         int swprintf(wchar_t * restrict s, size_t n,
+              const wchar_t * restrict format, ...);
+         int swscanf(const wchar_t * restrict s,
+              const wchar_t * restrict format, ...);
+         int vfwprintf(FILE * restrict stream,
+              const wchar_t * restrict format, va_list arg);
+         int vfwscanf(FILE * restrict stream,
+              const wchar_t * restrict format, va_list arg);
+         int vswprintf(wchar_t * restrict s, size_t n,
+              const wchar_t * restrict format, va_list arg);
+         int vswscanf(const wchar_t * restrict s,
+              const wchar_t * restrict format, va_list arg);
+         int vwprintf(const wchar_t * restrict format,
+              va_list arg);
+         int vwscanf(const wchar_t * restrict format,
+              va_list arg);
+         int wprintf(const wchar_t * restrict format, ...);
+         int wscanf(const wchar_t * restrict format, ...);
+         wint_t fgetwc(FILE *stream);
+         wchar_t *fgetws(wchar_t * restrict s, int n,
+              FILE * restrict stream);
+         wint_t fputwc(wchar_t c, FILE *stream);
+         int fputws(const wchar_t * restrict s,
+              FILE * restrict stream);
+         int fwide(FILE *stream, int mode);
+         wint_t getwc(FILE *stream);
+         wint_t getwchar(void);
+         wint_t putwc(wchar_t c, FILE *stream);
+         wint_t putwchar(wchar_t c);
+         wint_t ungetwc(wint_t c, FILE *stream);
+       double wcstod(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr);
+       float wcstof(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr);
+       long double wcstold(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr);
+       long int wcstol(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       long long int wcstoll(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       unsigned long int wcstoul(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       unsigned long long int wcstoull(
+            const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       wchar_t *wcscpy(wchar_t * restrict s1,
+            const wchar_t * restrict s2);
+       wchar_t *wcsncpy(wchar_t * restrict s1,
+            const wchar_t * restrict s2, size_t n);
+       wchar_t *wmemcpy(wchar_t * restrict s1,
+            const wchar_t * restrict s2, size_t n);
+       wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+            size_t n);
+       wchar_t *wcscat(wchar_t * restrict s1,
+            const wchar_t * restrict s2);
+       wchar_t *wcsncat(wchar_t * restrict s1,
+            const wchar_t * restrict s2, size_t n);
+       int wcscmp(const wchar_t *s1, const wchar_t *s2);
+       int wcscoll(const wchar_t *s1, const wchar_t *s2);
+       int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+            size_t n);
+       size_t wcsxfrm(wchar_t * restrict s1,
+            const wchar_t * restrict s2, size_t n);
+       int wmemcmp(const wchar_t *s1, const wchar_t *s2,
+            size_t n);
+       wchar_t *wcschr(const wchar_t *s, wchar_t c);
+       size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
+       wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2); *
+       wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
+       size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
+       wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
+         wchar_t *wcstok(wchar_t * restrict s1,
+              const wchar_t * restrict s2,
+              wchar_t ** restrict ptr);
+         wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
+         size_t wcslen(const wchar_t *s);
+         wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
+         size_t wcsftime(wchar_t * restrict s, size_t maxsize,
+              const wchar_t * restrict format,
+              const struct tm * restrict timeptr);
+         wint_t btowc(int c);
+         int wctob(wint_t c);
+         int mbsinit(const mbstate_t *ps);
+         size_t mbrlen(const char * restrict s, size_t n,
+              mbstate_t * restrict ps);
+         size_t mbrtowc(wchar_t * restrict pwc,
+              const char * restrict s, size_t n,
+              mbstate_t * restrict ps);
+         size_t wcrtomb(char * restrict s, wchar_t wc,
+              mbstate_t * restrict ps);
+         size_t mbsrtowcs(wchar_t * restrict dst,
+              const char ** restrict src, size_t len,
+              mbstate_t * restrict ps);
+         size_t wcsrtombs(char * restrict dst,
+              const wchar_t ** restrict src, size_t len,
+              mbstate_t * restrict ps);</pre>
+
+<a name="B.24" href="#B.24"><h3>B.24 Wide character classification and mapping utilities <wctype.h></h3></a>
+<!--page 450 indent -1-->
+<!--page 451 indent 4-->
+<pre>
+         wint_t         wctrans_t          wctype_t          WEOF
+         int   iswalnum(wint_t wc);
+         int   iswalpha(wint_t wc);
+         int   iswblank(wint_t wc);
+         int   iswcntrl(wint_t wc);
+         int   iswdigit(wint_t wc);
+         int   iswgraph(wint_t wc);
+         int   iswlower(wint_t wc);
+         int   iswprint(wint_t wc);
+         int   iswpunct(wint_t wc);
+         int   iswspace(wint_t wc);
+         int   iswupper(wint_t wc);
+         int   iswxdigit(wint_t wc);
+         int   iswctype(wint_t wc, wctype_t desc);
+       wctype_t wctype(const char *property);
+       wint_t towlower(wint_t wc);
+       wint_t towupper(wint_t wc);
+       wint_t towctrans(wint_t wc, wctrans_t desc);
+       wctrans_t wctrans(const char *property);</pre>
+
+<a name="C" href="#C"><h2>Annex C</h2></a>
+<p><!--para 1-->
+<pre>
+                                     (informative)
+                                   Sequence points</pre>
+ The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
+<ul>
+<li>  The call to a function, after the arguments have been evaluated (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  The end of the first operand of the following operators: logical AND &amp;&amp; (<a href="#6.5.13">6.5.13</a>);
+ logical OR || (<a href="#6.5.14">6.5.14</a>); conditional ? (<a href="#6.5.15">6.5.15</a>); comma , (<a href="#6.5.17">6.5.17</a>).
+<li>  The end of a full declarator: declarators (<a href="#6.7.5">6.7.5</a>);
+<li>  The end of a full expression: an initializer (<a href="#6.7.8">6.7.8</a>); the expression in an expression
+ statement (<a href="#6.8.3">6.8.3</a>); the controlling expression of a selection statement (if or switch)
+ (<a href="#6.8.4">6.8.4</a>); the controlling expression of a while or do statement (<a href="#6.8.5">6.8.5</a>); each of the
+ expressions of a for statement (<a href="#6.8.5.3">6.8.5.3</a>); the expression in a return statement
+ (<a href="#6.8.6.4">6.8.6.4</a>).
+<li>  Immediately before a library function returns (<a href="#7.1.4">7.1.4</a>).
+<li>  After the actions associated with each formatted input/output function conversion
+ specifier (<a href="#7.19.6">7.19.6</a>, <a href="#7.24.2">7.24.2</a>).
+<li>  Immediately before and immediately after each call to a comparison function, and
+ also between any call to a comparison function and any movement of the objects
+ passed as arguments to that call (<a href="#7.20.5">7.20.5</a>).
+<!--page 452 indent 4-->
+</ul>
+
+<a name="D" href="#D"><h2>Annex D</h2></a>
+<p><!--para 1-->
+<pre>
+                                     (normative)
+                Universal character names for identifiers</pre>
+ This clause lists the hexadecimal code values that are valid in universal character names
+ in identifiers.
+<p><!--para 2-->
+ This table is reproduced unchanged from ISO/IEC TR 10176:1998, produced by ISO/IEC
+ JTC 1/SC 22/WG 20, except for the omission of ranges that are part of the basic character
+ sets.
+ Latin:            00AA, 00BA, 00C0-00D6, 00D8-00F6, 00F8-01F5, 01FA-0217,
+<pre>
+                   0250-02A8, 1E00-1E9B, 1EA0-1EF9, 207F</pre>
+ Greek:            0386, 0388-038A, 038C, 038E-03A1, 03A3-03CE, 03D0-03D6,
+<pre>
+                   03DA, 03DC, 03DE, 03E0, 03E2-03F3, 1F00-1F15, 1F18-1F1D,
+                   1F20-1F45, 1F48-1F4D, 1F50-1F57, 1F59, 1F5B, 1F5D,
+                   1F5F-1F7D, 1F80-1FB4, 1FB6-1FBC, 1FC2-1FC4, 1FC6-1FCC,
+                   1FD0-1FD3, 1FD6-1FDB, 1FE0-1FEC, 1FF2-1FF4, 1FF6-1FFC</pre>
+ Cyrillic:         0401-040C, 040E-044F, 0451-045C, 045E-0481, 0490-04C4,
+<pre>
+                   04C7-04C8, 04CB-04CC, 04D0-04EB, 04EE-04F5, 04F8-04F9</pre>
+ Armenian:         0531-0556, 0561-0587
+ Hebrew:           05B0-05B9,      05BB-05BD,       05BF,   05C1-05C2,      05D0-05EA,
+<pre>
+                   05F0-05F2</pre>
+ Arabic:           0621-063A, 0640-0652, 0670-06B7, 06BA-06BE, 06C0-06CE,
+<pre>
+                   06D0-06DC, 06E5-06E8, 06EA-06ED</pre>
+ Devanagari:       0901-0903, 0905-0939, 093E-094D, 0950-0952, 0958-0963
+ Bengali:          0981-0983, 0985-098C, 098F-0990, 0993-09A8, 09AA-09B0,
+<pre>
+                   09B2, 09B6-09B9, 09BE-09C4, 09C7-09C8, 09CB-09CD,
+                   09DC-09DD, 09DF-09E3, 09F0-09F1</pre>
+ Gurmukhi:         0A02, 0A05-0A0A, 0A0F-0A10, 0A13-0A28, 0A2A-0A30,
+<pre>
+                   0A32-0A33, 0A35-0A36, 0A38-0A39, 0A3E-0A42, 0A47-0A48,
+                   0A4B-0A4D, 0A59-0A5C, 0A5E, 0A74</pre>
+ Gujarati:         0A81-0A83, 0A85-0A8B, 0A8D, 0A8F-0A91, 0A93-0AA8,
+<pre>
+                   0AAA-0AB0,    0AB2-0AB3,     0AB5-0AB9, 0ABD-0AC5,
+                   0AC7-0AC9, 0ACB-0ACD, 0AD0, 0AE0</pre>
+ Oriya:            0B01-0B03, 0B05-0B0C, 0B0F-0B10, 0B13-0B28, 0B2A-0B30,
+<!--page 453 indent 0-->
+<pre>
+                   0B32-0B33, 0B36-0B39, 0B3E-0B43, 0B47-0B48, 0B4B-0B4D,
+                 0B5C-0B5D, 0B5F-0B61</pre>
+ Tamil:          0B82-0B83, 0B85-0B8A, 0B8E-0B90, 0B92-0B95, 0B99-0B9A,
+<pre>
+                 0B9C, 0B9E-0B9F, 0BA3-0BA4, 0BA8-0BAA, 0BAE-0BB5,
+                 0BB7-0BB9, 0BBE-0BC2, 0BC6-0BC8, 0BCA-0BCD</pre>
+ Telugu:         0C01-0C03, 0C05-0C0C, 0C0E-0C10, 0C12-0C28, 0C2A-0C33,
+<pre>
+                 0C35-0C39, 0C3E-0C44, 0C46-0C48, 0C4A-0C4D, 0C60-0C61</pre>
+ Kannada:        0C82-0C83, 0C85-0C8C, 0C8E-0C90, 0C92-0CA8, 0CAA-0CB3,
+<pre>
+                 0CB5-0CB9, 0CBE-0CC4, 0CC6-0CC8, 0CCA-0CCD, 0CDE,
+                 0CE0-0CE1</pre>
+ Malayalam:      0D02-0D03, 0D05-0D0C, 0D0E-0D10, 0D12-0D28, 0D2A-0D39,
+<pre>
+                 0D3E-0D43, 0D46-0D48, 0D4A-0D4D, 0D60-0D61</pre>
+ Thai:           0E01-0E3A, 0E40-0E5B
+ Lao:            0E81-0E82, 0E84, 0E87-0E88, 0E8A, 0E8D, 0E94-0E97,
+<pre>
+                 0E99-0E9F,   0EA1-0EA3,  0EA5,  0EA7,  0EAA-0EAB,
+                 0EAD-0EAE, 0EB0-0EB9, 0EBB-0EBD, 0EC0-0EC4, 0EC6,
+                 0EC8-0ECD, 0EDC-0EDD</pre>
+ Tibetan:        0F00, 0F18-0F19, 0F35, 0F37, 0F39, 0F3E-0F47, 0F49-0F69,
+<pre>
+                 0F71-0F84, 0F86-0F8B, 0F90-0F95, 0F97, 0F99-0FAD,
+                 0FB1-0FB7, 0FB9</pre>
+ Georgian:       10A0-10C5, 10D0-10F6
+ Hiragana:       3041-3093, 309B-309C
+ Katakana:       30A1-30F6, 30FB-30FC
+ Bopomofo:       3105-312C
+ CJK Unified Ideographs: 4E00-9FA5
+ Hangul:         AC00-D7A3
+ Digits:         0660-0669, 06F0-06F9, 0966-096F, 09E6-09EF, 0A66-0A6F,
+<pre>
+                 0AE6-0AEF, 0B66-0B6F, 0BE7-0BEF, 0C66-0C6F, 0CE6-0CEF,
+                 0D66-0D6F, 0E50-0E59, 0ED0-0ED9, 0F20-0F33</pre>
+ Special characters: 00B5, 00B7, 02B0-02B8, 02BB, 02BD-02C1, 02D0-02D1,
+<!--page 454 indent 4-->
+<pre>
+                    02E0-02E4, 037A, 0559, 093D, 0B3D, 1FBE, 203F-2040, 2102,
+                    2107, 210A-2113, 2115, 2118-211D, 2124, 2126, 2128, 212A-2131,
+                    2133-2138, 2160-2182, 3005-3007, 3021-3029</pre>
+
+<a name="E" href="#E"><h2>Annex E</h2></a>
+<p><!--para 1-->
+<pre>
+                                    (informative)
+                             Implementation limits</pre>
+ The contents of the header &lt;limits.h&gt; are given below, in alphabetical order. The
+ minimum magnitudes shown shall be replaced by implementation-defined magnitudes
+ with the same sign. The values shall all be constant expressions suitable for use in #if
+ preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+<p><!--para 2-->
+<pre>
+        #define     CHAR_BIT                               8
+        #define     CHAR_MAX          UCHAR_MAX or SCHAR_MAX
+        #define     CHAR_MIN                  0 or SCHAR_MIN
+        #define     INT_MAX                           +32767
+        #define     INT_MIN                           -32767
+        #define     LONG_MAX                     +2147483647
+        #define     LONG_MIN                     -2147483647
+        #define     LLONG_MAX           +9223372036854775807
+        #define     LLONG_MIN           -9223372036854775807
+        #define     MB_LEN_MAX                             1
+        #define     SCHAR_MAX                           +127
+        #define     SCHAR_MIN                           -127
+        #define     SHRT_MAX                          +32767
+        #define     SHRT_MIN                          -32767
+        #define     UCHAR_MAX                            255
+        #define     USHRT_MAX                          65535
+        #define     UINT_MAX                           65535
+        #define     ULONG_MAX                     4294967295
+        #define     ULLONG_MAX          18446744073709551615</pre>
+ The contents of the header &lt;float.h&gt; are given below. All integer values, except
+ FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
+ directives; all floating values shall be constant expressions. The components are
+ described further in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+<p><!--para 3-->
+ The values given in the following list shall be replaced by implementation-defined
+ expressions:
+<p><!--para 4-->
+<pre>
+        #define FLT_EVAL_METHOD
+        #define FLT_ROUNDS</pre>
+ The values given in the following list shall be replaced by implementation-defined
+ constant expressions that are greater or equal in magnitude (absolute value) to those
+ shown, with the same sign:
+<!--page 455 indent 4-->
+<p><!--para 5-->
+<pre>
+        #define    DBL_DIG                                        10
+        #define    DBL_MANT_DIG
+        #define    DBL_MAX_10_EXP                               +37
+        #define    DBL_MAX_EXP
+        #define    DBL_MIN_10_EXP                               -37
+        #define    DBL_MIN_EXP
+        #define    DECIMAL_DIG                                    10
+        #define    FLT_DIG                                         6
+        #define    FLT_MANT_DIG
+        #define    FLT_MAX_10_EXP                               +37
+        #define    FLT_MAX_EXP
+        #define    FLT_MIN_10_EXP                               -37
+        #define    FLT_MIN_EXP
+        #define    FLT_RADIX                                       2
+        #define    LDBL_DIG                                       10
+        #define    LDBL_MANT_DIG
+        #define    LDBL_MAX_10_EXP                              +37
+        #define    LDBL_MAX_EXP
+        #define    LDBL_MIN_10_EXP                              -37
+        #define    LDBL_MIN_EXP</pre>
+ The values given in the following list shall be replaced by implementation-defined
+ constant expressions with values that are greater than or equal to those shown:
+<p><!--para 6-->
+<pre>
+        #define DBL_MAX                                      1E+37
+        #define FLT_MAX                                      1E+37
+        #define LDBL_MAX                                     1E+37</pre>
+ The values given in the following list shall be replaced by implementation-defined
+ constant expressions with (positive) values that are less than or equal to those shown:
+<!--page 456 indent 4-->
+<pre>
+        #define    DBL_EPSILON                                1E-9
+        #define    DBL_MIN                                   1E-37
+        #define    FLT_EPSILON                                1E-5
+        #define    FLT_MIN                                   1E-37
+        #define    LDBL_EPSILON                               1E-9
+        #define    LDBL_MIN                                  1E-37</pre>
+
+<a name="F" href="#F"><h2>Annex F</h2></a>
+<pre>
+                                           (normative)
+                       IEC 60559 floating-point arithmetic</pre>
+
+<a name="F.1" href="#F.1"><h3>F.1 Introduction</h3></a>
+<p><!--para 1-->
+ This annex specifies C language support for the IEC 60559 floating-point standard. The
+ IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for
+ microprocessor systems, second edition (IEC 60559:1989), previously designated
+ IEC 559:1989 and as IEEE Standard for Binary Floating-Point Arithmetic
+ (ANSI/IEEE 754-1985). IEEE Standard for Radix-Independent Floating-Point
+ Arithmetic (ANSI/IEEE 854-1987) generalizes the binary standard to remove
+ dependencies on radix and word length. IEC 60559 generally refers to the floating-point
+ standard, as in IEC 60559 operation, IEC 60559 format, etc. An implementation that
+ defines __STDC_IEC_559__ shall conform to the specifications in this annex. Where
+ a binding between the C language and IEC 60559 is indicated, the IEC 60559-specified
+ behavior is adopted by reference, unless stated otherwise.
+
+<a name="F.2" href="#F.2"><h3>F.2 Types</h3></a>
+<p><!--para 1-->
+ The C floating types match the IEC 60559 formats as follows:
+<ul>
+<li>  The float type matches the IEC 60559 single format.
+<li>  The double type matches the IEC 60559 double format.
+<li>  The long double type matches an IEC 60559 extended format,<sup><a href="#note307"><b>307)</b></a></sup> else a
+ non-IEC 60559 extended format, else the IEC 60559 double format.
+</ul>
+ Any non-IEC 60559 extended format used for the long double type shall have more
+ precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note308"><b>308)</b></a></sup>
+ Recommended practice
+<p><!--para 2-->
+ The long double type should match an IEC 60559 extended format.
+ 
+ 
+ 
+ 
+<!--page 457 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note307">307)</a> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
+ and quadruple 128-bit IEC 60559 formats.
+
+<p><a name="note308">308)</a> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
+ all double values.
+
+
+<a name="F.2.1" href="#F.2.1"><h4>F.2.1 Infinities, signed zeros, and NaNs</h4></a>
+<p><!--para 1-->
+ This specification does not define the behavior of signaling NaNs.<sup><a href="#note309"><b>309)</b></a></sup> It generally uses
+ the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
+ functions in &lt;math.h&gt; provide designations for IEC 60559 NaNs and infinities.
+
+<h6>footnotes</h6>
+<p><a name="note309">309)</a> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
+ sufficient for closure of the arithmetic.
+
+
+<a name="F.3" href="#F.3"><h3>F.3 Operators and functions</h3></a>
+<p><!--para 1-->
+ C operators and functions provide IEC 60559 required and recommended facilities as
+ listed below.
+<ul>
+<li>  The +, -, *, and / operators provide the IEC 60559 add, subtract, multiply, and
+ divide operations.
+<li>  The sqrt functions in &lt;math.h&gt; provide the IEC 60559 square root operation.
+<li>  The remainder functions in &lt;math.h&gt; provide the IEC 60559 remainder
+ operation. The remquo functions in &lt;math.h&gt; provide the same operation but
+ with additional information.
+<li>  The rint functions in &lt;math.h&gt; provide the IEC 60559 operation that rounds a
+ floating-point number to an integer value (in the same precision). The nearbyint
+ functions in &lt;math.h&gt; provide the nearbyinteger function recommended in the
+ Appendix to ANSI/IEEE 854.
+<li>  The conversions for floating types provide the IEC 60559 conversions between
+ floating-point precisions.
+<li>  The conversions from integer to floating types provide the IEC 60559 conversions
+ from integer to floating point.
+<li>  The conversions from floating to integer types provide IEC 60559-like conversions
+ but always round toward zero.
+<li>  The lrint and llrint functions in &lt;math.h&gt; provide the IEC 60559
+ conversions, which honor the directed rounding mode, from floating point to the
+ long int and long long int integer formats. The lrint and llrint
+ functions can be used to implement IEC 60559 conversions from floating to other
+ integer formats.
+<li>  The translation time conversion of floating constants and the strtod, strtof,
+ strtold, fprintf, fscanf, and related library functions in &lt;stdlib.h&gt;,
+ &lt;stdio.h&gt;, and &lt;wchar.h&gt; provide IEC 60559 binary-decimal conversions. The
+ strtold function in &lt;stdlib.h&gt; provides the conv function recommended in the
+ Appendix to ANSI/IEEE 854.
+ 
+<!--page 458 indent 0-->
+<li>  The relational and equality operators provide IEC 60559 comparisons. IEC 60559
+ identifies a need for additional comparison predicates to facilitate writing code that
+ accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
+ isless, islessequal, islessgreater, and isunordered) in &lt;math.h&gt;
+ supplement the language operators to address this need. The islessgreater and
+ isunordered macros provide respectively a quiet version of the &lt;&gt; predicate and
+ the unordered predicate recommended in the Appendix to IEC 60559.
+<li>  The feclearexcept, feraiseexcept, and fetestexcept functions in
+ &lt;fenv.h&gt; provide the facility to test and alter the IEC 60559 floating-point
+ exception status flags. The fegetexceptflag and fesetexceptflag
+ functions in &lt;fenv.h&gt; provide the facility to save and restore all five status flags at
+ one time. These functions are used in conjunction with the type fexcept_t and the
+ floating-point     exception      macros      (FE_INEXACT,         FE_DIVBYZERO,
+ FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in &lt;fenv.h&gt;.
+<li>  The fegetround and fesetround functions in &lt;fenv.h&gt; provide the facility
+ to select among the IEC 60559 directed rounding modes represented by the rounding
+ direction macros in &lt;fenv.h&gt; (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
+ FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the
+ IEC 60559 directed rounding modes.
+<li>  The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
+ &lt;fenv.h&gt; provide a facility to manage the floating-point environment, comprising
+ the IEC 60559 status flags and control modes.
+<li>  The copysign functions in &lt;math.h&gt; provide the copysign function
+ recommended in the Appendix to IEC 60559.
+<li>  The unary minus (-) operator provides the minus (-) operation recommended in the
+ Appendix to IEC 60559.
+<li>  The scalbn and scalbln functions in &lt;math.h&gt; provide the scalb function
+ recommended in the Appendix to IEC 60559.
+<li>  The logb functions in &lt;math.h&gt; provide the logb function recommended in the
+ Appendix to IEC 60559, but following the newer specifications in ANSI/IEEE 854.
+<li>  The nextafter and nexttoward functions in &lt;math.h&gt; provide the nextafter
+ function recommended in the Appendix to IEC 60559 (but with a minor change to
+ better handle signed zeros).
+<li>  The isfinite macro in &lt;math.h&gt; provides the finite function recommended in
+ the Appendix to IEC 60559.
+<li>  The isnan macro in &lt;math.h&gt; provides the isnan function recommended in the
+ Appendix to IEC 60559.
+<!--page 459 indent 4-->
+<li>  The signbit macro and the fpclassify macro in &lt;math.h&gt;, used in
+ conjunction with the number classification macros (FP_NAN, FP_INFINITE,
+ FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
+ function recommended in the Appendix to IEC 60559 (except that the classification
+ macros defined in <a href="#7.12.3">7.12.3</a> do not distinguish signaling from quiet NaNs).
+</ul>
+
+<a name="F.4" href="#F.4"><h3>F.4 Floating to integer conversion</h3></a>
+<p><!--para 1-->
+ If the floating value is infinite or NaN or if the integral part of the floating value exceeds
+ the range of the integer type, then the ''invalid'' floating-point exception is raised and the
+ resulting value is unspecified. Whether conversion of non-integer floating values whose
+ integral part is within the range of the integer type raises the ''inexact'' floating-point
+ exception is unspecified.<sup><a href="#note310"><b>310)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note310">310)</a> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
+ conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
+ cases where it matters, library functions can be used to effect such conversions with or without raising
+ the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
+ &lt;math.h&gt;.
+
+
+<a name="F.5" href="#F.5"><h3>F.5 Binary-decimal conversion</h3></a>
+<p><!--para 1-->
+ Conversion from the widest supported IEC 60559 format to decimal with
+ DECIMAL_DIG digits and back is the identity function.<sup><a href="#note311"><b>311)</b></a></sup>
+<p><!--para 2-->
+ Conversions involving IEC 60559 formats follow all pertinent recommended practice. In
+ particular, conversion between any supported IEC 60559 format and decimal with
+ DECIMAL_DIG or fewer significant digits is correctly rounded (honoring the current
+ rounding mode), which assures that conversion from the widest supported IEC 60559
+ format to decimal with DECIMAL_DIG digits and back is the identity function.
+<p><!--para 3-->
+ Functions such as strtod that convert character sequences to floating types honor the
+ rounding direction. Hence, if the rounding direction might be upward or downward, the
+ implementation cannot convert a minus-signed sequence by negating the converted
+ unsigned sequence.
+ 
+ 
+ 
+ 
+<!--page 460 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note311">311)</a> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
+ DECIMAL_DIG shall be at least 21. If IEC 60559 double (53 bits of precision) is the widest
+ IEC 60559 format supported, then DECIMAL_DIG shall be at least 17. (By contrast, LDBL_DIG and
+ DBL_DIG are 18 and 15, respectively, for these formats.)
+
+
+<a name="F.6" href="#F.6"><h3>F.6 Contracted expressions</h3></a>
+<p><!--para 1-->
+ A contracted expression treats infinities, NaNs, signed zeros, subnormals, and the
+ rounding directions in a manner consistent with the basic arithmetic operations covered
+ by IEC 60559.
+ Recommended practice
+<p><!--para 2-->
+ A contracted expression should raise floating-point exceptions in a manner generally
+ consistent with the basic arithmetic operations. A contracted expression should deliver
+ the same value as its uncontracted counterpart, else should be correctly rounded (once).
+
+<a name="F.7" href="#F.7"><h3>F.7 Floating-point environment</h3></a>
+<p><!--para 1-->
+ The floating-point environment defined in &lt;fenv.h&gt; includes the IEC 60559 floating-
+ point exception status flags and directed-rounding control modes. It includes also
+ IEC 60559 dynamic rounding precision and trap enablement modes, if the
+ implementation supports them.<sup><a href="#note312"><b>312)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note312">312)</a> This specification does not require dynamic rounding precision nor trap enablement modes.
+
+
+<a name="F.7.1" href="#F.7.1"><h4>F.7.1 Environment management</h4></a>
+<p><!--para 1-->
+ IEC 60559 requires that floating-point operations implicitly raise floating-point exception
+ status flags, and that rounding control modes can be set explicitly to affect result values of
+ floating-point operations. When the state for the FENV_ACCESS pragma (defined in
+ &lt;fenv.h&gt;) is ''on'', these changes to the floating-point state are treated as side effects
+ which respect sequence points.<sup><a href="#note313"><b>313)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note313">313)</a> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
+ point control modes will be the default ones and the floating-point status flags will not be tested,
+ which allows certain optimizations (see <a href="#F.8">F.8</a>).
+
+
+<a name="F.7.2" href="#F.7.2"><h4>F.7.2 Translation</h4></a>
+<p><!--para 1-->
+ During translation the IEC 60559 default modes are in effect:
+<ul>
+<li>  The rounding direction mode is rounding to nearest.
+<li>  The rounding precision mode (if supported) is set so that results are not shortened.
+<li>  Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+</ul>
+ Recommended practice
+<p><!--para 2-->
+ The implementation should produce a diagnostic message for each translation-time
+ 
+ 
+ 
+ 
+<!--page 461 indent 4-->
+ floating-point exception, other than ''inexact'';<sup><a href="#note314"><b>314)</b></a></sup> the implementation should then
+ proceed with the translation of the program.
+
+<h6>footnotes</h6>
+<p><a name="note314">314)</a> As floating constants are converted to appropriate internal representations at translation time, their
+ conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
+ (even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
+ strtod, provide execution-time conversion of numeric strings.
+
+
+<a name="F.7.3" href="#F.7.3"><h4>F.7.3 Execution</h4></a>
+<p><!--para 1-->
+ At program startup the floating-point environment is initialized as prescribed by
+ IEC 60559:
+<ul>
+<li>  All floating-point exception status flags are cleared.
+<li>  The rounding direction mode is rounding to nearest.
+<li>  The dynamic rounding precision mode (if supported) is set so that results are not
+ shortened.
+<li>  Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+</ul>
+
+<a name="F.7.4" href="#F.7.4"><h4>F.7.4 Constant expressions</h4></a>
+<p><!--para 1-->
+ An arithmetic constant expression of floating type, other than one in an initializer for an
+ object that has static storage duration, is evaluated (as if) during execution; thus, it is
+ affected by any operative floating-point control modes and raises floating-point
+ exceptions as required by IEC 60559 (provided the state for the FENV_ACCESS pragma
+ is ''on'').<sup><a href="#note315"><b>315)</b></a></sup>
+<p><!--para 2-->
+ EXAMPLE
+<p><!--para 3-->
+<pre>
+          #include &lt;fenv.h&gt;
           #pragma STDC FENV_ACCESS ON
-          double modf(double value, double *iptr)
+          void f(void)
           {
-               int save_round = fegetround();
-               fesetround(FE_TOWARDZERO);
-               *iptr = nearbyint(value);
-               fesetround(save_round);
-               return copysign(
-                    isinf(value) ? 0.0 :
-                         value - (*iptr), value);
-          }
-<a name="F.9.3.13" href="#F.9.3.13"><b>    F.9.3.13 The scalbn and scalbln functions</b></a>
-1   -- scalbn((+-)0, n) returns (+-)0.
-    -- scalbn(x, 0) returns x.
-    -- scalbn((+-)(inf), n) returns (+-)(inf).
-<a name="F.9.4" href="#F.9.4"><b>    F.9.4 Power and absolute value functions</b></a>
-<a name="F.9.4.1" href="#F.9.4.1"><b>    F.9.4.1 The cbrt functions</b></a>
-1   -- cbrt((+-)0) returns (+-)0.
-    -- cbrt((+-)(inf)) returns (+-)(inf).
-<a name="F.9.4.2" href="#F.9.4.2"><b>    F.9.4.2 The fabs functions</b></a>
-1   -- fabs((+-)0) returns +0.
-    -- fabs((+-)(inf)) returns +(inf).
-
-[<a name="p460" href="#p460">page 460</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.4.3" href="#F.9.4.3"><b>    F.9.4.3 The hypot functions</b></a>
-1   -- hypot(x, y), hypot(y, x), and hypot(x, -y) are equivalent.
-    -- hypot(x, (+-)0) is equivalent to fabs(x).
-    -- hypot((+-)(inf), y) returns +(inf), even if y is a NaN.
-<a name="F.9.4.4" href="#F.9.4.4"><b>    F.9.4.4 The pow functions</b></a>
-1   -- pow((+-)0, y) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception
-      for y an odd integer &lt; 0.
-    -- pow((+-)0, y) returns +(inf) and raises the ''divide-by-zero'' floating-point exception
-      for y &lt; 0 and not an odd integer.
-    -- pow((+-)0, y) returns (+-)0 for y an odd integer &gt; 0.
-    -- pow((+-)0, y) returns +0 for y &gt; 0 and not an odd integer.
-    -- pow(-1, (+-)(inf)) returns 1.
-    -- pow(+1, y) returns 1 for any y, even a NaN.
-    -- pow(x, (+-)0) returns 1 for any x, even a NaN.
-    -- pow(x, y) returns a NaN and raises the ''invalid'' floating-point exception for
-      finite x &lt; 0 and finite non-integer y.
-    -- pow(x, -(inf)) returns +(inf) for | x | &lt; 1.
-    -- pow(x, -(inf)) returns +0 for | x | &gt; 1.
-    -- pow(x, +(inf)) returns +0 for | x | &lt; 1.
-    -- pow(x, +(inf)) returns +(inf) for | x | &gt; 1.
-    -- pow(-(inf), y) returns -0 for y an odd integer &lt; 0.
-    -- pow(-(inf), y) returns +0 for y &lt; 0 and not an odd integer.
-    -- pow(-(inf), y) returns -(inf) for y an odd integer &gt; 0.
-    -- pow(-(inf), y) returns +(inf) for y &gt; 0 and not an odd integer.
-    -- pow(+(inf), y) returns +0 for y &lt; 0.
-    -- pow(+(inf), y) returns +(inf) for y &gt; 0.
-
-[<a name="p461" href="#p461">page 461</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.4.5" href="#F.9.4.5"><b>    F.9.4.5 The sqrt functions</b></a>
-1   sqrt is fully specified as a basic arithmetic operation in IEC 60559.
-<a name="F.9.5" href="#F.9.5"><b>    F.9.5 Error and gamma functions</b></a>
-<a name="F.9.5.1" href="#F.9.5.1"><b>    F.9.5.1 The erf functions</b></a>
-1   -- erf((+-)0) returns (+-)0.
-    -- erf((+-)(inf)) returns (+-)1.
-<a name="F.9.5.2" href="#F.9.5.2"><b>    F.9.5.2 The erfc functions</b></a>
-1   -- erfc(-(inf)) returns 2.
-    -- erfc(+(inf)) returns +0.
-<a name="F.9.5.3" href="#F.9.5.3"><b>    F.9.5.3 The lgamma functions</b></a>
-1   -- lgamma(1) returns +0.
-    -- lgamma(2) returns +0.
-    -- lgamma(x) returns +(inf) and raises the ''divide-by-zero'' floating-point exception for
-      x a negative integer or zero.
-    -- lgamma(-(inf)) returns +(inf).
-    -- lgamma(+(inf)) returns +(inf).
-<a name="F.9.5.4" href="#F.9.5.4"><b>    F.9.5.4 The tgamma functions</b></a>
-1   -- tgamma((+-)0) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- tgamma(x) returns a NaN and raises the ''invalid'' floating-point exception for x a
-      negative integer.
-    -- tgamma(-(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-    -- tgamma(+(inf)) returns +(inf).
-<a name="F.9.6" href="#F.9.6"><b>    F.9.6 Nearest integer functions</b></a>
-<a name="F.9.6.1" href="#F.9.6.1"><b>    F.9.6.1 The ceil functions</b></a>
-1   -- ceil((+-)0) returns (+-)0.
-    -- ceil((+-)(inf)) returns (+-)(inf).
-2   The double version of ceil behaves as though implemented by
-
-[<a name="p462" href="#p462">page 462</a>] (<a href="#Contents">Contents</a>)
-
-           #include <a href="#7.12">&lt;math.h&gt;</a>
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           #pragma STDC FENV_ACCESS ON
-           double ceil(double x)
-           {
-                double result;
-                int save_round = fegetround();
-                fesetround(FE_UPWARD);
-                result = rint(x); // or nearbyint instead of rint
-                fesetround(save_round);
-                return result;
-           }
-<a name="F.9.6.2" href="#F.9.6.2"><b>    F.9.6.2 The floor functions</b></a>
-1   -- floor((+-)0) returns (+-)0.
-    -- floor((+-)(inf)) returns (+-)(inf).
-2   See the sample implementation for ceil in <a href="#F.9.6.1">F.9.6.1</a>.
-<a name="F.9.6.3" href="#F.9.6.3"><b>    F.9.6.3 The nearbyint functions</b></a>
-1   The nearbyint functions use IEC 60559 rounding according to the current rounding
-    direction. They do not raise the ''inexact'' floating-point exception if the result differs in
-    value from the argument.
-    -- nearbyint((+-)0) returns (+-)0 (for all rounding directions).
-    -- nearbyint((+-)(inf)) returns (+-)(inf) (for all rounding directions).
-<a name="F.9.6.4" href="#F.9.6.4"><b>    F.9.6.4 The rint functions</b></a>
-1   The rint functions differ from the nearbyint functions only in that they do raise the
-    ''inexact'' floating-point exception if the result differs in value from the argument.
-<a name="F.9.6.5" href="#F.9.6.5"><b>    F.9.6.5 The lrint and llrint functions</b></a>
-1   The lrint and llrint functions provide floating-to-integer conversion as prescribed
-    by IEC 60559. They round according to the current rounding direction. If the rounded
-    value is outside the range of the return type, the numeric result is unspecified and the
-    ''invalid'' floating-point exception is raised. When they raise no other floating-point
-    exception and the result differs from the argument, they raise the ''inexact'' floating-point
-    exception.
-
-[<a name="p463" href="#p463">page 463</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.6.6" href="#F.9.6.6"><b>    F.9.6.6 The round functions</b></a>
-1   -- round((+-)0) returns (+-)0.
-    -- round((+-)(inf)) returns (+-)(inf).
-2   The double version of round behaves as though implemented by
-           #include <a href="#7.12">&lt;math.h&gt;</a>
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           #pragma STDC FENV_ACCESS ON
-           double round(double x)
-           {
-                double result;
-                fenv_t save_env;
-                feholdexcept(&amp;save_env);
-                result = rint(x);
-                if (fetestexcept(FE_INEXACT)) {
-                     fesetround(FE_TOWARDZERO);
-                     result = rint(copysign(0.5 + fabs(x), x));
-                }
-                feupdateenv(&amp;save_env);
-                return result;
-           }
-    The round functions may, but are not required to, raise the ''inexact'' floating-point
-    exception for non-integer numeric arguments, as this implementation does.
-<a name="F.9.6.7" href="#F.9.6.7"><b>    F.9.6.7 The lround and llround functions</b></a>
-1   The lround and llround functions differ from the lrint and llrint functions
-    with the default rounding direction just in that the lround and llround functions
-    round halfway cases away from zero and need not raise the ''inexact'' floating-point
-    exception for non-integer arguments that round to within the range of the return type.
-<a name="F.9.6.8" href="#F.9.6.8"><b>    F.9.6.8 The trunc functions</b></a>
-1   The trunc functions use IEC 60559 rounding toward zero (regardless of the current
-    rounding direction).
-    -- trunc((+-)0) returns (+-)0.
-    -- trunc((+-)(inf)) returns (+-)(inf).
-
-[<a name="p464" href="#p464">page 464</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.7" href="#F.9.7"><b>    F.9.7 Remainder functions</b></a>
-<a name="F.9.7.1" href="#F.9.7.1"><b>    F.9.7.1 The fmod functions</b></a>
-1   -- fmod((+-)0, y) returns (+-)0 for y not zero.
-    -- fmod(x, y) returns a NaN and raises the ''invalid'' floating-point exception for x
-      infinite or y zero.
-    -- fmod(x, (+-)(inf)) returns x for x not infinite.
-2   The double version of fmod behaves as though implemented by
-           #include <a href="#7.12">&lt;math.h&gt;</a>
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           #pragma STDC FENV_ACCESS ON
-           double fmod(double x, double y)
-           {
-                double result;
-                result = remainder(fabs(x), (y = fabs(y)));
-                if (signbit(result)) result += y;
-                return copysign(result, x);
-           }
-<a name="F.9.7.2" href="#F.9.7.2"><b>    F.9.7.2 The remainder functions</b></a>
-1   The remainder functions are fully specified as a basic arithmetic operation in
-    IEC 60559.
-<a name="F.9.7.3" href="#F.9.7.3"><b>    F.9.7.3 The remquo functions</b></a>
-1   The remquo functions follow the specifications for the remainder functions. They
-    have no further specifications special to IEC 60559 implementations.
-<a name="F.9.8" href="#F.9.8"><b>    F.9.8 Manipulation functions</b></a>
-<a name="F.9.8.1" href="#F.9.8.1"><b>    F.9.8.1 The copysign functions</b></a>
-1   copysign is specified in the Appendix to IEC 60559.
-<a name="F.9.8.2" href="#F.9.8.2"><b>    F.9.8.2 The nan functions</b></a>
-1   All IEC 60559 implementations support quiet NaNs, in all floating formats.
-
-[<a name="p465" href="#p465">page 465</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.8.3" href="#F.9.8.3"><b>    F.9.8.3 The nextafter functions</b></a>
-1   -- nextafter(x, y) raises the ''overflow'' and ''inexact'' floating-point exceptions
-      for x finite and the function value infinite.
-    -- nextafter(x, y) raises the ''underflow'' and ''inexact'' floating-point
-      exceptions for the function value subnormal or zero and x != y.
-<a name="F.9.8.4" href="#F.9.8.4"><b>    F.9.8.4 The nexttoward functions</b></a>
-1   No additional requirements beyond those on nextafter.
-<a name="F.9.9" href="#F.9.9"><b>    F.9.9 Maximum, minimum, and positive difference functions</b></a>
-<a name="F.9.9.1" href="#F.9.9.1"><b>    F.9.9.1 The fdim functions</b></a>
-1   No additional requirements.
-<a name="F.9.9.2" href="#F.9.9.2"><b>    F.9.9.2 The fmax functions</b></a>
-1   If just one argument is a NaN, the fmax functions return the other argument (if both
-    arguments are NaNs, the functions return a NaN).
-2   The body of the fmax function might be<sup><a href="#note323"><b>323)</b></a></sup>
-           { return (isgreaterequal(x, y) ||
-                isnan(y)) ? x : y; }
-<a name="F.9.9.3" href="#F.9.9.3"><b>    F.9.9.3 The fmin functions</b></a>
-1   The fmin functions are analogous to the fmax functions (see <a href="#F.9.9.2">F.9.9.2</a>).
-<a name="F.9.10" href="#F.9.10"><b>    F.9.10 Floating multiply-add</b></a>
-<a name="F.9.10.1" href="#F.9.10.1"><b>    F.9.10.1 The fma functions</b></a>
-1   -- fma(x, y, z) computes xy + z, correctly rounded once.
-    -- fma(x, y, z) returns a NaN and optionally raises the ''invalid'' floating-point
-      exception if one of x and y is infinite, the other is zero, and z is a NaN.
-    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if
-      one of x and y is infinite, the other is zero, and z is not a NaN.
-    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if x
-      times y is an exact infinity and z is also an infinity but with the opposite sign.
-
-
-
-
-    <sup><a name="note323" href="#note323"><b>323)</b></a></sup> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
-         return +0; however, implementation in software might be impractical.
-
-[<a name="p466" href="#p466">page 466</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G" href="#G"><b>                                          Annex G</b></a>
-                                        (informative)
-                  IEC 60559-compatible complex arithmetic
-<a name="G.1" href="#G.1"><b>    G.1 Introduction</b></a>
-1   This annex supplements <a href="#F">annex F</a> to specify complex arithmetic for compatibility with
-    IEC 60559 real floating-point arithmetic. Although these specifications have been
-    carefully designed, there is little existing practice to validate the design decisions.
-    Therefore, these specifications are not normative, but should be viewed more as
-    recommended          practice.       An         implementation        that     defines
-    __STDC_IEC_559_COMPLEX__ should conform to the specifications in this annex.
-<a name="G.2" href="#G.2"><b>    G.2 Types</b></a>
-1   There is a new keyword _Imaginary, which is used to specify imaginary types. It is
-    used as a type specifier within declaration specifiers in the same way as _Complex is
-    (thus, _Imaginary float is a valid type name).
-2   There are three imaginary types, designated as float _Imaginary, double
-    _Imaginary, and long double _Imaginary. The imaginary types (along with
-    the real floating and complex types) are floating types.
-3   For imaginary types, the corresponding real type is given by deleting the keyword
-    _Imaginary from the type name.
-4   Each imaginary type has the same representation and alignment requirements as the
-    corresponding real type. The value of an object of imaginary type is the value of the real
-    representation times the imaginary unit.
-5   The imaginary type domain comprises the imaginary types.
-<a name="G.3" href="#G.3"><b>    G.3 Conventions</b></a>
-1   A complex or imaginary value with at least one infinite part is regarded as an infinity
-    (even if its other part is a NaN). A complex or imaginary value is a finite number if each
-    of its parts is a finite number (neither infinite nor NaN). A complex or imaginary value is
-    a zero if each of its parts is a zero.
-
-[<a name="p467" href="#p467">page 467</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.4" href="#G.4"><b>    G.4 Conversions</b></a>
-<a name="G.4.1" href="#G.4.1"><b>    G.4.1 Imaginary types</b></a>
-1   Conversions among imaginary types follow rules analogous to those for real floating
-    types.
-<a name="G.4.2" href="#G.4.2"><b>    G.4.2 Real and imaginary</b></a>
-1   When a value of imaginary type is converted to a real type other than _Bool,<sup><a href="#note324"><b>324)</b></a></sup> the
-    result is a positive zero.
-2   When a value of real type is converted to an imaginary type, the result is a positive
-    imaginary zero.
-<a name="G.4.3" href="#G.4.3"><b>    G.4.3 Imaginary and complex</b></a>
-1   When a value of imaginary type is converted to a complex type, the real part of the
-    complex result value is a positive zero and the imaginary part of the complex result value
-    is determined by the conversion rules for the corresponding real types.
-2   When a value of complex type is converted to an imaginary type, the real part of the
-    complex value is discarded and the value of the imaginary part is converted according to
-    the conversion rules for the corresponding real types.
-<a name="G.5" href="#G.5"><b>    G.5 Binary operators</b></a>
-1   The following subclauses supplement <a href="#6.5">6.5</a> in order to specify the type of the result for an
-    operation with an imaginary operand.
-2   For most operand types, the value of the result of a binary operator with an imaginary or
-    complex operand is completely determined, with reference to real arithmetic, by the usual
-    mathematical formula. For some operand types, the usual mathematical formula is
-    problematic because of its treatment of infinities and because of undue overflow or
-    underflow; in these cases the result satisfies certain properties (specified in <a href="#G.5.1">G.5.1</a>), but is
-    not completely determined.
-
-
-
-
-    <sup><a name="note324" href="#note324"><b>324)</b></a></sup> See <a href="#6.3.1.2">6.3.1.2</a>.
-
-[<a name="p468" href="#p468">page 468</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.5.1" href="#G.5.1"><b>    G.5.1 Multiplicative operators</b></a>
-<b>    Semantics</b>
-1   If one operand has real type and the other operand has imaginary type, then the result has
-    imaginary type. If both operands have imaginary type, then the result has real type. (If
-    either operand has complex type, then the result has complex type.)
-2   If the operands are not both complex, then the result and floating-point exception
-    behavior of the * operator is defined by the usual mathematical formula:
-           *                  u                   iv                 u + iv
-
-           x                  xu                i(xv)            (xu) + i(xv)
-
-           iy               i(yu)                -yv            (-yv) + i(yu)
-
-           x + iy       (xu) + i(yu)        (-yv) + i(xv)
-3   If the second operand is not complex, then the result and floating-point exception
-    behavior of the / operator is defined by the usual mathematical formula:
-           /                   u                       iv
-
-           x                  x/u                 i(-x/v)
-
-           iy               i(y/u)                     y/v
-
-           x + iy       (x/u) + i(y/u)        (y/v) + i(-x/v)
-4   The * and / operators satisfy the following infinity properties for all real, imaginary, and
-    complex operands:<sup><a href="#note325"><b>325)</b></a></sup>
-    -- if one operand is an infinity and the other operand is a nonzero finite number or an
-      infinity, then the result of the * operator is an infinity;
-    -- if the first operand is an infinity and the second operand is a finite number, then the
-      result of the / operator is an infinity;
-    -- if the first operand is a finite number and the second operand is an infinity, then the
-      result of the / operator is a zero;
-
-
-
-
-    <sup><a name="note325" href="#note325"><b>325)</b></a></sup> These properties are already implied for those cases covered in the tables, but are required for all cases
-         (at least where the state for CX_LIMITED_RANGE is ''off'').
-
-[<a name="p469" href="#p469">page 469</a>] (<a href="#Contents">Contents</a>)
-
-    -- if the first operand is a nonzero finite number or an infinity and the second operand is
-      a zero, then the result of the / operator is an infinity.
-5   If both operands of the * operator are complex or if the second operand of the / operator
-    is complex, the operator raises floating-point exceptions if appropriate for the calculation
-    of the parts of the result, and may raise spurious floating-point exceptions.
-6   EXAMPLE 1 Multiplication of double _Complex operands could be implemented as follows. Note
-    that the imaginary unit I has imaginary type (see <a href="#G.6">G.6</a>).
-           #include <a href="#7.12">&lt;math.h&gt;</a>
-           #include <a href="#7.3">&lt;complex.h&gt;</a>
-           /* Multiply z * w ... */
-           double complex _Cmultd(double complex z, double complex w)
-           {
-                  #pragma STDC FP_CONTRACT OFF
-                  double a, b, c, d, ac, bd, ad, bc, x, y;
-                  a = creal(z); b = cimag(z);
-                  c = creal(w); d = cimag(w);
-                  ac = a * c;       bd = b * d;
-                  ad = a * d;       bc = b * c;
-                  x = ac - bd; y = ad + bc;
-                  if (isnan(x) &amp;&amp; isnan(y)) {
-                          /* Recover infinities that computed as NaN+iNaN ... */
-                          int recalc = 0;
-                          if ( isinf(a) || isinf(b) ) { // z is infinite
-                                  /* "Box" the infinity and change NaNs in the other factor to 0 */
-                                  a = copysign(isinf(a) ? 1.0 : 0.0, a);
-                                  b = copysign(isinf(b) ? 1.0 : 0.0, b);
-                                  if (isnan(c)) c = copysign(0.0, c);
-                                  if (isnan(d)) d = copysign(0.0, d);
-                                  recalc = 1;
-                          }
-                          if ( isinf(c) || isinf(d) ) { // w is infinite
-                                  /* "Box" the infinity and change NaNs in the other factor to 0 */
-                                  c = copysign(isinf(c) ? 1.0 : 0.0, c);
-                                  d = copysign(isinf(d) ? 1.0 : 0.0, d);
-                                  if (isnan(a)) a = copysign(0.0, a);
-                                  if (isnan(b)) b = copysign(0.0, b);
-                                  recalc = 1;
-                          }
-                          if (!recalc &amp;&amp; (isinf(ac) || isinf(bd) ||
-                                                 isinf(ad) || isinf(bc))) {
-                                  /* Recover infinities from overflow by changing NaNs to 0 ... */
-                                  if (isnan(a)) a = copysign(0.0, a);
-                                  if (isnan(b)) b = copysign(0.0, b);
-                                  if (isnan(c)) c = copysign(0.0, c);
-                                  if (isnan(d)) d = copysign(0.0, d);
-                                  recalc = 1;
-                          }
-                          if (recalc) {
-
-[<a name="p470" href="#p470">page 470</a>] (<a href="#Contents">Contents</a>)
-
-                                      x = INFINITY * ( a * c - b * d );
-                                      y = INFINITY * ( a * d + b * c );
-                           }
-                     }
-                     return x + I * y;
+                float w[] = { 0.0/0.0 };                  //   raises an exception
+                static float x = 0.0/0.0;                 //   does not raise an exception
+                float y = 0.0/0.0;                        //   raises an exception
+                double z = 0.0/0.0;                       //   raises an exception
+                /* ... */
+          }</pre>
+ For the static initialization, the division is done at translation time, raising no (execution-time) floating-
+ point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
+ 
+ 
+<!--page 462 indent 4-->
+ execution time.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note315">315)</a> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
+ are affected by rounding modes set at execution time, and expressions such as 0.0/0.0 and
+ 1.0/0.0 generate execution-time floating-point exceptions. The programmer can achieve the
+ efficiency of translation-time evaluation through static initialization, such as
+
+<pre>
+          const static double one_third = 1.0/3.0;</pre>
+
+
+<a name="F.7.5" href="#F.7.5"><h4>F.7.5 Initialization</h4></a>
+<p><!--para 1-->
+ All computation for automatic initialization is done (as if) at execution time; thus, it is
+ affected by any operative modes and raises floating-point exceptions as required by
+ IEC 60559 (provided the state for the FENV_ACCESS pragma is ''on''). All computation
+ for initialization of objects that have static storage duration is done (as if) at translation
+ time.
+<p><!--para 2-->
+ EXAMPLE
+<p><!--para 3-->
+<pre>
+          #include &lt;fenv.h&gt;
+          #pragma STDC FENV_ACCESS ON
+          void f(void)
+          {
+                float u[] = { 1.1e75 };                  //   raises exceptions
+                static float v = 1.1e75;                 //   does not raise exceptions
+                float w = 1.1e75;                        //   raises exceptions
+                double x = 1.1e75;                       //   may raise exceptions
+                float y = 1.1e75f;                       //   may raise exceptions
+                long double z = 1.1e75;                  //   does not raise exceptions
+                /* ... */
+          }</pre>
+ The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
+ done at translation time. The automatic initialization of u and w require an execution-time conversion to
+ float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
+ of x and y entail execution-time conversion; however, in some expression evaluation methods, the
+ conversions is not to a narrower format, in which case no floating-point exception is raised.<sup><a href="#note316"><b>316)</b></a></sup> The
+ automatic initialization of z entails execution-time conversion, but not to a narrower format, so no floating-
+ point exception is raised. Note that the conversions of the floating constants 1.1e75 and 1.1e75f to
+ their internal representations occur at translation time in all cases.
+ 
+ 
+ 
+ 
+<!--page 463 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note316">316)</a> Use of float_t and double_t variables increases the likelihood of translation-time computation.
+ For example, the automatic initialization
+
+<pre>
+           double_t x = 1.1e75;</pre>
+  could be done at translation time, regardless of the expression evaluation method.
+
+
+<a name="F.7.6" href="#F.7.6"><h4>F.7.6 Changing the environment</h4></a>
+<p><!--para 1-->
+ Operations defined in <a href="#6.5">6.5</a> and functions and macros defined for the standard libraries
+ change floating-point status flags and control modes just as indicated by their
+ specifications (including conformance to IEC 60559). They do not change flags or modes
+ (so as to be detectable by the user) in any other cases.
+<p><!--para 2-->
+ If the argument to the feraiseexcept function in &lt;fenv.h&gt; represents IEC 60559
+ valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
+ ''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
+ before ''inexact''.
+
+<a name="F.8" href="#F.8"><h3>F.8 Optimization</h3></a>
+<p><!--para 1-->
+ This section identifies code transformations that might subvert IEC 60559-specified
+ behavior, and others that do not.
+
+<a name="F.8.1" href="#F.8.1"><h4>F.8.1 Global transformations</h4></a>
+<p><!--para 1-->
+ Floating-point arithmetic operations and external function calls may entail side effects
+ which optimization shall honor, at least where the state of the FENV_ACCESS pragma is
+ ''on''. The flags and modes in the floating-point environment may be regarded as global
+ variables; floating-point operations (+, *, etc.) implicitly read the modes and write the
+ flags.
+<p><!--para 2-->
+ Concern about side effects may inhibit code motion and removal of seemingly useless
+ code. For example, in
+<pre>
+          #include &lt;fenv.h&gt;
+          #pragma STDC FENV_ACCESS ON
+          void f(double x)
+          {
+               /* ... */
+               for (i = 0; i &lt; n; i++) x + 1;
+               /* ... */
+          }</pre>
+ x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
+ body might not execute (maybe 0 &gt;= n), x + 1 cannot be moved out of the loop. (Of
+ course these optimizations are valid if the implementation can rule out the nettlesome
+ cases.)
+<p><!--para 3-->
+ This specification does not require support for trap handlers that maintain information
+ about the order or count of floating-point exceptions. Therefore, between function calls,
+ floating-point exceptions need not be precise: the actual order and number of occurrences
+ of floating-point exceptions (&gt; 1) may vary from what the source code expresses. Thus,
+ the preceding loop could be treated as
+<!--page 464 indent 4-->
+<pre>
+         if (0 &lt; n) x + 1;</pre>
+
+<a name="F.8.2" href="#F.8.2"><h4>F.8.2 Expression transformations</h4></a>
+<p><!--para 1-->
+ x / 2 &lt;-&gt; x * 0.5                         Although similar transformations involving inexact
+<pre>
+                                         constants generally do not yield numerically equivalent
+                                         expressions, if the constants are exact then such
+                                         transformations can be made on IEC 60559 machines
+                                         and others that round perfectly.</pre>
+ 1 * x and x / 1 -&gt; x                     The expressions 1 * x, x / 1, and x are equivalent
+<pre>
+                                         (on IEC 60559 machines, among others).<sup><a href="#note317"><b>317)</b></a></sup></pre>
+ x / x -&gt; 1.0                             The expressions x / x and 1.0 are not equivalent if x
+<pre>
+                                         can be zero, infinite, or NaN.</pre>
+ x - y &lt;-&gt; x + (-y)                        The expressions x - y, x + (-y), and (-y) + x
+<pre>
+                                         are equivalent (on IEC 60559 machines, among others).</pre>
+ x - y &lt;-&gt; -(y - x)                        The expressions x - y and -(y - x) are not
+<pre>
+                                         equivalent because 1 - 1 is +0 but -(1 - 1) is -0 (in the
+                                         default rounding direction).<sup><a href="#note318"><b>318)</b></a></sup></pre>
+ x - x -&gt; 0.0                             The expressions x - x and 0.0 are not equivalent if
+<pre>
+                                         x is a NaN or infinite.</pre>
+ 0 * x -&gt; 0.0                             The expressions 0 * x and 0.0 are not equivalent if
+<pre>
+                                         x is a NaN, infinite, or -0.</pre>
+ x + 0-&gt;x                                 The expressions x + 0 and x are not equivalent if x is
+<pre>
+                                         -0, because (-0) + (+0) yields +0 (in the default
+                                         rounding direction), not -0.</pre>
+ x - 0-&gt;x                                 (+0) - (+0) yields -0 when rounding is downward
+<pre>
+                                         (toward -(inf)), but +0 otherwise, and (-0) - (+0) always
+                                         yields -0; so, if the state of the FENV_ACCESS pragma
+                                         is ''off'', promising default rounding, then the
+                                         implementation can replace x - 0 by x, even if x</pre>
+ 
+ 
+<!--page 465 indent 4-->
+<pre>
+                                          might be zero.</pre>
+ -x &lt;-&gt; 0 - x                               The expressions -x and 0 - x are not equivalent if x
+<pre>
+                                          is +0, because -(+0) yields -0, but 0 - (+0) yields +0
+                                          (unless rounding is downward).</pre>
+
+<h6>footnotes</h6>
+<p><a name="note317">317)</a> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
+ other transformations that remove arithmetic operators.
+
+<p><a name="note318">318)</a> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
+ Examples include:
+
+<pre>
+    1/(1/ (+-) (inf)) is (+-) (inf)</pre>
+ and
+
+<pre>
+    conj(csqrt(z)) is csqrt(conj(z)),</pre>
+ for complex z.
+
+
+<a name="F.8.3" href="#F.8.3"><h4>F.8.3 Relational operators</h4></a>
+<p><!--para 1-->
+ x != x -&gt; false                           The statement x != x is true if x is a NaN.
+ x == x -&gt; true                            The statement x == x is false if x is a NaN.
+ x &lt; y -&gt; isless(x,y)                      (and similarly for &lt;=, &gt;, &gt;=) Though numerically
+<pre>
+                                          equal, these expressions are not equivalent because of
+                                          side effects when x or y is a NaN and the state of the
+                                          FENV_ACCESS pragma is ''on''. This transformation,
+                                          which would be desirable if extra code were required to
+                                          cause the ''invalid'' floating-point exception for
+                                          unordered cases, could be performed provided the state
+                                          of the FENV_ACCESS pragma is ''off''.</pre>
+ The sense of relational operators shall be maintained. This includes handling unordered
+ cases as expressed by the source code.
+<p><!--para 2-->
+ EXAMPLE
+<pre>
+          // calls g and raises ''invalid'' if a and b are unordered
+          if (a &lt; b)
+                  f();
+          else
+                  g();</pre>
+ is not equivalent to
+<pre>
+          // calls f and raises ''invalid'' if a and b are unordered
+          if (a &gt;= b)
+                  g();
+          else
+                  f();</pre>
+ nor to
+<pre>
+          // calls f without raising ''invalid'' if a and b are unordered
+          if (isgreaterequal(a,b))
+                  g();
+          else
+                  f();</pre>
+ nor, unless the state of the FENV_ACCESS pragma is ''off'', to
+<!--page 466 indent 4-->
+<pre>
+          // calls g without raising ''invalid'' if a and b are unordered
+          if (isless(a,b))
+                  f();
+          else
+                  g();</pre>
+ but is equivalent to
+<pre>
+          if (!(a &lt; b))
+                g();
+          else
+                f();</pre>
+ 
+
+<a name="F.8.4" href="#F.8.4"><h4>F.8.4 Constant arithmetic</h4></a>
+<p><!--para 1-->
+ The implementation shall honor floating-point exceptions raised by execution-time
+ constant arithmetic wherever the state of the FENV_ACCESS pragma is ''on''. (See <a href="#F.7.4">F.7.4</a>
+ and <a href="#F.7.5">F.7.5</a>.) An operation on constants that raises no floating-point exception can be
+ folded during translation, except, if the state of the FENV_ACCESS pragma is ''on'', a
+ further check is required to assure that changing the rounding direction to downward does
+ not alter the sign of the result,<sup><a href="#note319"><b>319)</b></a></sup> and implementations that support dynamic rounding
+ precision modes shall assure further that the result of the operation raises no floating-
+ point exception when converted to the semantic type of the operation.
+
+<h6>footnotes</h6>
+<p><a name="note319">319)</a> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
+
+
+<a name="F.9" href="#F.9"><h3>F.9 Mathematics <math.h></h3></a>
+<p><!--para 1-->
+ This subclause contains specifications of &lt;math.h&gt; facilities that are particularly suited
+ for IEC 60559 implementations.
+<p><!--para 2-->
+ The Standard C macro HUGE_VAL and its float and long double analogs,
+ HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
+ infinities.
+<p><!--para 3-->
+ Special cases for functions in &lt;math.h&gt; are covered directly or indirectly by
+ IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
+ other functions in &lt;math.h&gt; treat infinities, NaNs, signed zeros, subnormals, and
+ (provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
+ in a manner consistent with the basic arithmetic operations covered by IEC 60559.
+<p><!--para 4-->
+ The expression math_errhandling &amp; MATH_ERREXCEPT shall evaluate to a
+ nonzero value.
+<p><!--para 5-->
+ The ''invalid'' and ''divide-by-zero'' floating-point exceptions are raised as specified in
+ subsequent subclauses of this annex.
+<p><!--para 6-->
+ The ''overflow'' floating-point exception is raised whenever an infinity -- or, because of
+ rounding direction, a maximal-magnitude finite number -- is returned in lieu of a value
+ 
+ 
+<!--page 467 indent 5-->
+ whose magnitude is too large.
+<p><!--para 7-->
+ The ''underflow'' floating-point exception is raised whenever a result is tiny (essentially
+ subnormal or zero) and suffers loss of accuracy.<sup><a href="#note320"><b>320)</b></a></sup>
+<p><!--para 8-->
+ Whether or when library functions raise the ''inexact'' floating-point exception is
+ unspecified, unless explicitly specified otherwise.
+<p><!--para 9-->
+ Whether or when library functions raise an undeserved ''underflow'' floating-point
+ exception is unspecified.<sup><a href="#note321"><b>321)</b></a></sup> Otherwise, as implied by <a href="#F.7.6">F.7.6</a>, the &lt;math.h&gt; functions do
+ not raise spurious floating-point exceptions (detectable by the user), other than the
+ ''inexact'' floating-point exception.
+<p><!--para 10-->
+ Whether the functions honor the rounding direction mode is implementation-defined,
+ unless explicitly specified otherwise.
+<p><!--para 11-->
+ Functions with a NaN argument return a NaN result and raise no floating-point exception,
+ except where stated otherwise.
+<p><!--para 12-->
+ The specifications in the following subclauses append to the definitions in &lt;math.h&gt;.
+ For families of functions, the specifications apply to all of the functions even though only
+ the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
+ occurs in both an argument and the result, the result has the same sign as the argument.
+ Recommended practice
+<p><!--para 13-->
+ If a function with one or more NaN arguments returns a NaN result, the result should be
+ the same as one of the NaN arguments (after possible type conversion), except perhaps
+ for the sign.
+
+<h6>footnotes</h6>
+<p><a name="note320">320)</a> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
+ when the floating-point exception is raised.
+
+<p><a name="note321">321)</a> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
+ avoiding them would be too costly.
+
+
+<a name="F.9.1" href="#F.9.1"><h4>F.9.1 Trigonometric functions</h4></a>
+
+<a name="F.9.1.1" href="#F.9.1.1"><h5>F.9.1.1 The acos functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  acos(1) returns +0.
+<li>  acos(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ | x | &gt; 1.
+ 
+ 
+ 
+ 
+<!--page 468 indent 4-->
+</ul>
+
+<a name="F.9.1.2" href="#F.9.1.2"><h5>F.9.1.2 The asin functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  asin((+-)0) returns (+-)0.
+<li>  asin(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ | x | &gt; 1.
+</ul>
+
+<a name="F.9.1.3" href="#F.9.1.3"><h5>F.9.1.3 The atan functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  atan((+-)0) returns (+-)0.
+<li>  atan((+-)(inf)) returns (+-)pi /2.
+</ul>
+
+<a name="F.9.1.4" href="#F.9.1.4"><h5>F.9.1.4 The atan2 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  atan2((+-)0, -0) returns (+-)pi .<sup><a href="#note322"><b>322)</b></a></sup>
+<li>  atan2((+-)0, +0) returns (+-)0.
+<li>  atan2((+-)0, x) returns (+-)pi for x &lt; 0.
+<li>  atan2((+-)0, x) returns (+-)0 for x &gt; 0.
+<li>  atan2(y, (+-)0) returns -pi /2 for y &lt; 0.
+<li>  atan2(y, (+-)0) returns pi /2 for y &gt; 0.
+<li>  atan2((+-)y, -(inf)) returns (+-)pi for finite y &gt; 0.
+<li>  atan2((+-)y, +(inf)) returns (+-)0 for finite y &gt; 0.
+<li>  atan2((+-)(inf), x) returns (+-)pi /2 for finite x.
+<li>  atan2((+-)(inf), -(inf)) returns (+-)3pi /4.
+<li>  atan2((+-)(inf), +(inf)) returns (+-)pi /4.
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note322">322)</a> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y ,    0) raise
+ the ''divide-by-zero'' floating-point exception.
+
+
+<a name="F.9.1.5" href="#F.9.1.5"><h5>F.9.1.5 The cos functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cos((+-)0) returns 1.
+<li>  cos((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+</ul>
+
+<a name="F.9.1.6" href="#F.9.1.6"><h5>F.9.1.6 The sin functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  sin((+-)0) returns (+-)0.
+<li>  sin((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+ 
+ 
+ 
+ 
+<!--page 469 indent 4-->
+</ul>
+
+<a name="F.9.1.7" href="#F.9.1.7"><h5>F.9.1.7 The tan functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  tan((+-)0) returns (+-)0.
+<li>  tan((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+</ul>
+
+<a name="F.9.2" href="#F.9.2"><h4>F.9.2 Hyperbolic functions</h4></a>
+
+<a name="F.9.2.1" href="#F.9.2.1"><h5>F.9.2.1 The acosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  acosh(1) returns +0.
+<li>  acosh(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 1.
+<li>  acosh(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.2.2" href="#F.9.2.2"><h5>F.9.2.2 The asinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  asinh((+-)0) returns (+-)0.
+<li>  asinh((+-)(inf)) returns (+-)(inf).
+</ul>
+
+<a name="F.9.2.3" href="#F.9.2.3"><h5>F.9.2.3 The atanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  atanh((+-)0) returns (+-)0.
+<li>  atanh((+-)1) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  atanh(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ | x | &gt; 1.
+</ul>
+
+<a name="F.9.2.4" href="#F.9.2.4"><h5>F.9.2.4 The cosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cosh((+-)0) returns 1.
+<li>  cosh((+-)(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.2.5" href="#F.9.2.5"><h5>F.9.2.5 The sinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  sinh((+-)0) returns (+-)0.
+<li>  sinh((+-)(inf)) returns (+-)(inf).
+</ul>
+
+<a name="F.9.2.6" href="#F.9.2.6"><h5>F.9.2.6 The tanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  tanh((+-)0) returns (+-)0.
+<li>  tanh((+-)(inf)) returns (+-)1.
+<!--page 470 indent 4-->
+</ul>
+
+<a name="F.9.3" href="#F.9.3"><h4>F.9.3 Exponential and logarithmic functions</h4></a>
+
+<a name="F.9.3.1" href="#F.9.3.1"><h5>F.9.3.1 The exp functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  exp((+-)0) returns 1.
+<li>  exp(-(inf)) returns +0.
+<li>  exp(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.3.2" href="#F.9.3.2"><h5>F.9.3.2 The exp2 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  exp2((+-)0) returns 1.
+<li>  exp2(-(inf)) returns +0.
+<li>  exp2(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.3.3" href="#F.9.3.3"><h5>F.9.3.3 The expm1 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  expm1((+-)0) returns (+-)0.
+<li>  expm1(-(inf)) returns -1.
+<li>  expm1(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.3.4" href="#F.9.3.4"><h5>F.9.3.4 The frexp functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  frexp((+-)0, exp) returns (+-)0, and stores 0 in the object pointed to by exp.
+<li>  frexp((+-)(inf), exp) returns (+-)(inf), and stores an unspecified value in the object
+ pointed to by exp.
+<li>  frexp(NaN, exp) stores an unspecified value in the object pointed to by exp
+ (and returns a NaN).
+</ul>
+<p><!--para 2-->
+ frexp raises no floating-point exceptions.
+<p><!--para 3-->
+ On a binary system, the body of the frexp function might be
+<pre>
+        {
+               *exp = (value == 0) ? 0 : (int)(1 + logb(value));
+               return scalbn(value, -(*exp));
+        }</pre>
+
+<a name="F.9.3.5" href="#F.9.3.5"><h5>F.9.3.5 The ilogb functions</h5></a>
+<p><!--para 1-->
+ If the correct result is outside the range of the return type, the numeric result is
+ unspecified and the ''invalid'' floating-point exception is raised.
+<!--page 471 indent 4-->
+
+<a name="F.9.3.6" href="#F.9.3.6"><h5>F.9.3.6 The ldexp functions</h5></a>
+<p><!--para 1-->
+ On a binary system, ldexp(x, exp) is equivalent to scalbn(x, exp).
+
+<a name="F.9.3.7" href="#F.9.3.7"><h5>F.9.3.7 The log functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log(1) returns +0.
+<li>  log(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+<li>  log(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.3.8" href="#F.9.3.8"><h5>F.9.3.8 The log10 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log10((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log10(1) returns +0.
+<li>  log10(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+<li>  log10(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.3.9" href="#F.9.3.9"><h5>F.9.3.9 The log1p functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log1p((+-)0) returns (+-)0.
+<li>  log1p(-1) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log1p(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ x &lt; -1.
+<li>  log1p(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.3.10" href="#F.9.3.10"><h5>F.9.3.10 The log2 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log2((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log2(1) returns +0.
+<li>  log2(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+<li>  log2(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.3.11" href="#F.9.3.11"><h5>F.9.3.11 The logb functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  logb((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  logb((+-)(inf)) returns +(inf).
+<!--page 472 indent 4-->
+</ul>
+
+<a name="F.9.3.12" href="#F.9.3.12"><h5>F.9.3.12 The modf functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  modf((+-)x, iptr) returns a result with the same sign as x.
+<li>  modf((+-)(inf), iptr) returns (+-)0 and stores (+-)(inf) in the object pointed to by iptr.
+<li>  modf(NaN, iptr) stores a NaN in the object pointed to by iptr (and returns a
+ NaN).
+</ul>
+<p><!--para 2-->
+ modf behaves as though implemented by
+<pre>
+       #include &lt;math.h&gt;
+       #include &lt;fenv.h&gt;
+       #pragma STDC FENV_ACCESS ON
+       double modf(double value, double *iptr)
+       {
+            int save_round = fegetround();
+            fesetround(FE_TOWARDZERO);
+            *iptr = nearbyint(value);
+            fesetround(save_round);
+            return copysign(
+                 isinf(value) ? 0.0 :
+                      value - (*iptr), value);
+       }</pre>
+
+<a name="F.9.3.13" href="#F.9.3.13"><h5>F.9.3.13 The scalbn and scalbln functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  scalbn((+-)0, n) returns (+-)0.
+<li>  scalbn(x, 0) returns x.
+<li>  scalbn((+-)(inf), n) returns (+-)(inf).
+</ul>
+
+<a name="F.9.4" href="#F.9.4"><h4>F.9.4 Power and absolute value functions</h4></a>
+
+<a name="F.9.4.1" href="#F.9.4.1"><h5>F.9.4.1 The cbrt functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cbrt((+-)0) returns (+-)0.
+<li>  cbrt((+-)(inf)) returns (+-)(inf).
+</ul>
+
+<a name="F.9.4.2" href="#F.9.4.2"><h5>F.9.4.2 The fabs functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  fabs((+-)0) returns +0.
+<li>  fabs((+-)(inf)) returns +(inf).
+<!--page 473 indent 4-->
+</ul>
+
+<a name="F.9.4.3" href="#F.9.4.3"><h5>F.9.4.3 The hypot functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  hypot(x, y), hypot(y, x), and hypot(x, -y) are equivalent.
+<li>  hypot(x, (+-)0) is equivalent to fabs(x).
+<li>  hypot((+-)(inf), y) returns +(inf), even if y is a NaN.
+</ul>
+
+<a name="F.9.4.4" href="#F.9.4.4"><h5>F.9.4.4 The pow functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  pow((+-)0, y) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception
+ for y an odd integer &lt; 0.
+<li>  pow((+-)0, y) returns +(inf) and raises the ''divide-by-zero'' floating-point exception
+ for y &lt; 0 and not an odd integer.
+<li>  pow((+-)0, y) returns (+-)0 for y an odd integer &gt; 0.
+<li>  pow((+-)0, y) returns +0 for y &gt; 0 and not an odd integer.
+<li>  pow(-1, (+-)(inf)) returns 1.
+<li>  pow(+1, y) returns 1 for any y, even a NaN.
+<li>  pow(x, (+-)0) returns 1 for any x, even a NaN.
+<li>  pow(x, y) returns a NaN and raises the ''invalid'' floating-point exception for
+ finite x &lt; 0 and finite non-integer y.
+<li>  pow(x, -(inf)) returns +(inf) for | x | &lt; 1.
+<li>  pow(x, -(inf)) returns +0 for | x | &gt; 1.
+<li>  pow(x, +(inf)) returns +0 for | x | &lt; 1.
+<li>  pow(x, +(inf)) returns +(inf) for | x | &gt; 1.
+<li>  pow(-(inf), y) returns -0 for y an odd integer &lt; 0.
+<li>  pow(-(inf), y) returns +0 for y &lt; 0 and not an odd integer.
+<li>  pow(-(inf), y) returns -(inf) for y an odd integer &gt; 0.
+<li>  pow(-(inf), y) returns +(inf) for y &gt; 0 and not an odd integer.
+<li>  pow(+(inf), y) returns +0 for y &lt; 0.
+<li>  pow(+(inf), y) returns +(inf) for y &gt; 0.
+<!--page 474 indent 4-->
+</ul>
+
+<a name="F.9.4.5" href="#F.9.4.5"><h5>F.9.4.5 The sqrt functions</h5></a>
+<p><!--para 1-->
+ sqrt is fully specified as a basic arithmetic operation in IEC 60559.
+
+<a name="F.9.5" href="#F.9.5"><h4>F.9.5 Error and gamma functions</h4></a>
+
+<a name="F.9.5.1" href="#F.9.5.1"><h5>F.9.5.1 The erf functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  erf((+-)0) returns (+-)0.
+<li>  erf((+-)(inf)) returns (+-)1.
+</ul>
+
+<a name="F.9.5.2" href="#F.9.5.2"><h5>F.9.5.2 The erfc functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  erfc(-(inf)) returns 2.
+<li>  erfc(+(inf)) returns +0.
+</ul>
+
+<a name="F.9.5.3" href="#F.9.5.3"><h5>F.9.5.3 The lgamma functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  lgamma(1) returns +0.
+<li>  lgamma(2) returns +0.
+<li>  lgamma(x) returns +(inf) and raises the ''divide-by-zero'' floating-point exception for
+ x a negative integer or zero.
+<li>  lgamma(-(inf)) returns +(inf).
+<li>  lgamma(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.5.4" href="#F.9.5.4"><h5>F.9.5.4 The tgamma functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  tgamma((+-)0) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  tgamma(x) returns a NaN and raises the ''invalid'' floating-point exception for x a
+ negative integer.
+<li>  tgamma(-(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+<li>  tgamma(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.9.6" href="#F.9.6"><h4>F.9.6 Nearest integer functions</h4></a>
+
+<a name="F.9.6.1" href="#F.9.6.1"><h5>F.9.6.1 The ceil functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  ceil((+-)0) returns (+-)0.
+<li>  ceil((+-)(inf)) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ The double version of ceil behaves as though implemented by
+<!--page 475 indent 4-->
+<pre>
+        #include &lt;math.h&gt;
+        #include &lt;fenv.h&gt;
+        #pragma STDC FENV_ACCESS ON
+        double ceil(double x)
+        {
+             double result;
+             int save_round = fegetround();
+             fesetround(FE_UPWARD);
+             result = rint(x); // or nearbyint instead of rint
+             fesetround(save_round);
+             return result;
+        }</pre>
+
+<a name="F.9.6.2" href="#F.9.6.2"><h5>F.9.6.2 The floor functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  floor((+-)0) returns (+-)0.
+<li>  floor((+-)(inf)) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ See the sample implementation for ceil in <a href="#F.9.6.1">F.9.6.1</a>.
+
+<a name="F.9.6.3" href="#F.9.6.3"><h5>F.9.6.3 The nearbyint functions</h5></a>
+<p><!--para 1-->
+ The nearbyint functions use IEC 60559 rounding according to the current rounding
+ direction. They do not raise the ''inexact'' floating-point exception if the result differs in
+ value from the argument.
+<ul>
+<li>  nearbyint((+-)0) returns (+-)0 (for all rounding directions).
+<li>  nearbyint((+-)(inf)) returns (+-)(inf) (for all rounding directions).
+</ul>
+
+<a name="F.9.6.4" href="#F.9.6.4"><h5>F.9.6.4 The rint functions</h5></a>
+<p><!--para 1-->
+ The rint functions differ from the nearbyint functions only in that they do raise the
+ ''inexact'' floating-point exception if the result differs in value from the argument.
+
+<a name="F.9.6.5" href="#F.9.6.5"><h5>F.9.6.5 The lrint and llrint functions</h5></a>
+<p><!--para 1-->
+ The lrint and llrint functions provide floating-to-integer conversion as prescribed
+ by IEC 60559. They round according to the current rounding direction. If the rounded
+ value is outside the range of the return type, the numeric result is unspecified and the
+ ''invalid'' floating-point exception is raised. When they raise no other floating-point
+ exception and the result differs from the argument, they raise the ''inexact'' floating-point
+ exception.
+<!--page 476 indent 4-->
+
+<a name="F.9.6.6" href="#F.9.6.6"><h5>F.9.6.6 The round functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  round((+-)0) returns (+-)0.
+<li>  round((+-)(inf)) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ The double version of round behaves as though implemented by
+<pre>
+        #include &lt;math.h&gt;
+        #include &lt;fenv.h&gt;
+        #pragma STDC FENV_ACCESS ON
+        double round(double x)
+        {
+             double result;
+             fenv_t save_env;
+             feholdexcept(&amp;save_env);
+             result = rint(x);
+             if (fetestexcept(FE_INEXACT)) {
+                  fesetround(FE_TOWARDZERO);
+                  result = rint(copysign(0.5 + fabs(x), x));
              }
-7   This implementation achieves the required treatment of infinities at the cost of only one isnan test in
-    ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
-
-8   EXAMPLE 2      Division of two double _Complex operands could be implemented as follows.
-             #include <a href="#7.12">&lt;math.h&gt;</a>
-             #include <a href="#7.3">&lt;complex.h&gt;</a>
-             /* Divide z / w ... */
-             double complex _Cdivd(double complex z, double complex w)
-             {
-                    #pragma STDC FP_CONTRACT OFF
-                    double a, b, c, d, logbw, denom, x, y;
-                    int ilogbw = 0;
-                    a = creal(z); b = cimag(z);
-                    c = creal(w); d = cimag(w);
-                    logbw = logb(fmax(fabs(c), fabs(d)));
-                    if (isfinite(logbw)) {
-                           ilogbw = (int)logbw;
-                           c = scalbn(c, -ilogbw); d = scalbn(d, -ilogbw);
-                    }
-                    denom = c * c + d * d;
-                    x = scalbn((a * c + b * d) / denom, -ilogbw);
-                    y = scalbn((b * c - a * d) / denom, -ilogbw);
-                     /* Recover infinities and zeros that computed as NaN+iNaN;                 */
-                     /* the only cases are nonzero/zero, infinite/finite, and finite/infinite, ... */
-                     if (isnan(x) &amp;&amp; isnan(y)) {
-                           if ((denom == 0.0) &amp;&amp;
-                                 (!isnan(a) || !isnan(b))) {
-                                 x = copysign(INFINITY, c) * a;
-                                 y = copysign(INFINITY, c) * b;
-                           }
-                           else if ((isinf(a) || isinf(b)) &amp;&amp;
-                                 isfinite(c) &amp;&amp; isfinite(d)) {
-                                 a = copysign(isinf(a) ? 1.0 : 0.0,                        a);
-                                 b = copysign(isinf(b) ? 1.0 : 0.0,                        b);
-                                 x = INFINITY * ( a * c + b * d );
-                                 y = INFINITY * ( b * c - a * d );
-                           }
-                           else if (isinf(logbw) &amp;&amp;
-                                 isfinite(a) &amp;&amp; isfinite(b)) {
-                                 c = copysign(isinf(c) ? 1.0 : 0.0,                        c);
-                                 d = copysign(isinf(d) ? 1.0 : 0.0,                        d);
-                                 x = 0.0 * ( a * c + b * d );
-                                 y = 0.0 * ( b * c - a * d );
-
-[<a name="p471" href="#p471">page 471</a>] (<a href="#Contents">Contents</a>)
-
-                           }
-                     }
-                     return x + I * y;
-            }
-9   Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
-    for multiplication. In the spirit of the multiplication example above, this code does not defend against
-    overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
-    with division, provides better roundoff characteristics.
-
-<a name="G.5.2" href="#G.5.2"><b>    G.5.2 Additive operators</b></a>
-<b>    Semantics</b>
-1   If both operands have imaginary type, then the result has imaginary type. (If one operand
-    has real type and the other operand has imaginary type, or if either operand has complex
-    type, then the result has complex type.)
-2   In all cases the result and floating-point exception behavior of a + or - operator is defined
-    by the usual mathematical formula:
-           + or -              u                       iv                    u + iv
-
-           x                 x(+-)u                     x (+-) iv              (x (+-) u) (+-) iv
-
-           iy               (+-)u + iy                 i(y (+-) v)             (+-)u + i(y (+-) v)
-
-           x + iy         (x (+-) u) + iy            x + i(y (+-) v)        (x (+-) u) + i(y (+-) v)
-<a name="G.6" href="#G.6"><b>    G.6 Complex arithmetic &lt;complex.h&gt;</b></a>
-1   The macros
-            imaginary
-    and
-            _Imaginary_I
-    are defined, respectively, as _Imaginary and a constant expression of type const
-    float _Imaginary with the value of the imaginary unit. The macro
-            I
-    is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
-    the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
-    imaginary.
-2   This subclause contains specifications for the <a href="#7.3">&lt;complex.h&gt;</a> functions that are
-    particularly suited to IEC 60559 implementations. For families of functions, the
-    specifications apply to all of the functions even though only the principal function is
-
-[<a name="p472" href="#p472">page 472</a>] (<a href="#Contents">Contents</a>)
-
-    shown. Unless otherwise specified, where the symbol ''(+-)'' occurs in both an argument
-    and the result, the result has the same sign as the argument.
-3   The functions are continuous onto both sides of their branch cuts, taking into account the
-    sign of zero. For example, csqrt(-2 (+-) i0) = (+-)i(sqrt)2.  ???
-4   Since complex and imaginary values are composed of real values, each function may be
-    regarded as computing real values from real values. Except as noted, the functions treat
-    real infinities, NaNs, signed zeros, subnormals, and the floating-point exception flags in a
-    manner consistent with the specifications for real functions in F.9.<sup><a href="#note326"><b>326)</b></a></sup>
-5   The functions cimag, conj, cproj, and creal are fully specified for all
-    implementations, including IEC 60559 ones, in <a href="#7.3.9">7.3.9</a>. These functions raise no floating-
-    point exceptions.
-6   Each of the functions cabs and carg is specified by a formula in terms of a real
-    function (whose special cases are covered in <a href="#F">annex F</a>):
-            cabs(x + iy) = hypot(x, y)
-            carg(x + iy) = atan2(y, x)
-7   Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
-    a formula in terms of other complex functions (whose special cases are specified below):
-            casin(z)        =   -i casinh(iz)
-            catan(z)        =   -i catanh(iz)
-            ccos(z)         =   ccosh(iz)
-            csin(z)         =   -i csinh(iz)
-            ctan(z)         =   -i ctanh(iz)
-8   For the other functions, the following subclauses specify behavior for special cases,
-    including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
-    families of functions, the specifications apply to all of the functions even though only the
-    principal function is shown. For a function f satisfying f (conj(z)) = conj( f (z)), the
-    specifications for the upper half-plane imply the specifications for the lower half-plane; if
-    the function f is also either even, f (-z) = f (z), or odd, f (-z) = - f (z), then the
-    specifications for the first quadrant imply the specifications for the other three quadrants.
-9   In the following subclauses, cis(y) is defined as cos(y) + i sin(y).
-
-
-
-
-    <sup><a name="note326" href="#note326"><b>326)</b></a></sup> As noted in <a href="#G.3">G.3</a>, a complex value with at least one infinite part is regarded as an infinity even if its
-         other part is a NaN.
-
-[<a name="p473" href="#p473">page 473</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.6.1" href="#G.6.1"><b>    G.6.1 Trigonometric functions</b></a>
-<a name="G.6.1.1" href="#G.6.1.1"><b>    G.6.1.1 The cacos functions</b></a>
-1   -- cacos(conj(z)) = conj(cacos(z)).
-    -- cacos((+-)0 + i0) returns pi /2 - i0.
-    -- cacos((+-)0 + iNaN) returns pi /2 + iNaN.
-    -- cacos(x + i (inf)) returns pi /2 - i (inf), for finite x.
-    -- cacos(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for nonzero finite x.
-    -- cacos(-(inf) + iy) returns pi - i (inf), for positive-signed finite y.
-    -- cacos(+(inf) + iy) returns +0 - i (inf), for positive-signed finite y.
-    -- cacos(-(inf) + i (inf)) returns 3pi /4 - i (inf).
-    -- cacos(+(inf) + i (inf)) returns pi /4 - i (inf).
-    -- cacos((+-)(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
-      result is unspecified).
-    -- cacos(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite y.
-    -- cacos(NaN + i (inf)) returns NaN - i (inf).
-    -- cacos(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2" href="#G.6.2"><b>    G.6.2 Hyperbolic functions</b></a>
-<a name="G.6.2.1" href="#G.6.2.1"><b>    G.6.2.1 The cacosh functions</b></a>
-1   -- cacosh(conj(z)) = conj(cacosh(z)).
-    -- cacosh((+-)0 + i0) returns +0 + ipi /2.
-    -- cacosh(x + i (inf)) returns +(inf) + ipi /2, for finite x.
-    -- cacosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite x.
-    -- cacosh(-(inf) + iy) returns +(inf) + ipi , for positive-signed finite y.
-    -- cacosh(+(inf) + iy) returns +(inf) + i0, for positive-signed finite y.
-    -- cacosh(-(inf) + i (inf)) returns +(inf) + i3pi /4.
-    -- cacosh(+(inf) + i (inf)) returns +(inf) + ipi /4.
-    -- cacosh((+-)(inf) + iNaN) returns +(inf) + iNaN.
-
-[<a name="p474" href="#p474">page 474</a>] (<a href="#Contents">Contents</a>)
-
-    -- cacosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite y.
-    -- cacosh(NaN + i (inf)) returns +(inf) + iNaN.
-    -- cacosh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.2" href="#G.6.2.2"><b>    G.6.2.2 The casinh functions</b></a>
-1   -- casinh(conj(z)) = conj(casinh(z)) and casinh is odd.
-    -- casinh(+0 + i0) returns 0 + i0.
-    -- casinh(x + i (inf)) returns +(inf) + ipi /2 for positive-signed finite x.
-    -- casinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite x.
-    -- casinh(+(inf) + iy) returns +(inf) + i0 for positive-signed finite y.
-    -- casinh(+(inf) + i (inf)) returns +(inf) + ipi /4.
-    -- casinh(+(inf) + iNaN) returns +(inf) + iNaN.
-    -- casinh(NaN + i0) returns NaN + i0.
-    -- casinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite nonzero y.
-    -- casinh(NaN + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result
-      is unspecified).
-    -- casinh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.3" href="#G.6.2.3"><b>    G.6.2.3 The catanh functions</b></a>
-1   -- catanh(conj(z)) = conj(catanh(z)) and catanh is odd.
-    -- catanh(+0 + i0) returns +0 + i0.
-    -- catanh(+0 + iNaN) returns +0 + iNaN.
-    -- catanh(+1 + i0) returns +(inf) + i0 and raises the ''divide-by-zero'' floating-point
-      exception.
-    -- catanh(x + i (inf)) returns +0 + ipi /2, for finite positive-signed x.
-    -- catanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for nonzero finite x.
-    -- catanh(+(inf) + iy) returns +0 + ipi /2, for finite positive-signed y.
-    -- catanh(+(inf) + i (inf)) returns +0 + ipi /2.
-    -- catanh(+(inf) + iNaN) returns +0 + iNaN.
-
-[<a name="p475" href="#p475">page 475</a>] (<a href="#Contents">Contents</a>)
-
-    -- catanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite y.
-    -- catanh(NaN + i (inf)) returns (+-)0 + ipi /2 (where the sign of the real part of the result is
-      unspecified).
-    -- catanh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.4" href="#G.6.2.4"><b>    G.6.2.4 The ccosh functions</b></a>
-1   -- ccosh(conj(z)) = conj(ccosh(z)) and ccosh is even.
-    -- ccosh(+0 + i0) returns 1 + i0.
-    -- ccosh(+0 + i (inf)) returns NaN (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified) and raises the ''invalid'' floating-point exception.
-    -- ccosh(+0 + iNaN) returns NaN (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified).
-    -- ccosh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for finite nonzero x.
-    -- ccosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite nonzero x.
-    -- ccosh(+(inf) + i0) returns +(inf) + i0.
-    -- ccosh(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
-    -- ccosh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
-      unspecified) and raises the ''invalid'' floating-point exception.
-    -- ccosh(+(inf) + iNaN) returns +(inf) + iNaN.
-    -- ccosh(NaN + i0) returns NaN (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified).
-    -- ccosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- ccosh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.5" href="#G.6.2.5"><b>    G.6.2.5 The csinh functions</b></a>
-1   -- csinh(conj(z)) = conj(csinh(z)) and csinh is odd.
-    -- csinh(+0 + i0) returns +0 + i0.
-    -- csinh(+0 + i (inf)) returns (+-)0 + iNaN (where the sign of the real part of the result is
-      unspecified) and raises the ''invalid'' floating-point exception.
-    -- csinh(+0 + iNaN) returns (+-)0 + iNaN (where the sign of the real part of the result is
-      unspecified).
-
-[<a name="p476" href="#p476">page 476</a>] (<a href="#Contents">Contents</a>)
-
-    -- csinh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for positive finite x.
-    -- csinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite nonzero x.
-    -- csinh(+(inf) + i0) returns +(inf) + i0.
-    -- csinh(+(inf) + iy) returns +(inf) cis(y), for positive finite y.
-    -- csinh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
-      unspecified) and raises the ''invalid'' floating-point exception.
-    -- csinh(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
-      is unspecified).
-    -- csinh(NaN + i0) returns NaN + i0.
-    -- csinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- csinh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.6" href="#G.6.2.6"><b>    G.6.2.6 The ctanh functions</b></a>
-1   -- ctanh(conj(z)) = conj(ctanh(z))and ctanh is odd.
-    -- ctanh(+0 + i0) returns +0 + i0.
-    -- ctanh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for finite x.
-    -- ctanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-    -- ctanh(+(inf) + iy) returns 1 + i0 sin(2y), for positive-signed finite y.
-    -- ctanh(+(inf) + i (inf)) returns 1 (+-) i0 (where the sign of the imaginary part of the result
-      is unspecified).
-    -- ctanh(+(inf) + iNaN) returns 1 (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified).
-    -- ctanh(NaN + i0) returns NaN + i0.
-    -- ctanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- ctanh(NaN + iNaN) returns NaN + iNaN.
-
-[<a name="p477" href="#p477">page 477</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.6.3" href="#G.6.3"><b>    G.6.3 Exponential and logarithmic functions</b></a>
-<a name="G.6.3.1" href="#G.6.3.1"><b>    G.6.3.1 The cexp functions</b></a>
-1   -- cexp(conj(z)) = conj(cexp(z)).
-    -- cexp((+-)0 + i0) returns 1 + i0.
-    -- cexp(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for finite x.
-    -- cexp(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-    -- cexp(+(inf) + i0) returns +(inf) + i0.
-    -- cexp(-(inf) + iy) returns +0 cis(y), for finite y.
-    -- cexp(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
-    -- cexp(-(inf) + i (inf)) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts of
-      the result are unspecified).
-    -- cexp(+(inf) + i (inf)) returns (+-)(inf) + iNaN and raises the ''invalid'' floating-point
-      exception (where the sign of the real part of the result is unspecified).
-    -- cexp(-(inf) + iNaN) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts
-      of the result are unspecified).
-    -- cexp(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
-      is unspecified).
-    -- cexp(NaN + i0) returns NaN + i0.
-    -- cexp(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- cexp(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.3.2" href="#G.6.3.2"><b>    G.6.3.2 The clog functions</b></a>
-1   -- clog(conj(z)) = conj(clog(z)).
-    -- clog(-0 + i0) returns -(inf) + ipi and raises the ''divide-by-zero'' floating-point
-      exception.
-    -- clog(+0 + i0) returns -(inf) + i0 and raises the ''divide-by-zero'' floating-point
-      exception.
-    -- clog(x + i (inf)) returns +(inf) + ipi /2, for finite x.
-    -- clog(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-
-[<a name="p478" href="#p478">page 478</a>] (<a href="#Contents">Contents</a>)
-
-    -- clog(-(inf) + iy) returns +(inf) + ipi , for finite positive-signed y.
-    -- clog(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
-    -- clog(-(inf) + i (inf)) returns +(inf) + i3pi /4.
-    -- clog(+(inf) + i (inf)) returns +(inf) + ipi /4.
-    -- clog((+-)(inf) + iNaN) returns +(inf) + iNaN.
-    -- clog(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite y.
-    -- clog(NaN + i (inf)) returns +(inf) + iNaN.
-    -- clog(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.4" href="#G.6.4"><b>    G.6.4 Power and absolute-value functions</b></a>
-<a name="G.6.4.1" href="#G.6.4.1"><b>    G.6.4.1 The cpow functions</b></a>
-1   The cpow functions raise floating-point exceptions if appropriate for the calculation of
-    the parts of the result, and may raise spurious exceptions.<sup><a href="#note327"><b>327)</b></a></sup>
-<a name="G.6.4.2" href="#G.6.4.2"><b>    G.6.4.2 The csqrt functions</b></a>
-1   -- csqrt(conj(z)) = conj(csqrt(z)).
-    -- csqrt((+-)0 + i0) returns +0 + i0.
-    -- csqrt(x + i (inf)) returns +(inf) + i (inf), for all x (including NaN).
-    -- csqrt(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-    -- csqrt(-(inf) + iy) returns +0 + i (inf), for finite positive-signed y.
-    -- csqrt(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
-    -- csqrt(-(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
-      result is unspecified).
-    -- csqrt(+(inf) + iNaN) returns +(inf) + iNaN.
-    -- csqrt(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite y.
-    -- csqrt(NaN + iNaN) returns NaN + iNaN.
-
-
-
-
-    <sup><a name="note327" href="#note327"><b>327)</b></a></sup> This allows cpow( z , c ) to be implemented as cexp(c      clog( z )) without precluding
-         implementations that treat special cases more carefully.
-
-[<a name="p479" href="#p479">page 479</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.7" href="#G.7"><b>    G.7 Type-generic math &lt;tgmath.h&gt;</b></a>
-1   Type-generic macros that accept complex arguments also accept imaginary arguments. If
-    an argument is imaginary, the macro expands to an expression whose type is real,
-    imaginary, or complex, as appropriate for the particular function: if the argument is
-    imaginary, then the types of cos, cosh, fabs, carg, cimag, and creal are real; the
-    types of sin, tan, sinh, tanh, asin, atan, asinh, and atanh are imaginary; and
-    the types of the others are complex.
-2   Given an imaginary argument, each of the type-generic macros cos, sin, tan, cosh,
-    sinh, tanh, asin, atan, asinh, atanh is specified by a formula in terms of real
-    functions:
-           cos(iy)      =   cosh(y)
-           sin(iy)      =   i sinh(y)
-           tan(iy)      =   i tanh(y)
-           cosh(iy)     =   cos(y)
-           sinh(iy)     =   i sin(y)
-           tanh(iy)     =   i tan(y)
-           asin(iy)     =   i asinh(y)
-           atan(iy)     =   i atanh(y)
-           asinh(iy)    =   i asin(y)
-           atanh(iy)    =   i atan(y)
-
-[<a name="p480" href="#p480">page 480</a>] (<a href="#Contents">Contents</a>)
-
-<a name="H" href="#H"><b>                                          Annex H</b></a>
-                                        (informative)
-                        Language independent arithmetic
-<a name="H.1" href="#H.1"><b>    H.1 Introduction</b></a>
-1   This annex documents the extent to which the C language supports the ISO/IEC 10967-1
-    standard for language-independent arithmetic (LIA-1). LIA-1 is more general than
-    IEC 60559 (<a href="#F">annex F</a>) in that it covers integer and diverse floating-point arithmetics.
-<a name="H.2" href="#H.2"><b>    H.2 Types</b></a>
-1   The relevant C arithmetic types meet the requirements of LIA-1 types if an
-    implementation adds notification of exceptional arithmetic operations and meets the 1
-    unit in the last place (ULP) accuracy requirement (LIA-1 subclause <a href="#5.2.8">5.2.8</a>).
-<a name="H.2.1" href="#H.2.1"><b>    H.2.1 Boolean type</b></a>
-1   The LIA-1 data type Boolean is implemented by the C data type bool with values of
-    true and false, all from <a href="#7.16">&lt;stdbool.h&gt;</a>.
-<a name="H.2.2" href="#H.2.2"><b>    H.2.2 Integer types</b></a>
-1   The signed C integer types int, long int, long long int, and the corresponding
-    unsigned types are compatible with LIA-1. If an implementation adds support for the
-    LIA-1 exceptional values ''integer_overflow'' and ''undefined'', then those types are
-    LIA-1 conformant types. C's unsigned integer types are ''modulo'' in the LIA-1 sense
-    in that overflows or out-of-bounds results silently wrap. An implementation that defines
-    signed integer types as also being modulo need not detect integer overflow, in which case,
-    only integer divide-by-zero need be detected.
-2   The parameters for the integer data types can be accessed by the following:
-    maxint        INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
-                  ULLONG_MAX
-    minint        INT_MIN, LONG_MIN, LLONG_MIN
-3   The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
-    is always 0 for the unsigned types, and is not provided for those types.
-
-[<a name="p481" href="#p481">page 481</a>] (<a href="#Contents">Contents</a>)
-
-<a name="H.2.2.1" href="#H.2.2.1"><b>    H.2.2.1 Integer operations</b></a>
-1   The integer operations on integer types are the following:
-    addI           x + y
-    subI           x - y
-    mulI           x * y
-    divI, divtI    x / y
-    remI, remtI    x % y
-    negI           -x
-    absI           abs(x), labs(x), llabs(x)
-    eqI            x == y
-    neqI           x != y
-    lssI           x &lt; y
-    leqI           x &lt;= y
-    gtrI           x &gt; y
-    geqI           x &gt;= y
-    where x and y are expressions of the same integer type.
-<a name="H.2.3" href="#H.2.3"><b>    H.2.3 Floating-point types</b></a>
-1   The C floating-point types float, double, and long double are compatible with
-    LIA-1. If an implementation adds support for the LIA-1 exceptional values
-    ''underflow'', ''floating_overflow'', and ''"undefined'', then those types are conformant
-    with LIA-1. An implementation that uses IEC 60559 floating-point formats and
-    operations (see <a href="#F">annex F</a>) along with IEC 60559 status flags and traps has LIA-1
-    conformant types.
-<a name="H.2.3.1" href="#H.2.3.1"><b>    H.2.3.1 Floating-point parameters</b></a>
-1   The parameters for a floating point data type can be accessed by the following:
-    r              FLT_RADIX
-    p              FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG
-    emax           FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP
-    emin           FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP
-2   The derived constants for the floating point types are accessed by the following:
-
-[<a name="p482" href="#p482">page 482</a>] (<a href="#Contents">Contents</a>)
-
-    fmax          FLT_MAX, DBL_MAX, LDBL_MAX
-    fminN         FLT_MIN, DBL_MIN, LDBL_MIN
-    epsilon       FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON
-    rnd_style     FLT_ROUNDS
-<a name="H.2.3.2" href="#H.2.3.2"><b>    H.2.3.2 Floating-point operations</b></a>
-1   The floating-point operations on floating-point types are the following:
-    addF          x + y
-    subF          x - y
-    mulF          x * y
-    divF          x / y
-    negF          -x
-    absF          fabsf(x), fabs(x), fabsl(x)
-    exponentF     1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
-    scaleF        scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
-                  scalblnf(x, li), scalbln(x, li), scalblnl(x, li)
-    intpartF      modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
-    fractpartF    modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
-    eqF           x == y
-    neqF          x != y
-    lssF          x &lt; y
-    leqF          x &lt;= y
-    gtrF          x &gt; y
-    geqF          x &gt;= y
-    where x and y are expressions of the same floating point type, n is of type int, and li
-    is of type long int.
-<a name="H.2.3.3" href="#H.2.3.3"><b>    H.2.3.3 Rounding styles</b></a>
-1   The C Standard requires all floating types to use the same radix and rounding style, so
-    that only one identifier for each is provided to map to LIA-1.
-2   The FLT_ROUNDS parameter can be used to indicate the LIA-1 rounding styles:
-    truncate      FLT_ROUNDS == 0
-
-[<a name="p483" href="#p483">page 483</a>] (<a href="#Contents">Contents</a>)
-
-    nearest        FLT_ROUNDS == 1
-    other          FLT_ROUNDS != 0 &amp;&amp; FLT_ROUNDS != 1
-    provided that an implementation extends FLT_ROUNDS to cover the rounding style used
-    in all relevant LIA-1 operations, not just addition as in C.
-<a name="H.2.4" href="#H.2.4"><b>    H.2.4 Type conversions</b></a>
-1   The LIA-1 type conversions are the following type casts:
-    cvtI' -&gt; I      (int)i, (long int)i, (long long int)i,
-                   (unsigned int)i, (unsigned long int)i,
-                   (unsigned long long int)i
-    cvtF -&gt; I       (int)x, (long int)x, (long long int)x,
-                   (unsigned int)x, (unsigned long int)x,
-                   (unsigned long long int)x
-    cvtI -&gt; F       (float)i, (double)i, (long double)i
-    cvtF' -&gt; F      (float)x, (double)x, (long double)x
-2   In the above conversions from floating to integer, the use of (cast)x can be replaced with
-    (cast)round(x), (cast)rint(x), (cast)nearbyint(x), (cast)trunc(x),
-    (cast)ceil(x), or (cast)floor(x). In addition, C's floating-point to integer
-    conversion functions, lrint(), llrint(), lround(), and llround(), can be
-    used. They all meet LIA-1's requirements on floating to integer rounding for in-range
-    values. For out-of-range values, the conversions shall silently wrap for the modulo types.
-3   The fmod() function is useful for doing silent wrapping to unsigned integer types, e.g.,
-    fmod( fabs(rint(x)), 65536.0 ) or (0.0 &lt;= (y = fmod( rint(x),
-    65536.0 )) ? y : 65536.0 + y) will compute an integer value in the range 0.0
-    to 65535.0 which can then be cast to unsigned short int. But, the
-    remainder() function is not useful for doing silent wrapping to signed integer types,
-    e.g., remainder( rint(x), 65536.0 ) will compute an integer value in the
-    range -32767.0 to +32768.0 which is not, in general, in the range of signed short
-    int.
-4   C's conversions (casts) from floating-point to floating-point can meet LIA-1
-    requirements if an implementation uses round-to-nearest (IEC 60559 default).
-5   C's conversions (casts) from integer to floating-point can meet LIA-1 requirements if an
-    implementation uses round-to-nearest.
-
-[<a name="p484" href="#p484">page 484</a>] (<a href="#Contents">Contents</a>)
-
-<a name="H.3" href="#H.3"><b>    H.3 Notification</b></a>
-1   Notification is the process by which a user or program is informed that an exceptional
-    arithmetic operation has occurred. C's operations are compatible with LIA-1 in that C
-    allows an implementation to cause a notification to occur when any arithmetic operation
-    returns an exceptional value as defined in LIA-1 clause 5.
-<a name="H.3.1" href="#H.3.1"><b>    H.3.1 Notification alternatives</b></a>
-1   LIA-1 requires at least the following two alternatives for handling of notifications:
-    setting indicators or trap-and-terminate. LIA-1 allows a third alternative: trap-and-
-    resume.
-2   An implementation need only support a given notification alternative for the entire
-    program. An implementation may support the ability to switch between notification
-    alternatives during execution, but is not required to do so. An implementation can
-    provide separate selection for each kind of notification, but this is not required.
-3   C allows an implementation to provide notification. C's SIGFPE (for traps) and
-    FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW (for indicators)
-    can provide LIA-1 notification.
-4   C's signal handlers are compatible with LIA-1. Default handling of SIGFPE can
-    provide trap-and-terminate behavior, except for those LIA-1 operations implemented by
-    math library function calls. User-provided signal handlers for SIGFPE allow for trap-
-    and-resume behavior with the same constraint.
-<a name="H.3.1.1" href="#H.3.1.1"><b>    H.3.1.1 Indicators</b></a>
-1   C's <a href="#7.6">&lt;fenv.h&gt;</a> status flags are compatible with the LIA-1 indicators.
-2   The following mapping is for floating-point types:
-    undefined                FE_INVALID, FE_DIVBYZERO
-    floating_overflow         FE_OVERFLOW
-    underflow                FE_UNDERFLOW
-3   The floating-point indicator interrogation and manipulation operations are:
-    set_indicators          feraiseexcept(i)
-    clear_indicators        feclearexcept(i)
-    test_indicators         fetestexcept(i)
-    current_indicators      fetestexcept(FE_ALL_EXCEPT)
-    where i is an expression of type int representing a subset of the LIA-1 indicators.
-4   C allows an implementation to provide the following LIA-1 required behavior: at
-    program termination if any indicator is set the implementation shall send an unambiguous
-
-[<a name="p485" href="#p485">page 485</a>] (<a href="#Contents">Contents</a>)
-
-    and ''hard to ignore'' message (see LIA-1 subclause <a href="#6.1.2">6.1.2</a>)
-5   LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
-    This documentation makes that distinction because <a href="#7.6">&lt;fenv.h&gt;</a> covers only the floating-
-    point indicators.
-<a name="H.3.1.2" href="#H.3.1.2"><b>    H.3.1.2 Traps</b></a>
-1   C is compatible with LIA-1's trap requirements for arithmetic operations, but not for
-    math library functions (which are not permitted to generate any externally visible
-    exceptional conditions). An implementation can provide an alternative of notification
-    through termination with a ''hard-to-ignore'' message (see LIA-1 subclause <a href="#6.1.3">6.1.3</a>).
-2   LIA-1 does not require that traps be precise.
-3   C does require that SIGFPE be the signal corresponding to arithmetic exceptions, if there
-    is any signal raised for them.
-4   C supports signal handlers for SIGFPE and allows trapping of arithmetic exceptions.
-    When arithmetic exceptions do trap, C's signal-handler mechanism allows trap-and-
-    terminate (either default implementation behavior or user replacement for it) or trap-and-
-    resume, at the programmer's option.
-
-[<a name="p486" href="#p486">page 486</a>] (<a href="#Contents">Contents</a>)
-
-<a name="I" href="#I"><b>                                           Annex I</b></a>
-                                        (informative)
-                                   Common warnings
-1   An implementation may generate warnings in many situations, none of which are
-    specified as part of this International Standard. The following are a few of the more
-    common situations.
-2   -- A new struct or union type appears in a function prototype (<a href="#6.2.1">6.2.1</a>, <a href="#6.7.2.3">6.7.2.3</a>).
-    -- A block with initialization of an object that has automatic storage duration is jumped
-      into (<a href="#6.2.4">6.2.4</a>).
-    -- An implicit narrowing conversion is encountered, such as the assignment of a long
-      int or a double to an int, or a pointer to void to a pointer to any type other than
-      a character type (<a href="#6.3">6.3</a>).
-    -- A hexadecimal floating constant cannot be represented exactly in its evaluation format
-      (<a href="#6.4.4.2">6.4.4.2</a>).
-    -- An integer character constant includes more than one character or a wide character
-      constant includes more than one multibyte character (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- The characters /* are found in a comment (<a href="#6.4.7">6.4.7</a>).
-    -- An ''unordered'' binary operator (not comma, &amp;&amp;, or ||) contains a side effect to an
-      lvalue in one operand, and a side effect to, or an access to the value of, the identical
-      lvalue in the other operand (<a href="#6.5">6.5</a>).
-    -- A function is called but no prototype has been supplied (<a href="#6.5.2.2">6.5.2.2</a>).
-    -- The arguments in a function call do not agree in number and type with those of the
-      parameters in a function definition that is not a prototype (<a href="#6.5.2.2">6.5.2.2</a>).
-    -- An object is defined but not used (<a href="#6.7">6.7</a>).
-    -- A value is given to an object of an enumerated type other than by assignment of an
-      enumeration constant that is a member of that type, or an enumeration object that has
-      the same type, or the value of a function that returns the same enumerated type
-      (<a href="#6.7.2.2">6.7.2.2</a>).
-    -- An aggregate has a partly bracketed initialization (<a href="#6.7.7">6.7.7</a>).
-    -- A statement cannot be reached (<a href="#6.8">6.8</a>).
-    -- A statement with no apparent effect is encountered (<a href="#6.8">6.8</a>).
-    -- A constant expression is used as the controlling expression of a selection statement
-      (<a href="#6.8.4">6.8.4</a>).
-
-[<a name="p487" href="#p487">page 487</a>] (<a href="#Contents">Contents</a>)
-
--- An incorrectly formed preprocessing group is encountered while skipping a
-  preprocessing group (<a href="#6.10.1">6.10.1</a>).
--- An unrecognized #pragma directive is encountered (<a href="#6.10.6">6.10.6</a>).
-
-[<a name="p488" href="#p488">page 488</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J" href="#J"><b>                                            Annex J</b></a>
-                                         (informative)
-                                      Portability issues
-1   This annex collects some information about portability that appears in this International
-    Standard.
-<a name="J.1" href="#J.1"><b>    J.1 Unspecified behavior</b></a>
-1   The following are unspecified:
-    -- The manner and timing of static initialization (<a href="#5.1.2">5.1.2</a>).
-    -- The termination status returned to the hosted environment if the return type of main
-      is not compatible with int (<a href="#5.1.2.2.3">5.1.2.2.3</a>).
-    -- The behavior of the display device if a printing character is written when the active
-      position is at the final position of a line (<a href="#5.2.2">5.2.2</a>).
-    -- The behavior of the display device if a backspace character is written when the active
-      position is at the initial position of a line (<a href="#5.2.2">5.2.2</a>).
-    -- The behavior of the display device if a horizontal tab character is written when the
-      active position is at or past the last defined horizontal tabulation position (<a href="#5.2.2">5.2.2</a>).
-    -- The behavior of the display device if a vertical tab character is written when the active
-      position is at or past the last defined vertical tabulation position (<a href="#5.2.2">5.2.2</a>).
-    -- How an extended source character that does not correspond to a universal character
-      name counts toward the significant initial characters in an external identifier (<a href="#5.2.4.1">5.2.4.1</a>).
-    -- Many aspects of the representations of types (<a href="#6.2.6">6.2.6</a>).
-    -- The value of padding bytes when storing values in structures or unions (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- The value of a union member other than the last one stored into (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- The representation used when storing a value in an object that has more than one
-      object representation for that value (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- The values of any padding bits in integer representations (<a href="#6.2.6.2">6.2.6.2</a>).
-    -- Whether certain operators can generate negative zeros and whether a negative zero
-      becomes a normal zero when stored in an object (<a href="#6.2.6.2">6.2.6.2</a>).
-    -- Whether two string literals result in distinct arrays (<a href="#6.4.5">6.4.5</a>).
-    -- The order in which subexpressions are evaluated and the order in which side effects
-      take place, except as specified for the function-call (), &amp;&amp;, ||, ?:, and comma
-      operators (<a href="#6.5">6.5</a>).
-
-[<a name="p489" href="#p489">page 489</a>] (<a href="#Contents">Contents</a>)
-
--- The order in which the function designator, arguments, and subexpressions within the
-  arguments are evaluated in a function call (<a href="#6.5.2.2">6.5.2.2</a>).
--- The order of side effects among compound literal initialization list expressions
-  (<a href="#6.5.2.5">6.5.2.5</a>).
--- The order in which the operands of an assignment operator are evaluated (<a href="#6.5.16">6.5.16</a>).
--- The alignment of the addressable storage unit allocated to hold a bit-field (<a href="#6.7.2.1">6.7.2.1</a>).
--- Whether a call to an inline function uses the inline definition or the external definition
-  of the function (<a href="#6.7.4">6.7.4</a>).
--- Whether or not a size expression is evaluated when it is part of the operand of a
-  sizeof operator and changing the value of the size expression would not affect the
-  result of the operator (<a href="#6.7.5.2">6.7.5.2</a>).
--- The order in which any side effects occur among the initialization list expressions in
-  an initializer (<a href="#6.7.8">6.7.8</a>).
--- The layout of storage for function parameters (<a href="#6.9.1">6.9.1</a>).
--- When a fully expanded macro replacement list contains a function-like macro name
-  as its last preprocessing token and the next preprocessing token from the source file is
-  a (, and the fully expanded replacement of that macro ends with the name of the first
-  macro and the next preprocessing token from the source file is again a (, whether that
-  is considered a nested replacement (<a href="#6.10.3">6.10.3</a>).
--- The order in which # and ## operations are evaluated during macro substitution
-  (<a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>).
--- Whether errno is a macro or an identifier with external linkage (<a href="#7.5">7.5</a>).
--- The state of the floating-point status flags when execution passes from a part of the
-  program translated with FENV_ACCESS ''off'' to a part translated with
-  FENV_ACCESS ''on'' (<a href="#7.6.1">7.6.1</a>).
--- The order in which feraiseexcept raises floating-point exceptions, except as
-  stated in <a href="#F.7.6">F.7.6</a> (<a href="#7.6.2.3">7.6.2.3</a>).
--- Whether math_errhandling is a macro or an identifier with external linkage
-  (<a href="#7.12">7.12</a>).
--- The results of the frexp functions when the specified value is not a floating-point
-  number (<a href="#7.12.6.4">7.12.6.4</a>).
--- The numeric result of the ilogb functions when the correct value is outside the
-  range of the return type (<a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.9.3.5">F.9.3.5</a>).
--- The result of rounding when the value is out of range (<a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.5">F.9.6.5</a>).
-
-[<a name="p490" href="#p490">page 490</a>] (<a href="#Contents">Contents</a>)
-
--- The value stored by the remquo functions in the object pointed to by quo when y is
-  zero (<a href="#7.12.10.3">7.12.10.3</a>).
--- Whether setjmp is a macro or an identifier with external linkage (<a href="#7.13">7.13</a>).
--- Whether va_copy and va_end are macros or identifiers with external linkage
-  (<a href="#7.15.1">7.15.1</a>).
--- The hexadecimal digit before the decimal point when a non-normalized floating-point
-  number is printed with an a or A conversion specifier (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
--- The value of the file position indicator after a successful call to the ungetc function
-  for a text stream, or the ungetwc function for any stream, until all pushed-back
-  characters are read or discarded (<a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.24.3.10">7.24.3.10</a>).
--- The details of the value stored by the fgetpos function (<a href="#7.19.9.1">7.19.9.1</a>).
--- The details of the value returned by the ftell function for a text stream (<a href="#7.19.9.4">7.19.9.4</a>).
--- Whether the strtod, strtof, strtold, wcstod, wcstof, and wcstold
-  functions convert a minus-signed sequence to a negative number directly or by
-  negating the value resulting from converting the corresponding unsigned sequence
-  (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
--- The order and contiguity of storage allocated by successive calls to the calloc,
-  malloc, and realloc functions (<a href="#7.20.3">7.20.3</a>).
--- The amount of storage allocated by a successful call to the calloc, malloc, or
-  realloc function when 0 bytes was requested (<a href="#7.20.3">7.20.3</a>).
--- Which of two elements that compare as equal is matched by the bsearch function
-  (<a href="#7.20.5.1">7.20.5.1</a>).
--- The order of two elements that compare as equal in an array sorted by the qsort
-  function (<a href="#7.20.5.2">7.20.5.2</a>).
--- The encoding of the calendar time returned by the time function (<a href="#7.23.2.4">7.23.2.4</a>).
--- The characters stored by the strftime or wcsftime function if any of the time
-  values being converted is outside the normal range (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
--- The conversion state after an encoding error occurs (<a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>,
-  <a href="#7.24.6.4.2">7.24.6.4.2</a>,
--- The resulting value when the ''invalid'' floating-point exception is raised during
-  IEC 60559 floating to integer conversion (<a href="#F.4">F.4</a>).
--- Whether conversion of non-integer IEC 60559 floating values to integer raises the
-  ''inexact'' floating-point exception (<a href="#F.4">F.4</a>).
-
-[<a name="p491" href="#p491">page 491</a>] (<a href="#Contents">Contents</a>)
-
-    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise the ''inexact'' floating-point
-      exception in an IEC 60559 conformant implementation (<a href="#F.9">F.9</a>).
-    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise an undeserved ''underflow''
-      floating-point exception in an IEC 60559 conformant implementation (<a href="#F.9">F.9</a>).
-    -- The exponent value stored by frexp for a NaN or infinity (<a href="#F.9.3.4">F.9.3.4</a>).
-    -- The numeric result returned by the lrint, llrint, lround, and llround
-      functions if the rounded value is outside the range of the return type (<a href="#F.9.6.5">F.9.6.5</a>, <a href="#F.9.6.7">F.9.6.7</a>).
-    -- The sign of one part of the complex result of several math functions for certain
-      exceptional values in IEC 60559 compatible implementations (<a href="#G.6.1.1">G.6.1.1</a>, <a href="#G.6.2.2">G.6.2.2</a>,
-      <a href="#G.6.2.3">G.6.2.3</a>, <a href="#G.6.2.4">G.6.2.4</a>, <a href="#G.6.2.5">G.6.2.5</a>, <a href="#G.6.2.6">G.6.2.6</a>, <a href="#G.6.3.1">G.6.3.1</a>, <a href="#G.6.4.2">G.6.4.2</a>).
-<a name="J.2" href="#J.2"><b>    J.2 Undefined behavior</b></a>
-1   The behavior is undefined in the following circumstances:
-    -- A ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated
-      (clause 4).
-    -- A nonempty source file does not end in a new-line character which is not immediately
-      preceded by a backslash character or ends in a partial preprocessing token or
-      comment (<a href="#5.1.1.2">5.1.1.2</a>).
-    -- Token concatenation produces a character sequence matching the syntax of a
-      universal character name (<a href="#5.1.1.2">5.1.1.2</a>).
-    -- A program in a hosted environment does not define a function named main using one
-      of the specified forms (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-    -- A character not in the basic source character set is encountered in a source file, except
-      in an identifier, a character constant, a string literal, a header name, a comment, or a
-      preprocessing token that is never converted to a token (<a href="#5.2.1">5.2.1</a>).
-    -- An identifier, comment, string literal, character constant, or header name contains an
-      invalid multibyte character or does not begin and end in the initial shift state (<a href="#5.2.1.2">5.2.1.2</a>).
-    -- The same identifier has both internal and external linkage in the same translation unit
-      (<a href="#6.2.2">6.2.2</a>).
-    -- An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
-    -- The value of a pointer to an object whose lifetime has ended is used (<a href="#6.2.4">6.2.4</a>).
-    -- The value of an object with automatic storage duration is used while it is
-      indeterminate (<a href="#6.2.4">6.2.4</a>, <a href="#6.7.8">6.7.8</a>, <a href="#6.8">6.8</a>).
-    -- A trap representation is read by an lvalue expression that does not have character type
-      (<a href="#6.2.6.1">6.2.6.1</a>).
-
-[<a name="p492" href="#p492">page 492</a>] (<a href="#Contents">Contents</a>)
-
--- A trap representation is produced by a side effect that modifies any part of the object
-  using an lvalue expression that does not have character type (<a href="#6.2.6.1">6.2.6.1</a>).
--- The arguments to certain operators are such that could produce a negative zero result,
-  but the implementation does not support negative zeros (<a href="#6.2.6.2">6.2.6.2</a>).
--- Two declarations of the same object or function specify types that are not compatible
-  (<a href="#6.2.7">6.2.7</a>).
--- Conversion to or from an integer type produces a value outside the range that can be
-  represented (<a href="#6.3.1.4">6.3.1.4</a>).
--- Demotion of one real floating type to another produces a value outside the range that
-  can be represented (<a href="#6.3.1.5">6.3.1.5</a>).
--- An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
--- A non-array lvalue with an incomplete type is used in a context that requires the value
-  of the designated object (<a href="#6.3.2.1">6.3.2.1</a>).
--- An lvalue having array type is converted to a pointer to the initial element of the
-  array, and the array object has register storage class (<a href="#6.3.2.1">6.3.2.1</a>).
--- An attempt is made to use the value of a void expression, or an implicit or explicit
-  conversion (except to void) is applied to a void expression (<a href="#6.3.2.2">6.3.2.2</a>).
--- Conversion of a pointer to an integer type produces a value outside the range that can
-  be represented (<a href="#6.3.2.3">6.3.2.3</a>).
--- Conversion between two pointer types produces a result that is incorrectly aligned
-  (<a href="#6.3.2.3">6.3.2.3</a>).
--- A pointer is used to call a function whose type is not compatible with the pointed-to
-  type (<a href="#6.3.2.3">6.3.2.3</a>).
--- An unmatched ' or " character is encountered on a logical source line during
-  tokenization (<a href="#6.4">6.4</a>).
--- A reserved keyword token is used in translation phase 7 or 8 for some purpose other
-  than as a keyword (<a href="#6.4.1">6.4.1</a>).
--- A universal character name in an identifier does not designate a character whose
-  encoding falls into one of the specified ranges (<a href="#6.4.2.1">6.4.2.1</a>).
--- The initial character of an identifier is a universal character name designating a digit
-  (<a href="#6.4.2.1">6.4.2.1</a>).
--- Two identifiers differ only in nonsignificant characters (<a href="#6.4.2.1">6.4.2.1</a>).
--- The identifier __func__ is explicitly declared (<a href="#6.4.2.2">6.4.2.2</a>).
-
-[<a name="p493" href="#p493">page 493</a>] (<a href="#Contents">Contents</a>)
-
--- The program attempts to modify a string literal (<a href="#6.4.5">6.4.5</a>).
--- The characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt;
-  delimiters, or the characters ', \, //, or /* occur in the sequence between the "
-  delimiters, in a header name preprocessing token (<a href="#6.4.7">6.4.7</a>).
--- Between two sequence points, an object is modified more than once, or is modified
-  and the prior value is read other than to determine the value to be stored (<a href="#6.5">6.5</a>).
--- An exceptional condition occurs during the evaluation of an expression (<a href="#6.5">6.5</a>).
--- An object has its stored value accessed other than by an lvalue of an allowable type
-  (<a href="#6.5">6.5</a>).
--- An attempt is made to modify the result of a function call, a conditional operator, an
-  assignment operator, or a comma operator, or to access it after the next sequence
-  point (<a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.15">6.5.15</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.5.17">6.5.17</a>).
--- For a call to a function without a function prototype in scope, the number of
-  arguments does not equal the number of parameters (<a href="#6.5.2.2">6.5.2.2</a>).
--- For call to a function without a function prototype in scope where the function is
-  defined with a function prototype, either the prototype ends with an ellipsis or the
-  types of the arguments after promotion are not compatible with the types of the
-  parameters (<a href="#6.5.2.2">6.5.2.2</a>).
--- For a call to a function without a function prototype in scope where the function is not
-  defined with a function prototype, the types of the arguments after promotion are not
-  compatible with those of the parameters after promotion (with certain exceptions)
-  (<a href="#6.5.2.2">6.5.2.2</a>).
--- A function is defined with a type that is not compatible with the type (of the
-  expression) pointed to by the expression that denotes the called function (<a href="#6.5.2.2">6.5.2.2</a>).
--- The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
--- A pointer is converted to other than an integer or pointer type (<a href="#6.5.4">6.5.4</a>).
--- The value of the second operand of the / or % operator is zero (<a href="#6.5.5">6.5.5</a>).
--- Addition or subtraction of a pointer into, or just beyond, an array object and an
-  integer type produces a result that does not point into, or just beyond, the same array
-  object (<a href="#6.5.6">6.5.6</a>).
--- Addition or subtraction of a pointer into, or just beyond, an array object and an
-  integer type produces a result that points just beyond the array object and is used as
-  the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
--- Pointers that do not point into, or just beyond, the same array object are subtracted
-  (<a href="#6.5.6">6.5.6</a>).
-
-[<a name="p494" href="#p494">page 494</a>] (<a href="#Contents">Contents</a>)
-
--- An array subscript is out of range, even if an object is apparently accessible with the
-  given subscript (as in the lvalue expression a[1][7] given the declaration int
-  a[4][5]) (<a href="#6.5.6">6.5.6</a>).
--- The result of subtracting two pointers is not representable in an object of type
-  ptrdiff_t (<a href="#6.5.6">6.5.6</a>).
--- An expression is shifted by a negative number or by an amount greater than or equal
-  to the width of the promoted expression (<a href="#6.5.7">6.5.7</a>).
--- An expression having signed promoted type is left-shifted and either the value of the
-  expression is negative or the result of shifting would be not be representable in the
-  promoted type (<a href="#6.5.7">6.5.7</a>).
--- Pointers that do not point to the same aggregate or union (nor just beyond the same
-  array object) are compared using relational operators (<a href="#6.5.8">6.5.8</a>).
--- An object is assigned to an inexactly overlapping object or to an exactly overlapping
-  object with incompatible type (<a href="#6.5.16.1">6.5.16.1</a>).
--- An expression that is required to be an integer constant expression does not have an
-  integer type; has operands that are not integer constants, enumeration constants,
-  character constants, sizeof expressions whose results are integer constants, or
-  immediately-cast floating constants; or contains casts (outside operands to sizeof
-  operators) other than conversions of arithmetic types to integer types (<a href="#6.6">6.6</a>).
--- A constant expression in an initializer is not, or does not evaluate to, one of the
-  following: an arithmetic constant expression, a null pointer constant, an address
-  constant, or an address constant for an object type plus or minus an integer constant
-  expression (<a href="#6.6">6.6</a>).
--- An arithmetic constant expression does not have arithmetic type; has operands that
-  are not integer constants, floating constants, enumeration constants, character
-  constants, or sizeof expressions; or contains casts (outside operands to sizeof
-  operators) other than conversions of arithmetic types to arithmetic types (<a href="#6.6">6.6</a>).
--- The value of an object is accessed by an array-subscript [], member-access . or -&gt;,
-  address &amp;, or indirection * operator or a pointer cast in creating an address constant
-  (<a href="#6.6">6.6</a>).
--- An identifier for an object is declared with no linkage and the type of the object is
-  incomplete after its declarator, or after its init-declarator if it has an initializer (<a href="#6.7">6.7</a>).
--- A function is declared at block scope with an explicit storage-class specifier other
-  than extern (<a href="#6.7.1">6.7.1</a>).
--- A structure or union is defined as containing no named members (<a href="#6.7.2.1">6.7.2.1</a>).
-
-[<a name="p495" href="#p495">page 495</a>] (<a href="#Contents">Contents</a>)
-
--- An attempt is made to access, or generate a pointer to just past, a flexible array
-  member of a structure when the referenced object provides no elements for that array
-  (<a href="#6.7.2.1">6.7.2.1</a>).
--- When the complete type is needed, an incomplete structure or union type is not
-  completed in the same scope by another declaration of the tag that defines the content
-  (<a href="#6.7.2.3">6.7.2.3</a>).
--- An attempt is made to modify an object defined with a const-qualified type through
-  use of an lvalue with non-const-qualified type (<a href="#6.7.3">6.7.3</a>).
--- An attempt is made to refer to an object defined with a volatile-qualified type through
-  use of an lvalue with non-volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
--- The specification of a function type includes any type qualifiers (<a href="#6.7.3">6.7.3</a>).
--- Two qualified types that are required to be compatible do not have the identically
-  qualified version of a compatible type (<a href="#6.7.3">6.7.3</a>).
--- An object which has been modified is accessed through a restrict-qualified pointer to
-  a const-qualified type, or through a restrict-qualified pointer and another pointer that
-  are not both based on the same object (<a href="#6.7.3.1">6.7.3.1</a>).
--- A restrict-qualified pointer is assigned a value based on another restricted pointer
-  whose associated block neither began execution before the block associated with this
-  pointer, nor ended before the assignment (<a href="#6.7.3.1">6.7.3.1</a>).
--- A function with external linkage is declared with an inline function specifier, but is
-  not also defined in the same translation unit (<a href="#6.7.4">6.7.4</a>).
--- Two pointer types that are required to be compatible are not identically qualified, or
-  are not pointers to compatible types (<a href="#6.7.5.1">6.7.5.1</a>).
--- The size expression in an array declaration is not a constant expression and evaluates
-  at program execution time to a nonpositive value (<a href="#6.7.5.2">6.7.5.2</a>).
--- In a context requiring two array types to be compatible, they do not have compatible
-  element types, or their size specifiers evaluate to unequal values (<a href="#6.7.5.2">6.7.5.2</a>).
--- A declaration of an array parameter includes the keyword static within the [ and
-  ] and the corresponding argument does not provide access to the first element of an
-  array with at least the specified number of elements (<a href="#6.7.5.3">6.7.5.3</a>).
--- A storage-class specifier or type qualifier modifies the keyword void as a function
-  parameter type list (<a href="#6.7.5.3">6.7.5.3</a>).
--- In a context requiring two function types to be compatible, they do not have
-   compatible return types, or their parameters disagree in use of the ellipsis terminator
-   or the number and type of parameters (after default argument promotion, when there
-    is no parameter type list or when one type is specified by a function definition with an
-
-[<a name="p496" href="#p496">page 496</a>] (<a href="#Contents">Contents</a>)
-
-   identifier list) (<a href="#6.7.5.3">6.7.5.3</a>).
--- The value of an unnamed member of a structure or union is used (<a href="#6.7.8">6.7.8</a>).
--- The initializer for a scalar is neither a single expression nor a single expression
-  enclosed in braces (<a href="#6.7.8">6.7.8</a>).
--- The initializer for a structure or union object that has automatic storage duration is
-  neither an initializer list nor a single expression that has compatible structure or union
-  type (<a href="#6.7.8">6.7.8</a>).
--- The initializer for an aggregate or union, other than an array initialized by a string
-  literal, is not a brace-enclosed list of initializers for its elements or members (<a href="#6.7.8">6.7.8</a>).
--- An identifier with external linkage is used, but in the program there does not exist
-  exactly one external definition for the identifier, or the identifier is not used and there
-  exist multiple external definitions for the identifier (<a href="#6.9">6.9</a>).
--- A function definition includes an identifier list, but the types of the parameters are not
-  declared in a following declaration list (<a href="#6.9.1">6.9.1</a>).
--- An adjusted parameter type in a function definition is not an object type (<a href="#6.9.1">6.9.1</a>).
--- A function that accepts a variable number of arguments is defined without a
-  parameter type list that ends with the ellipsis notation (<a href="#6.9.1">6.9.1</a>).
--- The } that terminates a function is reached, and the value of the function call is used
-  by the caller (<a href="#6.9.1">6.9.1</a>).
--- An identifier for an object with internal linkage and an incomplete type is declared
-  with a tentative definition (<a href="#6.9.2">6.9.2</a>).
--- The token defined is generated during the expansion of a #if or #elif
-  preprocessing directive, or the use of the defined unary operator does not match
-  one of the two specified forms prior to macro replacement (<a href="#6.10.1">6.10.1</a>).
--- The #include preprocessing directive that results after expansion does not match
-  one of the two header name forms (<a href="#6.10.2">6.10.2</a>).
--- The character sequence in an #include preprocessing directive does not start with a
-  letter (<a href="#6.10.2">6.10.2</a>).
--- There are sequences of preprocessing tokens within the list of macro arguments that
-  would otherwise act as preprocessing directives (<a href="#6.10.3">6.10.3</a>).
--- The result of the preprocessing operator # is not a valid character string literal
-  (<a href="#6.10.3.2">6.10.3.2</a>).
--- The result of the preprocessing operator ## is not a valid preprocessing token
-  (<a href="#6.10.3.3">6.10.3.3</a>).
-
-[<a name="p497" href="#p497">page 497</a>] (<a href="#Contents">Contents</a>)
-
--- The #line preprocessing directive that results after expansion does not match one of
-  the two well-defined forms, or its digit sequence specifies zero or a number greater
-  than 2147483647 (<a href="#6.10.4">6.10.4</a>).
--- A non-STDC #pragma preprocessing directive that is documented as causing
-  translation failure or some other form of undefined behavior is encountered (<a href="#6.10.6">6.10.6</a>).
--- A #pragma STDC preprocessing directive does not match one of the well-defined
-  forms (<a href="#6.10.6">6.10.6</a>).
--- The name of a predefined macro, or the identifier defined, is the subject of a
-  #define or #undef preprocessing directive (<a href="#6.10.8">6.10.8</a>).
--- An attempt is made to copy an object to an overlapping object by use of a library
-  function, other than as explicitly allowed (e.g., memmove) (clause 7).
--- A file with the same name as one of the standard headers, not provided as part of the
-  implementation, is placed in any of the standard places that are searched for included
-  source files (<a href="#7.1.2">7.1.2</a>).
--- A header is included within an external declaration or definition (<a href="#7.1.2">7.1.2</a>).
--- A function, object, type, or macro that is specified as being declared or defined by
-  some standard header is used before any header that declares or defines it is included
-  (<a href="#7.1.2">7.1.2</a>).
--- A standard header is included while a macro is defined with the same name as a
-  keyword (<a href="#7.1.2">7.1.2</a>).
--- The program attempts to declare a library function itself, rather than via a standard
-  header, but the declaration does not have external linkage (<a href="#7.1.2">7.1.2</a>).
--- The program declares or defines a reserved identifier, other than as allowed by <a href="#7.1.4">7.1.4</a>
-  (<a href="#7.1.3">7.1.3</a>).
--- The program removes the definition of a macro whose name begins with an
-  underscore and either an uppercase letter or another underscore (<a href="#7.1.3">7.1.3</a>).
--- An argument to a library function has an invalid value or a type not expected by a
-  function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
--- The pointer passed to a library function array parameter does not have a value such
-  that all address computations and object accesses are valid (<a href="#7.1.4">7.1.4</a>).
--- The macro definition of assert is suppressed in order to access an actual function
-  (<a href="#7.2">7.2</a>).
--- The argument to the assert macro does not have a scalar type (<a href="#7.2">7.2</a>).
--- The CX_LIMITED_RANGE, FENV_ACCESS, or FP_CONTRACT pragma is used in
-  any context other than outside all external declarations or preceding all explicit
-
-[<a name="p498" href="#p498">page 498</a>] (<a href="#Contents">Contents</a>)
-
-   declarations and statements inside a compound statement (<a href="#7.3.4">7.3.4</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.12.2">7.12.2</a>).
--- The value of an argument to a character handling function is neither equal to the value
-  of EOF nor representable as an unsigned char (<a href="#7.4">7.4</a>).
--- A macro definition of errno is suppressed in order to access an actual object, or the
-  program defines an identifier with the name errno (<a href="#7.5">7.5</a>).
--- Part of the program tests floating-point status flags, sets floating-point control modes,
-  or runs under non-default mode settings, but was translated with the state for the
-  FENV_ACCESS pragma ''off'' (<a href="#7.6.1">7.6.1</a>).
--- The exception-mask argument for one of the functions that provide access to the
-  floating-point status flags has a nonzero value not obtained by bitwise OR of the
-  floating-point exception macros (<a href="#7.6.2">7.6.2</a>).
--- The fesetexceptflag function is used to set floating-point status flags that were
-  not specified in the call to the fegetexceptflag function that provided the value
-  of the corresponding fexcept_t object (<a href="#7.6.2.4">7.6.2.4</a>).
--- The argument to fesetenv or feupdateenv is neither an object set by a call to
-  fegetenv or feholdexcept, nor is it an environment macro (<a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>).
--- The value of the result of an integer arithmetic or conversion function cannot be
-  represented (<a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.6.1">7.20.6.1</a>, <a href="#7.20.6.2">7.20.6.2</a>, <a href="#7.20.1">7.20.1</a>).
--- The program modifies the string pointed to by the value returned by the setlocale
-  function (<a href="#7.11.1.1">7.11.1.1</a>).
--- The program modifies the structure pointed to by the value returned by the
-  localeconv function (<a href="#7.11.2.1">7.11.2.1</a>).
--- A macro definition of math_errhandling is suppressed or the program defines
-  an identifier with the name math_errhandling (<a href="#7.12">7.12</a>).
--- An argument to a floating-point classification or comparison macro is not of real
-  floating type (<a href="#7.12.3">7.12.3</a>, <a href="#7.12.14">7.12.14</a>).
--- A macro definition of setjmp is suppressed in order to access an actual function, or
-  the program defines an external identifier with the name setjmp (<a href="#7.13">7.13</a>).
--- An invocation of the setjmp macro occurs other than in an allowed context
-  (<a href="#7.13.2.1">7.13.2.1</a>).
--- The longjmp function is invoked to restore a nonexistent environment (<a href="#7.13.2.1">7.13.2.1</a>).
--- After a longjmp, there is an attempt to access the value of an object of automatic
-  storage class with non-volatile-qualified type, local to the function containing the
-  invocation of the corresponding setjmp macro, that was changed between the
-  setjmp invocation and longjmp call (<a href="#7.13.2.1">7.13.2.1</a>).
-
-[<a name="p499" href="#p499">page 499</a>] (<a href="#Contents">Contents</a>)
-
--- The program specifies an invalid pointer to a signal handler function (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal handler returns when the signal corresponded to a computational exception
-  (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal occurs as the result of calling the abort or raise function, and the signal
-  handler calls the raise function (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal occurs other than as the result of calling the abort or raise function, and
-  the signal handler refers to an object with static storage duration other than by
-  assigning a value to an object declared as volatile sig_atomic_t, or calls any
-  function in the standard library other than the abort function, the _Exit function,
-  or the signal function (for the same signal number) (<a href="#7.14.1.1">7.14.1.1</a>).
--- The value of errno is referred to after a signal occurred other than as the result of
-  calling the abort or raise function and the corresponding signal handler obtained
-  a SIG_ERR return from a call to the signal function (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal is generated by an asynchronous signal handler (<a href="#7.14.1.1">7.14.1.1</a>).
--- A function with a variable number of arguments attempts to access its varying
-  arguments other than through a properly declared and initialized va_list object, or
-  before the va_start macro is invoked (<a href="#7.15">7.15</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.4">7.15.1.4</a>).
--- The macro va_arg is invoked using the parameter ap that was passed to a function
-  that invoked the macro va_arg with the same parameter (<a href="#7.15">7.15</a>).
--- A macro definition of va_start, va_arg, va_copy, or va_end is suppressed in
-  order to access an actual function, or the program defines an external identifier with
-  the name va_copy or va_end (<a href="#7.15.1">7.15.1</a>).
--- The va_start or va_copy macro is invoked without a corresponding invocation
-  of the va_end macro in the same function, or vice versa (<a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.3">7.15.1.3</a>,
-  <a href="#7.15.1.4">7.15.1.4</a>).
--- The type parameter to the va_arg macro is not such that a pointer to an object of
-  that type can be obtained simply by postfixing a * (<a href="#7.15.1.1">7.15.1.1</a>).
--- The va_arg macro is invoked when there is no actual next argument, or with a
-  specified type that is not compatible with the promoted type of the actual next
-  argument, with certain exceptions (<a href="#7.15.1.1">7.15.1.1</a>).
--- The va_copy or va_start macro is called to initialize a va_list that was
-  previously initialized by either macro without an intervening invocation of the
-  va_end macro for the same va_list (<a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.4">7.15.1.4</a>).
--- The parameter parmN of a va_start macro is declared with the register
-  storage class, with a function or array type, or with a type that is not compatible with
-  the type that results after application of the default argument promotions (<a href="#7.15.1.4">7.15.1.4</a>).
-
-[<a name="p500" href="#p500">page 500</a>] (<a href="#Contents">Contents</a>)
-
--- The member designator parameter of an offsetof macro is an invalid right
-  operand of the . operator for the type parameter, or designates a bit-field (<a href="#7.17">7.17</a>).
--- The argument in an instance of one of the integer-constant macros is not a decimal,
-  octal, or hexadecimal constant, or it has a value that exceeds the limits for the
-  corresponding type (<a href="#7.18.4">7.18.4</a>).
--- A byte input/output function is applied to a wide-oriented stream, or a wide character
-  input/output function is applied to a byte-oriented stream (<a href="#7.19.2">7.19.2</a>).
--- Use is made of any portion of a file beyond the most recent wide character written to
-  a wide-oriented stream (<a href="#7.19.2">7.19.2</a>).
--- The value of a pointer to a FILE object is used after the associated file is closed
-  (<a href="#7.19.3">7.19.3</a>).
--- The stream for the fflush function points to an input stream or to an update stream
-  in which the most recent operation was input (<a href="#7.19.5.2">7.19.5.2</a>).
--- The string pointed to by the mode argument in a call to the fopen function does not
-  exactly match one of the specified character sequences (<a href="#7.19.5.3">7.19.5.3</a>).
--- An output operation on an update stream is followed by an input operation without an
-  intervening call to the fflush function or a file positioning function, or an input
-  operation on an update stream is followed by an output operation with an intervening
-  call to a file positioning function (<a href="#7.19.5.3">7.19.5.3</a>).
--- An attempt is made to use the contents of the array that was supplied in a call to the
-  setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>).
--- There are insufficient arguments for the format in a call to one of the formatted
-  input/output functions, or an argument does not have an appropriate type (<a href="#7.19.6.1">7.19.6.1</a>,
-  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- The format in a call to one of the formatted input/output functions or to the
-  strftime or wcsftime function is not a valid multibyte character sequence that
-  begins and ends in its initial shift state (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>,
-  <a href="#7.24.5.1">7.24.5.1</a>).
--- In a call to one of the formatted output functions, a precision appears with a
-  conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
--- A conversion specification for a formatted output function uses an asterisk to denote
-  an argument-supplied field width or precision, but the corresponding argument is not
-  provided (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
--- A conversion specification for a formatted output function uses a # or 0 flag with a
-  conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
-
-[<a name="p501" href="#p501">page 501</a>] (<a href="#Contents">Contents</a>)
-
--- A conversion specification for one of the formatted input/output functions uses a
-  length modifier with a conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>,
-  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- An s conversion specifier is encountered by one of the formatted output functions,
-  and the argument is missing the null terminator (unless a precision is specified that
-  does not require null termination) (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
--- An n conversion specification for one of the formatted input/output functions includes
-  any flags, an assignment-suppressing character, a field width, or a precision (<a href="#7.19.6.1">7.19.6.1</a>,
-  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- A % conversion specifier is encountered by one of the formatted input/output
-  functions, but the complete conversion specification is not exactly %% (<a href="#7.19.6.1">7.19.6.1</a>,
-  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- An invalid conversion specification is found in the format for one of the formatted
-  input/output functions, or the strftime or wcsftime function (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,
-  <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.5.1">7.24.5.1</a>).
--- The number of characters transmitted by a formatted output function is greater than
-  INT_MAX (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.10">7.19.6.10</a>).
--- The result of a conversion by one of the formatted input functions cannot be
-  represented in the corresponding object, or the receiving object does not have an
-  appropriate type (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- A c, s, or [ conversion specifier is encountered by one of the formatted input
-  functions, and the array pointed to by the corresponding argument is not large enough
-  to accept the input sequence (and a null terminator if the conversion specifier is s or
-  [) (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- A c, s, or [ conversion specifier with an l qualifier is encountered by one of the
-  formatted input functions, but the input is not a valid multibyte character sequence
-  that begins in the initial shift state (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- The input item for a %p conversion by one of the formatted input functions is not a
-  value converted earlier during the same program execution (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
--- The vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf,
-  vsscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, or
-  vwscanf function is called with an improperly initialized va_list argument, or
-  the argument is used (other than in an invocation of va_end) after the function
-  returns (<a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>, <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
-  <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>).
--- The contents of the array supplied in a call to the fgets, gets, or fgetws function
-  are used after a read error occurred (<a href="#7.19.7.2">7.19.7.2</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.24.3.2">7.24.3.2</a>).
-
-[<a name="p502" href="#p502">page 502</a>] (<a href="#Contents">Contents</a>)
-
--- The file position indicator for a binary stream is used after a call to the ungetc
-  function where its value was zero before the call (<a href="#7.19.7.11">7.19.7.11</a>).
--- The file position indicator for a stream is used after an error occurred during a call to
-  the fread or fwrite function (<a href="#7.19.8.1">7.19.8.1</a>, <a href="#7.19.8.2">7.19.8.2</a>).
--- A partial element read by a call to the fread function is used (<a href="#7.19.8.1">7.19.8.1</a>).
--- The fseek function is called for a text stream with a nonzero offset and either the
-  offset was not returned by a previous successful call to the ftell function on a
-  stream associated with the same file or whence is not SEEK_SET (<a href="#7.19.9.2">7.19.9.2</a>).
--- The fsetpos function is called to set a position that was not returned by a previous
-  successful call to the fgetpos function on a stream associated with the same file
-  (<a href="#7.19.9.3">7.19.9.3</a>).
--- A non-null pointer returned by a call to the calloc, malloc, or realloc function
-  with a zero requested size is used to access an object (<a href="#7.20.3">7.20.3</a>).
--- The value of a pointer that refers to space deallocated by a call to the free or
-  realloc function is used (<a href="#7.20.3">7.20.3</a>).
--- The pointer argument to the free or realloc function does not match a pointer
-  earlier returned by calloc, malloc, or realloc, or the space has been
-  deallocated by a call to free or realloc (<a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>).
--- The value of the object allocated by the malloc function is used (<a href="#7.20.3.3">7.20.3.3</a>).
--- The value of any bytes in a new object allocated by the realloc function beyond
-  the size of the old object are used (<a href="#7.20.3.4">7.20.3.4</a>).
--- The program executes more than one call to the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
--- During the call to a function registered with the atexit function, a call is made to
-  the longjmp function that would terminate the call to the registered function
-  (<a href="#7.20.4.3">7.20.4.3</a>).
--- The string set up by the getenv or strerror function is modified by the program
-  (<a href="#7.20.4.5">7.20.4.5</a>, <a href="#7.21.6.2">7.21.6.2</a>).
--- A command is executed through the system function in a way that is documented as
-  causing termination or some other form of undefined behavior (<a href="#7.20.4.6">7.20.4.6</a>).
--- A searching or sorting utility function is called with an invalid pointer argument, even
-  if the number of elements is zero (<a href="#7.20.5">7.20.5</a>).
--- The comparison function called by a searching or sorting utility function alters the
-  contents of the array being searched or sorted, or returns ordering values
-  inconsistently (<a href="#7.20.5">7.20.5</a>).
-
-[<a name="p503" href="#p503">page 503</a>] (<a href="#Contents">Contents</a>)
-
--- The array being searched by the bsearch function does not have its elements in
-  proper order (<a href="#7.20.5.1">7.20.5.1</a>).
--- The current conversion state is used by a multibyte/wide character conversion
-  function after changing the LC_CTYPE category (<a href="#7.20.7">7.20.7</a>).
--- A string or wide string utility function is instructed to access an array beyond the end
-  of an object (<a href="#7.21.1">7.21.1</a>, <a href="#7.24.4">7.24.4</a>).
--- A string or wide string utility function is called with an invalid pointer argument, even
-  if the length is zero (<a href="#7.21.1">7.21.1</a>, <a href="#7.24.4">7.24.4</a>).
--- The contents of the destination array are used after a call to the strxfrm,
-  strftime, wcsxfrm, or wcsftime function in which the specified length was
-  too small to hold the entire null-terminated result (<a href="#7.21.4.5">7.21.4.5</a>, <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>,
-  <a href="#7.24.5.1">7.24.5.1</a>).
--- The first argument in the very first call to the strtok or wcstok is a null pointer
-  (<a href="#7.21.5.8">7.21.5.8</a>, <a href="#7.24.4.5.7">7.24.4.5.7</a>).
--- The type of an argument to a type-generic macro is not compatible with the type of
-  the corresponding parameter of the selected function (<a href="#7.22">7.22</a>).
--- A complex argument is supplied for a generic parameter of a type-generic macro that
-  has no corresponding complex function (<a href="#7.22">7.22</a>).
--- The argument corresponding to an s specifier without an l qualifier in a call to the
-  fwprintf function does not point to a valid multibyte character sequence that
-  begins in the initial shift state (<a href="#7.24.2.11">7.24.2.11</a>).
--- In a call to the wcstok function, the object pointed to by ptr does not have the
-  value stored by the previous call for the same wide string (<a href="#7.24.4.5.7">7.24.4.5.7</a>).
--- An mbstate_t object is used inappropriately (<a href="#7.24.6">7.24.6</a>).
--- The value of an argument of type wint_t to a wide character classification or case
-  mapping function is neither equal to the value of WEOF nor representable as a
-  wchar_t (<a href="#7.25.1">7.25.1</a>).
--- The iswctype function is called using a different LC_CTYPE category from the
-  one in effect for the call to the wctype function that returned the description
-  (<a href="#7.25.2.2.1">7.25.2.2.1</a>).
--- The towctrans function is called using a different LC_CTYPE category from the
-  one in effect for the call to the wctrans function that returned the description
-  (<a href="#7.25.3.2.1">7.25.3.2.1</a>).
-
-[<a name="p504" href="#p504">page 504</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3" href="#J.3"><b>    J.3 Implementation-defined behavior</b></a>
-1   A conforming implementation is required to document its choice of behavior in each of
-    the areas listed in this subclause. The following are implementation-defined:
-<a name="J.3.1" href="#J.3.1"><b>    J.3.1 Translation</b></a>
-1   -- How a diagnostic is identified (<a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>).
-    -- Whether each nonempty sequence of white-space characters other than new-line is
-      retained or replaced by one space character in translation phase 3 (<a href="#5.1.1.2">5.1.1.2</a>).
-<a name="J.3.2" href="#J.3.2"><b>    J.3.2 Environment</b></a>
-1   -- The mapping between physical source file multibyte characters and the source
-      character set in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>).
-    -- The name and type of the function called at program startup in a freestanding
-      environment (<a href="#5.1.2.1">5.1.2.1</a>).
-    -- The effect of program termination in a freestanding environment (<a href="#5.1.2.1">5.1.2.1</a>).
-    -- An alternative manner in which the main function may be defined (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-    -- The values given to the strings pointed to by the argv argument to main (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-    -- What constitutes an interactive device (<a href="#5.1.2.3">5.1.2.3</a>).
-    -- The set of signals, their semantics, and their default handling (<a href="#7.14">7.14</a>).
-    -- Signal values other than SIGFPE, SIGILL, and SIGSEGV that correspond to a
-      computational exception (<a href="#7.14.1.1">7.14.1.1</a>).
-    -- Signals for which the equivalent of signal(sig, SIG_IGN); is executed at
-      program startup (<a href="#7.14.1.1">7.14.1.1</a>).
-    -- The set of environment names and the method for altering the environment list used
-      by the getenv function (<a href="#7.20.4.5">7.20.4.5</a>).
-    -- The manner of execution of the string by the system function (<a href="#7.20.4.6">7.20.4.6</a>).
-<a name="J.3.3" href="#J.3.3"><b>    J.3.3 Identifiers</b></a>
-1   -- Which additional multibyte characters may appear in identifiers and their
-      correspondence to universal character names (<a href="#6.4.2">6.4.2</a>).
-    -- The number of significant initial characters in an identifier (<a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2">6.4.2</a>).
-
-[<a name="p505" href="#p505">page 505</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3.4" href="#J.3.4"><b>    J.3.4 Characters</b></a>
-1   -- The number of bits in a byte (<a href="#3.6">3.6</a>).
-    -- The values of the members of the execution character set (<a href="#5.2.1">5.2.1</a>).
-    -- The unique value of the member of the execution character set produced for each of
-      the standard alphabetic escape sequences (<a href="#5.2.2">5.2.2</a>).
-    -- The value of a char object into which has been stored any character other than a
-      member of the basic execution character set (<a href="#6.2.5">6.2.5</a>).
-    -- Which of signed char or unsigned char has the same range, representation,
-      and behavior as ''plain'' char (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>).
-    -- The mapping of members of the source character set (in character constants and string
-      literals) to members of the execution character set (<a href="#6.4.4.4">6.4.4.4</a>, <a href="#5.1.1.2">5.1.1.2</a>).
-    -- The value of an integer character constant containing more than one character or
-      containing a character or escape sequence that does not map to a single-byte
-      execution character (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- The value of a wide character constant containing more than one multibyte character,
-      or containing a multibyte character or escape sequence not represented in the
-      extended execution character set (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- The current locale used to convert a wide character constant consisting of a single
-      multibyte character that maps to a member of the extended execution character set
-      into a corresponding wide character code (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- The current locale used to convert a wide string literal into corresponding wide
-      character codes (<a href="#6.4.5">6.4.5</a>).
-    -- The value of a string literal containing a multibyte character or escape sequence not
-      represented in the execution character set (<a href="#6.4.5">6.4.5</a>).
-<a name="J.3.5" href="#J.3.5"><b>    J.3.5 Integers</b></a>
-1   -- Any extended integer types that exist in the implementation (<a href="#6.2.5">6.2.5</a>).
-    -- Whether signed integer types are represented using sign and magnitude, two's
-      complement, or ones' complement, and whether the extraordinary value is a trap
-      representation or an ordinary value (<a href="#6.2.6.2">6.2.6.2</a>).
-    -- The rank of any extended integer type relative to another extended integer type with
-      the same precision (<a href="#6.3.1.1">6.3.1.1</a>).
-    -- The result of, or the signal raised by, converting an integer to a signed integer type
-      when the value cannot be represented in an object of that type (<a href="#6.3.1.3">6.3.1.3</a>).
-
-[<a name="p506" href="#p506">page 506</a>] (<a href="#Contents">Contents</a>)
-
-    -- The results of some bitwise operations on signed integers (<a href="#6.5">6.5</a>).
-<a name="J.3.6" href="#J.3.6"><b>    J.3.6 Floating point</b></a>
-1   -- The accuracy of the floating-point operations and of the library functions in
-      <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The accuracy of the conversions between floating-point internal representations and
-      string representations performed by the library functions in <a href="#7.19">&lt;stdio.h&gt;</a>,
-      <a href="#7.20">&lt;stdlib.h&gt;</a>, and <a href="#7.24">&lt;wchar.h&gt;</a> (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The rounding behaviors characterized by non-standard values of FLT_ROUNDS
-      (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The evaluation methods characterized by non-standard negative values of
-      FLT_EVAL_METHOD (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The direction of rounding when an integer is converted to a floating-point number that
-      cannot exactly represent the original value (<a href="#6.3.1.4">6.3.1.4</a>).
-    -- The direction of rounding when a floating-point number is converted to a narrower
-      floating-point number (<a href="#6.3.1.5">6.3.1.5</a>).
-    -- How the nearest representable value or the larger or smaller representable value
-      immediately adjacent to the nearest representable value is chosen for certain floating
-      constants (<a href="#6.4.4.2">6.4.4.2</a>).
-    -- Whether and how floating expressions are contracted when not disallowed by the
-      FP_CONTRACT pragma (<a href="#6.5">6.5</a>).
-    -- The default state for the FENV_ACCESS pragma (<a href="#7.6.1">7.6.1</a>).
-    -- Additional floating-point exceptions, rounding             modes,    environments,   and
-      classifications, and their macro names (<a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>).
-    -- The default state for the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>).                                    *
-<a name="J.3.7" href="#J.3.7"><b>    J.3.7 Arrays and pointers</b></a>
-1   -- The result of converting a pointer to an integer or vice versa (<a href="#6.3.2.3">6.3.2.3</a>).
-    -- The size of the result of subtracting two pointers to elements of the same array
-      (<a href="#6.5.6">6.5.6</a>).
-
-[<a name="p507" href="#p507">page 507</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3.8" href="#J.3.8"><b>    J.3.8 Hints</b></a>
-1   -- The extent to which suggestions made by using the register storage-class
-      specifier are effective (<a href="#6.7.1">6.7.1</a>).
-    -- The extent to which suggestions made by using the inline function specifier are
-      effective (<a href="#6.7.4">6.7.4</a>).
-<a name="J.3.9" href="#J.3.9"><b>    J.3.9 Structures, unions, enumerations, and bit-fields</b></a>
-1   -- Whether a ''plain'' int bit-field is treated as a signed int bit-field or as an
-      unsigned int bit-field (<a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.1">6.7.2.1</a>).
-    -- Allowable bit-field types other than _Bool, signed int, and unsigned int
-      (<a href="#6.7.2.1">6.7.2.1</a>).
-    -- Whether a bit-field can straddle a storage-unit boundary (<a href="#6.7.2.1">6.7.2.1</a>).
-    -- The order of allocation of bit-fields within a unit (<a href="#6.7.2.1">6.7.2.1</a>).
-    -- The alignment of non-bit-field members of structures (<a href="#6.7.2.1">6.7.2.1</a>). This should present
-      no problem unless binary data written by one implementation is read by another.
-    -- The integer type compatible with each enumerated type (<a href="#6.7.2.2">6.7.2.2</a>).
-<a name="J.3.10" href="#J.3.10"><b>    J.3.10 Qualifiers</b></a>
-1   -- What constitutes an access to an object that has volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
-<a name="J.3.11" href="#J.3.11"><b>    J.3.11 Preprocessing directives</b></a>
-1   -- The locations within #pragma directives where header name preprocessing tokens
-      are recognized (<a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>).
-    -- How sequences in both forms of header names are mapped to headers or external
-      source file names (<a href="#6.4.7">6.4.7</a>).
-    -- Whether the value of a character constant in a constant expression that controls
-      conditional inclusion matches the value of the same character constant in the
-      execution character set (<a href="#6.10.1">6.10.1</a>).
-    -- Whether the value of a single-character character constant in a constant expression
-      that controls conditional inclusion may have a negative value (<a href="#6.10.1">6.10.1</a>).
-    -- The places that are searched for an included &lt; &gt; delimited header, and how the places
-      are specified or the header is identified (<a href="#6.10.2">6.10.2</a>).
-    -- How the named source file is searched for in an included " " delimited header
-      (<a href="#6.10.2">6.10.2</a>).
-    -- The method by which preprocessing tokens (possibly resulting from macro
-      expansion) in a #include directive are combined into a header name (<a href="#6.10.2">6.10.2</a>).
-
-[<a name="p508" href="#p508">page 508</a>] (<a href="#Contents">Contents</a>)
-
-    -- The nesting limit for #include processing (<a href="#6.10.2">6.10.2</a>).
-    -- Whether the # operator inserts a \ character before the \ character that begins a
-      universal character name in a character constant or string literal (<a href="#6.10.3.2">6.10.3.2</a>).
-    -- The behavior on each recognized non-STDC #pragma directive (<a href="#6.10.6">6.10.6</a>).
-    -- The definitions for __DATE__ and __TIME__ when respectively, the date and
-      time of translation are not available (<a href="#6.10.8">6.10.8</a>).
-<a name="J.3.12" href="#J.3.12"><b>    J.3.12 Library functions</b></a>
-1   -- Any library facilities available to a freestanding program, other than the minimal set
-      required by clause 4 (<a href="#5.1.2.1">5.1.2.1</a>).
-    -- The format of the diagnostic printed by the assert macro (<a href="#7.2.1.1">7.2.1.1</a>).
-    -- The representation of the floating-point               status   flags     stored   by   the
-      fegetexceptflag function (<a href="#7.6.2.2">7.6.2.2</a>).
-    -- Whether the feraiseexcept function raises the ''inexact'' floating-point
-      exception in addition to the ''overflow'' or ''underflow'' floating-point exception
-      (<a href="#7.6.2.3">7.6.2.3</a>).
-    -- Strings other than "C" and "" that may be passed as the second argument to the
-      setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
-    -- The types defined for float_t and double_t when the value of the
-      FLT_EVAL_METHOD macro is less than 0 (<a href="#7.12">7.12</a>).
-    -- Domain errors for the mathematics functions, other than those required by this
-      International Standard (<a href="#7.12.1">7.12.1</a>).
-    -- The values returned by the mathematics functions on domain errors (<a href="#7.12.1">7.12.1</a>).
-    -- The values returned by the mathematics functions on underflow range errors, whether
-      errno is set to the value of the macro ERANGE when the integer expression
-      math_errhandling &amp; MATH_ERRNO is nonzero, and whether the ''underflow''
-      floating-point exception is raised when the integer expression math_errhandling
-      &amp; MATH_ERREXCEPT is nonzero. (<a href="#7.12.1">7.12.1</a>).
-    -- Whether a domain error occurs or zero is returned when an fmod function has a
-      second argument of zero (<a href="#7.12.10.1">7.12.10.1</a>).
-    -- Whether a domain error occurs or zero is returned when a remainder function has
-      a second argument of zero (<a href="#7.12.10.2">7.12.10.2</a>).
-    -- The base-2 logarithm of the modulus used by the remquo functions in reducing the
-      quotient (<a href="#7.12.10.3">7.12.10.3</a>).
-
-[<a name="p509" href="#p509">page 509</a>] (<a href="#Contents">Contents</a>)
-
--- Whether a domain error occurs or zero is returned when a remquo function has a
-  second argument of zero (<a href="#7.12.10.3">7.12.10.3</a>).
--- Whether the equivalent of signal(sig, SIG_DFL); is executed prior to the call
-  of a signal handler, and, if not, the blocking of signals that is performed (<a href="#7.14.1.1">7.14.1.1</a>).
--- The null pointer constant to which the macro NULL expands (<a href="#7.17">7.17</a>).
--- Whether the last line of a text stream requires a terminating new-line character
-  (<a href="#7.19.2">7.19.2</a>).
--- Whether space characters that are written out to a text stream immediately before a
-  new-line character appear when read in (<a href="#7.19.2">7.19.2</a>).
--- The number of null characters that may be appended to data written to a binary
-  stream (<a href="#7.19.2">7.19.2</a>).
--- Whether the file position indicator of an append-mode stream is initially positioned at
-  the beginning or end of the file (<a href="#7.19.3">7.19.3</a>).
--- Whether a write on a text stream causes the associated file to be truncated beyond that
-  point (<a href="#7.19.3">7.19.3</a>).
--- The characteristics of file buffering (<a href="#7.19.3">7.19.3</a>).
--- Whether a zero-length file actually exists (<a href="#7.19.3">7.19.3</a>).
--- The rules for composing valid file names (<a href="#7.19.3">7.19.3</a>).
--- Whether the same file can be simultaneously open multiple times (<a href="#7.19.3">7.19.3</a>).
--- The nature and choice of encodings used for multibyte characters in files (<a href="#7.19.3">7.19.3</a>).
--- The effect of the remove function on an open file (<a href="#7.19.4.1">7.19.4.1</a>).
--- The effect if a file with the new name exists prior to a call to the rename function
-  (<a href="#7.19.4.2">7.19.4.2</a>).
--- Whether an open temporary file is removed upon abnormal program termination
-  (<a href="#7.19.4.3">7.19.4.3</a>).
--- Which changes of mode are permitted (if any), and under what circumstances
-  (<a href="#7.19.5.4">7.19.5.4</a>).
--- The style used to print an infinity or NaN, and the meaning of any n-char or n-wchar
-  sequence printed for a NaN (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
--- The output for %p conversion in the fprintf or fwprintf function (<a href="#7.19.6.1">7.19.6.1</a>,
-  <a href="#7.24.2.1">7.24.2.1</a>).
--- The interpretation of a - character that is neither the first nor the last character, nor
-    the second where a ^ character is the first, in the scanlist for %[ conversion in the
-   fscanf or fwscanf function (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>).
-
-[<a name="p510" href="#p510">page 510</a>] (<a href="#Contents">Contents</a>)
-
-    -- The set of sequences matched by a %p conversion and the interpretation of the
-      corresponding input item in the fscanf or fwscanf function (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
-    -- The value to which the macro errno is set by the fgetpos, fsetpos, or ftell
-      functions on failure (<a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.9.4">7.19.9.4</a>).
-    -- The meaning of any n-char or n-wchar sequence in a string representing a NaN that is
-      converted by the strtod, strtof, strtold, wcstod, wcstof, or wcstold
-      function (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
-    -- Whether or not the strtod, strtof, strtold, wcstod, wcstof, or wcstold
-      function sets errno to ERANGE when underflow occurs (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
-    -- Whether the calloc, malloc, and realloc functions return a null pointer or a
-      pointer to an allocated object when the size requested is zero (<a href="#7.20.3">7.20.3</a>).
-    -- Whether open streams with unwritten buffered data are flushed, open streams are
-      closed, or temporary files are removed when the abort or _Exit function is called
-      (<a href="#7.20.4.1">7.20.4.1</a>, <a href="#7.20.4.4">7.20.4.4</a>).
-    -- The termination status returned to the host environment by the abort, exit, or
-      _Exit function (<a href="#7.20.4.1">7.20.4.1</a>, <a href="#7.20.4.3">7.20.4.3</a>, <a href="#7.20.4.4">7.20.4.4</a>).
-    -- The value returned by the system function when its argument is not a null pointer
-      (<a href="#7.20.4.6">7.20.4.6</a>).
-    -- The local time zone and Daylight Saving Time (<a href="#7.23.1">7.23.1</a>).
-    -- The range and precision of times representable in clock_t and time_t (<a href="#7.23">7.23</a>).
-    -- The era for the clock function (<a href="#7.23.2.1">7.23.2.1</a>).
-    -- The replacement string for the %Z specifier to the strftime, and wcsftime
-      functions in the "C" locale (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
-    -- Whether the functions in <a href="#7.12">&lt;math.h&gt;</a> honor the rounding direction mode in an
-      IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.9">F.9</a>).
-<a name="J.3.13" href="#J.3.13"><b>    J.3.13 Architecture</b></a>
-1   -- The values or expressions assigned to the macros specified in the headers
-      <a href="#7.7">&lt;float.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, and <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#5.2.4.2">5.2.4.2</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>).
-    -- The number, order, and encoding of bytes in any object (when not explicitly specified
-      in this International Standard) (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- The value of the result of the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>).
-
-[<a name="p511" href="#p511">page 511</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.4" href="#J.4"><b>    J.4 Locale-specific behavior</b></a>
-1   The following characteristics of a hosted environment are locale-specific and are required
-    to be documented by the implementation:
-    -- Additional members of the source and execution character sets beyond the basic
-      character set (<a href="#5.2.1">5.2.1</a>).
-    -- The presence, meaning, and representation of additional multibyte characters in the
-      execution character set beyond the basic character set (<a href="#5.2.1.2">5.2.1.2</a>).
-    -- The shift states used for the encoding of multibyte characters (<a href="#5.2.1.2">5.2.1.2</a>).
-    -- The direction of writing of successive printing characters (<a href="#5.2.2">5.2.2</a>).
-    -- The decimal-point character (<a href="#7.1.1">7.1.1</a>).
-    -- The set of printing characters (<a href="#7.4">7.4</a>, <a href="#7.25.2">7.25.2</a>).
-    -- The set of control characters (<a href="#7.4">7.4</a>, <a href="#7.25.2">7.25.2</a>).
-    -- The sets of characters tested for by the isalpha, isblank, islower, ispunct,
-      isspace, isupper, iswalpha, iswblank, iswlower, iswpunct,
-      iswspace, or iswupper functions (<a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>,
-      <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>).
-    -- The native environment (<a href="#7.11.1.1">7.11.1.1</a>).
-    -- Additional subject sequences accepted by the numeric conversion functions (<a href="#7.20.1">7.20.1</a>,
-      <a href="#7.24.4.1">7.24.4.1</a>).
-    -- The collation sequence of the execution character set (<a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.24.4.4.2">7.24.4.4.2</a>).
-    -- The contents of the error message strings set up by the strerror function
-      (<a href="#7.21.6.2">7.21.6.2</a>).
-    -- The formats for time and date (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
-    -- Character mappings that are supported by the towctrans function (<a href="#7.25.1">7.25.1</a>).
-    -- Character classifications that are supported by the iswctype function (<a href="#7.25.1">7.25.1</a>).
-
-[<a name="p512" href="#p512">page 512</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.5" href="#J.5"><b>    J.5 Common extensions</b></a>
-1   The following extensions are widely used in many systems, but are not portable to all
-    implementations. The inclusion of any extension that may cause a strictly conforming
-    program to become invalid renders an implementation nonconforming. Examples of such
-    extensions are new keywords, extra library functions declared in standard headers, or
-    predefined macros with names that do not begin with an underscore.
-<a name="J.5.1" href="#J.5.1"><b>    J.5.1 Environment arguments</b></a>
-1   In a hosted environment, the main function receives a third argument, char *envp[],
-    that points to a null-terminated array of pointers to char, each of which points to a string
-    that provides information about the environment for this execution of the program
-    (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-<a name="J.5.2" href="#J.5.2"><b>    J.5.2 Specialized identifiers</b></a>
-1   Characters other than the underscore _, letters, and digits, that are not part of the basic
-    source character set (such as the dollar sign $, or characters in national character sets)
-    may appear in an identifier (<a href="#6.4.2">6.4.2</a>).
-<a name="J.5.3" href="#J.5.3"><b>    J.5.3 Lengths and cases of identifiers</b></a>
-1   All characters in identifiers (with or without external linkage) are significant (<a href="#6.4.2">6.4.2</a>).
-<a name="J.5.4" href="#J.5.4"><b>    J.5.4 Scopes of identifiers</b></a>
-1   A function identifier, or the identifier of an object the declaration of which contains the
-    keyword extern, has file scope (<a href="#6.2.1">6.2.1</a>).
-<a name="J.5.5" href="#J.5.5"><b>    J.5.5 Writable string literals</b></a>
-1   String literals are modifiable (in which case, identical string literals should denote distinct
-    objects) (<a href="#6.4.5">6.4.5</a>).
-<a name="J.5.6" href="#J.5.6"><b>    J.5.6 Other arithmetic types</b></a>
-1   Additional arithmetic types, such as __int128 or double double, and their
-    appropriate conversions are defined (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1">6.3.1</a>). Additional floating types may have
-    more range or precision than long double, may be used for evaluating expressions of
-    other floating types, and may be used to define float_t or double_t.
-
-[<a name="p513" href="#p513">page 513</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.5.7" href="#J.5.7"><b>    J.5.7 Function pointer casts</b></a>
-1   A pointer to an object or to void may be cast to a pointer to a function, allowing data to
-    be invoked as a function (<a href="#6.5.4">6.5.4</a>).
-2   A pointer to a function may be cast to a pointer to an object or to void, allowing a
-    function to be inspected or modified (for example, by a debugger) (<a href="#6.5.4">6.5.4</a>).
-<a name="J.5.8" href="#J.5.8"><b>    J.5.8 Extended bit-field types</b></a>
-1   A bit-field may be declared with a type other than _Bool, unsigned int, or
-    signed int, with an appropriate maximum width (<a href="#6.7.2.1">6.7.2.1</a>).
-<a name="J.5.9" href="#J.5.9"><b>    J.5.9 The fortran keyword</b></a>
-1   The fortran function specifier may be used in a function declaration to indicate that
-    calls suitable for FORTRAN should be generated, or that a different representation for the
-    external name is to be generated (<a href="#6.7.4">6.7.4</a>).
-<a name="J.5.10" href="#J.5.10"><b>    J.5.10 The asm keyword</b></a>
-1   The asm keyword may be used to insert assembly language directly into the translator
-    output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
-           asm ( character-string-literal );
-<a name="J.5.11" href="#J.5.11"><b>    J.5.11 Multiple external definitions</b></a>
-1   There may be more than one external definition for the identifier of an object, with or
-    without the explicit use of the keyword extern; if the definitions disagree, or more than
-    one is initialized, the behavior is undefined (<a href="#6.9.2">6.9.2</a>).
-<a name="J.5.12" href="#J.5.12"><b>    J.5.12 Predefined macro names</b></a>
-1   Macro names that do not begin with an underscore, describing the translation and
-    execution environments, are defined by the implementation before translation begins
-    (<a href="#6.10.8">6.10.8</a>).
-<a name="J.5.13" href="#J.5.13"><b>    J.5.13 Floating-point status flags</b></a>
-1   If any floating-point status flags are set on normal termination after all calls to functions
-    registered by the atexit function have been made (see <a href="#7.20.4.3">7.20.4.3</a>), the implementation
-    writes some diagnostics indicating the fact to the stderr stream, if it is still open,
-
-[<a name="p514" href="#p514">page 514</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.5.14" href="#J.5.14"><b>    J.5.14 Extra arguments for signal handlers</b></a>
-1   Handlers for specific signals are called with extra arguments in addition to the signal
-    number (<a href="#7.14.1.1">7.14.1.1</a>).
-<a name="J.5.15" href="#J.5.15"><b>    J.5.15 Additional stream types and file-opening modes</b></a>
-1   Additional mappings from files to streams are supported (<a href="#7.19.2">7.19.2</a>).
-2   Additional file-opening modes may be specified by characters appended to the mode
-    argument of the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
-<a name="J.5.16" href="#J.5.16"><b>    J.5.16 Defined file position indicator</b></a>
-1   The file position indicator is decremented by each successful call to the ungetc or
-    ungetwc function for a text stream, except if its value was zero before a call (<a href="#7.19.7.11">7.19.7.11</a>,
-<a name="7.24.3.10)" href="#7.24.3.10)"><b>    7.24.3.10).</b></a>
-<a name="J.5.17" href="#J.5.17"><b>    J.5.17 Math error reporting</b></a>
-1   Functions declared in <a href="#7.3">&lt;complex.h&gt;</a> and <a href="#7.12">&lt;math.h&gt;</a> raise SIGFPE to report errors
-    instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
-<a name="7.12)" href="#7.12)"><b>    7.12).</b></a>
-
-[<a name="p515" href="#p515">page 515</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="Bibliography" href="#Bibliography"><b>                                 Bibliography</b></a>
-  1. ''The C Reference Manual'' by Dennis M. Ritchie, a version of which was
-     published in The C Programming Language by Brian W. Kernighan and Dennis
-     M. Ritchie, Prentice-Hall, Inc., (1978). Copyright owned by AT&amp;T.
-  2.   1984 /usr/group Standard by the /usr/group Standards Committee, Santa Clara,
-       California, USA, November 1984.
-  3.   ANSI X3/TR-1-82 (1982), American National Dictionary for Information
-       Processing Systems, Information Processing Systems Technical Report.
-  4.   ANSI/IEEE 754-1985, American National Standard for Binary Floating-Point
-       Arithmetic.
-  5.   ANSI/IEEE 854-1988, American National Standard for Radix-Independent
-       Floating-Point Arithmetic.
-  6.   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems,
-       second edition (previously designated IEC 559:1989).
-  7.   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and
-       symbols for use in the physical sciences and technology.
-  8. ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character set for
-     information interchange.
-  9. ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1:
-     Fundamental terms.
- 10. ISO 4217:1995, Codes for the representation of currencies and funds.
- 11. ISO 8601:1988, Data elements and interchange formats -- Information
-     interchange -- Representation of dates and times.
- 12.   ISO/IEC 9899:1990, Programming languages -- C.
- 13. ISO/IEC 9899/COR1:1994, Technical Corrigendum 1.
- 14. ISO/IEC 9899/COR2:1996, Technical Corrigendum 2.
- 15.   ISO/IEC 9899/AMD1:1995, Amendment 1 to ISO/IEC 9899:1990 C Integrity.
- 16.   ISO/IEC 9945-2:1993, Information technology -- Portable Operating System
-       Interface (POSIX) -- Part 2: Shell and Utilities.
- 17.   ISO/IEC TR 10176:1998, Information technology -- Guidelines for the
-       preparation of programming language standards.
- 18. ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet
-     Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.
-
-[<a name="p516" href="#p516">page 516</a>] (<a href="#Contents">Contents</a>)
-
- 19. ISO/IEC 10646-1/COR1:1996,      Technical       Corrigendum      1      to
-     ISO/IEC 10646-1:1993.
- 20. ISO/IEC 10646-1/COR2:1998,      Technical       Corrigendum      2      to
-     ISO/IEC 10646-1:1993.
- 21.   ISO/IEC 10646-1/AMD1:1996, Amendment 1 to ISO/IEC 10646-1:1993
-       Transformation Format for 16 planes of group 00 (UTF-16).
- 22.   ISO/IEC 10646-1/AMD2:1996, Amendment 2 to ISO/IEC 10646-1:1993 UCS
-       Transformation Format 8 (UTF-8).
- 23. ISO/IEC 10646-1/AMD3:1996, Amendment 3 to ISO/IEC 10646-1:1993.
- 24. ISO/IEC 10646-1/AMD4:1996, Amendment 4 to ISO/IEC 10646-1:1993.
- 25. ISO/IEC 10646-1/AMD5:1998, Amendment 5 to ISO/IEC 10646-1:1993 Hangul
-     syllables.
- 26. ISO/IEC 10646-1/AMD6:1997, Amendment 6 to ISO/IEC 10646-1:1993 Tibetan.
- 27. ISO/IEC 10646-1/AMD7:1997, Amendment 7 to ISO/IEC 10646-1:1993 33
-     additional characters.
- 28. ISO/IEC 10646-1/AMD8:1997, Amendment 8 to ISO/IEC 10646-1:1993.
- 29. ISO/IEC 10646-1/AMD9:1997,    Amendment     9   to    ISO/IEC 10646-1:1993
-     Identifiers for characters.
- 30.   ISO/IEC 10646-1/AMD10:1998, Amendment 10 to ISO/IEC 10646-1:1993
-       Ethiopic.
- 31. ISO/IEC 10646-1/AMD11:1998, Amendment 11 to ISO/IEC 10646-1:1993
-     Unified Canadian Aboriginal Syllabics.
- 32. ISO/IEC 10646-1/AMD12:1998, Amendment 12 to ISO/IEC 10646-1:1993
-     Cherokee.
- 33. ISO/IEC 10967-1:1994, Information technology -- Language independent
-     arithmetic -- Part 1: Integer and floating point arithmetic.
-
-[<a name="p517" href="#p517">page 517</a>] (<a href="#Contents">Contents</a>)
-
-
-[<a name="p518" href="#p518">page 518</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="Index" href="#Index"><b>Index</b></a>
-??? x ???, <a href="#3.18">3.18</a>                                                    , (comma punctuator), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,
-                                                                    <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>
-??? x ???, <a href="#3.19">3.19</a>                                                    - (subtraction operator), <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
-! (logical negation operator), <a href="#6.5.3.3">6.5.3.3</a>                         - (unary minus operator), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
-!= (inequality operator), <a href="#6.5.9">6.5.9</a>                                -- (postfix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
-# operator, <a href="#6.10.3.2">6.10.3.2</a>                                           -- (prefix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
-# preprocessing directive, <a href="#6.10.7">6.10.7</a>                              -= (subtraction assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
-# punctuator, <a href="#6.10">6.10</a>                                             -&gt; (structure/union pointer operator), <a href="#6.5.2.3">6.5.2.3</a>
-## operator, <a href="#6.10.3.3">6.10.3.3</a>                                          . (structure/union member operator), <a href="#6.3.2.1">6.3.2.1</a>,
-#define preprocessing directive, <a href="#6.10.3">6.10.3</a>                             <a href="#6.5.2.3">6.5.2.3</a>
-#elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                          . punctuator, <a href="#6.7.8">6.7.8</a>
-#else preprocessing directive, <a href="#6.10.1">6.10.1</a>                          ... (ellipsis punctuator), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>
-#endif preprocessing directive, <a href="#6.10.1">6.10.1</a>                         / (division operator), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
-#error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                      /* */ (comment delimiters), <a href="#6.4.9">6.4.9</a>
-#if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,             // (comment delimiter), <a href="#6.4.9">6.4.9</a>
-     <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             /= (division assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
-#ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                         : (colon punctuator), <a href="#6.7.2.1">6.7.2.1</a>
-#ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                        :&gt; (alternative spelling of ]), <a href="#6.4.6">6.4.6</a>
-#include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>,                     ; (semicolon punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
-     <a href="#6.10.2">6.10.2</a>                                                         <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
-#line preprocessing directive, <a href="#6.10.4">6.10.4</a>                          &lt; (less-than operator), <a href="#6.5.8">6.5.8</a>
-#pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>                        &lt;% (alternative spelling of {), <a href="#6.4.6">6.4.6</a>
-#undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,               &lt;: (alternative spelling of [), <a href="#6.4.6">6.4.6</a>
-     <a href="#7.1.4">7.1.4</a>                                                     &lt;&lt; (left-shift operator), <a href="#6.5.7">6.5.7</a>
-% (remainder operator), <a href="#6.5.5">6.5.5</a>                                  &lt;&lt;= (left-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
-%: (alternative spelling of #), <a href="#6.4.6">6.4.6</a>                          &lt;= (less-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>
-%:%: (alternative spelling of ##), <a href="#6.4.6">6.4.6</a>                       <a href="#7.2">&lt;assert.h&gt;</a> header, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
-%= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                   <a href="#7.3">&lt;complex.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>,
-%&gt; (alternative spelling of }), <a href="#6.4.6">6.4.6</a>                               <a href="#7.26.1">7.26.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
-&amp; (address operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                         <a href="#7.4">&lt;ctype.h&gt;</a> header, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
-&amp; (bitwise AND operator), <a href="#6.5.10">6.5.10</a>                               <a href="#7.5">&lt;errno.h&gt;</a> header, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
-&amp;&amp; (logical AND operator), <a href="#6.5.13">6.5.13</a>                              <a href="#7.6">&lt;fenv.h&gt;</a> header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>,
-&amp;= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                      <a href="#H">H</a>
-' ' (space character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,           <a href="#7.7">&lt;float.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,
-     <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>                                           <a href="#7.24.4.1.1">7.24.4.1.1</a>
-( ) (cast operator), <a href="#6.5.4">6.5.4</a>                                     <a href="#7.8">&lt;inttypes.h&gt;</a> header, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>
-( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a>                          <a href="#7.9">&lt;iso646.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
-( ) (parentheses punctuator), <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>            <a href="#7.10">&lt;limits.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
-( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                    <a href="#7.11">&lt;locale.h&gt;</a> header, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
-* (asterisk punctuator), <a href="#6.7.5.1">6.7.5.1</a>, <a href="#6.7.5.2">6.7.5.2</a>                      <a href="#7.12">&lt;math.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>,
-* (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                          <a href="#F.9">F.9</a>, <a href="#J.5.17">J.5.17</a>
-* (multiplication operator), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>                 <a href="#7.13">&lt;setjmp.h&gt;</a> header, <a href="#7.13">7.13</a>
-*= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              <a href="#7.14">&lt;signal.h&gt;</a> header, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>
-+ (addition operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>,           <a href="#7.15">&lt;stdarg.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>
-     <a href="#G.5.2">G.5.2</a>                                                     <a href="#7.16">&lt;stdbool.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>
-+ (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a>                               <a href="#7.17">&lt;stddef.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
-++ (postfix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>                    <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>
-++ (prefix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>                <a href="#7.18">&lt;stdint.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>,
-+= (addition assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                         <a href="#7.18">7.18</a>, <a href="#7.26.8">7.26.8</a>
-, (comma operator), <a href="#6.5.17">6.5.17</a>
-
-[<a name="p519" href="#p519">page 519</a>] (<a href="#Contents">Contents</a>)
-
-<a href="#7.19">&lt;stdio.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>                 __cplusplus macro, <a href="#6.10.8">6.10.8</a>
-<a href="#7.20">&lt;stdlib.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>               __DATE__ macro, <a href="#6.10.8">6.10.8</a>
-<a href="#7.21">&lt;string.h&gt;</a> header, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>                             __FILE__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#7.2.1.1">7.2.1.1</a>
-<a href="#7.22">&lt;tgmath.h&gt;</a> header, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                 __func__ identifier, <a href="#6.4.2.2">6.4.2.2</a>, <a href="#7.2.1.1">7.2.1.1</a>
-<a href="#7.23">&lt;time.h&gt;</a> header, <a href="#7.23">7.23</a>                                        __LINE__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#7.2.1.1">7.2.1.1</a>
-<a href="#7.24">&lt;wchar.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>,                   __STDC_, <a href="#6.11.9">6.11.9</a>
-     <a href="#7.26.12">7.26.12</a>, <a href="#F">F</a>                                              __STDC__ macro, <a href="#6.10.8">6.10.8</a>
-<a href="#7.25">&lt;wctype.h&gt;</a> header, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>                             __STDC_CONSTANT_MACROS macro, <a href="#7.18.4">7.18.4</a>
-= (equal-sign punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.8">6.7.8</a>               __STDC_FORMAT_MACROS macro, <a href="#7.8.1">7.8.1</a>
-= (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a>                     __STDC_HOSTED__ macro, <a href="#6.10.8">6.10.8</a>
-== (equality operator), <a href="#6.5.9">6.5.9</a>                                __STDC_IEC_559__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#F.1">F.1</a>
-&gt; (greater-than operator), <a href="#6.5.8">6.5.8</a>                             __STDC_IEC_559_COMPLEX__ macro,
-&gt;= (greater-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>                     <a href="#6.10.8">6.10.8</a>, <a href="#G.1">G.1</a>
-&gt;&gt; (right-shift operator), <a href="#6.5.7">6.5.7</a>                             __STDC_ISO_10646__ macro, <a href="#6.10.8">6.10.8</a>
-&gt;&gt;= (right-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              __STDC_LIMIT_MACROS macro, <a href="#7.18.2">7.18.2</a>,
-? : (conditional operator), <a href="#6.5.15">6.5.15</a>                                <a href="#7.18.3">7.18.3</a>
-?? (trigraph sequences), <a href="#5.2.1.1">5.2.1.1</a>                             __STDC_MB_MIGHT_NEQ_WC__ macro,
-[ ] (array subscript operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                  <a href="#6.10.8">6.10.8</a>, <a href="#7.17">7.17</a>
-[ ] (brackets punctuator), <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.8">6.7.8</a>                    __STDC_VERSION__ macro, <a href="#6.10.8">6.10.8</a>
-\ (backslash character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>             __TIME__ macro, <a href="#6.10.8">6.10.8</a>
-\ (escape character), <a href="#6.4.4.4">6.4.4.4</a>                                __VA_ARGS__ identifier, <a href="#6.10.3">6.10.3</a>, <a href="#6.10.3.1">6.10.3.1</a>
-\" (double-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>,                  _Bool type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>, <a href="#6.7.2">6.7.2</a>
-     <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                           _Bool type conversions, <a href="#6.3.1.2">6.3.1.2</a>
-\\ (backslash escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>              _Complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
-\' (single-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>            _Complex_I macro, <a href="#7.3.1">7.3.1</a>
-\0 (null character), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                   _Exit function, <a href="#7.20.4.4">7.20.4.4</a>
-  padding of binary stream, <a href="#7.19.2">7.19.2</a>                           _Imaginary keyword, <a href="#G.2">G.2</a>
-\? (question-mark escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                  _Imaginary types, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
-\a (alert escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                   _Imaginary_I macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
-\b (backspace escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>               _IOFBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
-\f (form-feed escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,              _IOLBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.6">7.19.5.6</a>
-     <a href="#7.4.1.10">7.4.1.10</a>                                                _IONBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
-\n (new-line escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               _Pragma operator, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>
-     <a href="#7.4.1.10">7.4.1.10</a>                                                { } (braces punctuator), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>,
-\octal digits (octal-character escape sequence),                  <a href="#6.8.2">6.8.2</a>
-     <a href="#6.4.4.4">6.4.4.4</a>                                                 { } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>
-\r (carriage-return escape sequence), <a href="#5.2.2">5.2.2</a>,                 | (bitwise inclusive OR operator), <a href="#6.5.12">6.5.12</a>
-     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                       |= (bitwise inclusive OR assignment operator),
-\t (horizontal-tab escape sequence), <a href="#5.2.2">5.2.2</a>,                       <a href="#6.5.16.2">6.5.16.2</a>
-     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>                  || (logical OR operator), <a href="#6.5.14">6.5.14</a>
-\U (universal character names), <a href="#6.4.3">6.4.3</a>                        ~ (bitwise complement operator), <a href="#6.5.3.3">6.5.3.3</a>
-\u (universal character names), <a href="#6.4.3">6.4.3</a>
-\v (vertical-tab escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           abort function, <a href="#7.2.1.1">7.2.1.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.19.3">7.19.3</a>,
-     <a href="#7.4.1.10">7.4.1.10</a>                                                     <a href="#7.20.4.1">7.20.4.1</a>
-\x hexadecimal digits (hexadecimal-character                 abs function, <a href="#7.20.6.1">7.20.6.1</a>
-     escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                               absolute-value functions
-^ (bitwise exclusive OR operator), <a href="#6.5.11">6.5.11</a>                      complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>
-^= (bitwise exclusive OR assignment operator),                 integer, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.20.6.1">7.20.6.1</a>
-     <a href="#6.5.16.2">6.5.16.2</a>                                                  real, <a href="#7.12.7">7.12.7</a>, <a href="#F.9.4">F.9.4</a>
-__bool_true_false_are_defined                               abstract declarator, <a href="#6.7.6">6.7.6</a>
-     macro, <a href="#7.16">7.16</a>                                             abstract machine, <a href="#5.1.2.3">5.1.2.3</a>
-
-[<a name="p520" href="#p520">page 520</a>] (<a href="#Contents">Contents</a>)
-
-access, <a href="#3.1">3.1</a>, <a href="#6.7.3">6.7.3</a>                                             array
-accuracy, see floating-point accuracy                              argument, <a href="#6.9.1">6.9.1</a>
-acos functions, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#F.9.1.1">F.9.1.1</a>                                 declarator, <a href="#6.7.5.2">6.7.5.2</a>
-acos type-generic macro, <a href="#7.22">7.22</a>                                     initialization, <a href="#6.7.8">6.7.8</a>
-acosh functions, <a href="#7.12.5.1">7.12.5.1</a>, <a href="#F.9.2.1">F.9.2.1</a>                                multidimensional, <a href="#6.5.2.1">6.5.2.1</a>
-acosh type-generic macro, <a href="#7.22">7.22</a>                                    parameter, <a href="#6.9.1">6.9.1</a>
-active position, <a href="#5.2.2">5.2.2</a>                                            storage order, <a href="#6.5.2.1">6.5.2.1</a>
-actual argument, <a href="#3.3">3.3</a>                                              subscript operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
-actual parameter (deprecated), <a href="#3.3">3.3</a>                                subscripting, <a href="#6.5.2.1">6.5.2.1</a>
-addition assignment operator (+=), <a href="#6.5.16.2">6.5.16.2</a>                       type, <a href="#6.2.5">6.2.5</a>
-addition operator (+), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>,              type conversion, <a href="#6.3.2.1">6.3.2.1</a>
-      <a href="#G.5.2">G.5.2</a>                                                       variable length, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
-additive expressions, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                             arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
-address constant, <a href="#6.6">6.6</a>                                          as-if rule, <a href="#5.1.2.3">5.1.2.3</a>
-address operator (&amp;), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                         ASCII code set, <a href="#5.2.1.1">5.2.1.1</a>
-aggregate initialization, <a href="#6.7.8">6.7.8</a>                                asctime function, <a href="#7.23.3.1">7.23.3.1</a>
-aggregate types, <a href="#6.2.5">6.2.5</a>                                         asin functions, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#F.9.1.2">F.9.1.2</a>
-alert escape sequence (\a), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                     asin type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-aliasing, <a href="#6.5">6.5</a>                                                  asinh functions, <a href="#7.12.5.2">7.12.5.2</a>, <a href="#F.9.2.2">F.9.2.2</a>
-alignment, <a href="#3.2">3.2</a>                                                 asinh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-   pointer, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.3">6.3.2.3</a>                                     asm keyword, <a href="#J.5.10">J.5.10</a>
-   structure/union member, <a href="#6.7.2.1">6.7.2.1</a>                             assert macro, <a href="#7.2.1.1">7.2.1.1</a>
-allocated storage, order and contiguity, <a href="#7.20.3">7.20.3</a>                assert.h header, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
-and macro, <a href="#7.9">7.9</a>                                                 assignment
-AND operators                                                     compound, <a href="#6.5.16.2">6.5.16.2</a>
-   bitwise (&amp;), <a href="#6.5.10">6.5.10</a>                                            conversion, <a href="#6.5.16.1">6.5.16.1</a>
-   bitwise assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>                              expression, <a href="#6.5.16">6.5.16</a>
-   logical (&amp;&amp;), <a href="#6.5.13">6.5.13</a>                                           operators, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>
-and_eq macro, <a href="#7.9">7.9</a>                                                 simple, <a href="#6.5.16.1">6.5.16.1</a>
-ANSI/IEEE 754, <a href="#F.1">F.1</a>                                             associativity of operators, <a href="#6.5">6.5</a>
-ANSI/IEEE 854, <a href="#F.1">F.1</a>                                             asterisk punctuator (*), <a href="#6.7.5.1">6.7.5.1</a>, <a href="#6.7.5.2">6.7.5.2</a>
-argc (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>                      atan functions, <a href="#7.12.4.3">7.12.4.3</a>, <a href="#F.9.1.3">F.9.1.3</a>
-argument, <a href="#3.3">3.3</a>                                                  atan type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-   array, <a href="#6.9.1">6.9.1</a>                                                atan2 functions, <a href="#7.12.4.4">7.12.4.4</a>, <a href="#F.9.1.4">F.9.1.4</a>
-   default promotions, <a href="#6.5.2.2">6.5.2.2</a>                                 atan2 type-generic macro, <a href="#7.22">7.22</a>
-   function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>                                    atanh functions, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#F.9.2.3">F.9.2.3</a>
-   macro, substitution, <a href="#6.10.3.1">6.10.3.1</a>                               atanh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-argument, complex, <a href="#7.3.9.1">7.3.9.1</a>                                     atexit function, <a href="#7.20.4.2">7.20.4.2</a>, <a href="#7.20.4.3">7.20.4.3</a>, <a href="#7.20.4.4">7.20.4.4</a>,
-argv (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>                            <a href="#J.5.13">J.5.13</a>
-arithmetic constant expression, <a href="#6.6">6.6</a>                            atof function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.1">7.20.1.1</a>
-arithmetic conversions, usual, see usual arithmetic            atoi function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
-      conversions                                              atol function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
-arithmetic operators                                           atoll function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
-   additive, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                                      auto storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
-   bitwise, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>                             automatic storage duration, <a href="#5.2.3">5.2.3</a>, <a href="#6.2.4">6.2.4</a>
-   increment and decrement, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>
-   multiplicative, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>                                backslash character (\), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
-   shift, <a href="#6.5.7">6.5.7</a>                                                backslash escape sequence (\\), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>
-   unary, <a href="#6.5.3.3">6.5.3.3</a>                                              backspace escape sequence (\b), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
-arithmetic types, <a href="#6.2.5">6.2.5</a>                                        basic character set, <a href="#3.6">3.6</a>, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>
-arithmetic, pointer, <a href="#6.5.6">6.5.6</a>                                     basic types, <a href="#6.2.5">6.2.5</a>
-
-[<a name="p521" href="#p521">page 521</a>] (<a href="#Contents">Contents</a>)
-
-behavior, <a href="#3.4">3.4</a>                                                  call by value, <a href="#6.5.2.2">6.5.2.2</a>
-binary streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,                   calloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.1">7.20.3.1</a>, <a href="#7.20.3.2">7.20.3.2</a>,
-      <a href="#7.19.9.4">7.19.9.4</a>                                                       <a href="#7.20.3.4">7.20.3.4</a>
-bit, <a href="#3.5">3.5</a>                                                       carg functions, <a href="#7.3.9.1">7.3.9.1</a>, <a href="#G.6">G.6</a>
-   high order, <a href="#3.6">3.6</a>                                             carg type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-   low order, <a href="#3.6">3.6</a>                                              carriage-return escape sequence (\r), <a href="#5.2.2">5.2.2</a>,
-bit-field, <a href="#6.7.2.1">6.7.2.1</a>                                                    <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>
-bitand macro, <a href="#7.9">7.9</a>                                              case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
-bitor macro, <a href="#7.9">7.9</a>                                               case mapping functions
-bitwise operators, <a href="#6.5">6.5</a>                                           character, <a href="#7.4.2">7.4.2</a>
-   AND, <a href="#6.5.10">6.5.10</a>                                                   wide character, <a href="#7.25.3.1">7.25.3.1</a>
-   AND assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>                                     extensible, <a href="#7.25.3.2">7.25.3.2</a>
-   complement (~), <a href="#6.5.3.3">6.5.3.3</a>                                     casin functions, <a href="#7.3.5.2">7.3.5.2</a>, <a href="#G.6">G.6</a>
-   exclusive OR, <a href="#6.5.11">6.5.11</a>                                          type-generic macro for, <a href="#7.22">7.22</a>
-   exclusive OR assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                      casinh functions, <a href="#7.3.6.2">7.3.6.2</a>, <a href="#G.6.2.2">G.6.2.2</a>
-   inclusive OR, <a href="#6.5.12">6.5.12</a>                                          type-generic macro for, <a href="#7.22">7.22</a>
-   inclusive OR assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>                      cast expression, <a href="#6.5.4">6.5.4</a>
-   shift, <a href="#6.5.7">6.5.7</a>                                                cast operator (( )), <a href="#6.5.4">6.5.4</a>
-blank character, <a href="#7.4.1.3">7.4.1.3</a>                                       catan functions, <a href="#7.3.5.3">7.3.5.3</a>, <a href="#G.6">G.6</a>
-block, <a href="#6.8">6.8</a>, <a href="#6.8.2">6.8.2</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>                                  type-generic macro for, <a href="#7.22">7.22</a>
-block scope, <a href="#6.2.1">6.2.1</a>                                             catanh functions, <a href="#7.3.6.3">7.3.6.3</a>, <a href="#G.6.2.3">G.6.2.3</a>
-block structure, <a href="#6.2.1">6.2.1</a>                                           type-generic macro for, <a href="#7.22">7.22</a>
-bold type convention, <a href="#6.1">6.1</a>                                      cbrt functions, <a href="#7.12.7.1">7.12.7.1</a>, <a href="#F.9.4.1">F.9.4.1</a>
-bool macro, <a href="#7.16">7.16</a>                                               cbrt type-generic macro, <a href="#7.22">7.22</a>
-boolean type, <a href="#6.3.1.2">6.3.1.2</a>                                          ccos functions, <a href="#7.3.5.4">7.3.5.4</a>, <a href="#G.6">G.6</a>
-boolean type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>                        type-generic macro for, <a href="#7.22">7.22</a>
-braces punctuator ({ }), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>,              ccosh functions, <a href="#7.3.6.4">7.3.6.4</a>, <a href="#G.6.2.4">G.6.2.4</a>
-      <a href="#6.8.2">6.8.2</a>                                                      type-generic macro for, <a href="#7.22">7.22</a>
-brackets operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                      ceil functions, <a href="#7.12.9.1">7.12.9.1</a>, <a href="#F.9.6.1">F.9.6.1</a>
-brackets punctuator ([ ]), <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.8">6.7.8</a>                      ceil type-generic macro, <a href="#7.22">7.22</a>
-branch cuts, <a href="#7.3.3">7.3.3</a>                                             cerf function, <a href="#7.26.1">7.26.1</a>
-break statement, <a href="#6.8.6.3">6.8.6.3</a>                                       cerfc function, <a href="#7.26.1">7.26.1</a>
-broken-down time, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.3">7.23.3</a>,                    cexp functions, <a href="#7.3.7.1">7.3.7.1</a>, <a href="#G.6.3.1">G.6.3.1</a>
-      <a href="#7.23.3.1">7.23.3.1</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>, <a href="#7.23.3.5">7.23.3.5</a>                     type-generic macro for, <a href="#7.22">7.22</a>
-bsearch function, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.1">7.20.5.1</a>                             cexp2 function, <a href="#7.26.1">7.26.1</a>
-btowc function, <a href="#7.24.6.1.1">7.24.6.1.1</a>                                     cexpm1 function, <a href="#7.26.1">7.26.1</a>
-BUFSIZ macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.5">7.19.5.5</a>                         char type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>
-byte, <a href="#3.6">3.6</a>, <a href="#6.5.3.4">6.5.3.4</a>                                             char type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
-byte input/output functions, <a href="#7.19.1">7.19.1</a>                                  <a href="#6.3.1.8">6.3.1.8</a>
-byte-oriented stream, <a href="#7.19.2">7.19.2</a>                                   CHAR_BIT macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-                                                               CHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-C program, <a href="#5.1.1.1">5.1.1.1</a>                                             CHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-C++, <a href="#7.8.1">7.8.1</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.18.4">7.18.4</a>                             character, <a href="#3.7">3.7</a>, <a href="#3.7.1">3.7.1</a>
-cabs functions, <a href="#7.3.8.1">7.3.8.1</a>, <a href="#G.6">G.6</a>                                   character array initialization, <a href="#6.7.8">6.7.8</a>
-  type-generic macro for, <a href="#7.22">7.22</a>                                 character case mapping functions, <a href="#7.4.2">7.4.2</a>
-cacos functions, <a href="#7.3.5.1">7.3.5.1</a>, <a href="#G.6.1.1">G.6.1.1</a>                                wide character, <a href="#7.25.3.1">7.25.3.1</a>
-  type-generic macro for, <a href="#7.22">7.22</a>                                       extensible, <a href="#7.25.3.2">7.25.3.2</a>
-cacosh functions, <a href="#7.3.6.1">7.3.6.1</a>, <a href="#G.6.2.1">G.6.2.1</a>                             character classification functions, <a href="#7.4.1">7.4.1</a>
-  type-generic macro for, <a href="#7.22">7.22</a>                                   wide character, <a href="#7.25.2.1">7.25.2.1</a>
-calendar time, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.2">7.23.2.2</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.2.4">7.23.2.4</a>,                 extensible, <a href="#7.25.2.2">7.25.2.2</a>
-     <a href="#7.23.3.2">7.23.3.2</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>                              character constant, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
-
-[<a name="p522" href="#p522">page 522</a>] (<a href="#Contents">Contents</a>)
-
-character display semantics, <a href="#5.2.2">5.2.2</a>                            complex.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>, <a href="#7.26.1">7.26.1</a>,
-character handling header, <a href="#7.4">7.4</a>, <a href="#7.11.1.1">7.11.1.1</a>                           <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
-character input/output functions, <a href="#7.19.7">7.19.7</a>                      compliance, see conformance
-   wide character, <a href="#7.24.3">7.24.3</a>                                     components of time, <a href="#7.23.1">7.23.1</a>
-character sets, <a href="#5.2.1">5.2.1</a>                                         composite type, <a href="#6.2.7">6.2.7</a>
-character string literal, see string literal                  compound assignment, <a href="#6.5.16.2">6.5.16.2</a>
-character type conversion, <a href="#6.3.1.1">6.3.1.1</a>                            compound literals, <a href="#6.5.2.5">6.5.2.5</a>
-character types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.8">6.7.8</a>                                 compound statement, <a href="#6.8.2">6.8.2</a>
-cimag functions, <a href="#7.3.9.2">7.3.9.2</a>, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                        compound-literal operator (( ){ }), <a href="#6.5.2.5">6.5.2.5</a>
-cimag type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                           concatenation functions
-cis function, <a href="#G.6">G.6</a>                                               string, <a href="#7.21.3">7.21.3</a>
-classification functions                                         wide string, <a href="#7.24.4.3">7.24.4.3</a>
-   character, <a href="#7.4.1">7.4.1</a>                                           concatenation, preprocessing, see preprocessing
-   floating-point, <a href="#7.12.3">7.12.3</a>                                           concatenation
-   wide character, <a href="#7.25.2.1">7.25.2.1</a>                                   conceptual models, <a href="#5.1">5.1</a>
-      extensible, <a href="#7.25.2.2">7.25.2.2</a>                                    conditional inclusion, <a href="#6.10.1">6.10.1</a>
-clearerr function, <a href="#7.19.10.1">7.19.10.1</a>                                  conditional operator (? :), <a href="#6.5.15">6.5.15</a>
-clgamma function, <a href="#7.26.1">7.26.1</a>                                      conformance, <a href="#4">4</a>
-clock function, <a href="#7.23.2.1">7.23.2.1</a>                                      conj functions, <a href="#7.3.9.3">7.3.9.3</a>, <a href="#G.6">G.6</a>
-clock_t type, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.1">7.23.2.1</a>                                conj type-generic macro, <a href="#7.22">7.22</a>
-CLOCKS_PER_SEC macro, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.1">7.23.2.1</a>                        const type qualifier, <a href="#6.7.3">6.7.3</a>
-clog functions, <a href="#7.3.7.2">7.3.7.2</a>, <a href="#G.6.3.2">G.6.3.2</a>                              const-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.7.3">6.7.3</a>
-   type-generic macro for, <a href="#7.22">7.22</a>                               constant expression, <a href="#6.6">6.6</a>, <a href="#F.7.4">F.7.4</a>
-clog10 function, <a href="#7.26.1">7.26.1</a>                                       constants, <a href="#6.4.4">6.4.4</a>
-clog1p function, <a href="#7.26.1">7.26.1</a>                                         as primary expression, <a href="#6.5.1">6.5.1</a>
-clog2 function, <a href="#7.26.1">7.26.1</a>                                          character, <a href="#6.4.4.4">6.4.4.4</a>
-collating sequences, <a href="#5.2.1">5.2.1</a>                                      enumeration, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
-colon punctuator (:), <a href="#6.7.2.1">6.7.2.1</a>                                   floating, <a href="#6.4.4.2">6.4.4.2</a>
-comma operator (,), <a href="#6.5.17">6.5.17</a>                                      hexadecimal, <a href="#6.4.4.1">6.4.4.1</a>
-comma punctuator (,), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,             integer, <a href="#6.4.4.1">6.4.4.1</a>
-      <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>                                            octal, <a href="#6.4.4.1">6.4.4.1</a>
-command processor, <a href="#7.20.4.6">7.20.4.6</a>                                   constraint, <a href="#3.8">3.8</a>, <a href="#4">4</a>
-comment delimiters (/* */ and //), <a href="#6.4.9">6.4.9</a>                      content of structure/union/enumeration, <a href="#6.7.2.3">6.7.2.3</a>
-comments, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.4.9">6.4.9</a>                                 contiguity of allocated storage, <a href="#7.20.3">7.20.3</a>
-common extensions, <a href="#J.5">J.5</a>                                        continue statement, <a href="#6.8.6.2">6.8.6.2</a>
-common initial sequence, <a href="#6.5.2.3">6.5.2.3</a>                              contracted expression, <a href="#6.5">6.5</a>, <a href="#7.12.2">7.12.2</a>, <a href="#F.6">F.6</a>
-common real type, <a href="#6.3.1.8">6.3.1.8</a>                                     control character, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
-common warnings, <a href="#I">I</a>                                            control wide character, <a href="#7.25.2">7.25.2</a>
-comparison functions, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.1">7.20.5.1</a>, <a href="#7.20.5.2">7.20.5.2</a>              conversion, <a href="#6.3">6.3</a>
-   string, <a href="#7.21.4">7.21.4</a>                                               arithmetic operands, <a href="#6.3.1">6.3.1</a>
-   wide string, <a href="#7.24.4.4">7.24.4.4</a>                                        array argument, <a href="#6.9.1">6.9.1</a>                           *
-comparison macros, <a href="#7.12.14">7.12.14</a>                                      array parameter, <a href="#6.9.1">6.9.1</a>
-comparison, pointer, <a href="#6.5.8">6.5.8</a>                                      arrays, <a href="#6.3.2.1">6.3.2.1</a>
-compatible type, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.5">6.7.5</a>                     boolean, <a href="#6.3.1.2">6.3.1.2</a>
-compl macro, <a href="#7.9">7.9</a>                                                boolean, characters, and integers, <a href="#6.3.1.1">6.3.1.1</a>
-complement operator (~), <a href="#6.5.3.3">6.5.3.3</a>                                by assignment, <a href="#6.5.16.1">6.5.16.1</a>
-complex macro, <a href="#7.3.1">7.3.1</a>                                            by return statement, <a href="#6.8.6.4">6.8.6.4</a>
-complex numbers, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>                                       complex types, <a href="#6.3.1.6">6.3.1.6</a>
-complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>                       explicit, <a href="#6.3">6.3</a>
-complex type domain, <a href="#6.2.5">6.2.5</a>                                      function, <a href="#6.3.2.1">6.3.2.1</a>
-complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#G">G</a>                                  function argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
-
-[<a name="p523" href="#p523">page 523</a>] (<a href="#Contents">Contents</a>)
-
-  function designators, <a href="#6.3.2.1">6.3.2.1</a>                                type-generic macro for, <a href="#7.22">7.22</a>
-  function parameter, <a href="#6.9.1">6.9.1</a>                                  csinh functions, <a href="#7.3.6.5">7.3.6.5</a>, <a href="#G.6.2.5">G.6.2.5</a>
-  imaginary, <a href="#G.4.1">G.4.1</a>                                             type-generic macro for, <a href="#7.22">7.22</a>
-  imaginary and complex, <a href="#G.4.3">G.4.3</a>                               csqrt functions, <a href="#7.3.8.3">7.3.8.3</a>, <a href="#G.6.4.2">G.6.4.2</a>
-  implicit, <a href="#6.3">6.3</a>                                                type-generic macro for, <a href="#7.22">7.22</a>
-  lvalues, <a href="#6.3.2.1">6.3.2.1</a>                                           ctan functions, <a href="#7.3.5.6">7.3.5.6</a>, <a href="#G.6">G.6</a>
-  pointer, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                                    type-generic macro for, <a href="#7.22">7.22</a>
-  real and complex, <a href="#6.3.1.7">6.3.1.7</a>                                  ctanh functions, <a href="#7.3.6.6">7.3.6.6</a>, <a href="#G.6.2.6">G.6.2.6</a>
-  real and imaginary, <a href="#G.4.2">G.4.2</a>                                    type-generic macro for, <a href="#7.22">7.22</a>
-  real floating and integer, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                ctgamma function, <a href="#7.26.1">7.26.1</a>
-  real floating types, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#F.3">F.3</a>                           ctime function, <a href="#7.23.3.2">7.23.3.2</a>
-  signed and unsigned integers, <a href="#6.3.1.3">6.3.1.3</a>                      ctype.h header, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
-  usual arithmetic, see usual arithmetic                     current object, <a href="#6.7.8">6.7.8</a>
-        conversions                                          CX_LIMITED_RANGE pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.3.4">7.3.4</a>
-  void type, <a href="#6.3.2.2">6.3.2.2</a>
-conversion functions                                         data stream, see streams
-  multibyte/wide character, <a href="#7.20.7">7.20.7</a>                           date and time header, <a href="#7.23">7.23</a>
-     extended, <a href="#7.24.6">7.24.6</a>                                        Daylight Saving Time, <a href="#7.23.1">7.23.1</a>
-     restartable, <a href="#7.24.6.3">7.24.6.3</a>                                   DBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  multibyte/wide string, <a href="#7.20.8">7.20.8</a>                              DBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-     restartable, <a href="#7.24.6.4">7.24.6.4</a>                                   DBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  numeric, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>                                   DBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-     wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1">7.24.4.1</a>                          DBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  single byte/wide character, <a href="#7.24.6.1">7.24.6.1</a>                       DBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  time, <a href="#7.23.3">7.23.3</a>                                               DBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-     wide character, <a href="#7.24.5">7.24.5</a>                                  DBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-conversion specifier, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>,           DBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-     <a href="#7.24.2.2">7.24.2.2</a>                                                decimal constant, <a href="#6.4.4.1">6.4.4.1</a>
-conversion state, <a href="#7.20.7">7.20.7</a>, <a href="#7.24.6">7.24.6</a>, <a href="#7.24.6.2.1">7.24.6.2.1</a>,                decimal digit, <a href="#5.2.1">5.2.1</a>
-     <a href="#7.24.6.3">7.24.6.3</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4">7.24.6.4</a>,             decimal-point character, <a href="#7.1.1">7.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-     <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                  DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
-conversion state functions, <a href="#7.24.6.2">7.24.6.2</a>                              <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.5">F.5</a>
-copying functions                                            declaration specifiers, <a href="#6.7">6.7</a>
-  string, <a href="#7.21.2">7.21.2</a>                                             declarations, <a href="#6.7">6.7</a>
-  wide string, <a href="#7.24.4.2">7.24.4.2</a>                                        function, <a href="#6.7.5.3">6.7.5.3</a>
-copysign functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#7.12.11.1">7.12.11.1</a>, <a href="#F.3">F.3</a>,                   pointer, <a href="#6.7.5.1">6.7.5.1</a>
-     <a href="#F.9.8.1">F.9.8.1</a>                                                   structure/union, <a href="#6.7.2.1">6.7.2.1</a>
-copysign type-generic macro, <a href="#7.22">7.22</a>                              typedef, <a href="#6.7.7">6.7.7</a>
-correctly rounded result, <a href="#3.9">3.9</a>                                declarator, <a href="#6.7.5">6.7.5</a>
-corresponding real type, <a href="#6.2.5">6.2.5</a>                                 abstract, <a href="#6.7.6">6.7.6</a>
-cos functions, <a href="#7.12.4.5">7.12.4.5</a>, <a href="#F.9.1.5">F.9.1.5</a>                             declarator type derivation, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.5">6.7.5</a>
-cos type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            decrement operators, see arithmetic operators,
-cosh functions, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#F.9.2.4">F.9.2.4</a>                                 increment and decrement
-cosh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                           default argument promotions, <a href="#6.5.2.2">6.5.2.2</a>
-cpow functions, <a href="#7.3.8.2">7.3.8.2</a>, <a href="#G.6.4.1">G.6.4.1</a>                             default initialization, <a href="#6.7.8">6.7.8</a>
-  type-generic macro for, <a href="#7.22">7.22</a>                               default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
-cproj functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                                define preprocessing directive, <a href="#6.10.3">6.10.3</a>
-cproj type-generic macro, <a href="#7.22">7.22</a>                               defined operator, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.8">6.10.8</a>
-creal functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                definition, <a href="#6.7">6.7</a>
-creal type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            function, <a href="#6.9.1">6.9.1</a>
-csin functions, <a href="#7.3.5.5">7.3.5.5</a>, <a href="#G.6">G.6</a>                                 derived declarator types, <a href="#6.2.5">6.2.5</a>
-
-[<a name="p524" href="#p524">page 524</a>] (<a href="#Contents">Contents</a>)
-
-derived types, <a href="#6.2.5">6.2.5</a>                                            end-of-file indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,
-designated initializer, <a href="#6.7.8">6.7.8</a>                                         <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,
-destringizing, <a href="#6.10.9">6.10.9</a>                                                 <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.10.1">7.19.10.1</a>, <a href="#7.19.10.2">7.19.10.2</a>, <a href="#7.24.3.1">7.24.3.1</a>,
-device input/output, <a href="#5.1.2.3">5.1.2.3</a>                                          <a href="#7.24.3.10">7.24.3.10</a>
-diagnostic message, <a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>                               end-of-file macro, see EOF macro
-diagnostics, <a href="#5.1.1.3">5.1.1.3</a>                                            end-of-line indicator, <a href="#5.2.1">5.2.1</a>
-diagnostics header, <a href="#7.2">7.2</a>                                         endif preprocessing directive, <a href="#6.10.1">6.10.1</a>
-difftime function, <a href="#7.23.2.2">7.23.2.2</a>                                     enum type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.2">6.7.2.2</a>
-digit, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                               enumerated type, <a href="#6.2.5">6.2.5</a>
-digraphs, <a href="#6.4.6">6.4.6</a>                                                 enumeration, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.2">6.7.2.2</a>
-direct input/output functions, <a href="#7.19.8">7.19.8</a>                           enumeration constant, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
-display device, <a href="#5.2.2">5.2.2</a>                                           enumeration content, <a href="#6.7.2.3">6.7.2.3</a>
-div function, <a href="#7.20.6.2">7.20.6.2</a>                                          enumeration members, <a href="#6.7.2.2">6.7.2.2</a>
-div_t type, <a href="#7.20">7.20</a>                                                enumeration specifiers, <a href="#6.7.2.2">6.7.2.2</a>
-division assignment operator (/=), <a href="#6.5.16.2">6.5.16.2</a>                     enumeration tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
-division operator (/), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>                        enumerator, <a href="#6.7.2.2">6.7.2.2</a>
-do statement, <a href="#6.8.5.2">6.8.5.2</a>                                           environment, <a href="#5">5</a>
-documentation of implementation, <a href="#4">4</a>                              environment functions, <a href="#7.20.4">7.20.4</a>
-domain error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#7.12.4.4">7.12.4.4</a>,             environment list, <a href="#7.20.4.5">7.20.4.5</a>
-      <a href="#7.12.5.1">7.12.5.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.7">7.12.6.7</a>,                   environmental considerations, <a href="#5.2">5.2</a>
-      <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>,                 environmental limits, <a href="#5.2.4">5.2.4</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.19.2">7.19.2</a>,
-      <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>,                         <a href="#7.19.3">7.19.3</a>, <a href="#7.19.4.4">7.19.4.4</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.20.2.1">7.20.2.1</a>, <a href="#7.20.4.2">7.20.4.2</a>,
-      <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>                       <a href="#7.24.2.1">7.24.2.1</a>
-dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                       EOF macro, <a href="#7.4">7.4</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.1">7.19.5.1</a>, <a href="#7.19.5.2">7.19.5.2</a>,
-double _Complex type, <a href="#6.2.5">6.2.5</a>                                           <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.11">7.19.6.11</a>,
-double _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                             <a href="#7.19.6.14">7.19.6.14</a>, <a href="#7.19.7.1">7.19.7.1</a>, <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.4">7.19.7.4</a>,
-      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                                <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.7.10">7.19.7.10</a>,
-double _Imaginary type, <a href="#G.2">G.2</a>                                           <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.2.4">7.24.2.4</a>,
-double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.2">7.19.6.2</a>,                         <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.2.12">7.24.2.12</a>,
-      <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.2">F.2</a>                                                   <a href="#7.24.3.4">7.24.3.4</a>, <a href="#7.24.6.1.1">7.24.6.1.1</a>, <a href="#7.24.6.1.2">7.24.6.1.2</a>
-double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,              equal-sign punctuator (=), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.8">6.7.8</a>
-      <a href="#6.3.1.8">6.3.1.8</a>                                                   equal-to operator, see equality operator
-double-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                            equality expressions, <a href="#6.5.9">6.5.9</a>
-double-quote escape sequence (\"), <a href="#6.4.4.4">6.4.4.4</a>,                     equality operator (==), <a href="#6.5.9">6.5.9</a>
-      <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                             ERANGE macro, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.12.1">7.12.1</a>,
-double_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                            <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, see
-                                                                      also range error
-EDOM macro, <a href="#7.5">7.5</a>, <a href="#7.12.1">7.12.1</a>, see also domain error                  erf functions, <a href="#7.12.8.1">7.12.8.1</a>, <a href="#F.9.5.1">F.9.5.1</a>
-effective type, <a href="#6.5">6.5</a>                                             erf type-generic macro, <a href="#7.22">7.22</a>
-EILSEQ macro, <a href="#7.5">7.5</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>,                  erfc functions, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#F.9.5.2">F.9.5.2</a>
-      <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>,           erfc type-generic macro, <a href="#7.22">7.22</a>
-      see also encoding error                                   errno macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.3.2">7.3.2</a>, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>,
-element type, <a href="#6.2.5">6.2.5</a>                                                   <a href="#7.12.1">7.12.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.10.4">7.19.10.4</a>,
-elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                                  <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.24.3.1">7.24.3.1</a>,
-ellipsis punctuator (...), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>                   <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>,
-else preprocessing directive, <a href="#6.10.1">6.10.1</a>                                  <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>, <a href="#J.5.17">J.5.17</a>
-else statement, <a href="#6.8.4.1">6.8.4.1</a>                                         errno.h header, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
-empty statement, <a href="#6.8.3">6.8.3</a>                                          error
-encoding error, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>,                        domain, see domain error
-      <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>               encoding, see encoding error
-end-of-file, <a href="#7.24.1">7.24.1</a>                                                 range, see range error
-
-[<a name="p525" href="#p525">page 525</a>] (<a href="#Contents">Contents</a>)
-
-error conditions, <a href="#7.12.1">7.12.1</a>                                     extended characters, <a href="#5.2.1">5.2.1</a>
-error functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.9.5">F.9.5</a>                               extended integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>,
-error indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,                      <a href="#7.18">7.18</a>
-      <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.8">7.19.7.8</a>,                extended multibyte/wide character conversion
-      <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.10.1">7.19.10.1</a>, <a href="#7.19.10.3">7.19.10.3</a>,                   utilities, <a href="#7.24.6">7.24.6</a>
-      <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>                                     extensible wide character case mapping functions,
-error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                          <a href="#7.25.3.2">7.25.3.2</a>
-error-handling functions, <a href="#7.19.10">7.19.10</a>, <a href="#7.21.6.2">7.21.6.2</a>                  extensible wide character classification functions,
-escape character (\), <a href="#6.4.4.4">6.4.4.4</a>                                     <a href="#7.25.2.2">7.25.2.2</a>
-escape sequences, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.11.4">6.11.4</a>              extern storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.7.1">6.7.1</a>
-evaluation format, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#7.12">7.12</a>                  external definition, <a href="#6.9">6.9</a>
-evaluation method, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#F.7.5">F.7.5</a>                     external identifiers, underscore, <a href="#7.1.3">7.1.3</a>
-evaluation order, <a href="#6.5">6.5</a>                                        external linkage, <a href="#6.2.2">6.2.2</a>
-exceptional condition, <a href="#6.5">6.5</a>, <a href="#7.12.1">7.12.1</a>                           external name, <a href="#6.4.2.1">6.4.2.1</a>
-excess precision, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>,               external object definitions, <a href="#6.9.2">6.9.2</a>
-      <a href="#6.8.6.4">6.8.6.4</a>
-excess range, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>           fabs functions, <a href="#7.12.7.2">7.12.7.2</a>, <a href="#F.9.4.2">F.9.4.2</a>
-exclusive OR operators                                       fabs type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-   bitwise (^), <a href="#6.5.11">6.5.11</a>                                       false macro, <a href="#7.16">7.16</a>
-   bitwise assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                         fclose function, <a href="#7.19.5.1">7.19.5.1</a>
-executable program, <a href="#5.1.1.1">5.1.1.1</a>                                  fdim functions, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#F.9.9.1">F.9.9.1</a>
-execution character set, <a href="#5.2.1">5.2.1</a>                               fdim type-generic macro, <a href="#7.22">7.22</a>
-execution environment, <a href="#5">5</a>, <a href="#5.1.2">5.1.2</a>, see also                    FE_ALL_EXCEPT macro, <a href="#7.6">7.6</a>
-      environmental limits                                   FE_DFL_ENV macro, <a href="#7.6">7.6</a>
-execution sequence, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.8">6.8</a>                             FE_DIVBYZERO macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-exit function, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>,            FE_DOWNWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-      <a href="#7.20.4.4">7.20.4.4</a>                                               FE_INEXACT macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-EXIT_FAILURE macro, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>                           FE_INVALID macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-EXIT_SUCCESS macro, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>                           FE_OVERFLOW macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-exp functions, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#F.9.3.1">F.9.3.1</a>                             FE_TONEAREST macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-exp type-generic macro, <a href="#7.22">7.22</a>                                 FE_TOWARDZERO macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-exp2 functions, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#F.9.3.2">F.9.3.2</a>                            FE_UNDERFLOW macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-exp2 type-generic macro, <a href="#7.22">7.22</a>                                FE_UPWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-explicit conversion, <a href="#6.3">6.3</a>                                     feclearexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.1">7.6.2.1</a>, <a href="#F.3">F.3</a>
-expm1 functions, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#F.9.3.3">F.9.3.3</a>                           fegetenv function, <a href="#7.6.4.1">7.6.4.1</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
-expm1 type-generic macro, <a href="#7.22">7.22</a>                               fegetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.2">7.6.2.2</a>, <a href="#F.3">F.3</a>
-exponent part, <a href="#6.4.4.2">6.4.4.2</a>                                       fegetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.1">7.6.3.1</a>, <a href="#F.3">F.3</a>
-exponential functions                                        feholdexcept function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.3">7.6.4.3</a>,
-   complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>                                        <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
-   real, <a href="#7.12.6">7.12.6</a>, <a href="#F.9.3">F.9.3</a>                                       fenv.h header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>
-expression, <a href="#6.5">6.5</a>                                              FENV_ACCESS pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#F.7">F.7</a>, <a href="#F.8">F.8</a>,
-   assignment, <a href="#6.5.16">6.5.16</a>                                           <a href="#F.9">F.9</a>
-   cast, <a href="#6.5.4">6.5.4</a>                                               fenv_t type, <a href="#7.6">7.6</a>
-   constant, <a href="#6.6">6.6</a>                                             feof function, <a href="#7.19.10.2">7.19.10.2</a>
-   full, <a href="#6.8">6.8</a>                                                 feraiseexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.3">7.6.2.3</a>, <a href="#F.3">F.3</a>
-   order of evaluation, <a href="#6.5">6.5</a>                                  ferror function, <a href="#7.19.10.3">7.19.10.3</a>
-   parenthesized, <a href="#6.5.1">6.5.1</a>                                      fesetenv function, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#F.3">F.3</a>
-   primary, <a href="#6.5.1">6.5.1</a>                                            fesetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.4">7.6.2.4</a>, <a href="#F.3">F.3</a>
-   unary, <a href="#6.5.3">6.5.3</a>                                              fesetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.2">7.6.3.2</a>, <a href="#F.3">F.3</a>
-expression statement, <a href="#6.8.3">6.8.3</a>                                  fetestexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.5">7.6.2.5</a>, <a href="#F.3">F.3</a>
-extended character set, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.1.2">5.2.1.2</a>                feupdateenv function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
-
-[<a name="p526" href="#p526">page 526</a>] (<a href="#Contents">Contents</a>)
-
-fexcept_t type, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                      floating-point status flag, <a href="#7.6">7.6</a>, <a href="#F.7.6">F.7.6</a>
-fflush function, <a href="#7.19.5.2">7.19.5.2</a>, <a href="#7.19.5.3">7.19.5.3</a>                           floor functions, <a href="#7.12.9.2">7.12.9.2</a>, <a href="#F.9.6.2">F.9.6.2</a>
-fgetc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,                     floor type-generic macro, <a href="#7.22">7.22</a>
-     <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.8.1">7.19.8.1</a>                                       FLT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-fgetpos function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>                  FLT_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-fgets function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.2">7.19.7.2</a>                              FLT_EVAL_METHOD macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.8.6.4">6.8.6.4</a>,
-fgetwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>,                         <a href="#7.12">7.12</a>
-     <a href="#7.24.3.6">7.24.3.6</a>                                                 FLT_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-fgetws function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.2">7.24.3.2</a>                             FLT_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-field width, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>                                FLT_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-file, <a href="#7.19.3">7.19.3</a>                                                   FLT_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  access functions, <a href="#7.19.5">7.19.5</a>                                    FLT_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  name, <a href="#7.19.3">7.19.3</a>                                                FLT_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  operations, <a href="#7.19.4">7.19.4</a>                                          FLT_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  position indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>,                 FLT_RADIX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
-        <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>, <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                   <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>
-        <a href="#7.19.8.1">7.19.8.1</a>, <a href="#7.19.8.2">7.19.8.2</a>, <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.2">7.19.9.2</a>,               FLT_ROUNDS macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-        <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.9.4">7.19.9.4</a>, <a href="#7.19.9.5">7.19.9.5</a>, <a href="#7.24.3.1">7.24.3.1</a>,               fma functions, <a href="#7.12">7.12</a>, <a href="#7.12.13.1">7.12.13.1</a>, <a href="#F.9.10.1">F.9.10.1</a>
-        <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.3.10">7.24.3.10</a>                                   fma type-generic macro, <a href="#7.22">7.22</a>
-  positioning functions, <a href="#7.19.9">7.19.9</a>                               fmax functions, <a href="#7.12.12.2">7.12.12.2</a>, <a href="#F.9.9.2">F.9.9.2</a>
-file scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.9">6.9</a>                                         fmax type-generic macro, <a href="#7.22">7.22</a>
-FILE type, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                                     fmin functions, <a href="#7.12.12.3">7.12.12.3</a>, <a href="#F.9.9.3">F.9.9.3</a>
-FILENAME_MAX macro, <a href="#7.19.1">7.19.1</a>                                    fmin type-generic macro, <a href="#7.22">7.22</a>
-flags, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>                                      fmod functions, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#F.9.7.1">F.9.7.1</a>
-  floating-point status, see floating-point status              fmod type-generic macro, <a href="#7.22">7.22</a>
-        flag                                                   fopen function, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.5.4">7.19.5.4</a>
-flexible array member, <a href="#6.7.2.1">6.7.2.1</a>                                 FOPEN_MAX macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.4.3">7.19.4.3</a>
-float _Complex type, <a href="#6.2.5">6.2.5</a>                                    for statement, <a href="#6.8.5">6.8.5</a>, <a href="#6.8.5.3">6.8.5.3</a>
-float _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                      form-feed character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
-     <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                         form-feed escape sequence (\f), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
-float _Imaginary type, <a href="#G.2">G.2</a>                                         <a href="#7.4.1.10">7.4.1.10</a>
-float type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.2">F.2</a>                        formal argument (deprecated), <a href="#3.15">3.15</a>
-float type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,             formal parameter, <a href="#3.15">3.15</a>
-     <a href="#6.3.1.8">6.3.1.8</a>                                                  formatted input/output functions, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.19.6">7.19.6</a>
-float.h header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,                     wide character, <a href="#7.24.2">7.24.2</a>
-     <a href="#7.24.4.1.1">7.24.4.1.1</a>                                               fortran keyword, <a href="#J.5.9">J.5.9</a>
-float_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                     forward reference, <a href="#3.11">3.11</a>
-floating constant, <a href="#6.4.4.2">6.4.4.2</a>                                     FP_CONTRACT pragma, <a href="#6.5">6.5</a>, <a href="#6.10.6">6.10.6</a>, <a href="#7.12.2">7.12.2</a>, see
-floating suffix, f or <a href="#F">F</a>, <a href="#6.4.4.2">6.4.4.2</a>                                     also contracted expression
-floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,           FP_FAST_FMA macro, <a href="#7.12">7.12</a>
-     <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                                 FP_FAST_FMAF macro, <a href="#7.12">7.12</a>
-floating types, <a href="#6.2.5">6.2.5</a>, <a href="#6.11.1">6.11.1</a>                                  FP_FAST_FMAL macro, <a href="#7.12">7.12</a>
-floating-point accuracy, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.5">6.5</a>,              FP_ILOGB0 macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
-     <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.5">F.5</a>, see also contracted expression            FP_ILOGBNAN macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
-floating-point arithmetic functions, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                 FP_INFINITE macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-floating-point classification functions, <a href="#7.12.3">7.12.3</a>                 FP_NAN macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-floating-point control mode, <a href="#7.6">7.6</a>, <a href="#F.7.6">F.7.6</a>                        FP_NORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-floating-point environment, <a href="#7.6">7.6</a>, <a href="#F.7">F.7</a>, <a href="#F.7.6">F.7.6</a>                    FP_SUBNORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-floating-point exception, <a href="#7.6">7.6</a>, <a href="#7.6.2">7.6.2</a>, <a href="#F.9">F.9</a>                      FP_ZERO macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-floating-point number, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.2.5">6.2.5</a>                        fpclassify macro, <a href="#7.12.3.1">7.12.3.1</a>, <a href="#F.3">F.3</a>
-floating-point rounding mode, <a href="#5.2.4.2.2">5.2.4.2.2</a>                        fpos_t type, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>
-
-[<a name="p527" href="#p527">page 527</a>] (<a href="#Contents">Contents</a>)
-
-fprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.1">7.19.6.1</a>,                       language, <a href="#6.11">6.11</a>
-      <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.5">7.19.6.5</a>, <a href="#7.19.6.6">7.19.6.6</a>,                    library, <a href="#7.26">7.26</a>
-      <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.3">F.3</a>                                  fwide function, <a href="#7.19.2">7.19.2</a>, <a href="#7.24.3.5">7.24.3.5</a>
-fputc function, <a href="#5.2.2">5.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.7.3">7.19.7.3</a>,               fwprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,
-      <a href="#7.19.7.8">7.19.7.8</a>, <a href="#7.19.8.2">7.19.8.2</a>                                            <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.2.3">7.24.2.3</a>, <a href="#7.24.2.5">7.24.2.5</a>,
-fputs function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.4">7.19.7.4</a>                                    <a href="#7.24.2.11">7.24.2.11</a>
-fputwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.3">7.24.3.3</a>,                     fwrite function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.8.2">7.19.8.2</a>
-      <a href="#7.24.3.8">7.24.3.8</a>                                                 fwscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.2">7.24.2.2</a>,
-fputws function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.4">7.24.3.4</a>                                   <a href="#7.24.2.4">7.24.2.4</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.12">7.24.2.12</a>, <a href="#7.24.3.10">7.24.3.10</a>
-fread function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.8.1">7.19.8.1</a>
-free function, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>                              gamma functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.9.5">F.9.5</a>
-freestanding execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>,                  general utilities, <a href="#7.20">7.20</a>
-      <a href="#5.1.2.1">5.1.2.1</a>                                                    wide string, <a href="#7.24.4">7.24.4</a>
-freopen function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.4">7.19.5.4</a>                             general wide string utilities, <a href="#7.24.4">7.24.4</a>
-frexp functions, <a href="#7.12.6.4">7.12.6.4</a>, <a href="#F.9.3.4">F.9.3.4</a>                             generic parameters, <a href="#7.22">7.22</a>
-frexp type-generic macro, <a href="#7.22">7.22</a>                                 getc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>
-fscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                      getchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.6">7.19.7.6</a>
-      <a href="#7.19.6.4">7.19.6.4</a>, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#F.3">F.3</a>                        getenv function, <a href="#7.20.4.5">7.20.4.5</a>
-fseek function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                   gets function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.26.9">7.26.9</a>
-      <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>, <a href="#7.19.9.5">7.19.9.5</a>, <a href="#7.24.3.10">7.24.3.10</a>                  getwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.6">7.24.3.6</a>, <a href="#7.24.3.7">7.24.3.7</a>
-fsetpos function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                 getwchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.7">7.24.3.7</a>
-      <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.24.3.10">7.24.3.10</a>                            gmtime function, <a href="#7.23.3.3">7.23.3.3</a>
-ftell function, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>                             goto statement, <a href="#6.2.1">6.2.1</a>, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.6.1">6.8.6.1</a>
-full declarator, <a href="#6.7.5">6.7.5</a>                                         graphic characters, <a href="#5.2.1">5.2.1</a>
-full expression, <a href="#6.8">6.8</a>                                           greater-than operator (&gt;), <a href="#6.5.8">6.5.8</a>
-fully buffered stream, <a href="#7.19.3">7.19.3</a>                                  greater-than-or-equal-to operator (&gt;=), <a href="#6.5.8">6.5.8</a>
-function
-   argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>                                    header, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.2">7.1.2</a>, see also standard headers
-   body, <a href="#6.9.1">6.9.1</a>                                                 header names, <a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>, <a href="#6.10.2">6.10.2</a>
-   call, <a href="#6.5.2.2">6.5.2.2</a>                                               hexadecimal constant, <a href="#6.4.4.1">6.4.4.1</a>
-      library, <a href="#7.1.4">7.1.4</a>                                           hexadecimal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
-   declarator, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.11.6">6.11.6</a>                                 hexadecimal prefix, <a href="#6.4.4.1">6.4.4.1</a>
-   definition, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.7">6.11.7</a>                           hexadecimal-character escape sequence
-   designator, <a href="#6.3.2.1">6.3.2.1</a>                                              (\x hexadecimal digits), <a href="#6.4.4.4">6.4.4.4</a>
-   image, <a href="#5.2.3">5.2.3</a>                                                high-order bit, <a href="#3.6">3.6</a>
-   library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.4">7.1.4</a>                                     horizontal-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
-   name length, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                       horizontal-tab escape sequence (\r), <a href="#7.25.2.1.3">7.25.2.1.3</a>
-   parameter, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>                   horizontal-tab escape sequence (\t), <a href="#5.2.2">5.2.2</a>,
-   prototype, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.7">6.2.7</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>,                <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>
-         <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.6">6.11.6</a>, <a href="#6.11.7">6.11.7</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.12">7.12</a>           hosted execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.2">5.1.2.2</a>
-   prototype scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.7.5.2">6.7.5.2</a>                             HUGE_VAL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
-   recursive call, <a href="#6.5.2.2">6.5.2.2</a>                                          <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
-   return, <a href="#6.8.6.4">6.8.6.4</a>                                             HUGE_VALF macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
-   scope, <a href="#6.2.1">6.2.1</a>                                                     <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
-   type, <a href="#6.2.5">6.2.5</a>                                                 HUGE_VALL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
-   type conversion, <a href="#6.3.2.1">6.3.2.1</a>                                         <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
-function specifiers, <a href="#6.7.4">6.7.4</a>                                      hyperbolic functions
-function type, <a href="#6.2.5">6.2.5</a>                                             complex, <a href="#7.3.6">7.3.6</a>, <a href="#G.6.2">G.6.2</a>
-function-call operator (( )), <a href="#6.5.2.2">6.5.2.2</a>                            real, <a href="#7.12.5">7.12.5</a>, <a href="#F.9.2">F.9.2</a>
-function-like macro, <a href="#6.10.3">6.10.3</a>                                    hypot functions, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#F.9.4.3">F.9.4.3</a>
-future directions                                              hypot type-generic macro, <a href="#7.22">7.22</a>
-
-[<a name="p528" href="#p528">page 528</a>] (<a href="#Contents">Contents</a>)
-
-I macro, <a href="#7.3.1">7.3.1</a>, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                                    initial position, <a href="#5.2.2">5.2.2</a>
-identifier, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.5.1">6.5.1</a>                                       initial shift state, <a href="#5.2.1.2">5.2.1.2</a>
-   linkage, see linkage                                         initialization, <a href="#5.1.2">5.1.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.5">6.5.2.5</a>, <a href="#6.7.8">6.7.8</a>,
-  maximum length, <a href="#6.4.2.1">6.4.2.1</a>                                             <a href="#F.7.5">F.7.5</a>
-   name spaces, <a href="#6.2.3">6.2.3</a>                                              in blocks, <a href="#6.8">6.8</a>
-   reserved, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>                                       initializer, <a href="#6.7.8">6.7.8</a>
-  scope, <a href="#6.2.1">6.2.1</a>                                                     permitted form, <a href="#6.6">6.6</a>
-   type, <a href="#6.2.5">6.2.5</a>                                                     string literal, <a href="#6.3.2.1">6.3.2.1</a>
-identifier list, <a href="#6.7.5">6.7.5</a>                                           inline, <a href="#6.7.4">6.7.4</a>
-identifier nondigit, <a href="#6.4.2.1">6.4.2.1</a>                                     inner scope, <a href="#6.2.1">6.2.1</a>
-IEC 559, <a href="#F.1">F.1</a>                                                    input failure, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>
-IEC 60559, <a href="#2">2</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8">6.10.8</a>, <a href="#7.3.3">7.3.3</a>, <a href="#7.6">7.6</a>,           input/output functions
-      <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.14">7.12.14</a>, <a href="#F">F</a>, <a href="#G">G</a>, <a href="#H.1">H.1</a>               character, <a href="#7.19.7">7.19.7</a>
-IEEE 754, <a href="#F.1">F.1</a>                                                      direct, <a href="#7.19.8">7.19.8</a>
-IEEE 854, <a href="#F.1">F.1</a>                                                      formatted, <a href="#7.19.6">7.19.6</a>
-IEEE floating-point arithmetic standard, see                           wide character, <a href="#7.24.2">7.24.2</a>
-      IEC 60559, ANSI/IEEE 754,                                    wide character, <a href="#7.24.3">7.24.3</a>
-      ANSI/IEEE 854                                                   formatted, <a href="#7.24.2">7.24.2</a>
-if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,               input/output header, <a href="#7.19">7.19</a>
-      <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             input/output, device, <a href="#5.1.2.3">5.1.2.3</a>
-if statement, <a href="#6.8.4.1">6.8.4.1</a>                                           int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.7.2">6.7.2</a>
-ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                           int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
-ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                                <a href="#6.3.1.8">6.3.1.8</a>
-ilogb functions, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.9.3.5">F.9.3.5</a>                        INT_FASTN_MAX macros, <a href="#7.18.2.3">7.18.2.3</a>
-ilogb type-generic macro, <a href="#7.22">7.22</a>                                  INT_FASTN_MIN macros, <a href="#7.18.2.3">7.18.2.3</a>
-imaginary macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>                                     int_fastN_t types, <a href="#7.18.1.3">7.18.1.3</a>
-imaginary numbers, <a href="#G">G</a>                                            INT_LEASTN_MAX macros, <a href="#7.18.2.2">7.18.2.2</a>
-imaginary type domain, <a href="#G.2">G.2</a>                                      INT_LEASTN_MIN macros, <a href="#7.18.2.2">7.18.2.2</a>
-imaginary types, <a href="#G">G</a>                                              int_leastN_t types, <a href="#7.18.1.2">7.18.1.2</a>
-imaxabs function, <a href="#7.8.2.1">7.8.2.1</a>                                       INT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
-imaxdiv function, <a href="#7.8">7.8</a>, <a href="#7.8.2.2">7.8.2.2</a>                                  INT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>
-imaxdiv_t type, <a href="#7.8">7.8</a>                                             integer arithmetic functions, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>,
-implementation, <a href="#3.12">3.12</a>                                                  <a href="#7.20.6">7.20.6</a>
-implementation limit, <a href="#3.13">3.13</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.4.2.1">6.4.2.1</a>,                integer character constant, <a href="#6.4.4.4">6.4.4.4</a>
-      <a href="#6.7.5">6.7.5</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#E">E</a>, see also environmental                 integer constant, <a href="#6.4.4.1">6.4.4.1</a>
-      limits                                                    integer constant expression, <a href="#6.6">6.6</a>
-implementation-defined behavior, <a href="#3.4.1">3.4.1</a>, <a href="#4">4</a>, <a href="#J.3">J.3</a>                   integer conversion rank, <a href="#6.3.1.1">6.3.1.1</a>
-implementation-defined value, <a href="#3.17.1">3.17.1</a>                             integer promotions, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.3.1.1">6.3.1.1</a>,
-implicit conversion, <a href="#6.3">6.3</a>                                              <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.7">6.5.7</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>,
-implicit initialization, <a href="#6.7.8">6.7.8</a>                                        <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>
-include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.2">6.10.2</a>                integer suffix, <a href="#6.4.4.1">6.4.4.1</a>
-inclusive OR operators                                          integer type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
-   bitwise (|), <a href="#6.5.12">6.5.12</a>                                                <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
-   bitwise assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>                            integer types, <a href="#6.2.5">6.2.5</a>, <a href="#7.18">7.18</a>
-incomplete type, <a href="#6.2.5">6.2.5</a>                                             extended, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#7.18">7.18</a>
-increment operators, see arithmetic operators,                  interactive device, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.3">7.19.5.3</a>
-      increment and decrement                                   internal linkage, <a href="#6.2.2">6.2.2</a>
-indeterminate value, <a href="#3.17.2">3.17.2</a>                                     internal name, <a href="#6.4.2.1">6.4.2.1</a>
-indirection operator (*), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                      interrupt, <a href="#5.2.3">5.2.3</a>
-inequality operator (!=), <a href="#6.5.9">6.5.9</a>                                 INTMAX_C macro, <a href="#7.18.4.2">7.18.4.2</a>
-INFINITY macro, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                            INTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>
-
-[<a name="p529" href="#p529">page 529</a>] (<a href="#Contents">Contents</a>)
-
-INTMAX_MIN macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>            iswalpha function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
-intmax_t type, <a href="#7.18.1.5">7.18.1.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                  <a href="#7.25.2.2.1">7.25.2.2.1</a>
-    <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  iswblank function, <a href="#7.25.2.1.3">7.25.2.1.3</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
-INTN_C macros, <a href="#7.18.4.1">7.18.4.1</a>                                 iswcntrl function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.4">7.25.2.1.4</a>,
-INTN_MAX macros, <a href="#7.18.2.1">7.18.2.1</a>                                     <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
-INTN_MIN macros, <a href="#7.18.2.1">7.18.2.1</a>                               iswctype function, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
-intN_t types, <a href="#7.18.1.1">7.18.1.1</a>                                  iswdigit function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
-INTPTR_MAX macro, <a href="#7.18.2.4">7.18.2.4</a>                                    <a href="#7.25.2.1.5">7.25.2.1.5</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
-INTPTR_MIN macro, <a href="#7.18.2.4">7.18.2.4</a>                              iswgraph function, <a href="#7.25.2.1">7.25.2.1</a>, <a href="#7.25.2.1.6">7.25.2.1.6</a>,
-intptr_t type, <a href="#7.18.1.4">7.18.1.4</a>                                       <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
-inttypes.h header, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>                          iswlower function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>,
-isalnum function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>                  <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.1.2">7.25.3.1.2</a>
-isalpha function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>                      iswprint function, <a href="#7.25.2.1.6">7.25.2.1.6</a>, <a href="#7.25.2.1.8">7.25.2.1.8</a>,
-isblank function, <a href="#7.4.1.3">7.4.1.3</a>                                     <a href="#7.25.2.2.1">7.25.2.2.1</a>
-iscntrl function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.4">7.4.1.4</a>, <a href="#7.4.1.7">7.4.1.7</a>,            iswpunct function, <a href="#7.25.2.1">7.25.2.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
-    <a href="#7.4.1.11">7.4.1.11</a>                                                  <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>,
-isdigit function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.5">7.4.1.5</a>,                  <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
-    <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.11.1.1">7.11.1.1</a>                         iswspace function, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,
-isfinite macro, <a href="#7.12.3.2">7.12.3.2</a>, <a href="#F.3">F.3</a>                                 <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.6">7.25.2.1.6</a>,
-isgraph function, <a href="#7.4.1.6">7.4.1.6</a>                                     <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>,
-isgreater macro, <a href="#7.12.14.1">7.12.14.1</a>, <a href="#F.3">F.3</a>                               <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
-isgreaterequal macro, <a href="#7.12.14.2">7.12.14.2</a>, <a href="#F.3">F.3</a>                    iswupper function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>,
-isinf macro, <a href="#7.12.3.3">7.12.3.3</a>                                         <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.1.2">7.25.3.1.2</a>
-isless macro, <a href="#7.12.14.3">7.12.14.3</a>, <a href="#F.3">F.3</a>                            iswxdigit function, <a href="#7.25.2.1.12">7.25.2.1.12</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
-islessequal macro, <a href="#7.12.14.4">7.12.14.4</a>, <a href="#F.3">F.3</a>                       isxdigit function, <a href="#7.4.1.12">7.4.1.12</a>, <a href="#7.11.1.1">7.11.1.1</a>
-islessgreater macro, <a href="#7.12.14.5">7.12.14.5</a>, <a href="#F.3">F.3</a>                     italic type convention, <a href="#3">3</a>, <a href="#6.1">6.1</a>
-islower function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.2.1">7.4.2.1</a>,            iteration statements, <a href="#6.8.5">6.8.5</a>
-    <a href="#7.4.2.2">7.4.2.2</a>
-isnan macro, <a href="#7.12.3.4">7.12.3.4</a>, <a href="#F.3">F.3</a>                              jmp_buf type, <a href="#7.13">7.13</a>
-isnormal macro, <a href="#7.12.3.5">7.12.3.5</a>                                jump statements, <a href="#6.8.6">6.8.6</a>
-ISO 31-11, <a href="#2">2</a>, <a href="#3">3</a>
-ISO 4217, <a href="#2">2</a>, <a href="#7.11.2.1">7.11.2.1</a>                                   keywords, <a href="#6.4.1">6.4.1</a>, <a href="#G.2">G.2</a>, <a href="#J.5.9">J.5.9</a>, <a href="#J.5.10">J.5.10</a>
-ISO 8601, <a href="#2">2</a>, <a href="#7.23.3.5">7.23.3.5</a>                                   known constant size, <a href="#6.2.5">6.2.5</a>
-ISO/IEC 10646, <a href="#2">2</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.4.3">6.4.3</a>, <a href="#6.10.8">6.10.8</a>
-ISO/IEC 10976-1, <a href="#H.1">H.1</a>                                    <a href="#L">L</a>_tmpnam macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.4">7.19.4.4</a>
-ISO/IEC 2382-1, <a href="#2">2</a>, <a href="#3">3</a>                                    label name, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.3">6.2.3</a>
-ISO/IEC 646, <a href="#2">2</a>, <a href="#5.2.1.1">5.2.1.1</a>                                 labeled statement, <a href="#6.8.1">6.8.1</a>
-ISO/IEC 9945-2, <a href="#7.11">7.11</a>                                    labs function, <a href="#7.20.6.1">7.20.6.1</a>
-ISO/IEC TR 10176, <a href="#D">D</a>                                     language, <a href="#6">6</a>
-iso646.h header, <a href="#4">4</a>, <a href="#7.9">7.9</a>                                    future directions, <a href="#6.11">6.11</a>
-isprint function, <a href="#5.2.2">5.2.2</a>, <a href="#7.4.1.8">7.4.1.8</a>                           syntax summary, <a href="#A">A</a>
-ispunct function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,            Latin alphabet, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
-    <a href="#7.4.1.11">7.4.1.11</a>                                            LC_ALL macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-isspace function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,            LC_COLLATE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.3">7.21.4.3</a>,
-    <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.3">7.20.1.3</a>,                   <a href="#7.24.4.4.2">7.24.4.4.2</a>
-    <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  LC_CTYPE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.20">7.20</a>, <a href="#7.20.7">7.20.7</a>,
-isunordered macro, <a href="#7.12.14.6">7.12.14.6</a>, <a href="#F.3">F.3</a>                             <a href="#7.20.8">7.20.8</a>, <a href="#7.24.6">7.24.6</a>, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>,
-isupper function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.4.2.1">7.4.2.1</a>,                 <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
-    <a href="#7.4.2.2">7.4.2.2</a>                                             LC_MONETARY macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-iswalnum function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>,              LC_NUMERIC macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-    <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>                             LC_TIME macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.3.5">7.23.3.5</a>
-
-[<a name="p530" href="#p530">page 530</a>] (<a href="#Contents">Contents</a>)
-
-lconv structure type, <a href="#7.11">7.11</a>                                 llabs function, <a href="#7.20.6.1">7.20.6.1</a>
-LDBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                  lldiv function, <a href="#7.20.6.2">7.20.6.2</a>
-LDBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                              lldiv_t type, <a href="#7.20">7.20</a>
-LDBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                             LLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,
-LDBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                       <a href="#7.24.4.1.2">7.24.4.1.2</a>
-LDBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                           LLONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,
-LDBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                   <a href="#7.24.4.1.2">7.24.4.1.2</a>
-LDBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                  llrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.5">F.9.6.5</a>
-LDBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                           llrint type-generic macro, <a href="#7.22">7.22</a>
-LDBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                              llround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.7">F.9.6.7</a>
-ldexp functions, <a href="#7.12.6.6">7.12.6.6</a>, <a href="#F.9.3.6">F.9.3.6</a>                         llround type-generic macro, <a href="#7.22">7.22</a>
-ldexp type-generic macro, <a href="#7.22">7.22</a>                             local time, <a href="#7.23.1">7.23.1</a>
-ldiv function, <a href="#7.20.6.2">7.20.6.2</a>                                    locale, <a href="#3.4.2">3.4.2</a>
-ldiv_t type, <a href="#7.20">7.20</a>                                          locale-specific behavior, <a href="#3.4.2">3.4.2</a>, <a href="#J.4">J.4</a>
-leading underscore in identifiers, <a href="#7.1.3">7.1.3</a>                    locale.h header, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
-left-shift assignment operator (&lt;&lt;=), <a href="#6.5.16.2">6.5.16.2</a>             localeconv function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-left-shift operator (&lt;&lt;), <a href="#6.5.7">6.5.7</a>                            localization, <a href="#7.11">7.11</a>
-length                                                     localtime function, <a href="#7.23.3.4">7.23.3.4</a>
-   external name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                 log functions, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#F.9.3.7">F.9.3.7</a>
-   function name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                 log type-generic macro, <a href="#7.22">7.22</a>
-   identifier, <a href="#6.4.2.1">6.4.2.1</a>                                      log10 functions, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#F.9.3.8">F.9.3.8</a>
-   internal name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>                         log10 type-generic macro, <a href="#7.22">7.22</a>
-length function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.24.4.6.1">7.24.4.6.1</a>,           log1p functions, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#F.9.3.9">F.9.3.9</a>
-      <a href="#7.24.6.3.1">7.24.6.3.1</a>                                           log1p type-generic macro, <a href="#7.22">7.22</a>
-length modifier, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>,              log2 functions, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#F.9.3.10">F.9.3.10</a>
-      <a href="#7.24.2.2">7.24.2.2</a>                                             log2 type-generic macro, <a href="#7.22">7.22</a>
-less-than operator (&lt;), <a href="#6.5.8">6.5.8</a>                              logarithmic functions
-less-than-or-equal-to operator (&lt;=), <a href="#6.5.8">6.5.8</a>                   complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
-letter, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                           real, <a href="#7.12.6">7.12.6</a>, <a href="#F.9.3">F.9.3</a>
-lexical elements, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>                             logb functions, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.11">F.9.3.11</a>
-lgamma functions, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#F.9.5.3">F.9.5.3</a>                        logb type-generic macro, <a href="#7.22">7.22</a>
-lgamma type-generic macro, <a href="#7.22">7.22</a>                            logical operators
-library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7">7</a>                                          AND (&amp;&amp;), <a href="#6.5.13">6.5.13</a>
-   future directions, <a href="#7.26">7.26</a>                                   negation (!), <a href="#6.5.3.3">6.5.3.3</a>
-   summary, <a href="#B">B</a>                                                OR (||), <a href="#6.5.14">6.5.14</a>
-   terms, <a href="#7.1.1">7.1.1</a>                                            logical source lines, <a href="#5.1.1.2">5.1.1.2</a>
-   use of functions, <a href="#7.1.4">7.1.4</a>                                 long double _Complex type, <a href="#6.2.5">6.2.5</a>
-lifetime, <a href="#6.2.4">6.2.4</a>                                            long double _Complex type conversion,
-limits                                                          <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
-   environmental, see environmental limits                 long double _Imaginary type, <a href="#G.2">G.2</a>
-   implementation, see implementation limits               long double suffix, l or <a href="#L">L</a>, <a href="#6.4.4.2">6.4.4.2</a>
-   numerical, see numerical limits                         long double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>,
-   translation, see translation limits                          <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.2">F.2</a>
-limits.h header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                 long double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,
-line buffered stream, <a href="#7.19.3">7.19.3</a>                                    <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
-line number, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8">6.10.8</a>                                long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
-line preprocessing directive, <a href="#6.10.4">6.10.4</a>                            <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
-lines, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#7.19.2">7.19.2</a>                                     long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
-   preprocessing directive, <a href="#6.10">6.10</a>                                <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
-linkage, <a href="#6.2.2">6.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.4">6.7.4</a>, <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.9">6.9</a>, <a href="#6.9.2">6.9.2</a>,           long integer suffix, l or <a href="#L">L</a>, <a href="#6.4.4.1">6.4.4.1</a>
-      <a href="#6.11.2">6.11.2</a>                                               long long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>,
-
-[<a name="p531" href="#p531">page 531</a>] (<a href="#Contents">Contents</a>)
-
-     <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                    mbsinit function, <a href="#7.24.6.2.1">7.24.6.2.1</a>
-long long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>,                        mbsrtowcs function, <a href="#7.24.6.4.1">7.24.6.4.1</a>
-     <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                 mbstate_t type, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.1">7.19.6.1</a>,
-long long integer suffix, ll or LL, <a href="#6.4.4.1">6.4.4.1</a>                          <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.6">7.24.6</a>,
-LONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                     <a href="#7.24.6.2.1">7.24.6.2.1</a>, <a href="#7.24.6.3">7.24.6.3</a>, <a href="#7.24.6.3.1">7.24.6.3.1</a>, <a href="#7.24.6.4">7.24.6.4</a>
-LONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                mbstowcs function, <a href="#6.4.5">6.4.5</a>, <a href="#7.20.8.1">7.20.8.1</a>, <a href="#7.24.6.4">7.24.6.4</a>
-longjmp function, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>, <a href="#7.20.4.3">7.20.4.3</a>                 mbtowc function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.20.7.2">7.20.7.2</a>, <a href="#7.20.8.1">7.20.8.1</a>,
-loop body, <a href="#6.8.5">6.8.5</a>                                                    <a href="#7.24.6.3">7.24.6.3</a>
-low-order bit, <a href="#3.6">3.6</a>                                             member access operators (. and -&gt;), <a href="#6.5.2.3">6.5.2.3</a>
-lowercase letter, <a href="#5.2.1">5.2.1</a>                                        member alignment, <a href="#6.7.2.1">6.7.2.1</a>
-lrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.5">F.9.6.5</a>                        memchr function, <a href="#7.21.5.1">7.21.5.1</a>
-lrint type-generic macro, <a href="#7.22">7.22</a>                                 memcmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.1">7.21.4.1</a>
-lround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.7">F.9.6.7</a>                            memcpy function, <a href="#7.21.2.1">7.21.2.1</a>
-lround type-generic macro, <a href="#7.22">7.22</a>                                memmove function, <a href="#7.21.2.2">7.21.2.2</a>
-lvalue, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>, <a href="#6.5.16">6.5.16</a>               memory management functions, <a href="#7.20.3">7.20.3</a>
-                                                               memset function, <a href="#7.21.6.1">7.21.6.1</a>
-macro argument substitution, <a href="#6.10.3.1">6.10.3.1</a>                          minimum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>
-macro definition                                                minus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>
-  library function, <a href="#7.1.4">7.1.4</a>                                      miscellaneous functions
-macro invocation, <a href="#6.10.3">6.10.3</a>                                         string, <a href="#7.21.6">7.21.6</a>
-macro name, <a href="#6.10.3">6.10.3</a>                                               wide string, <a href="#7.24.4.6">7.24.4.6</a>
-  length, <a href="#5.2.4.1">5.2.4.1</a>                                              mktime function, <a href="#7.23.2.3">7.23.2.3</a>
-  predefined, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>                                    modf functions, <a href="#7.12.6.12">7.12.6.12</a>, <a href="#F.9.3.12">F.9.3.12</a>
-  redefinition, <a href="#6.10.3">6.10.3</a>                                          modifiable lvalue, <a href="#6.3.2.1">6.3.2.1</a>
-  scope, <a href="#6.10.3.5">6.10.3.5</a>                                              modulus functions, <a href="#7.12.6.12">7.12.6.12</a>
-macro parameter, <a href="#6.10.3">6.10.3</a>                                        modulus, complex, <a href="#7.3.8.1">7.3.8.1</a>
-macro preprocessor, <a href="#6.10">6.10</a>                                       multibyte character, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
-macro replacement, <a href="#6.10.3">6.10.3</a>                                      multibyte conversion functions
-magnitude, complex, <a href="#7.3.8.1">7.3.8.1</a>                                      wide character, <a href="#7.20.7">7.20.7</a>
-main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.4">6.7.4</a>,                extended, <a href="#7.24.6">7.24.6</a>
-     <a href="#7.19.3">7.19.3</a>                                                         restartable, <a href="#7.24.6.3">7.24.6.3</a>
-malloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.3">7.20.3.3</a>,                     wide string, <a href="#7.20.8">7.20.8</a>
-     <a href="#7.20.3.4">7.20.3.4</a>                                                       restartable, <a href="#7.24.6.4">7.24.6.4</a>
-manipulation functions                                         multibyte string, <a href="#7.1.1">7.1.1</a>
-  complex, <a href="#7.3.9">7.3.9</a>                                               multibyte/wide character conversion functions,
-  real, <a href="#7.12.11">7.12.11</a>, <a href="#F.9.8">F.9.8</a>                                              <a href="#7.20.7">7.20.7</a>
-matching failure, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>                  extended, <a href="#7.24.6">7.24.6</a>
-math.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>, <a href="#F.9">F.9</a>,               restartable, <a href="#7.24.6.3">7.24.6.3</a>
-     <a href="#J.5.17">J.5.17</a>                                                    multibyte/wide string conversion functions, <a href="#7.20.8">7.20.8</a>
-MATH_ERREXCEPT macro, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                                  restartable, <a href="#7.24.6.4">7.24.6.4</a>
-math_errhandling macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                       multidimensional array, <a href="#6.5.2.1">6.5.2.1</a>
-MATH_ERRNO macro, <a href="#7.12">7.12</a>                                         multiplication assignment operator (*=), <a href="#6.5.16.2">6.5.16.2</a>
-maximum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>                              multiplication operator (*), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
-MB_CUR_MAX macro, <a href="#7.1.1">7.1.1</a>, <a href="#7.20">7.20</a>, <a href="#7.20.7.2">7.20.7.2</a>,                       multiplicative expressions, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
-     <a href="#7.20.7.3">7.20.7.3</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>
-MB_LEN_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.1.1">7.1.1</a>, <a href="#7.20">7.20</a>                       n-char sequence, <a href="#7.20.1.3">7.20.1.3</a>
-mblen function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.24.6.3">7.24.6.3</a>                             n-wchar sequence, <a href="#7.24.4.1.1">7.24.4.1.1</a>
-mbrlen function, <a href="#7.24.6.3.1">7.24.6.3.1</a>                                    name
-mbrtowc function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                    external, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
-     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.6.3.1">7.24.6.3.1</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>,                 file, <a href="#7.19.3">7.19.3</a>
-     <a href="#7.24.6.4.1">7.24.6.4.1</a>                                                  internal, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
-
-[<a name="p532" href="#p532">page 532</a>] (<a href="#Contents">Contents</a>)
-
-  label, <a href="#6.2.3">6.2.3</a>                                                  octal-character escape sequence (\octal digits),
-  structure/union member, <a href="#6.2.3">6.2.3</a>                                       <a href="#6.4.4.4">6.4.4.4</a>
-name spaces, <a href="#6.2.3">6.2.3</a>                                              offsetof macro, <a href="#7.17">7.17</a>
-named label, <a href="#6.8.1">6.8.1</a>                                              on-off switch, <a href="#6.10.6">6.10.6</a>
-NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                                  ones' complement, <a href="#6.2.6.2">6.2.6.2</a>
-nan functions, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#F.2.1">F.2.1</a>, <a href="#F.9.8.2">F.9.8.2</a>                        operand, <a href="#6.4.6">6.4.6</a>, <a href="#6.5">6.5</a>
-NAN macro, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                                          operating system, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#7.20.4.6">7.20.4.6</a>
-NDEBUG macro, <a href="#7.2">7.2</a>                                               operations on files, <a href="#7.19.4">7.19.4</a>
-nearbyint functions, <a href="#7.12.9.3">7.12.9.3</a>, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>,                   operator, <a href="#6.4.6">6.4.6</a>
-     <a href="#F.9.6.3">F.9.6.3</a>                                                    operators, <a href="#6.5">6.5</a>
-nearbyint type-generic macro, <a href="#7.22">7.22</a>                                 assignment, <a href="#6.5.16">6.5.16</a>
-nearest integer functions, <a href="#7.12.9">7.12.9</a>, <a href="#F.9.6">F.9.6</a>                           associativity, <a href="#6.5">6.5</a>
-negation operator (!), <a href="#6.5.3.3">6.5.3.3</a>                                     equality, <a href="#6.5.9">6.5.9</a>
-negative zero, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.12.11.1">7.12.11.1</a>                                  multiplicative, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
-new-line character, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#6.10.4">6.10.4</a>              postfix, <a href="#6.5.2">6.5.2</a>
-new-line escape sequence (\n), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,                     precedence, <a href="#6.5">6.5</a>
-     <a href="#7.4.1.10">7.4.1.10</a>                                                      preprocessing, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, <a href="#6.10.9">6.10.9</a>
-nextafter functions, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>,                    relational, <a href="#6.5.8">6.5.8</a>
-     <a href="#F.9.8.3">F.9.8.3</a>                                                       shift, <a href="#6.5.7">6.5.7</a>
-nextafter type-generic macro, <a href="#7.22">7.22</a>                                 unary, <a href="#6.5.3">6.5.3</a>
-nexttoward functions, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, <a href="#F.9.8.4">F.9.8.4</a>                      unary arithmetic, <a href="#6.5.3.3">6.5.3.3</a>
-nexttoward type-generic macro, <a href="#7.22">7.22</a>                             or macro, <a href="#7.9">7.9</a>
-no linkage, <a href="#6.2.2">6.2.2</a>                                               OR operators
-non-stop floating-point control mode, <a href="#7.6.4.2">7.6.4.2</a>                       bitwise exclusive (^), <a href="#6.5.11">6.5.11</a>
-nongraphic characters, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                              bitwise exclusive assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
-nonlocal jumps header, <a href="#7.13">7.13</a>                                        bitwise inclusive (|), <a href="#6.5.12">6.5.12</a>
-norm, complex, <a href="#7.3.8.1">7.3.8.1</a>                                             bitwise inclusive assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
-not macro, <a href="#7.9">7.9</a>                                                     logical (||), <a href="#6.5.14">6.5.14</a>
-not-equal-to operator, see inequality operator                  or_eq macro, <a href="#7.9">7.9</a>
-not_eq macro, <a href="#7.9">7.9</a>                                               order of allocated storage, <a href="#7.20.3">7.20.3</a>
-null character (\0), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                      order of evaluation, <a href="#6.5">6.5</a>
-  padding of binary stream, <a href="#7.19.2">7.19.2</a>                              ordinary identifier name space, <a href="#6.2.3">6.2.3</a>
-NULL macro, <a href="#7.11">7.11</a>, <a href="#7.17">7.17</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.20">7.20</a>, <a href="#7.21.1">7.21.1</a>,                   orientation of stream, <a href="#7.19.2">7.19.2</a>, <a href="#7.24.3.5">7.24.3.5</a>
-     <a href="#7.23.1">7.23.1</a>, <a href="#7.24.1">7.24.1</a>                                             outer scope, <a href="#6.2.1">6.2.1</a>
-null pointer, <a href="#6.3.2.3">6.3.2.3</a>
-null pointer constant, <a href="#6.3.2.3">6.3.2.3</a>                                  padding
-null preprocessing directive, <a href="#6.10.7">6.10.7</a>                              binary stream, <a href="#7.19.2">7.19.2</a>
-null statement, <a href="#6.8.3">6.8.3</a>                                             bits, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.18.1.1">7.18.1.1</a>
-null wide character, <a href="#7.1.1">7.1.1</a>                                        structure/union, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
-number classification macros, <a href="#7.12">7.12</a>, <a href="#7.12.3.1">7.12.3.1</a>                     parameter, <a href="#3.15">3.15</a>
-numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>                     array, <a href="#6.9.1">6.9.1</a>
-  wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1">7.24.4.1</a>                                  ellipsis, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>
-numerical limits, <a href="#5.2.4.2">5.2.4.2</a>                                         function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
-                                                                  macro, <a href="#6.10.3">6.10.3</a>
-object, <a href="#3.14">3.14</a>                                                      main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-object representation, <a href="#6.2.6.1">6.2.6.1</a>                                    program, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-object type, <a href="#6.2.5">6.2.5</a>                                              parameter type list, <a href="#6.7.5.3">6.7.5.3</a>
-object-like macro, <a href="#6.10.3">6.10.3</a>                                       parentheses punctuator (( )), <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
-obsolescence, <a href="#6.11">6.11</a>, <a href="#7.26">7.26</a>                                        parenthesized expression, <a href="#6.5.1">6.5.1</a>
-octal constant, <a href="#6.4.4.1">6.4.4.1</a>                                         parse state, <a href="#7.19.2">7.19.2</a>
-octal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.4">6.4.4.4</a>                                   permitted form of initializer, <a href="#6.6">6.6</a>
-
-[<a name="p533" href="#p533">page 533</a>] (<a href="#Contents">Contents</a>)
-
-perror function, <a href="#7.19.10.4">7.19.10.4</a>                                    PRIcPTR macros, <a href="#7.8.1">7.8.1</a>
-phase angle, complex, <a href="#7.3.9.1">7.3.9.1</a>                                 primary expression, <a href="#6.5.1">6.5.1</a>
-physical source lines, <a href="#5.1.1.2">5.1.1.2</a>                                printf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.10">7.19.6.10</a>
-placemarker, <a href="#6.10.3.3">6.10.3.3</a>                                         printing character, <a href="#5.2.2">5.2.2</a>, <a href="#7.4">7.4</a>, <a href="#7.4.1.8">7.4.1.8</a>
-plus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                                 printing wide character, <a href="#7.25.2">7.25.2</a>
-pointer arithmetic, <a href="#6.5.6">6.5.6</a>                                     program diagnostics, <a href="#7.2.1">7.2.1</a>
-pointer comparison, <a href="#6.5.8">6.5.8</a>                                     program execution, <a href="#5.1.2.2.2">5.1.2.2.2</a>, <a href="#5.1.2.3">5.1.2.3</a>
-pointer declarator, <a href="#6.7.5.1">6.7.5.1</a>                                   program file, <a href="#5.1.1.1">5.1.1.1</a>
-pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                program image, <a href="#5.1.1.2">5.1.1.2</a>
-pointer to function, <a href="#6.5.2.2">6.5.2.2</a>                                  program name (argv[0]), <a href="#5.1.2.2.1">5.1.2.2.1</a>
-pointer type, <a href="#6.2.5">6.2.5</a>                                           program parameters, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-pointer type conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                     program startup, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-pointer, null, <a href="#6.3.2.3">6.3.2.3</a>                                        program structure, <a href="#5.1.1.1">5.1.1.1</a>
-portability, <a href="#4">4</a>, <a href="#J">J</a>                                             program termination, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>,
-position indicator, file, see file position indicator                 <a href="#5.1.2.3">5.1.2.3</a>
-positive difference, <a href="#7.12.12.1">7.12.12.1</a>                                program, conforming, <a href="#4">4</a>
-positive difference functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>                 program, strictly conforming, <a href="#4">4</a>
-postfix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              promotions
-postfix expressions, <a href="#6.5.2">6.5.2</a>                                        default argument, <a href="#6.5.2.2">6.5.2.2</a>
-postfix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>                 integer, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.3.1.1">6.3.1.1</a>
-pow functions, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#F.9.4.4">F.9.4.4</a>                              prototype, see function prototype
-pow type-generic macro, <a href="#7.22">7.22</a>                                  pseudo-random sequence functions, <a href="#7.20.2">7.20.2</a>
-power functions                                               PTRDIFF_MAX macro, <a href="#7.18.3">7.18.3</a>
-  complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                       PTRDIFF_MIN macro, <a href="#7.18.3">7.18.3</a>
-  real, <a href="#7.12.7">7.12.7</a>, <a href="#F.9.4">F.9.4</a>                                         ptrdiff_t type, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>,
-pp-number, <a href="#6.4.8">6.4.8</a>                                                    <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
-pragma operator, <a href="#6.10.9">6.10.9</a>                                       punctuators, <a href="#6.4.6">6.4.6</a>
-pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                putc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.8">7.19.7.8</a>, <a href="#7.19.7.9">7.19.7.9</a>
-precedence of operators, <a href="#6.5">6.5</a>                                  putchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.9">7.19.7.9</a>
-precedence of syntax rules, <a href="#5.1.1.2">5.1.1.2</a>                           puts function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.10">7.19.7.10</a>
-precision, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>               putwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.8">7.24.3.8</a>, <a href="#7.24.3.9">7.24.3.9</a>
-   excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>               putwchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.9">7.24.3.9</a>
-predefined macro names, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>
-prefix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               qsort function, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.2">7.20.5.2</a>
-prefix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               qualified types, <a href="#6.2.5">6.2.5</a>
-preprocessing concatenation, <a href="#6.10.3.3">6.10.3.3</a>                         qualified version of type, <a href="#6.2.5">6.2.5</a>
-preprocessing directives, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10">6.10</a>                       question-mark escape sequence (\?), <a href="#6.4.4.4">6.4.4.4</a>
-preprocessing file, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.10">6.10</a>                              quiet NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-preprocessing numbers, <a href="#6.4">6.4</a>, <a href="#6.4.8">6.4.8</a>
-preprocessing operators                                       raise function, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>, <a href="#7.20.4.1">7.20.4.1</a>
-   #, <a href="#6.10.3.2">6.10.3.2</a>                                                rand function, <a href="#7.20">7.20</a>, <a href="#7.20.2.1">7.20.2.1</a>, <a href="#7.20.2.2">7.20.2.2</a>
-   ##, <a href="#6.10.3.3">6.10.3.3</a>                                               RAND_MAX macro, <a href="#7.20">7.20</a>, <a href="#7.20.2.1">7.20.2.1</a>
-   _Pragma, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>                                   range
-   defined, <a href="#6.10.1">6.10.1</a>                                              excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>
-preprocessing tokens, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>                      range error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#7.12.5.5">7.12.5.5</a>,
-preprocessing translation unit, <a href="#5.1.1.1">5.1.1.1</a>                            <a href="#7.12.6.1">7.12.6.1</a>, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#7.12.6.5">7.12.6.5</a>,
-preprocessor, <a href="#6.10">6.10</a>                                                 <a href="#7.12.6.6">7.12.6.6</a>, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>,
-PRIcFASTN macros, <a href="#7.8.1">7.8.1</a>                                            <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#7.12.7.3">7.12.7.3</a>,
-PRIcLEASTN macros, <a href="#7.8.1">7.8.1</a>                                           <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>,
-PRIcMAX macros, <a href="#7.8.1">7.8.1</a>                                              <a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.12.1">7.12.12.1</a>,
-PRIcN macros, <a href="#7.8.1">7.8.1</a>                                                <a href="#7.12.13.1">7.12.13.1</a>
-
-[<a name="p534" href="#p534">page 534</a>] (<a href="#Contents">Contents</a>)
-
-rank, see integer conversion rank                         same scope, <a href="#6.2.1">6.2.1</a>
-real floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,           save calling environment function, <a href="#7.13.1">7.13.1</a>
-      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                   scalar types, <a href="#6.2.5">6.2.5</a>
-real floating types, <a href="#6.2.5">6.2.5</a>                                 scalbln function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.13">F.9.3.13</a>
-real type domain, <a href="#6.2.5">6.2.5</a>                                   scalbln type-generic macro, <a href="#7.22">7.22</a>
-real types, <a href="#6.2.5">6.2.5</a>                                         scalbn function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.13">F.9.3.13</a>
-real-floating, <a href="#7.12.3">7.12.3</a>                                      scalbn type-generic macro, <a href="#7.22">7.22</a>
-realloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>              scanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.4">7.19.6.4</a>, <a href="#7.19.6.11">7.19.6.11</a>
-recommended practice, <a href="#3.16">3.16</a>                                scanlist, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>
-recursion, <a href="#6.5.2.2">6.5.2.2</a>                                        scanset, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>
-recursive function call, <a href="#6.5.2.2">6.5.2.2</a>                          SCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-redefinition of macro, <a href="#6.10.3">6.10.3</a>                              SCHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-reentrancy, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>                                SCNcFASTN macros, <a href="#7.8.1">7.8.1</a>
-   library functions, <a href="#7.1.4">7.1.4</a>                               SCNcLEASTN macros, <a href="#7.8.1">7.8.1</a>
-referenced type, <a href="#6.2.5">6.2.5</a>                                    SCNcMAX macros, <a href="#7.8.1">7.8.1</a>
-register storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>               SCNcN macros, <a href="#7.8.1">7.8.1</a>
-relational expressions, <a href="#6.5.8">6.5.8</a>                             SCNcPTR macros, <a href="#7.8.1">7.8.1</a>
-reliability of data, interrupted, <a href="#5.1.2.3">5.1.2.3</a>                 scope of identifier, <a href="#6.2.1">6.2.1</a>, <a href="#6.9.2">6.9.2</a>
-remainder assignment operator (%=), <a href="#6.5.16.2">6.5.16.2</a>              search functions
-remainder functions, <a href="#7.12.10">7.12.10</a>, <a href="#F.9.7">F.9.7</a>                          string, <a href="#7.21.5">7.21.5</a>
-remainder functions, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>,              utility, <a href="#7.20.5">7.20.5</a>
-      <a href="#F.9.7.2">F.9.7.2</a>                                                wide string, <a href="#7.24.4.5">7.24.4.5</a>
-remainder operator (%), <a href="#6.5.5">6.5.5</a>                             SEEK_CUR macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
-remainder type-generic macro, <a href="#7.22">7.22</a>                        SEEK_END macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
-remove function, <a href="#7.19.4.1">7.19.4.1</a>, <a href="#7.19.4.4">7.19.4.4</a>                       SEEK_SET macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
-remquo functions, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>, <a href="#F.9.7.3">F.9.7.3</a>                 selection statements, <a href="#6.8.4">6.8.4</a>
-remquo type-generic macro, <a href="#7.22">7.22</a>                           self-referential structure, <a href="#6.7.2.3">6.7.2.3</a>
-rename function, <a href="#7.19.4.2">7.19.4.2</a>                                 semicolon punctuator (;), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
-representations of types, <a href="#6.2.6">6.2.6</a>                                 <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
-   pointer, <a href="#6.2.5">6.2.5</a>                                         separate compilation, <a href="#5.1.1.1">5.1.1.1</a>
-rescanning and replacement, <a href="#6.10.3.4">6.10.3.4</a>                      separate translation, <a href="#5.1.1.1">5.1.1.1</a>
-reserved identifiers, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>                         sequence points, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.8">6.8</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.19.6">7.19.6</a>,
-restartable multibyte/wide character conversion                 <a href="#7.20.5">7.20.5</a>, <a href="#7.24.2">7.24.2</a>, <a href="#C">C</a>
-      functions, <a href="#7.24.6.3">7.24.6.3</a>                                 sequencing of statements, <a href="#6.8">6.8</a>
-restartable multibyte/wide string conversion              setbuf function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.1">7.19.5.1</a>, <a href="#7.19.5.5">7.19.5.5</a>
-      functions, <a href="#7.24.6.4">7.24.6.4</a>                                 setjmp macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>
-restore calling environment function, <a href="#7.13.2">7.13.2</a>              setjmp.h header, <a href="#7.13">7.13</a>
-restrict type qualifier, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>                    setlocale function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-restrict-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>                      setvbuf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.1">7.19.5.1</a>,
-return statement, <a href="#6.8.6.4">6.8.6.4</a>                                       <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
-rewind function, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.5">7.19.9.5</a>,           shall, <a href="#4">4</a>
-      <a href="#7.24.3.10">7.24.3.10</a>                                           shift expressions, <a href="#6.5.7">6.5.7</a>
-right-shift assignment operator (&gt;&gt;=), <a href="#6.5.16.2">6.5.16.2</a>           shift sequence, <a href="#7.1.1">7.1.1</a>
-right-shift operator (&gt;&gt;), <a href="#6.5.7">6.5.7</a>                          shift states, <a href="#5.2.1.2">5.2.1.2</a>
-rint functions, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.4">F.9.6.4</a>                    short identifier, character, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.3">6.4.3</a>
-rint type-generic macro, <a href="#7.22">7.22</a>                             short int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
-round functions, <a href="#7.12.9.6">7.12.9.6</a>, <a href="#F.9.6.6">F.9.6.6</a>                              <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
-round type-generic macro, <a href="#7.22">7.22</a>                            short int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
-rounding mode, floating point, <a href="#5.2.4.2.2">5.2.4.2.2</a>                         <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
-rvalue, <a href="#6.3.2.1">6.3.2.1</a>                                           SHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-                                                          SHRT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-
-[<a name="p535" href="#p535">page 535</a>] (<a href="#Contents">Contents</a>)
-
-side effects, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>                                   source lines, <a href="#5.1.1.2">5.1.1.2</a>
-SIG_ATOMIC_MAX macro, <a href="#7.18.3">7.18.3</a>                                 source text, <a href="#5.1.1.2">5.1.1.2</a>
-SIG_ATOMIC_MIN macro, <a href="#7.18.3">7.18.3</a>                                 space character (' '), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,
-sig_atomic_t type, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.18.3">7.18.3</a>                         <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>
-SIG_DFL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sprintf function, <a href="#7.19.6.6">7.19.6.6</a>, <a href="#7.19.6.13">7.19.6.13</a>
-SIG_ERR macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sqrt functions, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.4.5">F.9.4.5</a>
-SIG_IGN macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sqrt type-generic macro, <a href="#7.22">7.22</a>
-SIGABRT macro, <a href="#7.14">7.14</a>, <a href="#7.20.4.1">7.20.4.1</a>                                srand function, <a href="#7.20.2.2">7.20.2.2</a>
-SIGFPE macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.5.17">J.5.17</a>                         sscanf function, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.14">7.19.6.14</a>
-SIGILL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                 standard error stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.10.4">7.19.10.4</a>
-SIGINT macro, <a href="#7.14">7.14</a>                                           standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a>
-sign and magnitude, <a href="#6.2.6.2">6.2.6.2</a>                                     <a href="#7.2">&lt;assert.h&gt;</a>, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
-sign bit, <a href="#6.2.6.2">6.2.6.2</a>                                               <a href="#7.3">&lt;complex.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>, <a href="#7.26.1">7.26.1</a>,
-signal function, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.20.4.4">7.20.4.4</a>                                  <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
-signal handler, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>              <a href="#7.4">&lt;ctype.h&gt;</a>, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
-signal handling functions, <a href="#7.14.1">7.14.1</a>                               <a href="#7.5">&lt;errno.h&gt;</a>, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
-signal.h header, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>                                   <a href="#7.6">&lt;fenv.h&gt;</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>
-signaling NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#F.2.1">F.2.1</a>                                 <a href="#7.7">&lt;float.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,
-signals, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1">7.14.1</a>                                      <a href="#7.24.4.1.1">7.24.4.1.1</a>
-signbit macro, <a href="#7.12.3.6">7.12.3.6</a>, <a href="#F.3">F.3</a>                                    <a href="#7.8">&lt;inttypes.h&gt;</a>, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>
-signed char type, <a href="#6.2.5">6.2.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                    <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#4">4</a>, <a href="#7.9">7.9</a>
-     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                         <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
-signed character, <a href="#6.3.1.1">6.3.1.1</a>                                       <a href="#7.11">&lt;locale.h&gt;</a>, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
-signed integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>                   <a href="#7.12">&lt;math.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>, <a href="#F.9">F.9</a>,
-signed type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,                   <a href="#J.5.17">J.5.17</a>
-     <a href="#6.3.1.8">6.3.1.8</a>                                                    <a href="#7.13">&lt;setjmp.h&gt;</a>, <a href="#7.13">7.13</a>
-signed types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>                                      <a href="#7.14">&lt;signal.h&gt;</a>, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>
-significand part, <a href="#6.4.4.2">6.4.4.2</a>                                        <a href="#7.15">&lt;stdarg.h&gt;</a>, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>
-SIGSEGV macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                   <a href="#7.16">&lt;stdbool.h&gt;</a>, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>
-SIGTERM macro, <a href="#7.14">7.14</a>                                             <a href="#7.17">&lt;stddef.h&gt;</a>, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
-simple assignment operator (=), <a href="#6.5.16.1">6.5.16.1</a>                             <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>
-sin functions, <a href="#7.12.4.6">7.12.4.6</a>, <a href="#F.9.1.6">F.9.1.6</a>                                <a href="#7.18">&lt;stdint.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.18">7.18</a>,
-sin type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                    <a href="#7.26.8">7.26.8</a>
-single-byte character, <a href="#3.7.1">3.7.1</a>, <a href="#5.2.1.2">5.2.1.2</a>                           <a href="#7.19">&lt;stdio.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>
-single-byte/wide character conversion functions,                <a href="#7.20">&lt;stdlib.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>
-     <a href="#7.24.6.1">7.24.6.1</a>                                                   <a href="#7.21">&lt;string.h&gt;</a>, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>
-single-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                            <a href="#7.22">&lt;tgmath.h&gt;</a>, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-single-quote escape sequence (\'), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>               <a href="#7.23">&lt;time.h&gt;</a>, <a href="#7.23">7.23</a>
-sinh functions, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#F.9.2.5">F.9.2.5</a>                               <a href="#7.24">&lt;wchar.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>, <a href="#7.26.12">7.26.12</a>,
-sinh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                   <a href="#F">F</a>
-SIZE_MAX macro, <a href="#7.18.3">7.18.3</a>                                          <a href="#7.25">&lt;wctype.h&gt;</a>, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>
-size_t type, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.1">7.19.1</a>,                  standard input stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>
-     <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20">7.20</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.23.1">7.23.1</a>,               standard integer types, <a href="#6.2.5">6.2.5</a>
-     <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                              standard output stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>
-sizeof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>                     standard signed integer types, <a href="#6.2.5">6.2.5</a>
-snprintf function, <a href="#7.19.6.5">7.19.6.5</a>, <a href="#7.19.6.12">7.19.6.12</a>                       state-dependent encoding, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#7.20.7">7.20.7</a>
-sorting utility functions, <a href="#7.20.5">7.20.5</a>                            statements, <a href="#6.8">6.8</a>
-source character set, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>                            break, <a href="#6.8.6.3">6.8.6.3</a>
-source file, <a href="#5.1.1.1">5.1.1.1</a>                                             compound, <a href="#6.8.2">6.8.2</a>
-   name, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8">6.10.8</a>                                         continue, <a href="#6.8.6.2">6.8.6.2</a>
-source file inclusion, <a href="#6.10.2">6.10.2</a>                                    do, <a href="#6.8.5.2">6.8.5.2</a>
-
-[<a name="p536" href="#p536">page 536</a>] (<a href="#Contents">Contents</a>)
-
-   else, <a href="#6.8.4.1">6.8.4.1</a>                                             strictly conforming program, <a href="#4">4</a>
-   expression, <a href="#6.8.3">6.8.3</a>                                         string, <a href="#7.1.1">7.1.1</a>
-   for, <a href="#6.8.5.3">6.8.5.3</a>                                                 comparison functions, <a href="#7.21.4">7.21.4</a>
-   goto, <a href="#6.8.6.1">6.8.6.1</a>                                                concatenation functions, <a href="#7.21.3">7.21.3</a>
-   if, <a href="#6.8.4.1">6.8.4.1</a>                                                  conversion functions, <a href="#7.11.1.1">7.11.1.1</a>
-   iteration, <a href="#6.8.5">6.8.5</a>                                             copying functions, <a href="#7.21.2">7.21.2</a>
-   jump, <a href="#6.8.6">6.8.6</a>                                                  library function conventions, <a href="#7.21.1">7.21.1</a>
-   labeled, <a href="#6.8.1">6.8.1</a>                                               literal, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.7.8">6.7.8</a>
-   null, <a href="#6.8.3">6.8.3</a>                                                  miscellaneous functions, <a href="#7.21.6">7.21.6</a>
-   return, <a href="#6.8.6.4">6.8.6.4</a>                                              numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>
-   selection, <a href="#6.8.4">6.8.4</a>                                             search functions, <a href="#7.21.5">7.21.5</a>
-   sequencing, <a href="#6.8">6.8</a>                                           string handling header, <a href="#7.21">7.21</a>
-   switch, <a href="#6.8.4.2">6.8.4.2</a>                                           string.h header, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>
-   while, <a href="#6.8.5.1">6.8.5.1</a>                                            stringizing, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.9">6.10.9</a>
-static storage duration, <a href="#6.2.4">6.2.4</a>                               strlen function, <a href="#7.21.6.3">7.21.6.3</a>
-static storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.7.1">6.7.1</a>           strncat function, <a href="#7.21.3.2">7.21.3.2</a>
-static, in array declarators, <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.5.3">6.7.5.3</a>               strncmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.4">7.21.4.4</a>
-stdarg.h header, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>                            strncpy function, <a href="#7.21.2.4">7.21.2.4</a>
-stdbool.h header, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>                         strpbrk function, <a href="#7.21.5.4">7.21.5.4</a>
-STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                                         strrchr function, <a href="#7.21.5.5">7.21.5.5</a>
-stddef.h header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,               strspn function, <a href="#7.21.5.6">7.21.5.6</a>
-      <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>                            strstr function, <a href="#7.21.5.7">7.21.5.7</a>
-stderr macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>                         strtod function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.3">7.20.1.3</a>,
-stdin macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.4">7.19.6.4</a>,                     <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.3">F.3</a>
-      <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.24.2.12">7.24.2.12</a>, <a href="#7.24.3.7">7.24.3.7</a>                strtof function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.3">F.3</a>
-stdint.h header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.18">7.18</a>,              strtoimax function, <a href="#7.8.2.3">7.8.2.3</a>
-      <a href="#7.26.8">7.26.8</a>                                                 strtok function, <a href="#7.21.5.8">7.21.5.8</a>
-stdio.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>                   strtol function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.2">7.20.1.2</a>,
-stdlib.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>                       <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>
-stdout macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.3">7.19.6.3</a>,              strtold function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.3">F.3</a>
-      <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.7.10">7.19.7.10</a>, <a href="#7.24.2.11">7.24.2.11</a>, <a href="#7.24.3.9">7.24.3.9</a>               strtoll function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1.2">7.20.1.2</a>, <a href="#7.20.1.4">7.20.1.4</a>
-storage duration, <a href="#6.2.4">6.2.4</a>                                      strtoul function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.2">7.20.1.2</a>,
-storage order of array, <a href="#6.5.2.1">6.5.2.1</a>                                    <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>
-storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a>                       strtoull function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1.2">7.20.1.2</a>, <a href="#7.20.1.4">7.20.1.4</a>
-strcat function, <a href="#7.21.3.1">7.21.3.1</a>                                    strtoumax function, <a href="#7.8.2.3">7.8.2.3</a>
-strchr function, <a href="#7.21.5.2">7.21.5.2</a>                                    struct hack, see flexible array member
-strcmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.2">7.21.4.2</a>                            structure
-strcoll function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.5">7.21.4.5</a>                  arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
-strcpy function, <a href="#7.21.2.3">7.21.2.3</a>                                       content, <a href="#6.7.2.3">6.7.2.3</a>
-strcspn function, <a href="#7.21.5.3">7.21.5.3</a>                                      dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>
-streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.20.4.3">7.20.4.3</a>                                       initialization, <a href="#6.7.8">6.7.8</a>
-   fully buffered, <a href="#7.19.3">7.19.3</a>                                       member alignment, <a href="#6.7.2.1">6.7.2.1</a>
-   line buffered, <a href="#7.19.3">7.19.3</a>                                        member name space, <a href="#6.2.3">6.2.3</a>
-   orientation, <a href="#7.19.2">7.19.2</a>                                          member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>
-   standard error, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                               pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
-   standard input, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                               specifier, <a href="#6.7.2.1">6.7.2.1</a>
-   standard output, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                              tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
-   unbuffered, <a href="#7.19.3">7.19.3</a>                                           type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>
-strerror function, <a href="#7.19.10.4">7.19.10.4</a>, <a href="#7.21.6.2">7.21.6.2</a>                       strxfrm function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.5">7.21.4.5</a>
-strftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.3">7.23.3</a>, <a href="#7.23.3.5">7.23.3.5</a>,               subscripting, <a href="#6.5.2.1">6.5.2.1</a>
-      <a href="#7.24.5.1">7.24.5.1</a>                                               subtraction assignment operator (-=), <a href="#6.5.16.2">6.5.16.2</a>
-
-[<a name="p537" href="#p537">page 537</a>] (<a href="#Contents">Contents</a>)
-
-subtraction operator (-), <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                   tolower function, <a href="#7.4.2.1">7.4.2.1</a>
-suffix                                                         toupper function, <a href="#7.4.2.2">7.4.2.2</a>
-  floating constant, <a href="#6.4.4.2">6.4.4.2</a>                                   towctrans function, <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
-  integer constant, <a href="#6.4.4.1">6.4.4.1</a>                                   towlower function, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.2.1">7.25.3.2.1</a>
-switch body, <a href="#6.8.4.2">6.8.4.2</a>                                          towupper function, <a href="#7.25.3.1.2">7.25.3.1.2</a>, <a href="#7.25.3.2.1">7.25.3.2.1</a>
-switch case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                             translation environment, <a href="#5">5</a>, <a href="#5.1.1">5.1.1</a>
-switch default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                          translation limits, <a href="#5.2.4.1">5.2.4.1</a>
-switch statement, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                              translation phases, <a href="#5.1.1.2">5.1.1.2</a>
-swprintf function, <a href="#7.24.2.3">7.24.2.3</a>, <a href="#7.24.2.7">7.24.2.7</a>                         translation unit, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.9">6.9</a>
-swscanf function, <a href="#7.24.2.4">7.24.2.4</a>, <a href="#7.24.2.8">7.24.2.8</a>                          trap representation, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.2.3">6.3.2.3</a>,
-symbols, <a href="#3">3</a>                                                          <a href="#6.5.2.3">6.5.2.3</a>
-syntactic categories, <a href="#6.1">6.1</a>                                     trigonometric functions
-syntax notation, <a href="#6.1">6.1</a>                                             complex, <a href="#7.3.5">7.3.5</a>, <a href="#G.6.1">G.6.1</a>
-syntax rule precedence, <a href="#5.1.1.2">5.1.1.2</a>                                  real, <a href="#7.12.4">7.12.4</a>, <a href="#F.9.1">F.9.1</a>
-syntax summary, language, <a href="#A">A</a>                                   trigraph sequences, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1.1">5.2.1.1</a>
-system function, <a href="#7.20.4.6">7.20.4.6</a>                                     true macro, <a href="#7.16">7.16</a>
-                                                              trunc functions, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#F.9.6.8">F.9.6.8</a>
-tab characters, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                                    trunc type-generic macro, <a href="#7.22">7.22</a>
-tag compatibility, <a href="#6.2.7">6.2.7</a>                                      truncation, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.3">7.19.5.3</a>
-tag name space, <a href="#6.2.3">6.2.3</a>                                         truncation toward zero, <a href="#6.5.5">6.5.5</a>
-tags, <a href="#6.7.2.3">6.7.2.3</a>                                                 two's complement, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.18.1.1">7.18.1.1</a>
-tan functions, <a href="#7.12.4.7">7.12.4.7</a>, <a href="#F.9.1.7">F.9.1.7</a>                              type category, <a href="#6.2.5">6.2.5</a>
-tan type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                             type conversion, <a href="#6.3">6.3</a>
-tanh functions, <a href="#7.12.5.6">7.12.5.6</a>, <a href="#F.9.2.6">F.9.2.6</a>                             type definitions, <a href="#6.7.7">6.7.7</a>
-tanh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            type domain, <a href="#6.2.5">6.2.5</a>, <a href="#G.2">G.2</a>
-tentative definition, <a href="#6.9.2">6.9.2</a>                                    type names, <a href="#6.7.6">6.7.6</a>
-terms, <a href="#3">3</a>                                                      type punning, <a href="#6.5.2.3">6.5.2.3</a>
-text streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>           type qualifiers, <a href="#6.7.3">6.7.3</a>
-tgamma functions, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#F.9.5.4">F.9.5.4</a>                           type specifiers, <a href="#6.7.2">6.7.2</a>
-tgamma type-generic macro, <a href="#7.22">7.22</a>                               type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
-tgmath.h header, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                    typedef declaration, <a href="#6.7.7">6.7.7</a>
-time                                                          typedef storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.7.7">6.7.7</a>
-   broken down, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.3">7.23.3</a>, <a href="#7.23.3.1">7.23.3.1</a>,           types, <a href="#6.2.5">6.2.5</a>
-         <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>, <a href="#7.23.3.5">7.23.3.5</a>                            character, <a href="#6.7.8">6.7.8</a>
-   calendar, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.2">7.23.2.2</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.2.4">7.23.2.4</a>,               compatible, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.5">6.7.5</a>
-         <a href="#7.23.3.2">7.23.3.2</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>                            complex, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>
-   components, <a href="#7.23.1">7.23.1</a>                                            composite, <a href="#6.2.7">6.2.7</a>
-   conversion functions, <a href="#7.23.3">7.23.3</a>                                  const qualified, <a href="#6.7.3">6.7.3</a>
-      wide character, <a href="#7.24.5">7.24.5</a>                                     conversions, <a href="#6.3">6.3</a>
-   local, <a href="#7.23.1">7.23.1</a>                                                 imaginary, <a href="#G">G</a>
-   manipulation functions, <a href="#7.23.2">7.23.2</a>                                restrict qualified, <a href="#6.7.3">6.7.3</a>
-time function, <a href="#7.23.2.4">7.23.2.4</a>                                          volatile qualified, <a href="#6.7.3">6.7.3</a>
-time.h header, <a href="#7.23">7.23</a>
-time_t type, <a href="#7.23.1">7.23.1</a>                                           UCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-tm structure type, <a href="#7.23.1">7.23.1</a>, <a href="#7.24.1">7.24.1</a>                             UINT_FASTN_MAX macros, <a href="#7.18.2.3">7.18.2.3</a>
-TMP_MAX macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.19.4.4">7.19.4.4</a>                     uint_fastN_t types, <a href="#7.18.1.3">7.18.1.3</a>
-tmpfile function, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.20.4.3">7.20.4.3</a>                          UINT_LEASTN_MAX macros, <a href="#7.18.2.2">7.18.2.2</a>
-tmpnam function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.19.4.4">7.19.4.4</a>                   uint_leastN_t types, <a href="#7.18.1.2">7.18.1.2</a>
-token, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, see also preprocessing tokens            UINT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-token concatenation, <a href="#6.10.3.3">6.10.3.3</a>                                 UINTMAX_C macro, <a href="#7.18.4.2">7.18.4.2</a>
-token pasting, <a href="#6.10.3.3">6.10.3.3</a>                                       UINTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>
-
-[<a name="p538" href="#p538">page 538</a>] (<a href="#Contents">Contents</a>)
-
-uintmax_t type, <a href="#7.18.1.5">7.18.1.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,               USHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                     usual arithmetic conversions, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.5.5">6.5.5</a>, <a href="#6.5.6">6.5.6</a>,
-UINTN_C macros, <a href="#7.18.4.1">7.18.4.1</a>                                          <a href="#6.5.8">6.5.8</a>, <a href="#6.5.9">6.5.9</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>, <a href="#6.5.15">6.5.15</a>
-UINTN_MAX macros, <a href="#7.18.2.1">7.18.2.1</a>                                  utilities, general, <a href="#7.20">7.20</a>
-uintN_t types, <a href="#7.18.1.1">7.18.1.1</a>                                        wide string, <a href="#7.24.4">7.24.4</a>
-UINTPTR_MAX macro, <a href="#7.18.2.4">7.18.2.4</a>
-uintptr_t type, <a href="#7.18.1.4">7.18.1.4</a>                                    va_arg macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.2">7.15.1.2</a>,
-ULLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,                           <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>,
-     <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                  <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
-ULONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,                            <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>,
-     <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                  <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
-unary arithmetic operators, <a href="#6.5.3.3">6.5.3.3</a>                         va_copy macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.2">7.15.1.2</a>,
-unary expression, <a href="#6.5.3">6.5.3</a>                                          <a href="#7.15.1.3">7.15.1.3</a>
-unary minus operator (-), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>                      va_end macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.3">7.15.1.3</a>,
-unary operators, <a href="#6.5.3">6.5.3</a>                                           <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>,
-unary plus operator (+), <a href="#6.5.3.3">6.5.3.3</a>                                 <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
-unbuffered stream, <a href="#7.19.3">7.19.3</a>                                        <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>,
-undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,                  <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
-     <a href="#7.1.4">7.1.4</a>                                                  va_list type, <a href="#7.15">7.15</a>, <a href="#7.15.1.3">7.15.1.3</a>
-undefined behavior, <a href="#3.4.3">3.4.3</a>, <a href="#4">4</a>, <a href="#J.2">J.2</a>                            va_start macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>,
-underscore character, <a href="#6.4.2.1">6.4.2.1</a>                                    <a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.3">7.15.1.3</a>, <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>,
-underscore, leading, in identifier, <a href="#7.1.3">7.1.3</a>                         <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>, <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>,
-ungetc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,                    <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>, <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>,
-     <a href="#7.19.9.3">7.19.9.3</a>                                                    <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
-ungetwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.10">7.24.3.10</a>                         value, <a href="#3.17">3.17</a>
-Unicode required set, <a href="#6.10.8">6.10.8</a>                                value bits, <a href="#6.2.6.2">6.2.6.2</a>
-union                                                       variable arguments, <a href="#6.10.3">6.10.3</a>, <a href="#7.15">7.15</a>
-  arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                              variable arguments header, <a href="#7.15">7.15</a>
-  content, <a href="#6.7.2.3">6.7.2.3</a>                                          variable length array, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
-  dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                 variably modified type, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
-  initialization, <a href="#6.7.8">6.7.8</a>                                     vertical-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
-  member alignment, <a href="#6.7.2.1">6.7.2.1</a>                                 vertical-tab escape sequence (\v), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
-  member name space, <a href="#6.2.3">6.2.3</a>                                       <a href="#7.4.1.10">7.4.1.10</a>
-  member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>                     vfprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>
-  pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                            vfscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>
-  specifier, <a href="#6.7.2.1">6.7.2.1</a>                                         vfwprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.5">7.24.2.5</a>
-  tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>                                       vfwscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.3.10">7.24.3.10</a>
-  type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>                                      visibility of identifier, <a href="#6.2.1">6.2.1</a>
-universal character name, <a href="#6.4.3">6.4.3</a>                             VLA, see variable length array
-unqualified type, <a href="#6.2.5">6.2.5</a>                                      void expression, <a href="#6.3.2.2">6.3.2.2</a>
-unqualified version of type, <a href="#6.2.5">6.2.5</a>                           void function parameter, <a href="#6.7.5.3">6.7.5.3</a>
-unsigned integer suffix, u or <a href="#U">U</a>, <a href="#6.4.4.1">6.4.4.1</a>                     void type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.7.2">6.7.2</a>
-unsigned integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>             void type conversion, <a href="#6.3.2.2">6.3.2.2</a>
-unsigned type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,                 volatile storage, <a href="#5.1.2.3">5.1.2.3</a>
-     <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                       volatile type qualifier, <a href="#6.7.3">6.7.3</a>
-unsigned types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,           volatile-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
-     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                     vprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.10">7.19.6.10</a>
-unspecified behavior, <a href="#3.4.4">3.4.4</a>, <a href="#4">4</a>, <a href="#J.1">J.1</a>                          vscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.11">7.19.6.11</a>
-unspecified value, <a href="#3.17.3">3.17.3</a>                                    vsnprintf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.12">7.19.6.12</a>
-uppercase letter, <a href="#5.2.1">5.2.1</a>                                     vsprintf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.13">7.19.6.13</a>
-use of library functions, <a href="#7.1.4">7.1.4</a>                             vsscanf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.14">7.19.6.14</a>
-
-[<a name="p539" href="#p539">page 539</a>] (<a href="#Contents">Contents</a>)
-
-vswprintf function, <a href="#7.24.2.7">7.24.2.7</a>                                  wctype.h header, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>
-vswscanf function, <a href="#7.24.2.8">7.24.2.8</a>                                   wctype_t type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
-vwprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.9">7.24.2.9</a>                           WEOF macro, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.3.6">7.24.3.6</a>,
-vwscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.3.10">7.24.3.10</a>                     <a href="#7.24.3.7">7.24.3.7</a>, <a href="#7.24.3.8">7.24.3.8</a>, <a href="#7.24.3.9">7.24.3.9</a>, <a href="#7.24.3.10">7.24.3.10</a>,
-                                                                   <a href="#7.24.6.1.1">7.24.6.1.1</a>, <a href="#7.25.1">7.25.1</a>
-warnings, <a href="#I">I</a>                                                   while statement, <a href="#6.8.5.1">6.8.5.1</a>
-wchar.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>, <a href="#7.26.12">7.26.12</a>,             white space, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#7.4.1.10">7.4.1.10</a>,
-    <a href="#F">F</a>                                                              <a href="#7.25.2.1.10">7.25.2.1.10</a>
-WCHAR_MAX macro, <a href="#7.18.3">7.18.3</a>, <a href="#7.24.1">7.24.1</a>                               white-space characters, <a href="#6.4">6.4</a>
-WCHAR_MIN macro, <a href="#7.18.3">7.18.3</a>, <a href="#7.24.1">7.24.1</a>                               wide character, <a href="#3.7.3">3.7.3</a>
-wchar_t type, <a href="#3.7.3">3.7.3</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.8">6.7.8</a>,                     case mapping functions, <a href="#7.25.3.1">7.25.3.1</a>
-    <a href="#6.10.8">6.10.8</a>, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20">7.20</a>,                extensible, <a href="#7.25.3.2">7.25.3.2</a>
-    <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  classification functions, <a href="#7.25.2.1">7.25.2.1</a>
-wcrtomb function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                      extensible, <a href="#7.25.2.2">7.25.2.2</a>
-    <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                      constant, <a href="#6.4.4.4">6.4.4.4</a>
-wcscat function, <a href="#7.24.4.3.1">7.24.4.3.1</a>                                     formatted input/output functions, <a href="#7.24.2">7.24.2</a>
-wcschr function, <a href="#7.24.4.5.1">7.24.4.5.1</a>                                     input functions, <a href="#7.19.1">7.19.1</a>
-wcscmp function, <a href="#7.24.4.4.1">7.24.4.4.1</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>                         input/output functions, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3">7.24.3</a>
-wcscoll function, <a href="#7.24.4.4.2">7.24.4.4.2</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>                        output functions, <a href="#7.19.1">7.19.1</a>
-wcscpy function, <a href="#7.24.4.2.1">7.24.4.2.1</a>                                     single-byte conversion functions, <a href="#7.24.6.1">7.24.6.1</a>
-wcscspn function, <a href="#7.24.4.5.2">7.24.4.5.2</a>                                  wide string, <a href="#7.1.1">7.1.1</a>
-wcsftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.24.5.1">7.24.5.1</a>                         wide string comparison functions, <a href="#7.24.4.4">7.24.4.4</a>
-wcslen function, <a href="#7.24.4.6.1">7.24.4.6.1</a>                                   wide string concatenation functions, <a href="#7.24.4.3">7.24.4.3</a>
-wcsncat function, <a href="#7.24.4.3.2">7.24.4.3.2</a>                                  wide string copying functions, <a href="#7.24.4.2">7.24.4.2</a>
-wcsncmp function, <a href="#7.24.4.4.3">7.24.4.4.3</a>                                  wide string literal, see string literal
-wcsncpy function, <a href="#7.24.4.2.2">7.24.4.2.2</a>                                  wide string miscellaneous functions, <a href="#7.24.4.6">7.24.4.6</a>
-wcspbrk function, <a href="#7.24.4.5.3">7.24.4.5.3</a>                                  wide string numeric conversion functions, <a href="#7.8.2.4">7.8.2.4</a>,
-wcsrchr function, <a href="#7.24.4.5.4">7.24.4.5.4</a>                                       <a href="#7.24.4.1">7.24.4.1</a>
-wcsrtombs function, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                wide string search functions, <a href="#7.24.4.5">7.24.4.5</a>
-wcsspn function, <a href="#7.24.4.5.5">7.24.4.5.5</a>                                   wide-oriented stream, <a href="#7.19.2">7.19.2</a>
-wcsstr function, <a href="#7.24.4.5.6">7.24.4.5.6</a>                                   width, <a href="#6.2.6.2">6.2.6.2</a>
-wcstod function, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>                           WINT_MAX macro, <a href="#7.18.3">7.18.3</a>
-wcstod function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                   WINT_MIN macro, <a href="#7.18.3">7.18.3</a>
-wcstof function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                   wint_t type, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>,
-wcstoimax function, <a href="#7.8.2.4">7.8.2.4</a>                                        <a href="#7.25.1">7.25.1</a>
-wcstok function, <a href="#7.24.4.5.7">7.24.4.5.7</a>                                   wmemchr function, <a href="#7.24.4.5.8">7.24.4.5.8</a>
-wcstol function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                 wmemcmp function, <a href="#7.24.4.4.5">7.24.4.4.5</a>
-    <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                wmemcpy function, <a href="#7.24.4.2.3">7.24.4.2.3</a>
-wcstold function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                  wmemmove function, <a href="#7.24.4.2.4">7.24.4.2.4</a>
-wcstoll function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                         wmemset function, <a href="#7.24.4.6.2">7.24.4.6.2</a>
-wcstombs function, <a href="#7.20.8.2">7.20.8.2</a>, <a href="#7.24.6.4">7.24.6.4</a>                         wprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.11">7.24.2.11</a>
-wcstoul function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                wscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.2.12">7.24.2.12</a>,
-    <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                     <a href="#7.24.3.10">7.24.3.10</a>
-wcstoull function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>
-wcstoumax function, <a href="#7.8.2.4">7.8.2.4</a>                                   xor macro, <a href="#7.9">7.9</a>
-wcsxfrm function, <a href="#7.24.4.4.4">7.24.4.4.4</a>                                  xor_eq macro, <a href="#7.9">7.9</a>
-wctob function, <a href="#7.24.6.1.2">7.24.6.1.2</a>, <a href="#7.25.2.1">7.25.2.1</a>
-wctomb function, <a href="#7.20.7.3">7.20.7.3</a>, <a href="#7.20.8.2">7.20.8.2</a>, <a href="#7.24.6.3">7.24.6.3</a>
-wctrans function, <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
-wctrans_t type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
-wctype function, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
-
-[<a name="p540" href="#p540">page 540</a>] (<a href="#Contents">Contents</a>)
-</pre></body></html>
+             feupdateenv(&amp;save_env);
+             return result;
+        }</pre>
+ The round functions may, but are not required to, raise the ''inexact'' floating-point
+ exception for non-integer numeric arguments, as this implementation does.
+
+<a name="F.9.6.7" href="#F.9.6.7"><h5>F.9.6.7 The lround and llround functions</h5></a>
+<p><!--para 1-->
+ The lround and llround functions differ from the lrint and llrint functions
+ with the default rounding direction just in that the lround and llround functions
+ round halfway cases away from zero and need not raise the ''inexact'' floating-point
+ exception for non-integer arguments that round to within the range of the return type.
+
+<a name="F.9.6.8" href="#F.9.6.8"><h5>F.9.6.8 The trunc functions</h5></a>
+<p><!--para 1-->
+ The trunc functions use IEC 60559 rounding toward zero (regardless of the current
+ rounding direction).
+<ul>
+<li>  trunc((+-)0) returns (+-)0.
+<li>  trunc((+-)(inf)) returns (+-)(inf).
+<!--page 477 indent 4-->
+</ul>
+
+<a name="F.9.7" href="#F.9.7"><h4>F.9.7 Remainder functions</h4></a>
+
+<a name="F.9.7.1" href="#F.9.7.1"><h5>F.9.7.1 The fmod functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  fmod((+-)0, y) returns (+-)0 for y not zero.
+<li>  fmod(x, y) returns a NaN and raises the ''invalid'' floating-point exception for x
+ infinite or y zero.
+<li>  fmod(x, (+-)(inf)) returns x for x not infinite.
+</ul>
+<p><!--para 2-->
+ The double version of fmod behaves as though implemented by
+<pre>
+        #include &lt;math.h&gt;
+        #include &lt;fenv.h&gt;
+        #pragma STDC FENV_ACCESS ON
+        double fmod(double x, double y)
+        {
+             double result;
+             result = remainder(fabs(x), (y = fabs(y)));
+             if (signbit(result)) result += y;
+             return copysign(result, x);
+        }</pre>
+
+<a name="F.9.7.2" href="#F.9.7.2"><h5>F.9.7.2 The remainder functions</h5></a>
+<p><!--para 1-->
+ The remainder functions are fully specified as a basic arithmetic operation in
+ IEC 60559.
+
+<a name="F.9.7.3" href="#F.9.7.3"><h5>F.9.7.3 The remquo functions</h5></a>
+<p><!--para 1-->
+ The remquo functions follow the specifications for the remainder functions. They
+ have no further specifications special to IEC 60559 implementations.
+
+<a name="F.9.8" href="#F.9.8"><h4>F.9.8 Manipulation functions</h4></a>
+
+<a name="F.9.8.1" href="#F.9.8.1"><h5>F.9.8.1 The copysign functions</h5></a>
+<p><!--para 1-->
+ copysign is specified in the Appendix to IEC 60559.
+
+<a name="F.9.8.2" href="#F.9.8.2"><h5>F.9.8.2 The nan functions</h5></a>
+<p><!--para 1-->
+ All IEC 60559 implementations support quiet NaNs, in all floating formats.
+<!--page 478 indent 4-->
+
+<a name="F.9.8.3" href="#F.9.8.3"><h5>F.9.8.3 The nextafter functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  nextafter(x, y) raises the ''overflow'' and ''inexact'' floating-point exceptions
+ for x finite and the function value infinite.
+<li>  nextafter(x, y) raises the ''underflow'' and ''inexact'' floating-point
+ exceptions for the function value subnormal or zero and x != y.
+</ul>
+
+<a name="F.9.8.4" href="#F.9.8.4"><h5>F.9.8.4 The nexttoward functions</h5></a>
+<p><!--para 1-->
+ No additional requirements beyond those on nextafter.
+
+<a name="F.9.9" href="#F.9.9"><h4>F.9.9 Maximum, minimum, and positive difference functions</h4></a>
+
+<a name="F.9.9.1" href="#F.9.9.1"><h5>F.9.9.1 The fdim functions</h5></a>
+<p><!--para 1-->
+ No additional requirements.
+
+<a name="F.9.9.2" href="#F.9.9.2"><h5>F.9.9.2 The fmax functions</h5></a>
+<p><!--para 1-->
+ If just one argument is a NaN, the fmax functions return the other argument (if both
+ arguments are NaNs, the functions return a NaN).
+<p><!--para 2-->
+ The body of the fmax function might be<sup><a href="#note323"><b>323)</b></a></sup>
+<pre>
+        { return (isgreaterequal(x, y) ||
+             isnan(y)) ? x : y; }</pre>
+
+<h6>footnotes</h6>
+<p><a name="note323">323)</a> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
+ return +0; however, implementation in software might be impractical.
+
+
+<a name="F.9.9.3" href="#F.9.9.3"><h5>F.9.9.3 The fmin functions</h5></a>
+<p><!--para 1-->
+ The fmin functions are analogous to the fmax functions (see <a href="#F.9.9.2">F.9.9.2</a>).
+
+<a name="F.9.10" href="#F.9.10"><h4>F.9.10 Floating multiply-add</h4></a>
+
+<a name="F.9.10.1" href="#F.9.10.1"><h5>F.9.10.1 The fma functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  fma(x, y, z) computes xy + z, correctly rounded once.
+<li>  fma(x, y, z) returns a NaN and optionally raises the ''invalid'' floating-point
+ exception if one of x and y is infinite, the other is zero, and z is a NaN.
+<li>  fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if
+ one of x and y is infinite, the other is zero, and z is not a NaN.
+<li>  fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if x
+ times y is an exact infinity and z is also an infinity but with the opposite sign.
+ 
+ 
+ 
+ 
+<!--page 479 indent 4-->
+</ul>
+
+<a name="G" href="#G"><h2>Annex G</h2></a>
+<pre>
+                                     (informative)
+               IEC 60559-compatible complex arithmetic</pre>
+
+<a name="G.1" href="#G.1"><h3>G.1 Introduction</h3></a>
+<p><!--para 1-->
+ This annex supplements <a href="#F">annex F</a> to specify complex arithmetic for compatibility with
+ IEC 60559 real floating-point arithmetic. Although these specifications have been
+ carefully designed, there is little existing practice to validate the design decisions.
+ Therefore, these specifications are not normative, but should be viewed more as
+ recommended          practice.       An         implementation        that     defines
+ __STDC_IEC_559_COMPLEX__ should conform to the specifications in this annex.
+
+<a name="G.2" href="#G.2"><h3>G.2 Types</h3></a>
+<p><!--para 1-->
+ There is a new keyword _Imaginary, which is used to specify imaginary types. It is
+ used as a type specifier within declaration specifiers in the same way as _Complex is
+ (thus, _Imaginary float is a valid type name).
+<p><!--para 2-->
+ There are three imaginary types, designated as float _Imaginary, double
+ _Imaginary, and long double _Imaginary. The imaginary types (along with
+ the real floating and complex types) are floating types.
+<p><!--para 3-->
+ For imaginary types, the corresponding real type is given by deleting the keyword
+ _Imaginary from the type name.
+<p><!--para 4-->
+ Each imaginary type has the same representation and alignment requirements as the
+ corresponding real type. The value of an object of imaginary type is the value of the real
+ representation times the imaginary unit.
+<p><!--para 5-->
+ The imaginary type domain comprises the imaginary types.
+
+<a name="G.3" href="#G.3"><h3>G.3 Conventions</h3></a>
+<p><!--para 1-->
+ A complex or imaginary value with at least one infinite part is regarded as an infinity
+ (even if its other part is a NaN). A complex or imaginary value is a finite number if each
+ of its parts is a finite number (neither infinite nor NaN). A complex or imaginary value is
+ a zero if each of its parts is a zero.
+<!--page 480 indent 4-->
+
+<a name="G.4" href="#G.4"><h3>G.4 Conversions</h3></a>
+
+<a name="G.4.1" href="#G.4.1"><h4>G.4.1 Imaginary types</h4></a>
+<p><!--para 1-->
+ Conversions among imaginary types follow rules analogous to those for real floating
+ types.
+
+<a name="G.4.2" href="#G.4.2"><h4>G.4.2 Real and imaginary</h4></a>
+<p><!--para 1-->
+ When a value of imaginary type is converted to a real type other than _Bool,<sup><a href="#note324"><b>324)</b></a></sup> the
+ result is a positive zero.
+<p><!--para 2-->
+ When a value of real type is converted to an imaginary type, the result is a positive
+ imaginary zero.
+
+<h6>footnotes</h6>
+<p><a name="note324">324)</a> See <a href="#6.3.1.2">6.3.1.2</a>.
+
+
+<a name="G.4.3" href="#G.4.3"><h4>G.4.3 Imaginary and complex</h4></a>
+<p><!--para 1-->
+ When a value of imaginary type is converted to a complex type, the real part of the
+ complex result value is a positive zero and the imaginary part of the complex result value
+ is determined by the conversion rules for the corresponding real types.
+<p><!--para 2-->
+ When a value of complex type is converted to an imaginary type, the real part of the
+ complex value is discarded and the value of the imaginary part is converted according to
+ the conversion rules for the corresponding real types.
+
+<a name="G.5" href="#G.5"><h3>G.5 Binary operators</h3></a>
+<p><!--para 1-->
+ The following subclauses supplement <a href="#6.5">6.5</a> in order to specify the type of the result for an
+ operation with an imaginary operand.
+<p><!--para 2-->
+ For most operand types, the value of the result of a binary operator with an imaginary or
+ complex operand is completely determined, with reference to real arithmetic, by the usual
+ mathematical formula. For some operand types, the usual mathematical formula is
+ problematic because of its treatment of infinities and because of undue overflow or
+ underflow; in these cases the result satisfies certain properties (specified in <a href="#G.5.1">G.5.1</a>), but is
+ not completely determined.
+ 
+ 
+ 
+ 
+<!--page 481 indent 4-->
+
+<a name="G.5.1" href="#G.5.1"><h4>G.5.1 Multiplicative operators</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If one operand has real type and the other operand has imaginary type, then the result has
+ imaginary type. If both operands have imaginary type, then the result has real type. (If
+ either operand has complex type, then the result has complex type.)
+<p><!--para 2-->
+ If the operands are not both complex, then the result and floating-point exception
+ behavior of the * operator is defined by the usual mathematical formula:
+<pre>
+        *                  u                   iv                 u + iv</pre>
+ 
+<pre>
+        x                  xu                i(xv)            (xu) + i(xv)</pre>
+ 
+<pre>
+        iy               i(yu)                -yv            (-yv) + i(yu)</pre>
+ 
+<p><!--para 3-->
+<pre>
+        x + iy       (xu) + i(yu)        (-yv) + i(xv)</pre>
+ If the second operand is not complex, then the result and floating-point exception
+ behavior of the / operator is defined by the usual mathematical formula:
+<pre>
+        /                   u                       iv</pre>
+ 
+<pre>
+        x                  x/u                 i(-x/v)</pre>
+ 
+<pre>
+        iy               i(y/u)                     y/v</pre>
+ 
+<p><!--para 4-->
+<pre>
+        x + iy       (x/u) + i(y/u)        (y/v) + i(-x/v)</pre>
+ The * and / operators satisfy the following infinity properties for all real, imaginary, and
+ complex operands:<sup><a href="#note325"><b>325)</b></a></sup>
+<ul>
+<li>  if one operand is an infinity and the other operand is a nonzero finite number or an
+ infinity, then the result of the * operator is an infinity;
+<li>  if the first operand is an infinity and the second operand is a finite number, then the
+ result of the / operator is an infinity;
+<li>  if the first operand is a finite number and the second operand is an infinity, then the
+ result of the / operator is a zero;
+ 
+ 
+ 
+ 
+<!--page 482 indent 4-->
+<li>  if the first operand is a nonzero finite number or an infinity and the second operand is
+ a zero, then the result of the / operator is an infinity.
+</ul>
+<p><!--para 5-->
+ If both operands of the * operator are complex or if the second operand of the / operator
+ is complex, the operator raises floating-point exceptions if appropriate for the calculation
+ of the parts of the result, and may raise spurious floating-point exceptions.
+<p><!--para 6-->
+ EXAMPLE 1 Multiplication of double _Complex operands could be implemented as follows. Note
+ that the imaginary unit I has imaginary type (see <a href="#G.6">G.6</a>).
+<!--page 483 indent 4-->
+<p><!--para 7-->
+<pre>
+        #include &lt;math.h&gt;
+        #include &lt;complex.h&gt;
+        /* Multiply z * w ... */
+        double complex _Cmultd(double complex z, double complex w)
+        {
+               #pragma STDC FP_CONTRACT OFF
+               double a, b, c, d, ac, bd, ad, bc, x, y;
+               a = creal(z); b = cimag(z);
+               c = creal(w); d = cimag(w);
+               ac = a * c;       bd = b * d;
+               ad = a * d;       bc = b * c;
+               x = ac - bd; y = ad + bc;
+               if (isnan(x) &amp;&amp; isnan(y)) {
+                       /* Recover infinities that computed as NaN+iNaN ... */
+                       int recalc = 0;
+                       if ( isinf(a) || isinf(b) ) { // z is infinite
+                               /* "Box" the infinity and change NaNs in the other factor to 0 */
+                               a = copysign(isinf(a) ? 1.0 : 0.0, a);
+                               b = copysign(isinf(b) ? 1.0 : 0.0, b);
+                               if (isnan(c)) c = copysign(0.0, c);
+                               if (isnan(d)) d = copysign(0.0, d);
+                               recalc = 1;
+                       }
+                       if ( isinf(c) || isinf(d) ) { // w is infinite
+                               /* "Box" the infinity and change NaNs in the other factor to 0 */
+                               c = copysign(isinf(c) ? 1.0 : 0.0, c);
+                               d = copysign(isinf(d) ? 1.0 : 0.0, d);
+                               if (isnan(a)) a = copysign(0.0, a);
+                               if (isnan(b)) b = copysign(0.0, b);
+                               recalc = 1;
+                       }
+                       if (!recalc &amp;&amp; (isinf(ac) || isinf(bd) ||
+                                              isinf(ad) || isinf(bc))) {
+                               /* Recover infinities from overflow by changing NaNs to 0 ... */
+                               if (isnan(a)) a = copysign(0.0, a);
+                               if (isnan(b)) b = copysign(0.0, b);
+                               if (isnan(c)) c = copysign(0.0, c);
+                               if (isnan(d)) d = copysign(0.0, d);
+                               recalc = 1;
+                       }
+                       if (recalc) {
+                                   x = INFINITY * ( a * c - b * d );
+                                   y = INFINITY * ( a * d + b * c );
+                        }
+                  }
+                  return x + I * y;
+          }</pre>
+ This implementation achieves the required treatment of infinities at the cost of only one isnan test in
+ ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
+ 
+<p><!--para 8-->
+ EXAMPLE 2      Division of two double _Complex operands could be implemented as follows.
+<!--page 484 indent 4-->
+<p><!--para 9-->
+<pre>
+          #include &lt;math.h&gt;
+          #include &lt;complex.h&gt;
+          /* Divide z / w ... */
+          double complex _Cdivd(double complex z, double complex w)
+          {
+                 #pragma STDC FP_CONTRACT OFF
+                 double a, b, c, d, logbw, denom, x, y;
+                 int ilogbw = 0;
+                 a = creal(z); b = cimag(z);
+                 c = creal(w); d = cimag(w);
+                 logbw = logb(fmax(fabs(c), fabs(d)));
+                 if (isfinite(logbw)) {
+                        ilogbw = (int)logbw;
+                        c = scalbn(c, -ilogbw); d = scalbn(d, -ilogbw);
+                 }
+                 denom = c * c + d * d;
+                 x = scalbn((a * c + b * d) / denom, -ilogbw);
+                 y = scalbn((b * c - a * d) / denom, -ilogbw);
+                  /* Recover infinities and zeros that computed as NaN+iNaN;                 */
+                  /* the only cases are nonzero/zero, infinite/finite, and finite/infinite, ... */
+                  if (isnan(x) &amp;&amp; isnan(y)) {
+                        if ((denom == 0.0) &amp;&amp;
+                              (!isnan(a) || !isnan(b))) {
+                              x = copysign(INFINITY, c) * a;
+                              y = copysign(INFINITY, c) * b;
+                        }
+                        else if ((isinf(a) || isinf(b)) &amp;&amp;
+                              isfinite(c) &amp;&amp; isfinite(d)) {
+                              a = copysign(isinf(a) ? 1.0 : 0.0,                        a);
+                              b = copysign(isinf(b) ? 1.0 : 0.0,                        b);
+                              x = INFINITY * ( a * c + b * d );
+                              y = INFINITY * ( b * c - a * d );
+                        }
+                        else if (isinf(logbw) &amp;&amp;
+                              isfinite(a) &amp;&amp; isfinite(b)) {
+                              c = copysign(isinf(c) ? 1.0 : 0.0,                        c);
+                              d = copysign(isinf(d) ? 1.0 : 0.0,                        d);
+                              x = 0.0 * ( a * c + b * d );
+                              y = 0.0 * ( b * c - a * d );
+                        }
+                  }
+                  return x + I * y;
+         }</pre>
+ Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
+ for multiplication. In the spirit of the multiplication example above, this code does not defend against
+ overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
+ with division, provides better roundoff characteristics.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note325">325)</a> These properties are already implied for those cases covered in the tables, but are required for all cases
+ (at least where the state for CX_LIMITED_RANGE is ''off'').
+
+
+<a name="G.5.2" href="#G.5.2"><h4>G.5.2 Additive operators</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If both operands have imaginary type, then the result has imaginary type. (If one operand
+ has real type and the other operand has imaginary type, or if either operand has complex
+ type, then the result has complex type.)
+<p><!--para 2-->
+ In all cases the result and floating-point exception behavior of a + or - operator is defined
+ by the usual mathematical formula:
+<pre>
+        + or -              u                       iv                    u + iv</pre>
+ 
+<pre>
+        x                 x(+-)u                     x (+-) iv              (x (+-) u) (+-) iv</pre>
+ 
+<pre>
+        iy               (+-)u + iy                 i(y (+-) v)             (+-)u + i(y (+-) v)</pre>
+ 
+<pre>
+        x + iy         (x (+-) u) + iy            x + i(y (+-) v)        (x (+-) u) + i(y (+-) v)</pre>
+
+<a name="G.6" href="#G.6"><h3>G.6 Complex arithmetic <complex.h></h3></a>
+<p><!--para 1-->
+ The macros
+<pre>
+         imaginary</pre>
+ and
+<pre>
+         _Imaginary_I</pre>
+ are defined, respectively, as _Imaginary and a constant expression of type const
+ float _Imaginary with the value of the imaginary unit. The macro
+<pre>
+         I</pre>
+ is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
+ the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
+ imaginary.
+<p><!--para 2-->
+ This subclause contains specifications for the &lt;complex.h&gt; functions that are
+ particularly suited to IEC 60559 implementations. For families of functions, the
+ specifications apply to all of the functions even though only the principal function is
+<!--page 485 indent 4-->
+ shown. Unless otherwise specified, where the symbol ''(+-)'' occurs in both an argument
+ and the result, the result has the same sign as the argument.
+<p><!--para 3-->
+ The functions are continuous onto both sides of their branch cuts, taking into account the
+ sign of zero. For example, csqrt(-2 (+-) i0) = (+-)i(sqrt)2.  ???
+<p><!--para 4-->
+ Since complex and imaginary values are composed of real values, each function may be
+ regarded as computing real values from real values. Except as noted, the functions treat
+ real infinities, NaNs, signed zeros, subnormals, and the floating-point exception flags in a
+ manner consistent with the specifications for real functions in F.9.<sup><a href="#note326"><b>326)</b></a></sup>
+<p><!--para 5-->
+ The functions cimag, conj, cproj, and creal are fully specified for all
+ implementations, including IEC 60559 ones, in <a href="#7.3.9">7.3.9</a>. These functions raise no floating-
+ point exceptions.
+<p><!--para 6-->
+ Each of the functions cabs and carg is specified by a formula in terms of a real
+ function (whose special cases are covered in <a href="#F">annex F</a>):
+<p><!--para 7-->
+<pre>
+         cabs(x + iy) = hypot(x, y)
+         carg(x + iy) = atan2(y, x)</pre>
+ Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
+ a formula in terms of other complex functions (whose special cases are specified below):
+<p><!--para 8-->
+<pre>
+         casin(z)        =   -i casinh(iz)
+         catan(z)        =   -i catanh(iz)
+         ccos(z)         =   ccosh(iz)
+         csin(z)         =   -i csinh(iz)
+         ctan(z)         =   -i ctanh(iz)</pre>
+ For the other functions, the following subclauses specify behavior for special cases,
+ including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
+ families of functions, the specifications apply to all of the functions even though only the
+ principal function is shown. For a function f satisfying f (conj(z)) = conj( f (z)), the
+ specifications for the upper half-plane imply the specifications for the lower half-plane; if
+ the function f is also either even, f (-z) = f (z), or odd, f (-z) = - f (z), then the
+ specifications for the first quadrant imply the specifications for the other three quadrants.
+<p><!--para 9-->
+ In the following subclauses, cis(y) is defined as cos(y) + i sin(y).
+ 
+ 
+ 
+ 
+<!--page 486 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note326">326)</a> As noted in <a href="#G.3">G.3</a>, a complex value with at least one infinite part is regarded as an infinity even if its
+ other part is a NaN.
+
+
+<a name="G.6.1" href="#G.6.1"><h4>G.6.1 Trigonometric functions</h4></a>
+
+<a name="G.6.1.1" href="#G.6.1.1"><h5>G.6.1.1 The cacos functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cacos(conj(z)) = conj(cacos(z)).
+<li>  cacos((+-)0 + i0) returns pi /2 - i0.
+<li>  cacos((+-)0 + iNaN) returns pi /2 + iNaN.
+<li>  cacos(x + i (inf)) returns pi /2 - i (inf), for finite x.
+<li>  cacos(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for nonzero finite x.
+<li>  cacos(-(inf) + iy) returns pi - i (inf), for positive-signed finite y.
+<li>  cacos(+(inf) + iy) returns +0 - i (inf), for positive-signed finite y.
+<li>  cacos(-(inf) + i (inf)) returns 3pi /4 - i (inf).
+<li>  cacos(+(inf) + i (inf)) returns pi /4 - i (inf).
+<li>  cacos((+-)(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  cacos(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite y.
+<li>  cacos(NaN + i (inf)) returns NaN - i (inf).
+<li>  cacos(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2" href="#G.6.2"><h4>G.6.2 Hyperbolic functions</h4></a>
+
+<a name="G.6.2.1" href="#G.6.2.1"><h5>G.6.2.1 The cacosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cacosh(conj(z)) = conj(cacosh(z)).
+<li>  cacosh((+-)0 + i0) returns +0 + ipi /2.
+<li>  cacosh(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+<li>  cacosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite x.
+<li>  cacosh(-(inf) + iy) returns +(inf) + ipi , for positive-signed finite y.
+<li>  cacosh(+(inf) + iy) returns +(inf) + i0, for positive-signed finite y.
+<li>  cacosh(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+<li>  cacosh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+<li>  cacosh((+-)(inf) + iNaN) returns +(inf) + iNaN.
+<!--page 487 indent 4-->
+<li>  cacosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite y.
+<li>  cacosh(NaN + i (inf)) returns +(inf) + iNaN.
+<li>  cacosh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.2" href="#G.6.2.2"><h5>G.6.2.2 The casinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  casinh(conj(z)) = conj(casinh(z)) and casinh is odd.
+<li>  casinh(+0 + i0) returns 0 + i0.
+<li>  casinh(x + i (inf)) returns +(inf) + ipi /2 for positive-signed finite x.
+<li>  casinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite x.
+<li>  casinh(+(inf) + iy) returns +(inf) + i0 for positive-signed finite y.
+<li>  casinh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+<li>  casinh(+(inf) + iNaN) returns +(inf) + iNaN.
+<li>  casinh(NaN + i0) returns NaN + i0.
+<li>  casinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite nonzero y.
+<li>  casinh(NaN + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+ is unspecified).
+<li>  casinh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.3" href="#G.6.2.3"><h5>G.6.2.3 The catanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  catanh(conj(z)) = conj(catanh(z)) and catanh is odd.
+<li>  catanh(+0 + i0) returns +0 + i0.
+<li>  catanh(+0 + iNaN) returns +0 + iNaN.
+<li>  catanh(+1 + i0) returns +(inf) + i0 and raises the ''divide-by-zero'' floating-point
+ exception.
+<li>  catanh(x + i (inf)) returns +0 + ipi /2, for finite positive-signed x.
+<li>  catanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for nonzero finite x.
+<li>  catanh(+(inf) + iy) returns +0 + ipi /2, for finite positive-signed y.
+<li>  catanh(+(inf) + i (inf)) returns +0 + ipi /2.
+<li>  catanh(+(inf) + iNaN) returns +0 + iNaN.
+<!--page 488 indent 4-->
+<li>  catanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite y.
+<li>  catanh(NaN + i (inf)) returns (+-)0 + ipi /2 (where the sign of the real part of the result is
+ unspecified).
+<li>  catanh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.4" href="#G.6.2.4"><h5>G.6.2.4 The ccosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  ccosh(conj(z)) = conj(ccosh(z)) and ccosh is even.
+<li>  ccosh(+0 + i0) returns 1 + i0.
+<li>  ccosh(+0 + i (inf)) returns NaN (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified) and raises the ''invalid'' floating-point exception.
+<li>  ccosh(+0 + iNaN) returns NaN (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  ccosh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for finite nonzero x.
+<li>  ccosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite nonzero x.
+<li>  ccosh(+(inf) + i0) returns +(inf) + i0.
+<li>  ccosh(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+<li>  ccosh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+ unspecified) and raises the ''invalid'' floating-point exception.
+<li>  ccosh(+(inf) + iNaN) returns +(inf) + iNaN.
+<li>  ccosh(NaN + i0) returns NaN (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  ccosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  ccosh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.5" href="#G.6.2.5"><h5>G.6.2.5 The csinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  csinh(conj(z)) = conj(csinh(z)) and csinh is odd.
+<li>  csinh(+0 + i0) returns +0 + i0.
+<li>  csinh(+0 + i (inf)) returns (+-)0 + iNaN (where the sign of the real part of the result is
+ unspecified) and raises the ''invalid'' floating-point exception.
+<li>  csinh(+0 + iNaN) returns (+-)0 + iNaN (where the sign of the real part of the result is
+ unspecified).
+<!--page 489 indent 4-->
+<li>  csinh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for positive finite x.
+<li>  csinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite nonzero x.
+<li>  csinh(+(inf) + i0) returns +(inf) + i0.
+<li>  csinh(+(inf) + iy) returns +(inf) cis(y), for positive finite y.
+<li>  csinh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+ unspecified) and raises the ''invalid'' floating-point exception.
+<li>  csinh(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+ is unspecified).
+<li>  csinh(NaN + i0) returns NaN + i0.
+<li>  csinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  csinh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.6" href="#G.6.2.6"><h5>G.6.2.6 The ctanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  ctanh(conj(z)) = conj(ctanh(z))and ctanh is odd.
+<li>  ctanh(+0 + i0) returns +0 + i0.
+<li>  ctanh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for finite x.
+<li>  ctanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<li>  ctanh(+(inf) + iy) returns 1 + i0 sin(2y), for positive-signed finite y.
+<li>  ctanh(+(inf) + i (inf)) returns 1 (+-) i0 (where the sign of the imaginary part of the result
+ is unspecified).
+<li>  ctanh(+(inf) + iNaN) returns 1 (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  ctanh(NaN + i0) returns NaN + i0.
+<li>  ctanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  ctanh(NaN + iNaN) returns NaN + iNaN.
+<!--page 490 indent 4-->
+</ul>
+
+<a name="G.6.3" href="#G.6.3"><h4>G.6.3 Exponential and logarithmic functions</h4></a>
+
+<a name="G.6.3.1" href="#G.6.3.1"><h5>G.6.3.1 The cexp functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cexp(conj(z)) = conj(cexp(z)).
+<li>  cexp((+-)0 + i0) returns 1 + i0.
+<li>  cexp(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for finite x.
+<li>  cexp(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<li>  cexp(+(inf) + i0) returns +(inf) + i0.
+<li>  cexp(-(inf) + iy) returns +0 cis(y), for finite y.
+<li>  cexp(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+<li>  cexp(-(inf) + i (inf)) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts of
+ the result are unspecified).
+<li>  cexp(+(inf) + i (inf)) returns (+-)(inf) + iNaN and raises the ''invalid'' floating-point
+ exception (where the sign of the real part of the result is unspecified).
+<li>  cexp(-(inf) + iNaN) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts
+ of the result are unspecified).
+<li>  cexp(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+ is unspecified).
+<li>  cexp(NaN + i0) returns NaN + i0.
+<li>  cexp(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  cexp(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.3.2" href="#G.6.3.2"><h5>G.6.3.2 The clog functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  clog(conj(z)) = conj(clog(z)).
+<li>  clog(-0 + i0) returns -(inf) + ipi and raises the ''divide-by-zero'' floating-point
+ exception.
+<li>  clog(+0 + i0) returns -(inf) + i0 and raises the ''divide-by-zero'' floating-point
+ exception.
+<li>  clog(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+<li>  clog(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<!--page 491 indent 4-->
+<li>  clog(-(inf) + iy) returns +(inf) + ipi , for finite positive-signed y.
+<li>  clog(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+<li>  clog(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+<li>  clog(+(inf) + i (inf)) returns +(inf) + ipi /4.
+<li>  clog((+-)(inf) + iNaN) returns +(inf) + iNaN.
+<li>  clog(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite y.
+<li>  clog(NaN + i (inf)) returns +(inf) + iNaN.
+<li>  clog(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.4" href="#G.6.4"><h4>G.6.4 Power and absolute-value functions</h4></a>
+
+<a name="G.6.4.1" href="#G.6.4.1"><h5>G.6.4.1 The cpow functions</h5></a>
+<p><!--para 1-->
+ The cpow functions raise floating-point exceptions if appropriate for the calculation of
+ the parts of the result, and may raise spurious exceptions.<sup><a href="#note327"><b>327)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note327">327)</a> This allows cpow( z , c ) to be implemented as cexp(c      clog( z )) without precluding
+ implementations that treat special cases more carefully.
+
+
+<a name="G.6.4.2" href="#G.6.4.2"><h5>G.6.4.2 The csqrt functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  csqrt(conj(z)) = conj(csqrt(z)).
+<li>  csqrt((+-)0 + i0) returns +0 + i0.
+<li>  csqrt(x + i (inf)) returns +(inf) + i (inf), for all x (including NaN).
+<li>  csqrt(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<li>  csqrt(-(inf) + iy) returns +0 + i (inf), for finite positive-signed y.
+<li>  csqrt(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+<li>  csqrt(-(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  csqrt(+(inf) + iNaN) returns +(inf) + iNaN.
+<li>  csqrt(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite y.
+<li>  csqrt(NaN + iNaN) returns NaN + iNaN.
+ 
+ 
+ 
+ 
+<!--page 492 indent 4-->
+</ul>
+
+<a name="G.7" href="#G.7"><h3>G.7 Type-generic math <tgmath.h></h3></a>
+<p><!--para 1-->
+ Type-generic macros that accept complex arguments also accept imaginary arguments. If
+ an argument is imaginary, the macro expands to an expression whose type is real,
+ imaginary, or complex, as appropriate for the particular function: if the argument is
+ imaginary, then the types of cos, cosh, fabs, carg, cimag, and creal are real; the
+ types of sin, tan, sinh, tanh, asin, atan, asinh, and atanh are imaginary; and
+ the types of the others are complex.
+<p><!--para 2-->
+ Given an imaginary argument, each of the type-generic macros cos, sin, tan, cosh,
+ sinh, tanh, asin, atan, asinh, atanh is specified by a formula in terms of real
+ functions:
+<!--page 493 indent 4-->
+<pre>
+        cos(iy)      =   cosh(y)
+        sin(iy)      =   i sinh(y)
+        tan(iy)      =   i tanh(y)
+        cosh(iy)     =   cos(y)
+        sinh(iy)     =   i sin(y)
+        tanh(iy)     =   i tan(y)
+        asin(iy)     =   i asinh(y)
+        atan(iy)     =   i atanh(y)
+        asinh(iy)    =   i asin(y)
+        atanh(iy)    =   i atan(y)</pre>
+
+<a name="H" href="#H"><h2>Annex H</h2></a>
+<pre>
+                                     (informative)
+                     Language independent arithmetic</pre>
+
+<a name="H.1" href="#H.1"><h3>H.1 Introduction</h3></a>
+<p><!--para 1-->
+ This annex documents the extent to which the C language supports the ISO/IEC 10967-1
+ standard for language-independent arithmetic (LIA-1). LIA-1 is more general than
+ IEC 60559 (<a href="#F">annex F</a>) in that it covers integer and diverse floating-point arithmetics.
+
+<a name="H.2" href="#H.2"><h3>H.2 Types</h3></a>
+<p><!--para 1-->
+ The relevant C arithmetic types meet the requirements of LIA-1 types if an
+ implementation adds notification of exceptional arithmetic operations and meets the 1
+ unit in the last place (ULP) accuracy requirement (LIA-1 subclause <a href="#5.2.8">5.2.8</a>).
+
+<a name="H.2.1" href="#H.2.1"><h4>H.2.1 Boolean type</h4></a>
+<p><!--para 1-->
+ The LIA-1 data type Boolean is implemented by the C data type bool with values of
+ true and false, all from &lt;stdbool.h&gt;.
+
+<a name="H.2.2" href="#H.2.2"><h4>H.2.2 Integer types</h4></a>
+<p><!--para 1-->
+ The signed C integer types int, long int, long long int, and the corresponding
+ unsigned types are compatible with LIA-1. If an implementation adds support for the
+ LIA-1 exceptional values ''integer_overflow'' and ''undefined'', then those types are
+ LIA-1 conformant types. C's unsigned integer types are ''modulo'' in the LIA-1 sense
+ in that overflows or out-of-bounds results silently wrap. An implementation that defines
+ signed integer types as also being modulo need not detect integer overflow, in which case,
+ only integer divide-by-zero need be detected.
+<p><!--para 2-->
+ The parameters for the integer data types can be accessed by the following:
+ maxint        INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
+<pre>
+               ULLONG_MAX</pre>
+ minint        INT_MIN, LONG_MIN, LLONG_MIN
+<p><!--para 3-->
+ The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
+ is always 0 for the unsigned types, and is not provided for those types.
+<!--page 494 indent 4-->
+
+<a name="H.2.2.1" href="#H.2.2.1"><h5>H.2.2.1 Integer operations</h5></a>
+<p><!--para 1-->
+ The integer operations on integer types are the following:
+ addI           x + y
+ subI           x - y
+ mulI           x * y
+ divI, divtI    x / y
+ remI, remtI    x % y
+ negI           -x
+ absI           abs(x), labs(x), llabs(x)
+ eqI            x == y
+ neqI           x != y
+ lssI           x &lt; y
+ leqI           x &lt;= y
+ gtrI           x &gt; y
+ geqI           x &gt;= y
+ where x and y are expressions of the same integer type.
+
+<a name="H.2.3" href="#H.2.3"><h4>H.2.3 Floating-point types</h4></a>
+<p><!--para 1-->
+ The C floating-point types float, double, and long double are compatible with
+ LIA-1. If an implementation adds support for the LIA-1 exceptional values
+ ''underflow'', ''floating_overflow'', and ''"undefined'', then those types are conformant
+ with LIA-1. An implementation that uses IEC 60559 floating-point formats and
+ operations (see <a href="#F">annex F</a>) along with IEC 60559 status flags and traps has LIA-1
+ conformant types.
+
+<a name="H.2.3.1" href="#H.2.3.1"><h5>H.2.3.1 Floating-point parameters</h5></a>
+<p><!--para 1-->
+ The parameters for a floating point data type can be accessed by the following:
+ r              FLT_RADIX
+ p              FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG
+ emax           FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP
+ emin           FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP
+<p><!--para 2-->
+ The derived constants for the floating point types are accessed by the following:
+<!--page 495 indent 4-->
+ fmax          FLT_MAX, DBL_MAX, LDBL_MAX
+ fminN         FLT_MIN, DBL_MIN, LDBL_MIN
+ epsilon       FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON
+ rnd_style     FLT_ROUNDS
+
+<a name="H.2.3.2" href="#H.2.3.2"><h5>H.2.3.2 Floating-point operations</h5></a>
+<p><!--para 1-->
+ The floating-point operations on floating-point types are the following:
+ addF          x + y
+ subF          x - y
+ mulF          x * y
+ divF          x / y
+ negF          -x
+ absF          fabsf(x), fabs(x), fabsl(x)
+ exponentF     1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
+ scaleF        scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
+<pre>
+               scalblnf(x, li), scalbln(x, li), scalblnl(x, li)</pre>
+ intpartF      modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+ fractpartF    modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+ eqF           x == y
+ neqF          x != y
+ lssF          x &lt; y
+ leqF          x &lt;= y
+ gtrF          x &gt; y
+ geqF          x &gt;= y
+ where x and y are expressions of the same floating point type, n is of type int, and li
+ is of type long int.
+
+<a name="H.2.3.3" href="#H.2.3.3"><h5>H.2.3.3 Rounding styles</h5></a>
+<p><!--para 1-->
+ The C Standard requires all floating types to use the same radix and rounding style, so
+ that only one identifier for each is provided to map to LIA-1.
+<p><!--para 2-->
+ The FLT_ROUNDS parameter can be used to indicate the LIA-1 rounding styles:
+ truncate      FLT_ROUNDS == 0
+<!--page 496 indent 4-->
+ nearest        FLT_ROUNDS == 1
+ other          FLT_ROUNDS != 0 &amp;&amp; FLT_ROUNDS != 1
+ provided that an implementation extends FLT_ROUNDS to cover the rounding style used
+ in all relevant LIA-1 operations, not just addition as in C.
+
+<a name="H.2.4" href="#H.2.4"><h4>H.2.4 Type conversions</h4></a>
+<p><!--para 1-->
+ The LIA-1 type conversions are the following type casts:
+ cvtI' -&gt; I      (int)i, (long int)i, (long long int)i,
+<pre>
+                (unsigned int)i, (unsigned long int)i,
+                (unsigned long long int)i</pre>
+ cvtF -&gt; I       (int)x, (long int)x, (long long int)x,
+<pre>
+                (unsigned int)x, (unsigned long int)x,
+                (unsigned long long int)x</pre>
+ cvtI -&gt; F       (float)i, (double)i, (long double)i
+ cvtF' -&gt; F      (float)x, (double)x, (long double)x
+<p><!--para 2-->
+ In the above conversions from floating to integer, the use of (cast)x can be replaced with
+ (cast)round(x), (cast)rint(x), (cast)nearbyint(x), (cast)trunc(x),
+ (cast)ceil(x), or (cast)floor(x). In addition, C's floating-point to integer
+ conversion functions, lrint(), llrint(), lround(), and llround(), can be
+ used. They all meet LIA-1's requirements on floating to integer rounding for in-range
+ values. For out-of-range values, the conversions shall silently wrap for the modulo types.
+<p><!--para 3-->
+ The fmod() function is useful for doing silent wrapping to unsigned integer types, e.g.,
+ fmod( fabs(rint(x)), 65536.0 ) or (0.0 &lt;= (y = fmod( rint(x),
+ 65536.0 )) ? y : 65536.0 + y) will compute an integer value in the range 0.0
+ to 65535.0 which can then be cast to unsigned short int. But, the
+ remainder() function is not useful for doing silent wrapping to signed integer types,
+ e.g., remainder( rint(x), 65536.0 ) will compute an integer value in the
+ range -32767.0 to +32768.0 which is not, in general, in the range of signed short
+ int.
+<p><!--para 4-->
+ C's conversions (casts) from floating-point to floating-point can meet LIA-1
+ requirements if an implementation uses round-to-nearest (IEC 60559 default).
+<p><!--para 5-->
+ C's conversions (casts) from integer to floating-point can meet LIA-1 requirements if an
+ implementation uses round-to-nearest.
+<!--page 497 indent 4-->
+
+<a name="H.3" href="#H.3"><h3>H.3 Notification</h3></a>
+<p><!--para 1-->
+ Notification is the process by which a user or program is informed that an exceptional
+ arithmetic operation has occurred. C's operations are compatible with LIA-1 in that C
+ allows an implementation to cause a notification to occur when any arithmetic operation
+ returns an exceptional value as defined in LIA-1 clause 5.
+
+<a name="H.3.1" href="#H.3.1"><h4>H.3.1 Notification alternatives</h4></a>
+<p><!--para 1-->
+ LIA-1 requires at least the following two alternatives for handling of notifications:
+ setting indicators or trap-and-terminate. LIA-1 allows a third alternative: trap-and-
+ resume.
+<p><!--para 2-->
+ An implementation need only support a given notification alternative for the entire
+ program. An implementation may support the ability to switch between notification
+ alternatives during execution, but is not required to do so. An implementation can
+ provide separate selection for each kind of notification, but this is not required.
+<p><!--para 3-->
+ C allows an implementation to provide notification. C's SIGFPE (for traps) and
+ FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW (for indicators)
+ can provide LIA-1 notification.
+<p><!--para 4-->
+ C's signal handlers are compatible with LIA-1. Default handling of SIGFPE can
+ provide trap-and-terminate behavior, except for those LIA-1 operations implemented by
+ math library function calls. User-provided signal handlers for SIGFPE allow for trap-
+ and-resume behavior with the same constraint.
+
+<a name="H.3.1.1" href="#H.3.1.1"><h5>H.3.1.1 Indicators</h5></a>
+<p><!--para 1-->
+ C's &lt;fenv.h&gt; status flags are compatible with the LIA-1 indicators.
+<p><!--para 2-->
+ The following mapping is for floating-point types:
+ undefined                FE_INVALID, FE_DIVBYZERO
+ floating_overflow         FE_OVERFLOW
+ underflow                FE_UNDERFLOW
+<p><!--para 3-->
+ The floating-point indicator interrogation and manipulation operations are:
+ set_indicators          feraiseexcept(i)
+ clear_indicators        feclearexcept(i)
+ test_indicators         fetestexcept(i)
+ current_indicators      fetestexcept(FE_ALL_EXCEPT)
+ where i is an expression of type int representing a subset of the LIA-1 indicators.
+<p><!--para 4-->
+ C allows an implementation to provide the following LIA-1 required behavior: at
+ program termination if any indicator is set the implementation shall send an unambiguous
+<!--page 498 indent 4-->
+ and ''hard to ignore'' message (see LIA-1 subclause <a href="#6.1.2">6.1.2</a>)
+<p><!--para 5-->
+ LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
+ This documentation makes that distinction because &lt;fenv.h&gt; covers only the floating-
+ point indicators.
+
+<a name="H.3.1.2" href="#H.3.1.2"><h5>H.3.1.2 Traps</h5></a>
+<p><!--para 1-->
+ C is compatible with LIA-1's trap requirements for arithmetic operations, but not for
+ math library functions (which are not permitted to generate any externally visible
+ exceptional conditions). An implementation can provide an alternative of notification
+ through termination with a ''hard-to-ignore'' message (see LIA-1 subclause <a href="#6.1.3">6.1.3</a>).
+<p><!--para 2-->
+ LIA-1 does not require that traps be precise.
+<p><!--para 3-->
+ C does require that SIGFPE be the signal corresponding to arithmetic exceptions, if there
+ is any signal raised for them.
+<p><!--para 4-->
+ C supports signal handlers for SIGFPE and allows trapping of arithmetic exceptions.
+ When arithmetic exceptions do trap, C's signal-handler mechanism allows trap-and-
+ terminate (either default implementation behavior or user replacement for it) or trap-and-
+ resume, at the programmer's option.
+<!--page 499 indent 4-->
+
+<a name="I" href="#I"><h2>Annex I</h2></a>
+<p><!--para 1-->
+<pre>
+                                     (informative)
+                                Common warnings</pre>
+ An implementation may generate warnings in many situations, none of which are
+ specified as part of this International Standard. The following are a few of the more
+ common situations.
+<p><!--para 2-->
+<ul>
+<li>  A new struct or union type appears in a function prototype (<a href="#6.2.1">6.2.1</a>, <a href="#6.7.2.3">6.7.2.3</a>).
+<li>  A block with initialization of an object that has automatic storage duration is jumped
+ into (<a href="#6.2.4">6.2.4</a>).
+<li>  An implicit narrowing conversion is encountered, such as the assignment of a long
+ int or a double to an int, or a pointer to void to a pointer to any type other than
+ a character type (<a href="#6.3">6.3</a>).
+<li>  A hexadecimal floating constant cannot be represented exactly in its evaluation format
+ (<a href="#6.4.4.2">6.4.4.2</a>).
+<li>  An integer character constant includes more than one character or a wide character
+ constant includes more than one multibyte character (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  The characters /* are found in a comment (<a href="#6.4.7">6.4.7</a>).
+<li>  An ''unordered'' binary operator (not comma, &amp;&amp;, or ||) contains a side effect to an
+ lvalue in one operand, and a side effect to, or an access to the value of, the identical
+ lvalue in the other operand (<a href="#6.5">6.5</a>).
+<li>  A function is called but no prototype has been supplied (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  The arguments in a function call do not agree in number and type with those of the
+ parameters in a function definition that is not a prototype (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  An object is defined but not used (<a href="#6.7">6.7</a>).
+<li>  A value is given to an object of an enumerated type other than by assignment of an
+ enumeration constant that is a member of that type, or an enumeration object that has
+ the same type, or the value of a function that returns the same enumerated type
+ (<a href="#6.7.2.2">6.7.2.2</a>).
+<li>  An aggregate has a partly bracketed initialization (<a href="#6.7.7">6.7.7</a>).
+<li>  A statement cannot be reached (<a href="#6.8">6.8</a>).
+<li>  A statement with no apparent effect is encountered (<a href="#6.8">6.8</a>).
+<li>  A constant expression is used as the controlling expression of a selection statement
+ (<a href="#6.8.4">6.8.4</a>).
+<!--page 500 indent 0-->
+<li>  An incorrectly formed preprocessing group is encountered while skipping a
+ preprocessing group (<a href="#6.10.1">6.10.1</a>).
+<li>  An unrecognized #pragma directive is encountered (<a href="#6.10.6">6.10.6</a>).
+<!--page 501 indent 4-->
+</ul>
+
+<a name="J" href="#J"><h2>Annex J</h2></a>
+<p><!--para 1-->
+<pre>
+                                      (informative)
+                                   Portability issues</pre>
+ This annex collects some information about portability that appears in this International
+ Standard.
+
+<a name="J.1" href="#J.1"><h3>J.1 Unspecified behavior</h3></a>
+<p><!--para 1-->
+ The following are unspecified:
+<ul>
+<li>  The manner and timing of static initialization (<a href="#5.1.2">5.1.2</a>).
+<li>  The termination status returned to the hosted environment if the return type of main
+ is not compatible with int (<a href="#5.1.2.2.3">5.1.2.2.3</a>).
+<li>  The behavior of the display device if a printing character is written when the active
+ position is at the final position of a line (<a href="#5.2.2">5.2.2</a>).
+<li>  The behavior of the display device if a backspace character is written when the active
+ position is at the initial position of a line (<a href="#5.2.2">5.2.2</a>).
+<li>  The behavior of the display device if a horizontal tab character is written when the
+ active position is at or past the last defined horizontal tabulation position (<a href="#5.2.2">5.2.2</a>).
+<li>  The behavior of the display device if a vertical tab character is written when the active
+ position is at or past the last defined vertical tabulation position (<a href="#5.2.2">5.2.2</a>).
+<li>  How an extended source character that does not correspond to a universal character
+ name counts toward the significant initial characters in an external identifier (<a href="#5.2.4.1">5.2.4.1</a>).
+<li>  Many aspects of the representations of types (<a href="#6.2.6">6.2.6</a>).
+<li>  The value of padding bytes when storing values in structures or unions (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The value of a union member other than the last one stored into (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The representation used when storing a value in an object that has more than one
+ object representation for that value (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The values of any padding bits in integer representations (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  Whether certain operators can generate negative zeros and whether a negative zero
+ becomes a normal zero when stored in an object (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  Whether two string literals result in distinct arrays (<a href="#6.4.5">6.4.5</a>).
+<li>  The order in which subexpressions are evaluated and the order in which side effects
+ take place, except as specified for the function-call (), &amp;&amp;, ||, ?:, and comma
+ operators (<a href="#6.5">6.5</a>).
+<!--page 502 indent 0-->
+<li>  The order in which the function designator, arguments, and subexpressions within the
+ arguments are evaluated in a function call (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  The order of side effects among compound literal initialization list expressions
+ (<a href="#6.5.2.5">6.5.2.5</a>).
+<li>  The order in which the operands of an assignment operator are evaluated (<a href="#6.5.16">6.5.16</a>).
+<li>  The alignment of the addressable storage unit allocated to hold a bit-field (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  Whether a call to an inline function uses the inline definition or the external definition
+ of the function (<a href="#6.7.4">6.7.4</a>).
+<li>  Whether or not a size expression is evaluated when it is part of the operand of a
+ sizeof operator and changing the value of the size expression would not affect the
+ result of the operator (<a href="#6.7.5.2">6.7.5.2</a>).
+<li>  The order in which any side effects occur among the initialization list expressions in
+ an initializer (<a href="#6.7.8">6.7.8</a>).
+<li>  The layout of storage for function parameters (<a href="#6.9.1">6.9.1</a>).
+<li>  When a fully expanded macro replacement list contains a function-like macro name
+ as its last preprocessing token and the next preprocessing token from the source file is
+ a (, and the fully expanded replacement of that macro ends with the name of the first
+ macro and the next preprocessing token from the source file is again a (, whether that
+ is considered a nested replacement (<a href="#6.10.3">6.10.3</a>).
+<li>  The order in which # and ## operations are evaluated during macro substitution
+ (<a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>).
+<li>  Whether errno is a macro or an identifier with external linkage (<a href="#7.5">7.5</a>).
+<li>  The state of the floating-point status flags when execution passes from a part of the
+ program translated with FENV_ACCESS ''off'' to a part translated with
+ FENV_ACCESS ''on'' (<a href="#7.6.1">7.6.1</a>).
+<li>  The order in which feraiseexcept raises floating-point exceptions, except as
+ stated in <a href="#F.7.6">F.7.6</a> (<a href="#7.6.2.3">7.6.2.3</a>).
+<li>  Whether math_errhandling is a macro or an identifier with external linkage
+ (<a href="#7.12">7.12</a>).
+<li>  The results of the frexp functions when the specified value is not a floating-point
+ number (<a href="#7.12.6.4">7.12.6.4</a>).
+<li>  The numeric result of the ilogb functions when the correct value is outside the
+ range of the return type (<a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.9.3.5">F.9.3.5</a>).
+<li>  The result of rounding when the value is out of range (<a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.5">F.9.6.5</a>).
+<!--page 503 indent 0-->
+<li>  The value stored by the remquo functions in the object pointed to by quo when y is
+ zero (<a href="#7.12.10.3">7.12.10.3</a>).
+<li>  Whether setjmp is a macro or an identifier with external linkage (<a href="#7.13">7.13</a>).
+<li>  Whether va_copy and va_end are macros or identifiers with external linkage
+ (<a href="#7.15.1">7.15.1</a>).
+<li>  The hexadecimal digit before the decimal point when a non-normalized floating-point
+ number is printed with an a or A conversion specifier (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+<li>  The value of the file position indicator after a successful call to the ungetc function
+ for a text stream, or the ungetwc function for any stream, until all pushed-back
+ characters are read or discarded (<a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.24.3.10">7.24.3.10</a>).
+<li>  The details of the value stored by the fgetpos function (<a href="#7.19.9.1">7.19.9.1</a>).
+<li>  The details of the value returned by the ftell function for a text stream (<a href="#7.19.9.4">7.19.9.4</a>).
+<li>  Whether the strtod, strtof, strtold, wcstod, wcstof, and wcstold
+ functions convert a minus-signed sequence to a negative number directly or by
+ negating the value resulting from converting the corresponding unsigned sequence
+ (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
+<li>  The order and contiguity of storage allocated by successive calls to the calloc,
+ malloc, and realloc functions (<a href="#7.20.3">7.20.3</a>).
+<li>  The amount of storage allocated by a successful call to the calloc, malloc, or
+ realloc function when 0 bytes was requested (<a href="#7.20.3">7.20.3</a>).
+<li>  Which of two elements that compare as equal is matched by the bsearch function
+ (<a href="#7.20.5.1">7.20.5.1</a>).
+<li>  The order of two elements that compare as equal in an array sorted by the qsort
+ function (<a href="#7.20.5.2">7.20.5.2</a>).
+<li>  The encoding of the calendar time returned by the time function (<a href="#7.23.2.4">7.23.2.4</a>).
+<li>  The characters stored by the strftime or wcsftime function if any of the time
+ values being converted is outside the normal range (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+<li>  The conversion state after an encoding error occurs (<a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>,
+ <a href="#7.24.6.4.2">7.24.6.4.2</a>,
+<li>  The resulting value when the ''invalid'' floating-point exception is raised during
+ IEC 60559 floating to integer conversion (<a href="#F.4">F.4</a>).
+<li>  Whether conversion of non-integer IEC 60559 floating values to integer raises the
+ ''inexact'' floating-point exception (<a href="#F.4">F.4</a>).
+<!--page 504 indent 4-->
+<li>  Whether or when library functions in &lt;math.h&gt; raise the ''inexact'' floating-point
+ exception in an IEC 60559 conformant implementation (<a href="#F.9">F.9</a>).
+<li>  Whether or when library functions in &lt;math.h&gt; raise an undeserved ''underflow''
+ floating-point exception in an IEC 60559 conformant implementation (<a href="#F.9">F.9</a>).
+<li>  The exponent value stored by frexp for a NaN or infinity (<a href="#F.9.3.4">F.9.3.4</a>).
+<li>  The numeric result returned by the lrint, llrint, lround, and llround
+ functions if the rounded value is outside the range of the return type (<a href="#F.9.6.5">F.9.6.5</a>, <a href="#F.9.6.7">F.9.6.7</a>).
+<li>  The sign of one part of the complex result of several math functions for certain
+ exceptional values in IEC 60559 compatible implementations (<a href="#G.6.1.1">G.6.1.1</a>, <a href="#G.6.2.2">G.6.2.2</a>,
+ <a href="#G.6.2.3">G.6.2.3</a>, <a href="#G.6.2.4">G.6.2.4</a>, <a href="#G.6.2.5">G.6.2.5</a>, <a href="#G.6.2.6">G.6.2.6</a>, <a href="#G.6.3.1">G.6.3.1</a>, <a href="#G.6.4.2">G.6.4.2</a>).
+</ul>
+
+<a name="J.2" href="#J.2"><h3>J.2 Undefined behavior</h3></a>
+<p><!--para 1-->
+ The behavior is undefined in the following circumstances:
+<ul>
+<li>  A ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated
+ (clause 4).
+<li>  A nonempty source file does not end in a new-line character which is not immediately
+ preceded by a backslash character or ends in a partial preprocessing token or
+ comment (<a href="#5.1.1.2">5.1.1.2</a>).
+<li>  Token concatenation produces a character sequence matching the syntax of a
+ universal character name (<a href="#5.1.1.2">5.1.1.2</a>).
+<li>  A program in a hosted environment does not define a function named main using one
+ of the specified forms (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<li>  A character not in the basic source character set is encountered in a source file, except
+ in an identifier, a character constant, a string literal, a header name, a comment, or a
+ preprocessing token that is never converted to a token (<a href="#5.2.1">5.2.1</a>).
+<li>  An identifier, comment, string literal, character constant, or header name contains an
+ invalid multibyte character or does not begin and end in the initial shift state (<a href="#5.2.1.2">5.2.1.2</a>).
+<li>  The same identifier has both internal and external linkage in the same translation unit
+ (<a href="#6.2.2">6.2.2</a>).
+<li>  An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
+<li>  The value of a pointer to an object whose lifetime has ended is used (<a href="#6.2.4">6.2.4</a>).
+<li>  The value of an object with automatic storage duration is used while it is
+ indeterminate (<a href="#6.2.4">6.2.4</a>, <a href="#6.7.8">6.7.8</a>, <a href="#6.8">6.8</a>).
+<li>  A trap representation is read by an lvalue expression that does not have character type
+ (<a href="#6.2.6.1">6.2.6.1</a>).
+<!--page 505 indent 0-->
+<li>  A trap representation is produced by a side effect that modifies any part of the object
+ using an lvalue expression that does not have character type (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The arguments to certain operators are such that could produce a negative zero result,
+ but the implementation does not support negative zeros (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  Two declarations of the same object or function specify types that are not compatible
+ (<a href="#6.2.7">6.2.7</a>).
+<li>  Conversion to or from an integer type produces a value outside the range that can be
+ represented (<a href="#6.3.1.4">6.3.1.4</a>).
+<li>  Demotion of one real floating type to another produces a value outside the range that
+ can be represented (<a href="#6.3.1.5">6.3.1.5</a>).
+<li>  An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  A non-array lvalue with an incomplete type is used in a context that requires the value
+ of the designated object (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  An lvalue having array type is converted to a pointer to the initial element of the
+ array, and the array object has register storage class (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  An attempt is made to use the value of a void expression, or an implicit or explicit
+ conversion (except to void) is applied to a void expression (<a href="#6.3.2.2">6.3.2.2</a>).
+<li>  Conversion of a pointer to an integer type produces a value outside the range that can
+ be represented (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  Conversion between two pointer types produces a result that is incorrectly aligned
+ (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  A pointer is used to call a function whose type is not compatible with the pointed-to
+ type (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  An unmatched ' or " character is encountered on a logical source line during
+ tokenization (<a href="#6.4">6.4</a>).
+<li>  A reserved keyword token is used in translation phase 7 or 8 for some purpose other
+ than as a keyword (<a href="#6.4.1">6.4.1</a>).
+<li>  A universal character name in an identifier does not designate a character whose
+ encoding falls into one of the specified ranges (<a href="#6.4.2.1">6.4.2.1</a>).
+<li>  The initial character of an identifier is a universal character name designating a digit
+ (<a href="#6.4.2.1">6.4.2.1</a>).
+<li>  Two identifiers differ only in nonsignificant characters (<a href="#6.4.2.1">6.4.2.1</a>).
+<li>  The identifier __func__ is explicitly declared (<a href="#6.4.2.2">6.4.2.2</a>).
+<!--page 506 indent 0-->
+<li>  The program attempts to modify a string literal (<a href="#6.4.5">6.4.5</a>).
+<li>  The characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt;
+ delimiters, or the characters ', \, //, or /* occur in the sequence between the "
+ delimiters, in a header name preprocessing token (<a href="#6.4.7">6.4.7</a>).
+<li>  Between two sequence points, an object is modified more than once, or is modified
+ and the prior value is read other than to determine the value to be stored (<a href="#6.5">6.5</a>).
+<li>  An exceptional condition occurs during the evaluation of an expression (<a href="#6.5">6.5</a>).
+<li>  An object has its stored value accessed other than by an lvalue of an allowable type
+ (<a href="#6.5">6.5</a>).
+<li>  An attempt is made to modify the result of a function call, a conditional operator, an
+ assignment operator, or a comma operator, or to access it after the next sequence
+ point (<a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.15">6.5.15</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.5.17">6.5.17</a>).
+<li>  For a call to a function without a function prototype in scope, the number of
+ arguments does not equal the number of parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  For call to a function without a function prototype in scope where the function is
+ defined with a function prototype, either the prototype ends with an ellipsis or the
+ types of the arguments after promotion are not compatible with the types of the
+ parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  For a call to a function without a function prototype in scope where the function is not
+ defined with a function prototype, the types of the arguments after promotion are not
+ compatible with those of the parameters after promotion (with certain exceptions)
+ (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  A function is defined with a type that is not compatible with the type (of the
+ expression) pointed to by the expression that denotes the called function (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
+<li>  A pointer is converted to other than an integer or pointer type (<a href="#6.5.4">6.5.4</a>).
+<li>  The value of the second operand of the / or % operator is zero (<a href="#6.5.5">6.5.5</a>).
+<li>  Addition or subtraction of a pointer into, or just beyond, an array object and an
+ integer type produces a result that does not point into, or just beyond, the same array
+ object (<a href="#6.5.6">6.5.6</a>).
+<li>  Addition or subtraction of a pointer into, or just beyond, an array object and an
+ integer type produces a result that points just beyond the array object and is used as
+ the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
+<li>  Pointers that do not point into, or just beyond, the same array object are subtracted
+ (<a href="#6.5.6">6.5.6</a>).
+<!--page 507 indent 0-->
+<li>  An array subscript is out of range, even if an object is apparently accessible with the
+ given subscript (as in the lvalue expression a[1][7] given the declaration int
+ a[4][5]) (<a href="#6.5.6">6.5.6</a>).
+<li>  The result of subtracting two pointers is not representable in an object of type
+ ptrdiff_t (<a href="#6.5.6">6.5.6</a>).
+<li>  An expression is shifted by a negative number or by an amount greater than or equal
+ to the width of the promoted expression (<a href="#6.5.7">6.5.7</a>).
+<li>  An expression having signed promoted type is left-shifted and either the value of the
+ expression is negative or the result of shifting would be not be representable in the
+ promoted type (<a href="#6.5.7">6.5.7</a>).
+<li>  Pointers that do not point to the same aggregate or union (nor just beyond the same
+ array object) are compared using relational operators (<a href="#6.5.8">6.5.8</a>).
+<li>  An object is assigned to an inexactly overlapping object or to an exactly overlapping
+ object with incompatible type (<a href="#6.5.16.1">6.5.16.1</a>).
+<li>  An expression that is required to be an integer constant expression does not have an
+ integer type; has operands that are not integer constants, enumeration constants,
+ character constants, sizeof expressions whose results are integer constants, or
+ immediately-cast floating constants; or contains casts (outside operands to sizeof
+ operators) other than conversions of arithmetic types to integer types (<a href="#6.6">6.6</a>).
+<li>  A constant expression in an initializer is not, or does not evaluate to, one of the
+ following: an arithmetic constant expression, a null pointer constant, an address
+ constant, or an address constant for an object type plus or minus an integer constant
+ expression (<a href="#6.6">6.6</a>).
+<li>  An arithmetic constant expression does not have arithmetic type; has operands that
+ are not integer constants, floating constants, enumeration constants, character
+ constants, or sizeof expressions; or contains casts (outside operands to sizeof
+ operators) other than conversions of arithmetic types to arithmetic types (<a href="#6.6">6.6</a>).
+<li>  The value of an object is accessed by an array-subscript [], member-access . or -&gt;,
+ address &amp;, or indirection * operator or a pointer cast in creating an address constant
+ (<a href="#6.6">6.6</a>).
+<li>  An identifier for an object is declared with no linkage and the type of the object is
+ incomplete after its declarator, or after its init-declarator if it has an initializer (<a href="#6.7">6.7</a>).
+<li>  A function is declared at block scope with an explicit storage-class specifier other
+ than extern (<a href="#6.7.1">6.7.1</a>).
+<li>  A structure or union is defined as containing no named members (<a href="#6.7.2.1">6.7.2.1</a>).
+<!--page 508 indent 0-->
+<li>  An attempt is made to access, or generate a pointer to just past, a flexible array
+ member of a structure when the referenced object provides no elements for that array
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  When the complete type is needed, an incomplete structure or union type is not
+ completed in the same scope by another declaration of the tag that defines the content
+ (<a href="#6.7.2.3">6.7.2.3</a>).
+<li>  An attempt is made to modify an object defined with a const-qualified type through
+ use of an lvalue with non-const-qualified type (<a href="#6.7.3">6.7.3</a>).
+<li>  An attempt is made to refer to an object defined with a volatile-qualified type through
+ use of an lvalue with non-volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+<li>  The specification of a function type includes any type qualifiers (<a href="#6.7.3">6.7.3</a>).
+<li>  Two qualified types that are required to be compatible do not have the identically
+ qualified version of a compatible type (<a href="#6.7.3">6.7.3</a>).
+<li>  An object which has been modified is accessed through a restrict-qualified pointer to
+ a const-qualified type, or through a restrict-qualified pointer and another pointer that
+ are not both based on the same object (<a href="#6.7.3.1">6.7.3.1</a>).
+<li>  A restrict-qualified pointer is assigned a value based on another restricted pointer
+ whose associated block neither began execution before the block associated with this
+ pointer, nor ended before the assignment (<a href="#6.7.3.1">6.7.3.1</a>).
+<li>  A function with external linkage is declared with an inline function specifier, but is
+ not also defined in the same translation unit (<a href="#6.7.4">6.7.4</a>).
+<li>  Two pointer types that are required to be compatible are not identically qualified, or
+ are not pointers to compatible types (<a href="#6.7.5.1">6.7.5.1</a>).
+<li>  The size expression in an array declaration is not a constant expression and evaluates
+ at program execution time to a nonpositive value (<a href="#6.7.5.2">6.7.5.2</a>).
+<li>  In a context requiring two array types to be compatible, they do not have compatible
+ element types, or their size specifiers evaluate to unequal values (<a href="#6.7.5.2">6.7.5.2</a>).
+<li>  A declaration of an array parameter includes the keyword static within the [ and
+ ] and the corresponding argument does not provide access to the first element of an
+ array with at least the specified number of elements (<a href="#6.7.5.3">6.7.5.3</a>).
+<li>  A storage-class specifier or type qualifier modifies the keyword void as a function
+ parameter type list (<a href="#6.7.5.3">6.7.5.3</a>).
+<li>  In a context requiring two function types to be compatible, they do not have
+  compatible return types, or their parameters disagree in use of the ellipsis terminator
+  or the number and type of parameters (after default argument promotion, when there
+   is no parameter type list or when one type is specified by a function definition with an
+<!--page 509 indent 0-->
+  identifier list) (<a href="#6.7.5.3">6.7.5.3</a>).
+<li>  The value of an unnamed member of a structure or union is used (<a href="#6.7.8">6.7.8</a>).
+<li>  The initializer for a scalar is neither a single expression nor a single expression
+ enclosed in braces (<a href="#6.7.8">6.7.8</a>).
+<li>  The initializer for a structure or union object that has automatic storage duration is
+ neither an initializer list nor a single expression that has compatible structure or union
+ type (<a href="#6.7.8">6.7.8</a>).
+<li>  The initializer for an aggregate or union, other than an array initialized by a string
+ literal, is not a brace-enclosed list of initializers for its elements or members (<a href="#6.7.8">6.7.8</a>).
+<li>  An identifier with external linkage is used, but in the program there does not exist
+ exactly one external definition for the identifier, or the identifier is not used and there
+ exist multiple external definitions for the identifier (<a href="#6.9">6.9</a>).
+<li>  A function definition includes an identifier list, but the types of the parameters are not
+ declared in a following declaration list (<a href="#6.9.1">6.9.1</a>).
+<li>  An adjusted parameter type in a function definition is not an object type (<a href="#6.9.1">6.9.1</a>).
+<li>  A function that accepts a variable number of arguments is defined without a
+ parameter type list that ends with the ellipsis notation (<a href="#6.9.1">6.9.1</a>).
+<li>  The } that terminates a function is reached, and the value of the function call is used
+ by the caller (<a href="#6.9.1">6.9.1</a>).
+<li>  An identifier for an object with internal linkage and an incomplete type is declared
+ with a tentative definition (<a href="#6.9.2">6.9.2</a>).
+<li>  The token defined is generated during the expansion of a #if or #elif
+ preprocessing directive, or the use of the defined unary operator does not match
+ one of the two specified forms prior to macro replacement (<a href="#6.10.1">6.10.1</a>).
+<li>  The #include preprocessing directive that results after expansion does not match
+ one of the two header name forms (<a href="#6.10.2">6.10.2</a>).
+<li>  The character sequence in an #include preprocessing directive does not start with a
+ letter (<a href="#6.10.2">6.10.2</a>).
+<li>  There are sequences of preprocessing tokens within the list of macro arguments that
+ would otherwise act as preprocessing directives (<a href="#6.10.3">6.10.3</a>).
+<li>  The result of the preprocessing operator # is not a valid character string literal
+ (<a href="#6.10.3.2">6.10.3.2</a>).
+<li>  The result of the preprocessing operator ## is not a valid preprocessing token
+ (<a href="#6.10.3.3">6.10.3.3</a>).
+<!--page 510 indent 0-->
+<li>  The #line preprocessing directive that results after expansion does not match one of
+ the two well-defined forms, or its digit sequence specifies zero or a number greater
+ than 2147483647 (<a href="#6.10.4">6.10.4</a>).
+<li>  A non-STDC #pragma preprocessing directive that is documented as causing
+ translation failure or some other form of undefined behavior is encountered (<a href="#6.10.6">6.10.6</a>).
+<li>  A #pragma STDC preprocessing directive does not match one of the well-defined
+ forms (<a href="#6.10.6">6.10.6</a>).
+<li>  The name of a predefined macro, or the identifier defined, is the subject of a
+ #define or #undef preprocessing directive (<a href="#6.10.8">6.10.8</a>).
+<li>  An attempt is made to copy an object to an overlapping object by use of a library
+ function, other than as explicitly allowed (e.g., memmove) (clause 7).
+<li>  A file with the same name as one of the standard headers, not provided as part of the
+ implementation, is placed in any of the standard places that are searched for included
+ source files (<a href="#7.1.2">7.1.2</a>).
+<li>  A header is included within an external declaration or definition (<a href="#7.1.2">7.1.2</a>).
+<li>  A function, object, type, or macro that is specified as being declared or defined by
+ some standard header is used before any header that declares or defines it is included
+ (<a href="#7.1.2">7.1.2</a>).
+<li>  A standard header is included while a macro is defined with the same name as a
+ keyword (<a href="#7.1.2">7.1.2</a>).
+<li>  The program attempts to declare a library function itself, rather than via a standard
+ header, but the declaration does not have external linkage (<a href="#7.1.2">7.1.2</a>).
+<li>  The program declares or defines a reserved identifier, other than as allowed by <a href="#7.1.4">7.1.4</a>
+ (<a href="#7.1.3">7.1.3</a>).
+<li>  The program removes the definition of a macro whose name begins with an
+ underscore and either an uppercase letter or another underscore (<a href="#7.1.3">7.1.3</a>).
+<li>  An argument to a library function has an invalid value or a type not expected by a
+ function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
+<li>  The pointer passed to a library function array parameter does not have a value such
+ that all address computations and object accesses are valid (<a href="#7.1.4">7.1.4</a>).
+<li>  The macro definition of assert is suppressed in order to access an actual function
+ (<a href="#7.2">7.2</a>).
+<li>  The argument to the assert macro does not have a scalar type (<a href="#7.2">7.2</a>).
+<li>  The CX_LIMITED_RANGE, FENV_ACCESS, or FP_CONTRACT pragma is used in
+ any context other than outside all external declarations or preceding all explicit
+<!--page 511 indent 0-->
+  declarations and statements inside a compound statement (<a href="#7.3.4">7.3.4</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.12.2">7.12.2</a>).
+<li>  The value of an argument to a character handling function is neither equal to the value
+ of EOF nor representable as an unsigned char (<a href="#7.4">7.4</a>).
+<li>  A macro definition of errno is suppressed in order to access an actual object, or the
+ program defines an identifier with the name errno (<a href="#7.5">7.5</a>).
+<li>  Part of the program tests floating-point status flags, sets floating-point control modes,
+ or runs under non-default mode settings, but was translated with the state for the
+ FENV_ACCESS pragma ''off'' (<a href="#7.6.1">7.6.1</a>).
+<li>  The exception-mask argument for one of the functions that provide access to the
+ floating-point status flags has a nonzero value not obtained by bitwise OR of the
+ floating-point exception macros (<a href="#7.6.2">7.6.2</a>).
+<li>  The fesetexceptflag function is used to set floating-point status flags that were
+ not specified in the call to the fegetexceptflag function that provided the value
+ of the corresponding fexcept_t object (<a href="#7.6.2.4">7.6.2.4</a>).
+<li>  The argument to fesetenv or feupdateenv is neither an object set by a call to
+ fegetenv or feholdexcept, nor is it an environment macro (<a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>).
+<li>  The value of the result of an integer arithmetic or conversion function cannot be
+ represented (<a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.6.1">7.20.6.1</a>, <a href="#7.20.6.2">7.20.6.2</a>, <a href="#7.20.1">7.20.1</a>).
+<li>  The program modifies the string pointed to by the value returned by the setlocale
+ function (<a href="#7.11.1.1">7.11.1.1</a>).
+<li>  The program modifies the structure pointed to by the value returned by the
+ localeconv function (<a href="#7.11.2.1">7.11.2.1</a>).
+<li>  A macro definition of math_errhandling is suppressed or the program defines
+ an identifier with the name math_errhandling (<a href="#7.12">7.12</a>).
+<li>  An argument to a floating-point classification or comparison macro is not of real
+ floating type (<a href="#7.12.3">7.12.3</a>, <a href="#7.12.14">7.12.14</a>).
+<li>  A macro definition of setjmp is suppressed in order to access an actual function, or
+ the program defines an external identifier with the name setjmp (<a href="#7.13">7.13</a>).
+<li>  An invocation of the setjmp macro occurs other than in an allowed context
+ (<a href="#7.13.2.1">7.13.2.1</a>).
+<li>  The longjmp function is invoked to restore a nonexistent environment (<a href="#7.13.2.1">7.13.2.1</a>).
+<li>  After a longjmp, there is an attempt to access the value of an object of automatic
+ storage class with non-volatile-qualified type, local to the function containing the
+ invocation of the corresponding setjmp macro, that was changed between the
+ setjmp invocation and longjmp call (<a href="#7.13.2.1">7.13.2.1</a>).
+<!--page 512 indent 0-->
+<li>  The program specifies an invalid pointer to a signal handler function (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal handler returns when the signal corresponded to a computational exception
+ (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal occurs as the result of calling the abort or raise function, and the signal
+ handler calls the raise function (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal occurs other than as the result of calling the abort or raise function, and
+ the signal handler refers to an object with static storage duration other than by
+ assigning a value to an object declared as volatile sig_atomic_t, or calls any
+ function in the standard library other than the abort function, the _Exit function,
+ or the signal function (for the same signal number) (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  The value of errno is referred to after a signal occurred other than as the result of
+ calling the abort or raise function and the corresponding signal handler obtained
+ a SIG_ERR return from a call to the signal function (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal is generated by an asynchronous signal handler (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A function with a variable number of arguments attempts to access its varying
+ arguments other than through a properly declared and initialized va_list object, or
+ before the va_start macro is invoked (<a href="#7.15">7.15</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.4">7.15.1.4</a>).
+<li>  The macro va_arg is invoked using the parameter ap that was passed to a function
+ that invoked the macro va_arg with the same parameter (<a href="#7.15">7.15</a>).
+<li>  A macro definition of va_start, va_arg, va_copy, or va_end is suppressed in
+ order to access an actual function, or the program defines an external identifier with
+ the name va_copy or va_end (<a href="#7.15.1">7.15.1</a>).
+<li>  The va_start or va_copy macro is invoked without a corresponding invocation
+ of the va_end macro in the same function, or vice versa (<a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.3">7.15.1.3</a>,
+ <a href="#7.15.1.4">7.15.1.4</a>).
+<li>  The type parameter to the va_arg macro is not such that a pointer to an object of
+ that type can be obtained simply by postfixing a * (<a href="#7.15.1.1">7.15.1.1</a>).
+<li>  The va_arg macro is invoked when there is no actual next argument, or with a
+ specified type that is not compatible with the promoted type of the actual next
+ argument, with certain exceptions (<a href="#7.15.1.1">7.15.1.1</a>).
+<li>  The va_copy or va_start macro is called to initialize a va_list that was
+ previously initialized by either macro without an intervening invocation of the
+ va_end macro for the same va_list (<a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.4">7.15.1.4</a>).
+<li>  The parameter parmN of a va_start macro is declared with the register
+ storage class, with a function or array type, or with a type that is not compatible with
+ the type that results after application of the default argument promotions (<a href="#7.15.1.4">7.15.1.4</a>).
+<!--page 513 indent 0-->
+<li>  The member designator parameter of an offsetof macro is an invalid right
+ operand of the . operator for the type parameter, or designates a bit-field (<a href="#7.17">7.17</a>).
+<li>  The argument in an instance of one of the integer-constant macros is not a decimal,
+ octal, or hexadecimal constant, or it has a value that exceeds the limits for the
+ corresponding type (<a href="#7.18.4">7.18.4</a>).
+<li>  A byte input/output function is applied to a wide-oriented stream, or a wide character
+ input/output function is applied to a byte-oriented stream (<a href="#7.19.2">7.19.2</a>).
+<li>  Use is made of any portion of a file beyond the most recent wide character written to
+ a wide-oriented stream (<a href="#7.19.2">7.19.2</a>).
+<li>  The value of a pointer to a FILE object is used after the associated file is closed
+ (<a href="#7.19.3">7.19.3</a>).
+<li>  The stream for the fflush function points to an input stream or to an update stream
+ in which the most recent operation was input (<a href="#7.19.5.2">7.19.5.2</a>).
+<li>  The string pointed to by the mode argument in a call to the fopen function does not
+ exactly match one of the specified character sequences (<a href="#7.19.5.3">7.19.5.3</a>).
+<li>  An output operation on an update stream is followed by an input operation without an
+ intervening call to the fflush function or a file positioning function, or an input
+ operation on an update stream is followed by an output operation with an intervening
+ call to a file positioning function (<a href="#7.19.5.3">7.19.5.3</a>).
+<li>  An attempt is made to use the contents of the array that was supplied in a call to the
+ setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>).
+<li>  There are insufficient arguments for the format in a call to one of the formatted
+ input/output functions, or an argument does not have an appropriate type (<a href="#7.19.6.1">7.19.6.1</a>,
+ <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  The format in a call to one of the formatted input/output functions or to the
+ strftime or wcsftime function is not a valid multibyte character sequence that
+ begins and ends in its initial shift state (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>,
+ <a href="#7.24.5.1">7.24.5.1</a>).
+<li>  In a call to one of the formatted output functions, a precision appears with a
+ conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+<li>  A conversion specification for a formatted output function uses an asterisk to denote
+ an argument-supplied field width or precision, but the corresponding argument is not
+ provided (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+<li>  A conversion specification for a formatted output function uses a # or 0 flag with a
+ conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+<!--page 514 indent 0-->
+<li>  A conversion specification for one of the formatted input/output functions uses a
+ length modifier with a conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>,
+ <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  An s conversion specifier is encountered by one of the formatted output functions,
+ and the argument is missing the null terminator (unless a precision is specified that
+ does not require null termination) (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+<li>  An n conversion specification for one of the formatted input/output functions includes
+ any flags, an assignment-suppressing character, a field width, or a precision (<a href="#7.19.6.1">7.19.6.1</a>,
+ <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  A % conversion specifier is encountered by one of the formatted input/output
+ functions, but the complete conversion specification is not exactly %% (<a href="#7.19.6.1">7.19.6.1</a>,
+ <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  An invalid conversion specification is found in the format for one of the formatted
+ input/output functions, or the strftime or wcsftime function (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,
+ <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+<li>  The number of characters transmitted by a formatted output function is greater than
+ INT_MAX (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.10">7.19.6.10</a>).
+<li>  The result of a conversion by one of the formatted input functions cannot be
+ represented in the corresponding object, or the receiving object does not have an
+ appropriate type (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  A c, s, or [ conversion specifier is encountered by one of the formatted input
+ functions, and the array pointed to by the corresponding argument is not large enough
+ to accept the input sequence (and a null terminator if the conversion specifier is s or
+ [) (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  A c, s, or [ conversion specifier with an l qualifier is encountered by one of the
+ formatted input functions, but the input is not a valid multibyte character sequence
+ that begins in the initial shift state (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  The input item for a %p conversion by one of the formatted input functions is not a
+ value converted earlier during the same program execution (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  The vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf,
+ vsscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, or
+ vwscanf function is called with an improperly initialized va_list argument, or
+ the argument is used (other than in an invocation of va_end) after the function
+ returns (<a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>, <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
+ <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>).
+<li>  The contents of the array supplied in a call to the fgets, gets, or fgetws function
+ are used after a read error occurred (<a href="#7.19.7.2">7.19.7.2</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.24.3.2">7.24.3.2</a>).
+<!--page 515 indent 0-->
+<li>  The file position indicator for a binary stream is used after a call to the ungetc
+ function where its value was zero before the call (<a href="#7.19.7.11">7.19.7.11</a>).
+<li>  The file position indicator for a stream is used after an error occurred during a call to
+ the fread or fwrite function (<a href="#7.19.8.1">7.19.8.1</a>, <a href="#7.19.8.2">7.19.8.2</a>).
+<li>  A partial element read by a call to the fread function is used (<a href="#7.19.8.1">7.19.8.1</a>).
+<li>  The fseek function is called for a text stream with a nonzero offset and either the
+ offset was not returned by a previous successful call to the ftell function on a
+ stream associated with the same file or whence is not SEEK_SET (<a href="#7.19.9.2">7.19.9.2</a>).
+<li>  The fsetpos function is called to set a position that was not returned by a previous
+ successful call to the fgetpos function on a stream associated with the same file
+ (<a href="#7.19.9.3">7.19.9.3</a>).
+<li>  A non-null pointer returned by a call to the calloc, malloc, or realloc function
+ with a zero requested size is used to access an object (<a href="#7.20.3">7.20.3</a>).
+<li>  The value of a pointer that refers to space deallocated by a call to the free or
+ realloc function is used (<a href="#7.20.3">7.20.3</a>).
+<li>  The pointer argument to the free or realloc function does not match a pointer
+ earlier returned by calloc, malloc, or realloc, or the space has been
+ deallocated by a call to free or realloc (<a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>).
+<li>  The value of the object allocated by the malloc function is used (<a href="#7.20.3.3">7.20.3.3</a>).
+<li>  The value of any bytes in a new object allocated by the realloc function beyond
+ the size of the old object are used (<a href="#7.20.3.4">7.20.3.4</a>).
+<li>  The program executes more than one call to the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+<li>  During the call to a function registered with the atexit function, a call is made to
+ the longjmp function that would terminate the call to the registered function
+ (<a href="#7.20.4.3">7.20.4.3</a>).
+<li>  The string set up by the getenv or strerror function is modified by the program
+ (<a href="#7.20.4.5">7.20.4.5</a>, <a href="#7.21.6.2">7.21.6.2</a>).
+<li>  A command is executed through the system function in a way that is documented as
+ causing termination or some other form of undefined behavior (<a href="#7.20.4.6">7.20.4.6</a>).
+<li>  A searching or sorting utility function is called with an invalid pointer argument, even
+ if the number of elements is zero (<a href="#7.20.5">7.20.5</a>).
+<li>  The comparison function called by a searching or sorting utility function alters the
+ contents of the array being searched or sorted, or returns ordering values
+ inconsistently (<a href="#7.20.5">7.20.5</a>).
+<!--page 516 indent 0-->
+<li>  The array being searched by the bsearch function does not have its elements in
+ proper order (<a href="#7.20.5.1">7.20.5.1</a>).
+<li>  The current conversion state is used by a multibyte/wide character conversion
+ function after changing the LC_CTYPE category (<a href="#7.20.7">7.20.7</a>).
+<li>  A string or wide string utility function is instructed to access an array beyond the end
+ of an object (<a href="#7.21.1">7.21.1</a>, <a href="#7.24.4">7.24.4</a>).
+<li>  A string or wide string utility function is called with an invalid pointer argument, even
+ if the length is zero (<a href="#7.21.1">7.21.1</a>, <a href="#7.24.4">7.24.4</a>).
+<li>  The contents of the destination array are used after a call to the strxfrm,
+ strftime, wcsxfrm, or wcsftime function in which the specified length was
+ too small to hold the entire null-terminated result (<a href="#7.21.4.5">7.21.4.5</a>, <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>,
+ <a href="#7.24.5.1">7.24.5.1</a>).
+<li>  The first argument in the very first call to the strtok or wcstok is a null pointer
+ (<a href="#7.21.5.8">7.21.5.8</a>, <a href="#7.24.4.5.7">7.24.4.5.7</a>).
+<li>  The type of an argument to a type-generic macro is not compatible with the type of
+ the corresponding parameter of the selected function (<a href="#7.22">7.22</a>).
+<li>  A complex argument is supplied for a generic parameter of a type-generic macro that
+ has no corresponding complex function (<a href="#7.22">7.22</a>).
+<li>  The argument corresponding to an s specifier without an l qualifier in a call to the
+ fwprintf function does not point to a valid multibyte character sequence that
+ begins in the initial shift state (<a href="#7.24.2.11">7.24.2.11</a>).
+<li>  In a call to the wcstok function, the object pointed to by ptr does not have the
+ value stored by the previous call for the same wide string (<a href="#7.24.4.5.7">7.24.4.5.7</a>).
+<li>  An mbstate_t object is used inappropriately (<a href="#7.24.6">7.24.6</a>).
+<li>  The value of an argument of type wint_t to a wide character classification or case
+ mapping function is neither equal to the value of WEOF nor representable as a
+ wchar_t (<a href="#7.25.1">7.25.1</a>).
+<li>  The iswctype function is called using a different LC_CTYPE category from the
+ one in effect for the call to the wctype function that returned the description
+ (<a href="#7.25.2.2.1">7.25.2.2.1</a>).
+<li>  The towctrans function is called using a different LC_CTYPE category from the
+ one in effect for the call to the wctrans function that returned the description
+ (<a href="#7.25.3.2.1">7.25.3.2.1</a>).
+<!--page 517 indent 4-->
+</ul>
+
+<a name="J.3" href="#J.3"><h3>J.3 Implementation-defined behavior</h3></a>
+<p><!--para 1-->
+ A conforming implementation is required to document its choice of behavior in each of
+ the areas listed in this subclause. The following are implementation-defined:
+
+<a name="J.3.1" href="#J.3.1"><h4>J.3.1 Translation</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  How a diagnostic is identified (<a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>).
+<li>  Whether each nonempty sequence of white-space characters other than new-line is
+ retained or replaced by one space character in translation phase 3 (<a href="#5.1.1.2">5.1.1.2</a>).
+</ul>
+
+<a name="J.3.2" href="#J.3.2"><h4>J.3.2 Environment</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The mapping between physical source file multibyte characters and the source
+ character set in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>).
+<li>  The name and type of the function called at program startup in a freestanding
+ environment (<a href="#5.1.2.1">5.1.2.1</a>).
+<li>  The effect of program termination in a freestanding environment (<a href="#5.1.2.1">5.1.2.1</a>).
+<li>  An alternative manner in which the main function may be defined (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<li>  The values given to the strings pointed to by the argv argument to main (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<li>  What constitutes an interactive device (<a href="#5.1.2.3">5.1.2.3</a>).
+<li>  The set of signals, their semantics, and their default handling (<a href="#7.14">7.14</a>).
+<li>  Signal values other than SIGFPE, SIGILL, and SIGSEGV that correspond to a
+ computational exception (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  Signals for which the equivalent of signal(sig, SIG_IGN); is executed at
+ program startup (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  The set of environment names and the method for altering the environment list used
+ by the getenv function (<a href="#7.20.4.5">7.20.4.5</a>).
+<li>  The manner of execution of the string by the system function (<a href="#7.20.4.6">7.20.4.6</a>).
+</ul>
+
+<a name="J.3.3" href="#J.3.3"><h4>J.3.3 Identifiers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Which additional multibyte characters may appear in identifiers and their
+ correspondence to universal character names (<a href="#6.4.2">6.4.2</a>).
+<li>  The number of significant initial characters in an identifier (<a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2">6.4.2</a>).
+<!--page 518 indent 4-->
+</ul>
+
+<a name="J.3.4" href="#J.3.4"><h4>J.3.4 Characters</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The number of bits in a byte (<a href="#3.6">3.6</a>).
+<li>  The values of the members of the execution character set (<a href="#5.2.1">5.2.1</a>).
+<li>  The unique value of the member of the execution character set produced for each of
+ the standard alphabetic escape sequences (<a href="#5.2.2">5.2.2</a>).
+<li>  The value of a char object into which has been stored any character other than a
+ member of the basic execution character set (<a href="#6.2.5">6.2.5</a>).
+<li>  Which of signed char or unsigned char has the same range, representation,
+ and behavior as ''plain'' char (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>).
+<li>  The mapping of members of the source character set (in character constants and string
+ literals) to members of the execution character set (<a href="#6.4.4.4">6.4.4.4</a>, <a href="#5.1.1.2">5.1.1.2</a>).
+<li>  The value of an integer character constant containing more than one character or
+ containing a character or escape sequence that does not map to a single-byte
+ execution character (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  The value of a wide character constant containing more than one multibyte character,
+ or containing a multibyte character or escape sequence not represented in the
+ extended execution character set (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  The current locale used to convert a wide character constant consisting of a single
+ multibyte character that maps to a member of the extended execution character set
+ into a corresponding wide character code (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  The current locale used to convert a wide string literal into corresponding wide
+ character codes (<a href="#6.4.5">6.4.5</a>).
+<li>  The value of a string literal containing a multibyte character or escape sequence not
+ represented in the execution character set (<a href="#6.4.5">6.4.5</a>).
+</ul>
+
+<a name="J.3.5" href="#J.3.5"><h4>J.3.5 Integers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Any extended integer types that exist in the implementation (<a href="#6.2.5">6.2.5</a>).
+<li>  Whether signed integer types are represented using sign and magnitude, two's
+ complement, or ones' complement, and whether the extraordinary value is a trap
+ representation or an ordinary value (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  The rank of any extended integer type relative to another extended integer type with
+ the same precision (<a href="#6.3.1.1">6.3.1.1</a>).
+<li>  The result of, or the signal raised by, converting an integer to a signed integer type
+ when the value cannot be represented in an object of that type (<a href="#6.3.1.3">6.3.1.3</a>).
+<!--page 519 indent 4-->
+<li>  The results of some bitwise operations on signed integers (<a href="#6.5">6.5</a>).
+</ul>
+
+<a name="J.3.6" href="#J.3.6"><h4>J.3.6 Floating point</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The accuracy of the floating-point operations and of the library functions in
+ &lt;math.h&gt; and &lt;complex.h&gt; that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The accuracy of the conversions between floating-point internal representations and
+ string representations performed by the library functions in &lt;stdio.h&gt;,
+ &lt;stdlib.h&gt;, and &lt;wchar.h&gt; (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The rounding behaviors characterized by non-standard values of FLT_ROUNDS
+ (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The evaluation methods characterized by non-standard negative values of
+ FLT_EVAL_METHOD (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The direction of rounding when an integer is converted to a floating-point number that
+ cannot exactly represent the original value (<a href="#6.3.1.4">6.3.1.4</a>).
+<li>  The direction of rounding when a floating-point number is converted to a narrower
+ floating-point number (<a href="#6.3.1.5">6.3.1.5</a>).
+<li>  How the nearest representable value or the larger or smaller representable value
+ immediately adjacent to the nearest representable value is chosen for certain floating
+ constants (<a href="#6.4.4.2">6.4.4.2</a>).
+<li>  Whether and how floating expressions are contracted when not disallowed by the
+ FP_CONTRACT pragma (<a href="#6.5">6.5</a>).
+<li>  The default state for the FENV_ACCESS pragma (<a href="#7.6.1">7.6.1</a>).
+<li>  Additional floating-point exceptions, rounding             modes,    environments,   and
+ classifications, and their macro names (<a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>).
+<li>  The default state for the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>).                                    *
+</ul>
+
+<a name="J.3.7" href="#J.3.7"><h4>J.3.7 Arrays and pointers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The result of converting a pointer to an integer or vice versa (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  The size of the result of subtracting two pointers to elements of the same array
+ (<a href="#6.5.6">6.5.6</a>).
+<!--page 520 indent 4-->
+</ul>
+
+<a name="J.3.8" href="#J.3.8"><h4>J.3.8 Hints</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The extent to which suggestions made by using the register storage-class
+ specifier are effective (<a href="#6.7.1">6.7.1</a>).
+<li>  The extent to which suggestions made by using the inline function specifier are
+ effective (<a href="#6.7.4">6.7.4</a>).
+</ul>
+
+<a name="J.3.9" href="#J.3.9"><h4>J.3.9 Structures, unions, enumerations, and bit-fields</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Whether a ''plain'' int bit-field is treated as a signed int bit-field or as an
+ unsigned int bit-field (<a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.1">6.7.2.1</a>).
+<li>  Allowable bit-field types other than _Bool, signed int, and unsigned int
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  Whether a bit-field can straddle a storage-unit boundary (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  The order of allocation of bit-fields within a unit (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  The alignment of non-bit-field members of structures (<a href="#6.7.2.1">6.7.2.1</a>). This should present
+ no problem unless binary data written by one implementation is read by another.
+<li>  The integer type compatible with each enumerated type (<a href="#6.7.2.2">6.7.2.2</a>).
+</ul>
+
+<a name="J.3.10" href="#J.3.10"><h4>J.3.10 Qualifiers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  What constitutes an access to an object that has volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+</ul>
+
+<a name="J.3.11" href="#J.3.11"><h4>J.3.11 Preprocessing directives</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The locations within #pragma directives where header name preprocessing tokens
+ are recognized (<a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>).
+<li>  How sequences in both forms of header names are mapped to headers or external
+ source file names (<a href="#6.4.7">6.4.7</a>).
+<li>  Whether the value of a character constant in a constant expression that controls
+ conditional inclusion matches the value of the same character constant in the
+ execution character set (<a href="#6.10.1">6.10.1</a>).
+<li>  Whether the value of a single-character character constant in a constant expression
+ that controls conditional inclusion may have a negative value (<a href="#6.10.1">6.10.1</a>).
+<li>  The places that are searched for an included &lt; &gt; delimited header, and how the places
+ are specified or the header is identified (<a href="#6.10.2">6.10.2</a>).
+<li>  How the named source file is searched for in an included " " delimited header
+ (<a href="#6.10.2">6.10.2</a>).
+<li>  The method by which preprocessing tokens (possibly resulting from macro
+ expansion) in a #include directive are combined into a header name (<a href="#6.10.2">6.10.2</a>).
+<!--page 521 indent 4-->
+<li>  The nesting limit for #include processing (<a href="#6.10.2">6.10.2</a>).
+<li>  Whether the # operator inserts a \ character before the \ character that begins a
+ universal character name in a character constant or string literal (<a href="#6.10.3.2">6.10.3.2</a>).
+<li>  The behavior on each recognized non-STDC #pragma directive (<a href="#6.10.6">6.10.6</a>).
+<li>  The definitions for __DATE__ and __TIME__ when respectively, the date and
+ time of translation are not available (<a href="#6.10.8">6.10.8</a>).
+</ul>
+
+<a name="J.3.12" href="#J.3.12"><h4>J.3.12 Library functions</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Any library facilities available to a freestanding program, other than the minimal set
+ required by clause 4 (<a href="#5.1.2.1">5.1.2.1</a>).
+<li>  The format of the diagnostic printed by the assert macro (<a href="#7.2.1.1">7.2.1.1</a>).
+<li>  The representation of the floating-point               status   flags     stored   by   the
+ fegetexceptflag function (<a href="#7.6.2.2">7.6.2.2</a>).
+<li>  Whether the feraiseexcept function raises the ''inexact'' floating-point
+ exception in addition to the ''overflow'' or ''underflow'' floating-point exception
+ (<a href="#7.6.2.3">7.6.2.3</a>).
+<li>  Strings other than "C" and "" that may be passed as the second argument to the
+ setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+<li>  The types defined for float_t and double_t when the value of the
+ FLT_EVAL_METHOD macro is less than 0 (<a href="#7.12">7.12</a>).
+<li>  Domain errors for the mathematics functions, other than those required by this
+ International Standard (<a href="#7.12.1">7.12.1</a>).
+<li>  The values returned by the mathematics functions on domain errors (<a href="#7.12.1">7.12.1</a>).
+<li>  The values returned by the mathematics functions on underflow range errors, whether
+ errno is set to the value of the macro ERANGE when the integer expression
+ math_errhandling &amp; MATH_ERRNO is nonzero, and whether the ''underflow''
+ floating-point exception is raised when the integer expression math_errhandling
+ &amp; MATH_ERREXCEPT is nonzero. (<a href="#7.12.1">7.12.1</a>).
+<li>  Whether a domain error occurs or zero is returned when an fmod function has a
+ second argument of zero (<a href="#7.12.10.1">7.12.10.1</a>).
+<li>  Whether a domain error occurs or zero is returned when a remainder function has
+ a second argument of zero (<a href="#7.12.10.2">7.12.10.2</a>).
+<li>  The base-2 logarithm of the modulus used by the remquo functions in reducing the
+ quotient (<a href="#7.12.10.3">7.12.10.3</a>).
+<!--page 522 indent 0-->
+<li>  Whether a domain error occurs or zero is returned when a remquo function has a
+ second argument of zero (<a href="#7.12.10.3">7.12.10.3</a>).
+<li>  Whether the equivalent of signal(sig, SIG_DFL); is executed prior to the call
+ of a signal handler, and, if not, the blocking of signals that is performed (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  The null pointer constant to which the macro NULL expands (<a href="#7.17">7.17</a>).
+<li>  Whether the last line of a text stream requires a terminating new-line character
+ (<a href="#7.19.2">7.19.2</a>).
+<li>  Whether space characters that are written out to a text stream immediately before a
+ new-line character appear when read in (<a href="#7.19.2">7.19.2</a>).
+<li>  The number of null characters that may be appended to data written to a binary
+ stream (<a href="#7.19.2">7.19.2</a>).
+<li>  Whether the file position indicator of an append-mode stream is initially positioned at
+ the beginning or end of the file (<a href="#7.19.3">7.19.3</a>).
+<li>  Whether a write on a text stream causes the associated file to be truncated beyond that
+ point (<a href="#7.19.3">7.19.3</a>).
+<li>  The characteristics of file buffering (<a href="#7.19.3">7.19.3</a>).
+<li>  Whether a zero-length file actually exists (<a href="#7.19.3">7.19.3</a>).
+<li>  The rules for composing valid file names (<a href="#7.19.3">7.19.3</a>).
+<li>  Whether the same file can be simultaneously open multiple times (<a href="#7.19.3">7.19.3</a>).
+<li>  The nature and choice of encodings used for multibyte characters in files (<a href="#7.19.3">7.19.3</a>).
+<li>  The effect of the remove function on an open file (<a href="#7.19.4.1">7.19.4.1</a>).
+<li>  The effect if a file with the new name exists prior to a call to the rename function
+ (<a href="#7.19.4.2">7.19.4.2</a>).
+<li>  Whether an open temporary file is removed upon abnormal program termination
+ (<a href="#7.19.4.3">7.19.4.3</a>).
+<li>  Which changes of mode are permitted (if any), and under what circumstances
+ (<a href="#7.19.5.4">7.19.5.4</a>).
+<li>  The style used to print an infinity or NaN, and the meaning of any n-char or n-wchar
+ sequence printed for a NaN (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+<li>  The output for %p conversion in the fprintf or fwprintf function (<a href="#7.19.6.1">7.19.6.1</a>,
+ <a href="#7.24.2.1">7.24.2.1</a>).
+<li>  The interpretation of a - character that is neither the first nor the last character, nor
+   the second where a ^ character is the first, in the scanlist for %[ conversion in the
+  fscanf or fwscanf function (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+<!--page 523 indent 4-->
+<li>  The set of sequences matched by a %p conversion and the interpretation of the
+ corresponding input item in the fscanf or fwscanf function (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+<li>  The value to which the macro errno is set by the fgetpos, fsetpos, or ftell
+ functions on failure (<a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.9.4">7.19.9.4</a>).
+<li>  The meaning of any n-char or n-wchar sequence in a string representing a NaN that is
+ converted by the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+ function (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
+<li>  Whether or not the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+ function sets errno to ERANGE when underflow occurs (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
+<li>  Whether the calloc, malloc, and realloc functions return a null pointer or a
+ pointer to an allocated object when the size requested is zero (<a href="#7.20.3">7.20.3</a>).
+<li>  Whether open streams with unwritten buffered data are flushed, open streams are
+ closed, or temporary files are removed when the abort or _Exit function is called
+ (<a href="#7.20.4.1">7.20.4.1</a>, <a href="#7.20.4.4">7.20.4.4</a>).
+<li>  The termination status returned to the host environment by the abort, exit, or
+ _Exit function (<a href="#7.20.4.1">7.20.4.1</a>, <a href="#7.20.4.3">7.20.4.3</a>, <a href="#7.20.4.4">7.20.4.4</a>).
+<li>  The value returned by the system function when its argument is not a null pointer
+ (<a href="#7.20.4.6">7.20.4.6</a>).
+<li>  The local time zone and Daylight Saving Time (<a href="#7.23.1">7.23.1</a>).
+<li>  The range and precision of times representable in clock_t and time_t (<a href="#7.23">7.23</a>).
+<li>  The era for the clock function (<a href="#7.23.2.1">7.23.2.1</a>).
+<li>  The replacement string for the %Z specifier to the strftime, and wcsftime
+ functions in the "C" locale (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+<li>  Whether the functions in &lt;math.h&gt; honor the rounding direction mode in an
+ IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.9">F.9</a>).
+</ul>
+
+<a name="J.3.13" href="#J.3.13"><h4>J.3.13 Architecture</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The values or expressions assigned to the macros specified in the headers
+ &lt;float.h&gt;, &lt;limits.h&gt;, and &lt;stdint.h&gt; (<a href="#5.2.4.2">5.2.4.2</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>).
+<li>  The number, order, and encoding of bytes in any object (when not explicitly specified
+ in this International Standard) (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The value of the result of the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>).
+<!--page 524 indent 4-->
+</ul>
+
+<a name="J.4" href="#J.4"><h3>J.4 Locale-specific behavior</h3></a>
+<p><!--para 1-->
+ The following characteristics of a hosted environment are locale-specific and are required
+ to be documented by the implementation:
+<ul>
+<li>  Additional members of the source and execution character sets beyond the basic
+ character set (<a href="#5.2.1">5.2.1</a>).
+<li>  The presence, meaning, and representation of additional multibyte characters in the
+ execution character set beyond the basic character set (<a href="#5.2.1.2">5.2.1.2</a>).
+<li>  The shift states used for the encoding of multibyte characters (<a href="#5.2.1.2">5.2.1.2</a>).
+<li>  The direction of writing of successive printing characters (<a href="#5.2.2">5.2.2</a>).
+<li>  The decimal-point character (<a href="#7.1.1">7.1.1</a>).
+<li>  The set of printing characters (<a href="#7.4">7.4</a>, <a href="#7.25.2">7.25.2</a>).
+<li>  The set of control characters (<a href="#7.4">7.4</a>, <a href="#7.25.2">7.25.2</a>).
+<li>  The sets of characters tested for by the isalpha, isblank, islower, ispunct,
+ isspace, isupper, iswalpha, iswblank, iswlower, iswpunct,
+ iswspace, or iswupper functions (<a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+ <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>).
+<li>  The native environment (<a href="#7.11.1.1">7.11.1.1</a>).
+<li>  Additional subject sequences accepted by the numeric conversion functions (<a href="#7.20.1">7.20.1</a>,
+ <a href="#7.24.4.1">7.24.4.1</a>).
+<li>  The collation sequence of the execution character set (<a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.24.4.4.2">7.24.4.4.2</a>).
+<li>  The contents of the error message strings set up by the strerror function
+ (<a href="#7.21.6.2">7.21.6.2</a>).
+<li>  The formats for time and date (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+<li>  Character mappings that are supported by the towctrans function (<a href="#7.25.1">7.25.1</a>).
+<li>  Character classifications that are supported by the iswctype function (<a href="#7.25.1">7.25.1</a>).
+<!--page 525 indent 4-->
+</ul>
+
+<a name="J.5" href="#J.5"><h3>J.5 Common extensions</h3></a>
+<p><!--para 1-->
+ The following extensions are widely used in many systems, but are not portable to all
+ implementations. The inclusion of any extension that may cause a strictly conforming
+ program to become invalid renders an implementation nonconforming. Examples of such
+ extensions are new keywords, extra library functions declared in standard headers, or
+ predefined macros with names that do not begin with an underscore.
+
+<a name="J.5.1" href="#J.5.1"><h4>J.5.1 Environment arguments</h4></a>
+<p><!--para 1-->
+ In a hosted environment, the main function receives a third argument, char *envp[],
+ that points to a null-terminated array of pointers to char, each of which points to a string
+ that provides information about the environment for this execution of the program
+ (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+
+<a name="J.5.2" href="#J.5.2"><h4>J.5.2 Specialized identifiers</h4></a>
+<p><!--para 1-->
+ Characters other than the underscore _, letters, and digits, that are not part of the basic
+ source character set (such as the dollar sign $, or characters in national character sets)
+ may appear in an identifier (<a href="#6.4.2">6.4.2</a>).
+
+<a name="J.5.3" href="#J.5.3"><h4>J.5.3 Lengths and cases of identifiers</h4></a>
+<p><!--para 1-->
+ All characters in identifiers (with or without external linkage) are significant (<a href="#6.4.2">6.4.2</a>).
+
+<a name="J.5.4" href="#J.5.4"><h4>J.5.4 Scopes of identifiers</h4></a>
+<p><!--para 1-->
+ A function identifier, or the identifier of an object the declaration of which contains the
+ keyword extern, has file scope (<a href="#6.2.1">6.2.1</a>).
+
+<a name="J.5.5" href="#J.5.5"><h4>J.5.5 Writable string literals</h4></a>
+<p><!--para 1-->
+ String literals are modifiable (in which case, identical string literals should denote distinct
+ objects) (<a href="#6.4.5">6.4.5</a>).
+
+<a name="J.5.6" href="#J.5.6"><h4>J.5.6 Other arithmetic types</h4></a>
+<p><!--para 1-->
+ Additional arithmetic types, such as __int128 or double double, and their
+ appropriate conversions are defined (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1">6.3.1</a>). Additional floating types may have
+ more range or precision than long double, may be used for evaluating expressions of
+ other floating types, and may be used to define float_t or double_t.
+<!--page 526 indent 4-->
+
+<a name="J.5.7" href="#J.5.7"><h4>J.5.7 Function pointer casts</h4></a>
+<p><!--para 1-->
+ A pointer to an object or to void may be cast to a pointer to a function, allowing data to
+ be invoked as a function (<a href="#6.5.4">6.5.4</a>).
+<p><!--para 2-->
+ A pointer to a function may be cast to a pointer to an object or to void, allowing a
+ function to be inspected or modified (for example, by a debugger) (<a href="#6.5.4">6.5.4</a>).
+
+<a name="J.5.8" href="#J.5.8"><h4>J.5.8 Extended bit-field types</h4></a>
+<p><!--para 1-->
+ A bit-field may be declared with a type other than _Bool, unsigned int, or
+ signed int, with an appropriate maximum width (<a href="#6.7.2.1">6.7.2.1</a>).
+
+<a name="J.5.9" href="#J.5.9"><h4>J.5.9 The fortran keyword</h4></a>
+<p><!--para 1-->
+ The fortran function specifier may be used in a function declaration to indicate that
+ calls suitable for FORTRAN should be generated, or that a different representation for the
+ external name is to be generated (<a href="#6.7.4">6.7.4</a>).
+
+<a name="J.5.10" href="#J.5.10"><h4>J.5.10 The asm keyword</h4></a>
+<p><!--para 1-->
+ The asm keyword may be used to insert assembly language directly into the translator
+ output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
+<pre>
+        asm ( character-string-literal );</pre>
+
+<a name="J.5.11" href="#J.5.11"><h4>J.5.11 Multiple external definitions</h4></a>
+<p><!--para 1-->
+ There may be more than one external definition for the identifier of an object, with or
+ without the explicit use of the keyword extern; if the definitions disagree, or more than
+ one is initialized, the behavior is undefined (<a href="#6.9.2">6.9.2</a>).
+
+<a name="J.5.12" href="#J.5.12"><h4>J.5.12 Predefined macro names</h4></a>
+<p><!--para 1-->
+ Macro names that do not begin with an underscore, describing the translation and
+ execution environments, are defined by the implementation before translation begins
+ (<a href="#6.10.8">6.10.8</a>).
+
+<a name="J.5.13" href="#J.5.13"><h4>J.5.13 Floating-point status flags</h4></a>
+<p><!--para 1-->
+ If any floating-point status flags are set on normal termination after all calls to functions
+ registered by the atexit function have been made (see <a href="#7.20.4.3">7.20.4.3</a>), the implementation
+ writes some diagnostics indicating the fact to the stderr stream, if it is still open,
+<!--page 527 indent 4-->
+
+<a name="J.5.14" href="#J.5.14"><h4>J.5.14 Extra arguments for signal handlers</h4></a>
+<p><!--para 1-->
+ Handlers for specific signals are called with extra arguments in addition to the signal
+ number (<a href="#7.14.1.1">7.14.1.1</a>).
+
+<a name="J.5.15" href="#J.5.15"><h4>J.5.15 Additional stream types and file-opening modes</h4></a>
+<p><!--para 1-->
+ Additional mappings from files to streams are supported (<a href="#7.19.2">7.19.2</a>).
+<p><!--para 2-->
+ Additional file-opening modes may be specified by characters appended to the mode
+ argument of the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
+
+<a name="J.5.16" href="#J.5.16"><h4>J.5.16 Defined file position indicator</h4></a>
+<p><!--para 1-->
+ The file position indicator is decremented by each successful call to the ungetc or
+ ungetwc function for a text stream, except if its value was zero before a call (<a href="#7.19.7.11">7.19.7.11</a>,
+ <a href="#7.24.3.10">7.24.3.10</a>).
+
+<a name="J.5.17" href="#J.5.17"><h4>J.5.17 Math error reporting</h4></a>
+<p><!--para 1-->
+ Functions declared in &lt;complex.h&gt; and &lt;math.h&gt; raise SIGFPE to report errors
+ instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
+ <a href="#7.12">7.12</a>).
+<!--page 528 indent -1-->
+
+<a name="Bibliography" href="#Bibliography"><h2>Bibliography</h2></a>
+<ol>
+<li>  ''The C Reference Manual'' by Dennis M. Ritchie, a version of which was
+ published in The C Programming Language by Brian W. Kernighan and Dennis
+ M. Ritchie, Prentice-Hall, Inc., (1978). Copyright owned by AT&amp;T.
+<li>  1984 /usr/group Standard by the /usr/group Standards Committee, Santa Clara,
+ California, USA, November 1984.
+<li>  ANSI X3/TR-1-82 (1982), American National Dictionary for Information
+ Processing Systems, Information Processing Systems Technical Report.
+<li>  ANSI/IEEE 754-1985, American National Standard for Binary Floating-Point
+ Arithmetic.
+<li>  ANSI/IEEE 854-1988, American National Standard for Radix-Independent
+ Floating-Point Arithmetic.
+<li>  IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems,
+ second edition (previously designated IEC 559:1989).
+<li>  ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and
+ symbols for use in the physical sciences and technology.
+<li>  ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character set for
+ information interchange.
+<li>  ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1:
+ Fundamental terms.
+<li>  ISO 4217:1995, Codes for the representation of currencies and funds.
+<li>  ISO 8601:1988, Data elements and interchange formats -- Information
+ interchange -- Representation of dates and times.
+<li>  ISO/IEC 9899:1990, Programming languages -- C.
+<li>  ISO/IEC 9899/COR1:1994, Technical Corrigendum 1.
+<li>  ISO/IEC 9899/COR2:1996, Technical Corrigendum 2.
+<li>  ISO/IEC 9899/AMD1:1995, Amendment 1 to ISO/IEC 9899:1990 C Integrity.
+<li>  ISO/IEC 9945-2:1993, Information technology -- Portable Operating System
+ Interface (POSIX) -- Part 2: Shell and Utilities.
+<li>  ISO/IEC TR 10176:1998, Information technology -- Guidelines for the
+ preparation of programming language standards.
+<li>  ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet
+ Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.
+<!--page 529 indent -1-->
+<li>  ISO/IEC 10646-1/COR1:1996,      Technical       Corrigendum      1      to
+ ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/COR2:1998,      Technical       Corrigendum      2      to
+ ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD1:1996, Amendment 1 to ISO/IEC 10646-1:1993
+ Transformation Format for 16 planes of group 00 (UTF-16).
+<li>  ISO/IEC 10646-1/AMD2:1996, Amendment 2 to ISO/IEC 10646-1:1993 UCS
+ Transformation Format 8 (UTF-8).
+<li>  ISO/IEC 10646-1/AMD3:1996, Amendment 3 to ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD4:1996, Amendment 4 to ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD5:1998, Amendment 5 to ISO/IEC 10646-1:1993 Hangul
+ syllables.
+<li>  ISO/IEC 10646-1/AMD6:1997, Amendment 6 to ISO/IEC 10646-1:1993 Tibetan.
+<li>  ISO/IEC 10646-1/AMD7:1997, Amendment 7 to ISO/IEC 10646-1:1993 33
+ additional characters.
+<li>  ISO/IEC 10646-1/AMD8:1997, Amendment 8 to ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD9:1997,    Amendment     9   to    ISO/IEC 10646-1:1993
+ Identifiers for characters.
+<li>  ISO/IEC 10646-1/AMD10:1998, Amendment 10 to ISO/IEC 10646-1:1993
+ Ethiopic.
+<li>  ISO/IEC 10646-1/AMD11:1998, Amendment 11 to ISO/IEC 10646-1:1993
+ Unified Canadian Aboriginal Syllabics.
+<li>  ISO/IEC 10646-1/AMD12:1998, Amendment 12 to ISO/IEC 10646-1:1993
+ Cherokee.
+<li>  ISO/IEC 10967-1:1994, Information technology -- Language independent
+ arithmetic -- Part 1: Integer and floating point arithmetic.
+<!--page 530 indent 0-->
+<!--page 531 indent 0-->
+</ol>
+
+<a name="Index" href="#Index"><h2>Index</h2></a>
+<pre>
+ ??? x ???, <a href="#3.18">3.18</a>                                                    , (comma punctuator), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,
+                                                                     <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>
+ ??? x ???, <a href="#3.19">3.19</a>                                                    - (subtraction operator), <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
+ ! (logical negation operator), <a href="#6.5.3.3">6.5.3.3</a>                         - (unary minus operator), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
+ != (inequality operator), <a href="#6.5.9">6.5.9</a>                                -- (postfix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
+ # operator, <a href="#6.10.3.2">6.10.3.2</a>                                           -- (prefix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
+ # preprocessing directive, <a href="#6.10.7">6.10.7</a>                              -= (subtraction assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+ # punctuator, <a href="#6.10">6.10</a>                                             -&gt; (structure/union pointer operator), <a href="#6.5.2.3">6.5.2.3</a>
+ ## operator, <a href="#6.10.3.3">6.10.3.3</a>                                          . (structure/union member operator), <a href="#6.3.2.1">6.3.2.1</a>,
+ #define preprocessing directive, <a href="#6.10.3">6.10.3</a>                             <a href="#6.5.2.3">6.5.2.3</a>
+ #elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                          . punctuator, <a href="#6.7.8">6.7.8</a>
+ #else preprocessing directive, <a href="#6.10.1">6.10.1</a>                          ... (ellipsis punctuator), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>
+ #endif preprocessing directive, <a href="#6.10.1">6.10.1</a>                         / (division operator), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
+ #error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                      /* */ (comment delimiters), <a href="#6.4.9">6.4.9</a>
+ #if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,             // (comment delimiter), <a href="#6.4.9">6.4.9</a>
+      <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             /= (division assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+ #ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                         : (colon punctuator), <a href="#6.7.2.1">6.7.2.1</a>
+ #ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                        :&gt; (alternative spelling of ]), <a href="#6.4.6">6.4.6</a>
+ #include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>,                     ; (semicolon punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
+      <a href="#6.10.2">6.10.2</a>                                                         <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
+ #line preprocessing directive, <a href="#6.10.4">6.10.4</a>                          &lt; (less-than operator), <a href="#6.5.8">6.5.8</a>
+ #pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>                        &lt;% (alternative spelling of {), <a href="#6.4.6">6.4.6</a>
+ #undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,               &lt;: (alternative spelling of [), <a href="#6.4.6">6.4.6</a>
+      <a href="#7.1.4">7.1.4</a>                                                     &lt;&lt; (left-shift operator), <a href="#6.5.7">6.5.7</a>
+ % (remainder operator), <a href="#6.5.5">6.5.5</a>                                  &lt;&lt;= (left-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+ %: (alternative spelling of #), <a href="#6.4.6">6.4.6</a>                          &lt;= (less-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>
+ %:%: (alternative spelling of ##), <a href="#6.4.6">6.4.6</a>                       &lt;assert.h&gt; header, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
+ %= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                   &lt;complex.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>,
+ %&gt; (alternative spelling of }), <a href="#6.4.6">6.4.6</a>                               <a href="#7.26.1">7.26.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+ &amp; (address operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                         &lt;ctype.h&gt; header, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
+ &amp; (bitwise AND operator), <a href="#6.5.10">6.5.10</a>                               &lt;errno.h&gt; header, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
+ &amp;&amp; (logical AND operator), <a href="#6.5.13">6.5.13</a>                              &lt;fenv.h&gt; header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>,
+ &amp;= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                      <a href="#H">H</a>
+ ' ' (space character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,           &lt;float.h&gt; header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+      <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>                                           <a href="#7.24.4.1.1">7.24.4.1.1</a>
+ ( ) (cast operator), <a href="#6.5.4">6.5.4</a>                                     &lt;inttypes.h&gt; header, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>
+ ( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a>                          &lt;iso646.h&gt; header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
+ ( ) (parentheses punctuator), <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>            &lt;limits.h&gt; header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
+ ( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                    &lt;locale.h&gt; header, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
+ * (asterisk punctuator), <a href="#6.7.5.1">6.7.5.1</a>, <a href="#6.7.5.2">6.7.5.2</a>                      &lt;math.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>,
+ * (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                          <a href="#F.9">F.9</a>, <a href="#J.5.17">J.5.17</a>
+ * (multiplication operator), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>                 &lt;setjmp.h&gt; header, <a href="#7.13">7.13</a>
+ *= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              &lt;signal.h&gt; header, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>
+ + (addition operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>,           &lt;stdarg.h&gt; header, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>
+      <a href="#G.5.2">G.5.2</a>                                                     &lt;stdbool.h&gt; header, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>
+ + (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a>                               &lt;stddef.h&gt; header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+ ++ (postfix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>                    <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>
+ ++ (prefix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>                &lt;stdint.h&gt; header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>,
+ += (addition assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                         <a href="#7.18">7.18</a>, <a href="#7.26.8">7.26.8</a>
+ , (comma operator), <a href="#6.5.17">6.5.17</a>
+<!--page 532 indent 0-->
+ &lt;stdio.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>                 __cplusplus macro, <a href="#6.10.8">6.10.8</a>
+ &lt;stdlib.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>               __DATE__ macro, <a href="#6.10.8">6.10.8</a>
+ &lt;string.h&gt; header, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>                             __FILE__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#7.2.1.1">7.2.1.1</a>
+ &lt;tgmath.h&gt; header, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                 __func__ identifier, <a href="#6.4.2.2">6.4.2.2</a>, <a href="#7.2.1.1">7.2.1.1</a>
+ &lt;time.h&gt; header, <a href="#7.23">7.23</a>                                        __LINE__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#7.2.1.1">7.2.1.1</a>
+ &lt;wchar.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>,                   __STDC_, <a href="#6.11.9">6.11.9</a>
+      <a href="#7.26.12">7.26.12</a>, <a href="#F">F</a>                                              __STDC__ macro, <a href="#6.10.8">6.10.8</a>
+ &lt;wctype.h&gt; header, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>                             __STDC_CONSTANT_MACROS macro, <a href="#7.18.4">7.18.4</a>
+ = (equal-sign punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.8">6.7.8</a>               __STDC_FORMAT_MACROS macro, <a href="#7.8.1">7.8.1</a>
+ = (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a>                     __STDC_HOSTED__ macro, <a href="#6.10.8">6.10.8</a>
+ == (equality operator), <a href="#6.5.9">6.5.9</a>                                __STDC_IEC_559__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#F.1">F.1</a>
+ &gt; (greater-than operator), <a href="#6.5.8">6.5.8</a>                             __STDC_IEC_559_COMPLEX__ macro,
+ &gt;= (greater-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>                     <a href="#6.10.8">6.10.8</a>, <a href="#G.1">G.1</a>
+ &gt;&gt; (right-shift operator), <a href="#6.5.7">6.5.7</a>                             __STDC_ISO_10646__ macro, <a href="#6.10.8">6.10.8</a>
+ &gt;&gt;= (right-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              __STDC_LIMIT_MACROS macro, <a href="#7.18.2">7.18.2</a>,
+ ? : (conditional operator), <a href="#6.5.15">6.5.15</a>                                <a href="#7.18.3">7.18.3</a>
+ ?? (trigraph sequences), <a href="#5.2.1.1">5.2.1.1</a>                             __STDC_MB_MIGHT_NEQ_WC__ macro,
+ [ ] (array subscript operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                  <a href="#6.10.8">6.10.8</a>, <a href="#7.17">7.17</a>
+ [ ] (brackets punctuator), <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.8">6.7.8</a>                    __STDC_VERSION__ macro, <a href="#6.10.8">6.10.8</a>
+ \ (backslash character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>             __TIME__ macro, <a href="#6.10.8">6.10.8</a>
+ \ (escape character), <a href="#6.4.4.4">6.4.4.4</a>                                __VA_ARGS__ identifier, <a href="#6.10.3">6.10.3</a>, <a href="#6.10.3.1">6.10.3.1</a>
+ \" (double-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>,                  _Bool type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>, <a href="#6.7.2">6.7.2</a>
+      <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                           _Bool type conversions, <a href="#6.3.1.2">6.3.1.2</a>
+ \\ (backslash escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>              _Complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+ \' (single-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>            _Complex_I macro, <a href="#7.3.1">7.3.1</a>
+ \0 (null character), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                   _Exit function, <a href="#7.20.4.4">7.20.4.4</a>
+   padding of binary stream, <a href="#7.19.2">7.19.2</a>                           _Imaginary keyword, <a href="#G.2">G.2</a>
+ \? (question-mark escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                  _Imaginary types, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+ \a (alert escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                   _Imaginary_I macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
+ \b (backspace escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>               _IOFBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
+ \f (form-feed escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,              _IOLBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.6">7.19.5.6</a>
+      <a href="#7.4.1.10">7.4.1.10</a>                                                _IONBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
+ \n (new-line escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               _Pragma operator, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>
+      <a href="#7.4.1.10">7.4.1.10</a>                                                { } (braces punctuator), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>,
+ \octal digits (octal-character escape sequence),                  <a href="#6.8.2">6.8.2</a>
+      <a href="#6.4.4.4">6.4.4.4</a>                                                 { } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>
+ \r (carriage-return escape sequence), <a href="#5.2.2">5.2.2</a>,                 | (bitwise inclusive OR operator), <a href="#6.5.12">6.5.12</a>
+      <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                       |= (bitwise inclusive OR assignment operator),
+ \t (horizontal-tab escape sequence), <a href="#5.2.2">5.2.2</a>,                       <a href="#6.5.16.2">6.5.16.2</a>
+      <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>                  || (logical OR operator), <a href="#6.5.14">6.5.14</a>
+ \U (universal character names), <a href="#6.4.3">6.4.3</a>                        ~ (bitwise complement operator), <a href="#6.5.3.3">6.5.3.3</a>
+ \u (universal character names), <a href="#6.4.3">6.4.3</a>
+ \v (vertical-tab escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           abort function, <a href="#7.2.1.1">7.2.1.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.19.3">7.19.3</a>,
+      <a href="#7.4.1.10">7.4.1.10</a>                                                     <a href="#7.20.4.1">7.20.4.1</a>
+ \x hexadecimal digits (hexadecimal-character                 abs function, <a href="#7.20.6.1">7.20.6.1</a>
+      escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                               absolute-value functions
+ ^ (bitwise exclusive OR operator), <a href="#6.5.11">6.5.11</a>                      complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>
+ ^= (bitwise exclusive OR assignment operator),                 integer, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.20.6.1">7.20.6.1</a>
+      <a href="#6.5.16.2">6.5.16.2</a>                                                  real, <a href="#7.12.7">7.12.7</a>, <a href="#F.9.4">F.9.4</a>
+ __bool_true_false_are_defined                               abstract declarator, <a href="#6.7.6">6.7.6</a>
+      macro, <a href="#7.16">7.16</a>                                             abstract machine, <a href="#5.1.2.3">5.1.2.3</a>
+<!--page 533 indent 0-->
+ access, <a href="#3.1">3.1</a>, <a href="#6.7.3">6.7.3</a>                                             array
+ accuracy, see floating-point accuracy                              argument, <a href="#6.9.1">6.9.1</a>
+ acos functions, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#F.9.1.1">F.9.1.1</a>                                 declarator, <a href="#6.7.5.2">6.7.5.2</a>
+ acos type-generic macro, <a href="#7.22">7.22</a>                                     initialization, <a href="#6.7.8">6.7.8</a>
+ acosh functions, <a href="#7.12.5.1">7.12.5.1</a>, <a href="#F.9.2.1">F.9.2.1</a>                                multidimensional, <a href="#6.5.2.1">6.5.2.1</a>
+ acosh type-generic macro, <a href="#7.22">7.22</a>                                    parameter, <a href="#6.9.1">6.9.1</a>
+ active position, <a href="#5.2.2">5.2.2</a>                                            storage order, <a href="#6.5.2.1">6.5.2.1</a>
+ actual argument, <a href="#3.3">3.3</a>                                              subscript operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+ actual parameter (deprecated), <a href="#3.3">3.3</a>                                subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+ addition assignment operator (+=), <a href="#6.5.16.2">6.5.16.2</a>                       type, <a href="#6.2.5">6.2.5</a>
+ addition operator (+), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>,              type conversion, <a href="#6.3.2.1">6.3.2.1</a>
+       <a href="#G.5.2">G.5.2</a>                                                       variable length, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
+ additive expressions, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                             arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+ address constant, <a href="#6.6">6.6</a>                                          as-if rule, <a href="#5.1.2.3">5.1.2.3</a>
+ address operator (&amp;), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                         ASCII code set, <a href="#5.2.1.1">5.2.1.1</a>
+ aggregate initialization, <a href="#6.7.8">6.7.8</a>                                asctime function, <a href="#7.23.3.1">7.23.3.1</a>
+ aggregate types, <a href="#6.2.5">6.2.5</a>                                         asin functions, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#F.9.1.2">F.9.1.2</a>
+ alert escape sequence (\a), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                     asin type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+ aliasing, <a href="#6.5">6.5</a>                                                  asinh functions, <a href="#7.12.5.2">7.12.5.2</a>, <a href="#F.9.2.2">F.9.2.2</a>
+ alignment, <a href="#3.2">3.2</a>                                                 asinh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+    pointer, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.3">6.3.2.3</a>                                     asm keyword, <a href="#J.5.10">J.5.10</a>
+    structure/union member, <a href="#6.7.2.1">6.7.2.1</a>                             assert macro, <a href="#7.2.1.1">7.2.1.1</a>
+ allocated storage, order and contiguity, <a href="#7.20.3">7.20.3</a>                assert.h header, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
+ and macro, <a href="#7.9">7.9</a>                                                 assignment
+ AND operators                                                     compound, <a href="#6.5.16.2">6.5.16.2</a>
+    bitwise (&amp;), <a href="#6.5.10">6.5.10</a>                                            conversion, <a href="#6.5.16.1">6.5.16.1</a>
+    bitwise assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>                              expression, <a href="#6.5.16">6.5.16</a>
+    logical (&amp;&amp;), <a href="#6.5.13">6.5.13</a>                                           operators, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>
+ and_eq macro, <a href="#7.9">7.9</a>                                                 simple, <a href="#6.5.16.1">6.5.16.1</a>
+ ANSI/IEEE 754, <a href="#F.1">F.1</a>                                             associativity of operators, <a href="#6.5">6.5</a>
+ ANSI/IEEE 854, <a href="#F.1">F.1</a>                                             asterisk punctuator (*), <a href="#6.7.5.1">6.7.5.1</a>, <a href="#6.7.5.2">6.7.5.2</a>
+ argc (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>                      atan functions, <a href="#7.12.4.3">7.12.4.3</a>, <a href="#F.9.1.3">F.9.1.3</a>
+ argument, <a href="#3.3">3.3</a>                                                  atan type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+    array, <a href="#6.9.1">6.9.1</a>                                                atan2 functions, <a href="#7.12.4.4">7.12.4.4</a>, <a href="#F.9.1.4">F.9.1.4</a>
+    default promotions, <a href="#6.5.2.2">6.5.2.2</a>                                 atan2 type-generic macro, <a href="#7.22">7.22</a>
+    function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>                                    atanh functions, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#F.9.2.3">F.9.2.3</a>
+    macro, substitution, <a href="#6.10.3.1">6.10.3.1</a>                               atanh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+ argument, complex, <a href="#7.3.9.1">7.3.9.1</a>                                     atexit function, <a href="#7.20.4.2">7.20.4.2</a>, <a href="#7.20.4.3">7.20.4.3</a>, <a href="#7.20.4.4">7.20.4.4</a>,
+ argv (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>                            <a href="#J.5.13">J.5.13</a>
+ arithmetic constant expression, <a href="#6.6">6.6</a>                            atof function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.1">7.20.1.1</a>
+ arithmetic conversions, usual, see usual arithmetic            atoi function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
+       conversions                                              atol function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
+ arithmetic operators                                           atoll function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
+    additive, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                                      auto storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
+    bitwise, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>                             automatic storage duration, <a href="#5.2.3">5.2.3</a>, <a href="#6.2.4">6.2.4</a>
+    increment and decrement, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>
+    multiplicative, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>                                backslash character (\), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+    shift, <a href="#6.5.7">6.5.7</a>                                                backslash escape sequence (\\), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>
+    unary, <a href="#6.5.3.3">6.5.3.3</a>                                              backspace escape sequence (\b), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+ arithmetic types, <a href="#6.2.5">6.2.5</a>                                        basic character set, <a href="#3.6">3.6</a>, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>
+ arithmetic, pointer, <a href="#6.5.6">6.5.6</a>                                     basic types, <a href="#6.2.5">6.2.5</a>
+<!--page 534 indent 0-->
+ behavior, <a href="#3.4">3.4</a>                                                  call by value, <a href="#6.5.2.2">6.5.2.2</a>
+ binary streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,                   calloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.1">7.20.3.1</a>, <a href="#7.20.3.2">7.20.3.2</a>,
+       <a href="#7.19.9.4">7.19.9.4</a>                                                       <a href="#7.20.3.4">7.20.3.4</a>
+ bit, <a href="#3.5">3.5</a>                                                       carg functions, <a href="#7.3.9.1">7.3.9.1</a>, <a href="#G.6">G.6</a>
+    high order, <a href="#3.6">3.6</a>                                             carg type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+    low order, <a href="#3.6">3.6</a>                                              carriage-return escape sequence (\r), <a href="#5.2.2">5.2.2</a>,
+ bit-field, <a href="#6.7.2.1">6.7.2.1</a>                                                    <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>
+ bitand macro, <a href="#7.9">7.9</a>                                              case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+ bitor macro, <a href="#7.9">7.9</a>                                               case mapping functions
+ bitwise operators, <a href="#6.5">6.5</a>                                           character, <a href="#7.4.2">7.4.2</a>
+    AND, <a href="#6.5.10">6.5.10</a>                                                   wide character, <a href="#7.25.3.1">7.25.3.1</a>
+    AND assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>                                     extensible, <a href="#7.25.3.2">7.25.3.2</a>
+    complement (~), <a href="#6.5.3.3">6.5.3.3</a>                                     casin functions, <a href="#7.3.5.2">7.3.5.2</a>, <a href="#G.6">G.6</a>
+    exclusive OR, <a href="#6.5.11">6.5.11</a>                                          type-generic macro for, <a href="#7.22">7.22</a>
+    exclusive OR assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                      casinh functions, <a href="#7.3.6.2">7.3.6.2</a>, <a href="#G.6.2.2">G.6.2.2</a>
+    inclusive OR, <a href="#6.5.12">6.5.12</a>                                          type-generic macro for, <a href="#7.22">7.22</a>
+    inclusive OR assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>                      cast expression, <a href="#6.5.4">6.5.4</a>
+    shift, <a href="#6.5.7">6.5.7</a>                                                cast operator (( )), <a href="#6.5.4">6.5.4</a>
+ blank character, <a href="#7.4.1.3">7.4.1.3</a>                                       catan functions, <a href="#7.3.5.3">7.3.5.3</a>, <a href="#G.6">G.6</a>
+ block, <a href="#6.8">6.8</a>, <a href="#6.8.2">6.8.2</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>                                  type-generic macro for, <a href="#7.22">7.22</a>
+ block scope, <a href="#6.2.1">6.2.1</a>                                             catanh functions, <a href="#7.3.6.3">7.3.6.3</a>, <a href="#G.6.2.3">G.6.2.3</a>
+ block structure, <a href="#6.2.1">6.2.1</a>                                           type-generic macro for, <a href="#7.22">7.22</a>
+ bold type convention, <a href="#6.1">6.1</a>                                      cbrt functions, <a href="#7.12.7.1">7.12.7.1</a>, <a href="#F.9.4.1">F.9.4.1</a>
+ bool macro, <a href="#7.16">7.16</a>                                               cbrt type-generic macro, <a href="#7.22">7.22</a>
+ boolean type, <a href="#6.3.1.2">6.3.1.2</a>                                          ccos functions, <a href="#7.3.5.4">7.3.5.4</a>, <a href="#G.6">G.6</a>
+ boolean type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>                        type-generic macro for, <a href="#7.22">7.22</a>
+ braces punctuator ({ }), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>,              ccosh functions, <a href="#7.3.6.4">7.3.6.4</a>, <a href="#G.6.2.4">G.6.2.4</a>
+       <a href="#6.8.2">6.8.2</a>                                                      type-generic macro for, <a href="#7.22">7.22</a>
+ brackets operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                      ceil functions, <a href="#7.12.9.1">7.12.9.1</a>, <a href="#F.9.6.1">F.9.6.1</a>
+ brackets punctuator ([ ]), <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.8">6.7.8</a>                      ceil type-generic macro, <a href="#7.22">7.22</a>
+ branch cuts, <a href="#7.3.3">7.3.3</a>                                             cerf function, <a href="#7.26.1">7.26.1</a>
+ break statement, <a href="#6.8.6.3">6.8.6.3</a>                                       cerfc function, <a href="#7.26.1">7.26.1</a>
+ broken-down time, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.3">7.23.3</a>,                    cexp functions, <a href="#7.3.7.1">7.3.7.1</a>, <a href="#G.6.3.1">G.6.3.1</a>
+       <a href="#7.23.3.1">7.23.3.1</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>, <a href="#7.23.3.5">7.23.3.5</a>                     type-generic macro for, <a href="#7.22">7.22</a>
+ bsearch function, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.1">7.20.5.1</a>                             cexp2 function, <a href="#7.26.1">7.26.1</a>
+ btowc function, <a href="#7.24.6.1.1">7.24.6.1.1</a>                                     cexpm1 function, <a href="#7.26.1">7.26.1</a>
+ BUFSIZ macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.5">7.19.5.5</a>                         char type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>
+ byte, <a href="#3.6">3.6</a>, <a href="#6.5.3.4">6.5.3.4</a>                                             char type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+ byte input/output functions, <a href="#7.19.1">7.19.1</a>                                  <a href="#6.3.1.8">6.3.1.8</a>
+ byte-oriented stream, <a href="#7.19.2">7.19.2</a>                                   CHAR_BIT macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+                                                                CHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ <a href="#C">C</a> program, <a href="#5.1.1.1">5.1.1.1</a>                                             CHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ <a href="#C">C</a>++, <a href="#7.8.1">7.8.1</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.18.4">7.18.4</a>                             character, <a href="#3.7">3.7</a>, <a href="#3.7.1">3.7.1</a>
+ cabs functions, <a href="#7.3.8.1">7.3.8.1</a>, <a href="#G.6">G.6</a>                                   character array initialization, <a href="#6.7.8">6.7.8</a>
+   type-generic macro for, <a href="#7.22">7.22</a>                                 character case mapping functions, <a href="#7.4.2">7.4.2</a>
+ cacos functions, <a href="#7.3.5.1">7.3.5.1</a>, <a href="#G.6.1.1">G.6.1.1</a>                                wide character, <a href="#7.25.3.1">7.25.3.1</a>
+   type-generic macro for, <a href="#7.22">7.22</a>                                       extensible, <a href="#7.25.3.2">7.25.3.2</a>
+ cacosh functions, <a href="#7.3.6.1">7.3.6.1</a>, <a href="#G.6.2.1">G.6.2.1</a>                             character classification functions, <a href="#7.4.1">7.4.1</a>
+   type-generic macro for, <a href="#7.22">7.22</a>                                   wide character, <a href="#7.25.2.1">7.25.2.1</a>
+ calendar time, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.2">7.23.2.2</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.2.4">7.23.2.4</a>,                 extensible, <a href="#7.25.2.2">7.25.2.2</a>
+      <a href="#7.23.3.2">7.23.3.2</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>                              character constant, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+<!--page 535 indent 0-->
+ character display semantics, <a href="#5.2.2">5.2.2</a>                            complex.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>, <a href="#7.26.1">7.26.1</a>,
+ character handling header, <a href="#7.4">7.4</a>, <a href="#7.11.1.1">7.11.1.1</a>                           <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+ character input/output functions, <a href="#7.19.7">7.19.7</a>                      compliance, see conformance
+    wide character, <a href="#7.24.3">7.24.3</a>                                     components of time, <a href="#7.23.1">7.23.1</a>
+ character sets, <a href="#5.2.1">5.2.1</a>                                         composite type, <a href="#6.2.7">6.2.7</a>
+ character string literal, see string literal                  compound assignment, <a href="#6.5.16.2">6.5.16.2</a>
+ character type conversion, <a href="#6.3.1.1">6.3.1.1</a>                            compound literals, <a href="#6.5.2.5">6.5.2.5</a>
+ character types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.8">6.7.8</a>                                 compound statement, <a href="#6.8.2">6.8.2</a>
+ cimag functions, <a href="#7.3.9.2">7.3.9.2</a>, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                        compound-literal operator (( ){ }), <a href="#6.5.2.5">6.5.2.5</a>
+ cimag type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                           concatenation functions
+ cis function, <a href="#G.6">G.6</a>                                               string, <a href="#7.21.3">7.21.3</a>
+ classification functions                                         wide string, <a href="#7.24.4.3">7.24.4.3</a>
+    character, <a href="#7.4.1">7.4.1</a>                                           concatenation, preprocessing, see preprocessing
+    floating-point, <a href="#7.12.3">7.12.3</a>                                           concatenation
+    wide character, <a href="#7.25.2.1">7.25.2.1</a>                                   conceptual models, <a href="#5.1">5.1</a>
+       extensible, <a href="#7.25.2.2">7.25.2.2</a>                                    conditional inclusion, <a href="#6.10.1">6.10.1</a>
+ clearerr function, <a href="#7.19.10.1">7.19.10.1</a>                                  conditional operator (? :), <a href="#6.5.15">6.5.15</a>
+ clgamma function, <a href="#7.26.1">7.26.1</a>                                      conformance, <a href="#4">4</a>
+ clock function, <a href="#7.23.2.1">7.23.2.1</a>                                      conj functions, <a href="#7.3.9.3">7.3.9.3</a>, <a href="#G.6">G.6</a>
+ clock_t type, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.1">7.23.2.1</a>                                conj type-generic macro, <a href="#7.22">7.22</a>
+ CLOCKS_PER_SEC macro, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.1">7.23.2.1</a>                        const type qualifier, <a href="#6.7.3">6.7.3</a>
+ clog functions, <a href="#7.3.7.2">7.3.7.2</a>, <a href="#G.6.3.2">G.6.3.2</a>                              const-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.7.3">6.7.3</a>
+    type-generic macro for, <a href="#7.22">7.22</a>                               constant expression, <a href="#6.6">6.6</a>, <a href="#F.7.4">F.7.4</a>
+ clog10 function, <a href="#7.26.1">7.26.1</a>                                       constants, <a href="#6.4.4">6.4.4</a>
+ clog1p function, <a href="#7.26.1">7.26.1</a>                                         as primary expression, <a href="#6.5.1">6.5.1</a>
+ clog2 function, <a href="#7.26.1">7.26.1</a>                                          character, <a href="#6.4.4.4">6.4.4.4</a>
+ collating sequences, <a href="#5.2.1">5.2.1</a>                                      enumeration, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+ colon punctuator (:), <a href="#6.7.2.1">6.7.2.1</a>                                   floating, <a href="#6.4.4.2">6.4.4.2</a>
+ comma operator (,), <a href="#6.5.17">6.5.17</a>                                      hexadecimal, <a href="#6.4.4.1">6.4.4.1</a>
+ comma punctuator (,), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,             integer, <a href="#6.4.4.1">6.4.4.1</a>
+       <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>                                            octal, <a href="#6.4.4.1">6.4.4.1</a>
+ command processor, <a href="#7.20.4.6">7.20.4.6</a>                                   constraint, <a href="#3.8">3.8</a>, <a href="#4">4</a>
+ comment delimiters (/* */ and //), <a href="#6.4.9">6.4.9</a>                      content of structure/union/enumeration, <a href="#6.7.2.3">6.7.2.3</a>
+ comments, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.4.9">6.4.9</a>                                 contiguity of allocated storage, <a href="#7.20.3">7.20.3</a>
+ common extensions, <a href="#J.5">J.5</a>                                        continue statement, <a href="#6.8.6.2">6.8.6.2</a>
+ common initial sequence, <a href="#6.5.2.3">6.5.2.3</a>                              contracted expression, <a href="#6.5">6.5</a>, <a href="#7.12.2">7.12.2</a>, <a href="#F.6">F.6</a>
+ common real type, <a href="#6.3.1.8">6.3.1.8</a>                                     control character, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
+ common warnings, <a href="#I">I</a>                                            control wide character, <a href="#7.25.2">7.25.2</a>
+ comparison functions, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.1">7.20.5.1</a>, <a href="#7.20.5.2">7.20.5.2</a>              conversion, <a href="#6.3">6.3</a>
+    string, <a href="#7.21.4">7.21.4</a>                                               arithmetic operands, <a href="#6.3.1">6.3.1</a>
+    wide string, <a href="#7.24.4.4">7.24.4.4</a>                                        array argument, <a href="#6.9.1">6.9.1</a>                           *
+ comparison macros, <a href="#7.12.14">7.12.14</a>                                      array parameter, <a href="#6.9.1">6.9.1</a>
+ comparison, pointer, <a href="#6.5.8">6.5.8</a>                                      arrays, <a href="#6.3.2.1">6.3.2.1</a>
+ compatible type, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.5">6.7.5</a>                     boolean, <a href="#6.3.1.2">6.3.1.2</a>
+ compl macro, <a href="#7.9">7.9</a>                                                boolean, characters, and integers, <a href="#6.3.1.1">6.3.1.1</a>
+ complement operator (~), <a href="#6.5.3.3">6.5.3.3</a>                                by assignment, <a href="#6.5.16.1">6.5.16.1</a>
+ complex macro, <a href="#7.3.1">7.3.1</a>                                            by return statement, <a href="#6.8.6.4">6.8.6.4</a>
+ complex numbers, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>                                       complex types, <a href="#6.3.1.6">6.3.1.6</a>
+ complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>                       explicit, <a href="#6.3">6.3</a>
+ complex type domain, <a href="#6.2.5">6.2.5</a>                                      function, <a href="#6.3.2.1">6.3.2.1</a>
+ complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#G">G</a>                                  function argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+<!--page 536 indent 0-->
+   function designators, <a href="#6.3.2.1">6.3.2.1</a>                                type-generic macro for, <a href="#7.22">7.22</a>
+   function parameter, <a href="#6.9.1">6.9.1</a>                                  csinh functions, <a href="#7.3.6.5">7.3.6.5</a>, <a href="#G.6.2.5">G.6.2.5</a>
+   imaginary, <a href="#G.4.1">G.4.1</a>                                             type-generic macro for, <a href="#7.22">7.22</a>
+   imaginary and complex, <a href="#G.4.3">G.4.3</a>                               csqrt functions, <a href="#7.3.8.3">7.3.8.3</a>, <a href="#G.6.4.2">G.6.4.2</a>
+   implicit, <a href="#6.3">6.3</a>                                                type-generic macro for, <a href="#7.22">7.22</a>
+   lvalues, <a href="#6.3.2.1">6.3.2.1</a>                                           ctan functions, <a href="#7.3.5.6">7.3.5.6</a>, <a href="#G.6">G.6</a>
+   pointer, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                                    type-generic macro for, <a href="#7.22">7.22</a>
+   real and complex, <a href="#6.3.1.7">6.3.1.7</a>                                  ctanh functions, <a href="#7.3.6.6">7.3.6.6</a>, <a href="#G.6.2.6">G.6.2.6</a>
+   real and imaginary, <a href="#G.4.2">G.4.2</a>                                    type-generic macro for, <a href="#7.22">7.22</a>
+   real floating and integer, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                ctgamma function, <a href="#7.26.1">7.26.1</a>
+   real floating types, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#F.3">F.3</a>                           ctime function, <a href="#7.23.3.2">7.23.3.2</a>
+   signed and unsigned integers, <a href="#6.3.1.3">6.3.1.3</a>                      ctype.h header, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
+   usual arithmetic, see usual arithmetic                     current object, <a href="#6.7.8">6.7.8</a>
+         conversions                                          CX_LIMITED_RANGE pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.3.4">7.3.4</a>
+   void type, <a href="#6.3.2.2">6.3.2.2</a>
+ conversion functions                                         data stream, see streams
+   multibyte/wide character, <a href="#7.20.7">7.20.7</a>                           date and time header, <a href="#7.23">7.23</a>
+      extended, <a href="#7.24.6">7.24.6</a>                                        Daylight Saving Time, <a href="#7.23.1">7.23.1</a>
+      restartable, <a href="#7.24.6.3">7.24.6.3</a>                                   DBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   multibyte/wide string, <a href="#7.20.8">7.20.8</a>                              DBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      restartable, <a href="#7.24.6.4">7.24.6.4</a>                                   DBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   numeric, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>                                   DBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1">7.24.4.1</a>                          DBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   single byte/wide character, <a href="#7.24.6.1">7.24.6.1</a>                       DBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   time, <a href="#7.23.3">7.23.3</a>                                               DBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      wide character, <a href="#7.24.5">7.24.5</a>                                  DBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ conversion specifier, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>,           DBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.24.2.2">7.24.2.2</a>                                                decimal constant, <a href="#6.4.4.1">6.4.4.1</a>
+ conversion state, <a href="#7.20.7">7.20.7</a>, <a href="#7.24.6">7.24.6</a>, <a href="#7.24.6.2.1">7.24.6.2.1</a>,                decimal digit, <a href="#5.2.1">5.2.1</a>
+      <a href="#7.24.6.3">7.24.6.3</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4">7.24.6.4</a>,             decimal-point character, <a href="#7.1.1">7.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+      <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                  DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+ conversion state functions, <a href="#7.24.6.2">7.24.6.2</a>                              <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.5">F.5</a>
+ copying functions                                            declaration specifiers, <a href="#6.7">6.7</a>
+   string, <a href="#7.21.2">7.21.2</a>                                             declarations, <a href="#6.7">6.7</a>
+   wide string, <a href="#7.24.4.2">7.24.4.2</a>                                        function, <a href="#6.7.5.3">6.7.5.3</a>
+ copysign functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#7.12.11.1">7.12.11.1</a>, <a href="#F.3">F.3</a>,                   pointer, <a href="#6.7.5.1">6.7.5.1</a>
+      <a href="#F.9.8.1">F.9.8.1</a>                                                   structure/union, <a href="#6.7.2.1">6.7.2.1</a>
+ copysign type-generic macro, <a href="#7.22">7.22</a>                              typedef, <a href="#6.7.7">6.7.7</a>
+ correctly rounded result, <a href="#3.9">3.9</a>                                declarator, <a href="#6.7.5">6.7.5</a>
+ corresponding real type, <a href="#6.2.5">6.2.5</a>                                 abstract, <a href="#6.7.6">6.7.6</a>
+ cos functions, <a href="#7.12.4.5">7.12.4.5</a>, <a href="#F.9.1.5">F.9.1.5</a>                             declarator type derivation, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.5">6.7.5</a>
+ cos type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            decrement operators, see arithmetic operators,
+ cosh functions, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#F.9.2.4">F.9.2.4</a>                                 increment and decrement
+ cosh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                           default argument promotions, <a href="#6.5.2.2">6.5.2.2</a>
+ cpow functions, <a href="#7.3.8.2">7.3.8.2</a>, <a href="#G.6.4.1">G.6.4.1</a>                             default initialization, <a href="#6.7.8">6.7.8</a>
+   type-generic macro for, <a href="#7.22">7.22</a>                               default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+ cproj functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                                define preprocessing directive, <a href="#6.10.3">6.10.3</a>
+ cproj type-generic macro, <a href="#7.22">7.22</a>                               defined operator, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.8">6.10.8</a>
+ creal functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                definition, <a href="#6.7">6.7</a>
+ creal type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            function, <a href="#6.9.1">6.9.1</a>
+ csin functions, <a href="#7.3.5.5">7.3.5.5</a>, <a href="#G.6">G.6</a>                                 derived declarator types, <a href="#6.2.5">6.2.5</a>
+<!--page 537 indent 0-->
+ derived types, <a href="#6.2.5">6.2.5</a>                                            end-of-file indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,
+ designated initializer, <a href="#6.7.8">6.7.8</a>                                         <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,
+ destringizing, <a href="#6.10.9">6.10.9</a>                                                 <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.10.1">7.19.10.1</a>, <a href="#7.19.10.2">7.19.10.2</a>, <a href="#7.24.3.1">7.24.3.1</a>,
+ device input/output, <a href="#5.1.2.3">5.1.2.3</a>                                          <a href="#7.24.3.10">7.24.3.10</a>
+ diagnostic message, <a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>                               end-of-file macro, see EOF macro
+ diagnostics, <a href="#5.1.1.3">5.1.1.3</a>                                            end-of-line indicator, <a href="#5.2.1">5.2.1</a>
+ diagnostics header, <a href="#7.2">7.2</a>                                         endif preprocessing directive, <a href="#6.10.1">6.10.1</a>
+ difftime function, <a href="#7.23.2.2">7.23.2.2</a>                                     enum type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.2">6.7.2.2</a>
+ digit, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                               enumerated type, <a href="#6.2.5">6.2.5</a>
+ digraphs, <a href="#6.4.6">6.4.6</a>                                                 enumeration, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.2">6.7.2.2</a>
+ direct input/output functions, <a href="#7.19.8">7.19.8</a>                           enumeration constant, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+ display device, <a href="#5.2.2">5.2.2</a>                                           enumeration content, <a href="#6.7.2.3">6.7.2.3</a>
+ div function, <a href="#7.20.6.2">7.20.6.2</a>                                          enumeration members, <a href="#6.7.2.2">6.7.2.2</a>
+ div_t type, <a href="#7.20">7.20</a>                                                enumeration specifiers, <a href="#6.7.2.2">6.7.2.2</a>
+ division assignment operator (/=), <a href="#6.5.16.2">6.5.16.2</a>                     enumeration tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+ division operator (/), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>                        enumerator, <a href="#6.7.2.2">6.7.2.2</a>
+ do statement, <a href="#6.8.5.2">6.8.5.2</a>                                           environment, <a href="#5">5</a>
+ documentation of implementation, <a href="#4">4</a>                              environment functions, <a href="#7.20.4">7.20.4</a>
+ domain error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#7.12.4.4">7.12.4.4</a>,             environment list, <a href="#7.20.4.5">7.20.4.5</a>
+       <a href="#7.12.5.1">7.12.5.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.7">7.12.6.7</a>,                   environmental considerations, <a href="#5.2">5.2</a>
+       <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>,                 environmental limits, <a href="#5.2.4">5.2.4</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.19.2">7.19.2</a>,
+       <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>,                         <a href="#7.19.3">7.19.3</a>, <a href="#7.19.4.4">7.19.4.4</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.20.2.1">7.20.2.1</a>, <a href="#7.20.4.2">7.20.4.2</a>,
+       <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>                       <a href="#7.24.2.1">7.24.2.1</a>
+ dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                       EOF macro, <a href="#7.4">7.4</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.1">7.19.5.1</a>, <a href="#7.19.5.2">7.19.5.2</a>,
+ double _Complex type, <a href="#6.2.5">6.2.5</a>                                           <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.11">7.19.6.11</a>,
+ double _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                             <a href="#7.19.6.14">7.19.6.14</a>, <a href="#7.19.7.1">7.19.7.1</a>, <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.4">7.19.7.4</a>,
+       <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                                <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.7.10">7.19.7.10</a>,
+ double _Imaginary type, <a href="#G.2">G.2</a>                                           <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.2.4">7.24.2.4</a>,
+ double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.2">7.19.6.2</a>,                         <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.2.12">7.24.2.12</a>,
+       <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.2">F.2</a>                                                   <a href="#7.24.3.4">7.24.3.4</a>, <a href="#7.24.6.1.1">7.24.6.1.1</a>, <a href="#7.24.6.1.2">7.24.6.1.2</a>
+ double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,              equal-sign punctuator (=), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.8">6.7.8</a>
+       <a href="#6.3.1.8">6.3.1.8</a>                                                   equal-to operator, see equality operator
+ double-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                            equality expressions, <a href="#6.5.9">6.5.9</a>
+ double-quote escape sequence (\"), <a href="#6.4.4.4">6.4.4.4</a>,                     equality operator (==), <a href="#6.5.9">6.5.9</a>
+       <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                             ERANGE macro, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.12.1">7.12.1</a>,
+ double_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                            <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, see
+                                                                       also range error
+ EDOM macro, <a href="#7.5">7.5</a>, <a href="#7.12.1">7.12.1</a>, see also domain error                  erf functions, <a href="#7.12.8.1">7.12.8.1</a>, <a href="#F.9.5.1">F.9.5.1</a>
+ effective type, <a href="#6.5">6.5</a>                                             erf type-generic macro, <a href="#7.22">7.22</a>
+ EILSEQ macro, <a href="#7.5">7.5</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>,                  erfc functions, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#F.9.5.2">F.9.5.2</a>
+       <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>,           erfc type-generic macro, <a href="#7.22">7.22</a>
+       see also encoding error                                   errno macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.3.2">7.3.2</a>, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>,
+ element type, <a href="#6.2.5">6.2.5</a>                                                   <a href="#7.12.1">7.12.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.10.4">7.19.10.4</a>,
+ elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                                  <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.24.3.1">7.24.3.1</a>,
+ ellipsis punctuator (...), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>                   <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>,
+ else preprocessing directive, <a href="#6.10.1">6.10.1</a>                                  <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>, <a href="#J.5.17">J.5.17</a>
+ else statement, <a href="#6.8.4.1">6.8.4.1</a>                                         errno.h header, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
+ empty statement, <a href="#6.8.3">6.8.3</a>                                          error
+ encoding error, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>,                        domain, see domain error
+       <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>               encoding, see encoding error
+ end-of-file, <a href="#7.24.1">7.24.1</a>                                                 range, see range error
+<!--page 538 indent 0-->
+ error conditions, <a href="#7.12.1">7.12.1</a>                                     extended characters, <a href="#5.2.1">5.2.1</a>
+ error functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.9.5">F.9.5</a>                               extended integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>,
+ error indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,                      <a href="#7.18">7.18</a>
+       <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.8">7.19.7.8</a>,                extended multibyte/wide character conversion
+       <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.10.1">7.19.10.1</a>, <a href="#7.19.10.3">7.19.10.3</a>,                   utilities, <a href="#7.24.6">7.24.6</a>
+       <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>                                     extensible wide character case mapping functions,
+ error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                          <a href="#7.25.3.2">7.25.3.2</a>
+ error-handling functions, <a href="#7.19.10">7.19.10</a>, <a href="#7.21.6.2">7.21.6.2</a>                  extensible wide character classification functions,
+ escape character (\), <a href="#6.4.4.4">6.4.4.4</a>                                     <a href="#7.25.2.2">7.25.2.2</a>
+ escape sequences, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.11.4">6.11.4</a>              extern storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.7.1">6.7.1</a>
+ evaluation format, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#7.12">7.12</a>                  external definition, <a href="#6.9">6.9</a>
+ evaluation method, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#F.7.5">F.7.5</a>                     external identifiers, underscore, <a href="#7.1.3">7.1.3</a>
+ evaluation order, <a href="#6.5">6.5</a>                                        external linkage, <a href="#6.2.2">6.2.2</a>
+ exceptional condition, <a href="#6.5">6.5</a>, <a href="#7.12.1">7.12.1</a>                           external name, <a href="#6.4.2.1">6.4.2.1</a>
+ excess precision, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>,               external object definitions, <a href="#6.9.2">6.9.2</a>
+       <a href="#6.8.6.4">6.8.6.4</a>
+ excess range, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>           fabs functions, <a href="#7.12.7.2">7.12.7.2</a>, <a href="#F.9.4.2">F.9.4.2</a>
+ exclusive OR operators                                       fabs type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+    bitwise (^), <a href="#6.5.11">6.5.11</a>                                       false macro, <a href="#7.16">7.16</a>
+    bitwise assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                         fclose function, <a href="#7.19.5.1">7.19.5.1</a>
+ executable program, <a href="#5.1.1.1">5.1.1.1</a>                                  fdim functions, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#F.9.9.1">F.9.9.1</a>
+ execution character set, <a href="#5.2.1">5.2.1</a>                               fdim type-generic macro, <a href="#7.22">7.22</a>
+ execution environment, <a href="#5">5</a>, <a href="#5.1.2">5.1.2</a>, see also                    FE_ALL_EXCEPT macro, <a href="#7.6">7.6</a>
+       environmental limits                                   FE_DFL_ENV macro, <a href="#7.6">7.6</a>
+ execution sequence, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.8">6.8</a>                             FE_DIVBYZERO macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ exit function, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>,            FE_DOWNWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+       <a href="#7.20.4.4">7.20.4.4</a>                                               FE_INEXACT macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+ EXIT_FAILURE macro, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>                           FE_INVALID macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ EXIT_SUCCESS macro, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>                           FE_OVERFLOW macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ exp functions, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#F.9.3.1">F.9.3.1</a>                             FE_TONEAREST macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+ exp type-generic macro, <a href="#7.22">7.22</a>                                 FE_TOWARDZERO macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+ exp2 functions, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#F.9.3.2">F.9.3.2</a>                            FE_UNDERFLOW macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+ exp2 type-generic macro, <a href="#7.22">7.22</a>                                FE_UPWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+ explicit conversion, <a href="#6.3">6.3</a>                                     feclearexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.1">7.6.2.1</a>, <a href="#F.3">F.3</a>
+ expm1 functions, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#F.9.3.3">F.9.3.3</a>                           fegetenv function, <a href="#7.6.4.1">7.6.4.1</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
+ expm1 type-generic macro, <a href="#7.22">7.22</a>                               fegetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.2">7.6.2.2</a>, <a href="#F.3">F.3</a>
+ exponent part, <a href="#6.4.4.2">6.4.4.2</a>                                       fegetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.1">7.6.3.1</a>, <a href="#F.3">F.3</a>
+ exponential functions                                        feholdexcept function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.3">7.6.4.3</a>,
+    complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>                                        <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
+    real, <a href="#7.12.6">7.12.6</a>, <a href="#F.9.3">F.9.3</a>                                       fenv.h header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>
+ expression, <a href="#6.5">6.5</a>                                              FENV_ACCESS pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#F.7">F.7</a>, <a href="#F.8">F.8</a>,
+    assignment, <a href="#6.5.16">6.5.16</a>                                           <a href="#F.9">F.9</a>
+    cast, <a href="#6.5.4">6.5.4</a>                                               fenv_t type, <a href="#7.6">7.6</a>
+    constant, <a href="#6.6">6.6</a>                                             feof function, <a href="#7.19.10.2">7.19.10.2</a>
+    full, <a href="#6.8">6.8</a>                                                 feraiseexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.3">7.6.2.3</a>, <a href="#F.3">F.3</a>
+    order of evaluation, <a href="#6.5">6.5</a>                                  ferror function, <a href="#7.19.10.3">7.19.10.3</a>
+    parenthesized, <a href="#6.5.1">6.5.1</a>                                      fesetenv function, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#F.3">F.3</a>
+    primary, <a href="#6.5.1">6.5.1</a>                                            fesetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.4">7.6.2.4</a>, <a href="#F.3">F.3</a>
+    unary, <a href="#6.5.3">6.5.3</a>                                              fesetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.2">7.6.3.2</a>, <a href="#F.3">F.3</a>
+ expression statement, <a href="#6.8.3">6.8.3</a>                                  fetestexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.5">7.6.2.5</a>, <a href="#F.3">F.3</a>
+ extended character set, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.1.2">5.2.1.2</a>                feupdateenv function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
+<!--page 539 indent 0-->
+ fexcept_t type, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                      floating-point status flag, <a href="#7.6">7.6</a>, <a href="#F.7.6">F.7.6</a>
+ fflush function, <a href="#7.19.5.2">7.19.5.2</a>, <a href="#7.19.5.3">7.19.5.3</a>                           floor functions, <a href="#7.12.9.2">7.12.9.2</a>, <a href="#F.9.6.2">F.9.6.2</a>
+ fgetc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,                     floor type-generic macro, <a href="#7.22">7.22</a>
+      <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.8.1">7.19.8.1</a>                                       FLT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ fgetpos function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>                  FLT_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ fgets function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.2">7.19.7.2</a>                              FLT_EVAL_METHOD macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.8.6.4">6.8.6.4</a>,
+ fgetwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>,                         <a href="#7.12">7.12</a>
+      <a href="#7.24.3.6">7.24.3.6</a>                                                 FLT_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ fgetws function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.2">7.24.3.2</a>                             FLT_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ field width, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>                                FLT_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ file, <a href="#7.19.3">7.19.3</a>                                                   FLT_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   access functions, <a href="#7.19.5">7.19.5</a>                                    FLT_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   name, <a href="#7.19.3">7.19.3</a>                                                FLT_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   operations, <a href="#7.19.4">7.19.4</a>                                          FLT_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   position indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>,                 FLT_RADIX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+         <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>, <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                   <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>
+         <a href="#7.19.8.1">7.19.8.1</a>, <a href="#7.19.8.2">7.19.8.2</a>, <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.2">7.19.9.2</a>,               FLT_ROUNDS macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+         <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.9.4">7.19.9.4</a>, <a href="#7.19.9.5">7.19.9.5</a>, <a href="#7.24.3.1">7.24.3.1</a>,               fma functions, <a href="#7.12">7.12</a>, <a href="#7.12.13.1">7.12.13.1</a>, <a href="#F.9.10.1">F.9.10.1</a>
+         <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.3.10">7.24.3.10</a>                                   fma type-generic macro, <a href="#7.22">7.22</a>
+   positioning functions, <a href="#7.19.9">7.19.9</a>                               fmax functions, <a href="#7.12.12.2">7.12.12.2</a>, <a href="#F.9.9.2">F.9.9.2</a>
+ file scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.9">6.9</a>                                         fmax type-generic macro, <a href="#7.22">7.22</a>
+ FILE type, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                                     fmin functions, <a href="#7.12.12.3">7.12.12.3</a>, <a href="#F.9.9.3">F.9.9.3</a>
+ FILENAME_MAX macro, <a href="#7.19.1">7.19.1</a>                                    fmin type-generic macro, <a href="#7.22">7.22</a>
+ flags, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>                                      fmod functions, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#F.9.7.1">F.9.7.1</a>
+   floating-point status, see floating-point status              fmod type-generic macro, <a href="#7.22">7.22</a>
+         flag                                                   fopen function, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.5.4">7.19.5.4</a>
+ flexible array member, <a href="#6.7.2.1">6.7.2.1</a>                                 FOPEN_MAX macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.4.3">7.19.4.3</a>
+ float _Complex type, <a href="#6.2.5">6.2.5</a>                                    for statement, <a href="#6.8.5">6.8.5</a>, <a href="#6.8.5.3">6.8.5.3</a>
+ float _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                      form-feed character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                         form-feed escape sequence (\f), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+ float _Imaginary type, <a href="#G.2">G.2</a>                                         <a href="#7.4.1.10">7.4.1.10</a>
+ float type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.2">F.2</a>                        formal argument (deprecated), <a href="#3.15">3.15</a>
+ float type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,             formal parameter, <a href="#3.15">3.15</a>
+      <a href="#6.3.1.8">6.3.1.8</a>                                                  formatted input/output functions, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.19.6">7.19.6</a>
+ float.h header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,                     wide character, <a href="#7.24.2">7.24.2</a>
+      <a href="#7.24.4.1.1">7.24.4.1.1</a>                                               fortran keyword, <a href="#J.5.9">J.5.9</a>
+ float_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                     forward reference, <a href="#3.11">3.11</a>
+ floating constant, <a href="#6.4.4.2">6.4.4.2</a>                                     FP_CONTRACT pragma, <a href="#6.5">6.5</a>, <a href="#6.10.6">6.10.6</a>, <a href="#7.12.2">7.12.2</a>, see
+ floating suffix, f or <a href="#F">F</a>, <a href="#6.4.4.2">6.4.4.2</a>                                     also contracted expression
+ floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,           FP_FAST_FMA macro, <a href="#7.12">7.12</a>
+      <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                                 FP_FAST_FMAF macro, <a href="#7.12">7.12</a>
+ floating types, <a href="#6.2.5">6.2.5</a>, <a href="#6.11.1">6.11.1</a>                                  FP_FAST_FMAL macro, <a href="#7.12">7.12</a>
+ floating-point accuracy, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.5">6.5</a>,              FP_ILOGB0 macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
+      <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.5">F.5</a>, see also contracted expression            FP_ILOGBNAN macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
+ floating-point arithmetic functions, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                 FP_INFINITE macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ floating-point classification functions, <a href="#7.12.3">7.12.3</a>                 FP_NAN macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ floating-point control mode, <a href="#7.6">7.6</a>, <a href="#F.7.6">F.7.6</a>                        FP_NORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ floating-point environment, <a href="#7.6">7.6</a>, <a href="#F.7">F.7</a>, <a href="#F.7.6">F.7.6</a>                    FP_SUBNORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ floating-point exception, <a href="#7.6">7.6</a>, <a href="#7.6.2">7.6.2</a>, <a href="#F.9">F.9</a>                      FP_ZERO macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ floating-point number, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.2.5">6.2.5</a>                        fpclassify macro, <a href="#7.12.3.1">7.12.3.1</a>, <a href="#F.3">F.3</a>
+ floating-point rounding mode, <a href="#5.2.4.2.2">5.2.4.2.2</a>                        fpos_t type, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>
+<!--page 540 indent 0-->
+ fprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.1">7.19.6.1</a>,                       language, <a href="#6.11">6.11</a>
+       <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.5">7.19.6.5</a>, <a href="#7.19.6.6">7.19.6.6</a>,                    library, <a href="#7.26">7.26</a>
+       <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.3">F.3</a>                                  fwide function, <a href="#7.19.2">7.19.2</a>, <a href="#7.24.3.5">7.24.3.5</a>
+ fputc function, <a href="#5.2.2">5.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.7.3">7.19.7.3</a>,               fwprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,
+       <a href="#7.19.7.8">7.19.7.8</a>, <a href="#7.19.8.2">7.19.8.2</a>                                            <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.2.3">7.24.2.3</a>, <a href="#7.24.2.5">7.24.2.5</a>,
+ fputs function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.4">7.19.7.4</a>                                    <a href="#7.24.2.11">7.24.2.11</a>
+ fputwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.3">7.24.3.3</a>,                     fwrite function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.8.2">7.19.8.2</a>
+       <a href="#7.24.3.8">7.24.3.8</a>                                                 fwscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.2">7.24.2.2</a>,
+ fputws function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.4">7.24.3.4</a>                                   <a href="#7.24.2.4">7.24.2.4</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.12">7.24.2.12</a>, <a href="#7.24.3.10">7.24.3.10</a>
+ fread function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.8.1">7.19.8.1</a>
+ free function, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>                              gamma functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.9.5">F.9.5</a>
+ freestanding execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>,                  general utilities, <a href="#7.20">7.20</a>
+       <a href="#5.1.2.1">5.1.2.1</a>                                                    wide string, <a href="#7.24.4">7.24.4</a>
+ freopen function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.4">7.19.5.4</a>                             general wide string utilities, <a href="#7.24.4">7.24.4</a>
+ frexp functions, <a href="#7.12.6.4">7.12.6.4</a>, <a href="#F.9.3.4">F.9.3.4</a>                             generic parameters, <a href="#7.22">7.22</a>
+ frexp type-generic macro, <a href="#7.22">7.22</a>                                 getc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>
+ fscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                      getchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.6">7.19.7.6</a>
+       <a href="#7.19.6.4">7.19.6.4</a>, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#F.3">F.3</a>                        getenv function, <a href="#7.20.4.5">7.20.4.5</a>
+ fseek function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                   gets function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.26.9">7.26.9</a>
+       <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>, <a href="#7.19.9.5">7.19.9.5</a>, <a href="#7.24.3.10">7.24.3.10</a>                  getwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.6">7.24.3.6</a>, <a href="#7.24.3.7">7.24.3.7</a>
+ fsetpos function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                 getwchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.7">7.24.3.7</a>
+       <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.24.3.10">7.24.3.10</a>                            gmtime function, <a href="#7.23.3.3">7.23.3.3</a>
+ ftell function, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>                             goto statement, <a href="#6.2.1">6.2.1</a>, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.6.1">6.8.6.1</a>
+ full declarator, <a href="#6.7.5">6.7.5</a>                                         graphic characters, <a href="#5.2.1">5.2.1</a>
+ full expression, <a href="#6.8">6.8</a>                                           greater-than operator (&gt;), <a href="#6.5.8">6.5.8</a>
+ fully buffered stream, <a href="#7.19.3">7.19.3</a>                                  greater-than-or-equal-to operator (&gt;=), <a href="#6.5.8">6.5.8</a>
+ function
+    argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>                                    header, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.2">7.1.2</a>, see also standard headers
+    body, <a href="#6.9.1">6.9.1</a>                                                 header names, <a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>, <a href="#6.10.2">6.10.2</a>
+    call, <a href="#6.5.2.2">6.5.2.2</a>                                               hexadecimal constant, <a href="#6.4.4.1">6.4.4.1</a>
+       library, <a href="#7.1.4">7.1.4</a>                                           hexadecimal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+    declarator, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.11.6">6.11.6</a>                                 hexadecimal prefix, <a href="#6.4.4.1">6.4.4.1</a>
+    definition, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.7">6.11.7</a>                           hexadecimal-character escape sequence
+    designator, <a href="#6.3.2.1">6.3.2.1</a>                                              (\x hexadecimal digits), <a href="#6.4.4.4">6.4.4.4</a>
+    image, <a href="#5.2.3">5.2.3</a>                                                high-order bit, <a href="#3.6">3.6</a>
+    library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.4">7.1.4</a>                                     horizontal-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+    name length, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                       horizontal-tab escape sequence (\r), <a href="#7.25.2.1.3">7.25.2.1.3</a>
+    parameter, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>                   horizontal-tab escape sequence (\t), <a href="#5.2.2">5.2.2</a>,
+    prototype, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.7">6.2.7</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>,                <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>
+          <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.6">6.11.6</a>, <a href="#6.11.7">6.11.7</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.12">7.12</a>           hosted execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.2">5.1.2.2</a>
+    prototype scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.7.5.2">6.7.5.2</a>                             HUGE_VAL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+    recursive call, <a href="#6.5.2.2">6.5.2.2</a>                                          <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
+    return, <a href="#6.8.6.4">6.8.6.4</a>                                             HUGE_VALF macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+    scope, <a href="#6.2.1">6.2.1</a>                                                     <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
+    type, <a href="#6.2.5">6.2.5</a>                                                 HUGE_VALL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+    type conversion, <a href="#6.3.2.1">6.3.2.1</a>                                         <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
+ function specifiers, <a href="#6.7.4">6.7.4</a>                                      hyperbolic functions
+ function type, <a href="#6.2.5">6.2.5</a>                                             complex, <a href="#7.3.6">7.3.6</a>, <a href="#G.6.2">G.6.2</a>
+ function-call operator (( )), <a href="#6.5.2.2">6.5.2.2</a>                            real, <a href="#7.12.5">7.12.5</a>, <a href="#F.9.2">F.9.2</a>
+ function-like macro, <a href="#6.10.3">6.10.3</a>                                    hypot functions, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#F.9.4.3">F.9.4.3</a>
+ future directions                                              hypot type-generic macro, <a href="#7.22">7.22</a>
+<!--page 541 indent 0-->
+ <a href="#I">I</a> macro, <a href="#7.3.1">7.3.1</a>, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                                    initial position, <a href="#5.2.2">5.2.2</a>
+ identifier, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.5.1">6.5.1</a>                                       initial shift state, <a href="#5.2.1.2">5.2.1.2</a>
+    linkage, see linkage                                         initialization, <a href="#5.1.2">5.1.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.5">6.5.2.5</a>, <a href="#6.7.8">6.7.8</a>,
+   maximum length, <a href="#6.4.2.1">6.4.2.1</a>                                             <a href="#F.7.5">F.7.5</a>
+    name spaces, <a href="#6.2.3">6.2.3</a>                                              in blocks, <a href="#6.8">6.8</a>
+    reserved, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>                                       initializer, <a href="#6.7.8">6.7.8</a>
+   scope, <a href="#6.2.1">6.2.1</a>                                                     permitted form, <a href="#6.6">6.6</a>
+    type, <a href="#6.2.5">6.2.5</a>                                                     string literal, <a href="#6.3.2.1">6.3.2.1</a>
+ identifier list, <a href="#6.7.5">6.7.5</a>                                           inline, <a href="#6.7.4">6.7.4</a>
+ identifier nondigit, <a href="#6.4.2.1">6.4.2.1</a>                                     inner scope, <a href="#6.2.1">6.2.1</a>
+ IEC 559, <a href="#F.1">F.1</a>                                                    input failure, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>
+ IEC 60559, <a href="#2">2</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8">6.10.8</a>, <a href="#7.3.3">7.3.3</a>, <a href="#7.6">7.6</a>,           input/output functions
+       <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.14">7.12.14</a>, <a href="#F">F</a>, <a href="#G">G</a>, <a href="#H.1">H.1</a>               character, <a href="#7.19.7">7.19.7</a>
+ IEEE 754, <a href="#F.1">F.1</a>                                                      direct, <a href="#7.19.8">7.19.8</a>
+ IEEE 854, <a href="#F.1">F.1</a>                                                      formatted, <a href="#7.19.6">7.19.6</a>
+ IEEE floating-point arithmetic standard, see                           wide character, <a href="#7.24.2">7.24.2</a>
+       IEC 60559, ANSI/IEEE 754,                                    wide character, <a href="#7.24.3">7.24.3</a>
+       ANSI/IEEE 854                                                   formatted, <a href="#7.24.2">7.24.2</a>
+ if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,               input/output header, <a href="#7.19">7.19</a>
+       <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             input/output, device, <a href="#5.1.2.3">5.1.2.3</a>
+ if statement, <a href="#6.8.4.1">6.8.4.1</a>                                           int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.7.2">6.7.2</a>
+ ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                           int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+ ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                                <a href="#6.3.1.8">6.3.1.8</a>
+ ilogb functions, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.9.3.5">F.9.3.5</a>                        INT_FASTN_MAX macros, <a href="#7.18.2.3">7.18.2.3</a>
+ ilogb type-generic macro, <a href="#7.22">7.22</a>                                  INT_FASTN_MIN macros, <a href="#7.18.2.3">7.18.2.3</a>
+ imaginary macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>                                     int_fastN_t types, <a href="#7.18.1.3">7.18.1.3</a>
+ imaginary numbers, <a href="#G">G</a>                                            INT_LEASTN_MAX macros, <a href="#7.18.2.2">7.18.2.2</a>
+ imaginary type domain, <a href="#G.2">G.2</a>                                      INT_LEASTN_MIN macros, <a href="#7.18.2.2">7.18.2.2</a>
+ imaginary types, <a href="#G">G</a>                                              int_leastN_t types, <a href="#7.18.1.2">7.18.1.2</a>
+ imaxabs function, <a href="#7.8.2.1">7.8.2.1</a>                                       INT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
+ imaxdiv function, <a href="#7.8">7.8</a>, <a href="#7.8.2.2">7.8.2.2</a>                                  INT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>
+ imaxdiv_t type, <a href="#7.8">7.8</a>                                             integer arithmetic functions, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>,
+ implementation, <a href="#3.12">3.12</a>                                                  <a href="#7.20.6">7.20.6</a>
+ implementation limit, <a href="#3.13">3.13</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.4.2.1">6.4.2.1</a>,                integer character constant, <a href="#6.4.4.4">6.4.4.4</a>
+       <a href="#6.7.5">6.7.5</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#E">E</a>, see also environmental                 integer constant, <a href="#6.4.4.1">6.4.4.1</a>
+       limits                                                    integer constant expression, <a href="#6.6">6.6</a>
+ implementation-defined behavior, <a href="#3.4.1">3.4.1</a>, <a href="#4">4</a>, <a href="#J.3">J.3</a>                   integer conversion rank, <a href="#6.3.1.1">6.3.1.1</a>
+ implementation-defined value, <a href="#3.17.1">3.17.1</a>                             integer promotions, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.3.1.1">6.3.1.1</a>,
+ implicit conversion, <a href="#6.3">6.3</a>                                              <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.7">6.5.7</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>,
+ implicit initialization, <a href="#6.7.8">6.7.8</a>                                        <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>
+ include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.2">6.10.2</a>                integer suffix, <a href="#6.4.4.1">6.4.4.1</a>
+ inclusive OR operators                                          integer type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+    bitwise (|), <a href="#6.5.12">6.5.12</a>                                                <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
+    bitwise assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>                            integer types, <a href="#6.2.5">6.2.5</a>, <a href="#7.18">7.18</a>
+ incomplete type, <a href="#6.2.5">6.2.5</a>                                             extended, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#7.18">7.18</a>
+ increment operators, see arithmetic operators,                  interactive device, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.3">7.19.5.3</a>
+       increment and decrement                                   internal linkage, <a href="#6.2.2">6.2.2</a>
+ indeterminate value, <a href="#3.17.2">3.17.2</a>                                     internal name, <a href="#6.4.2.1">6.4.2.1</a>
+ indirection operator (*), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                      interrupt, <a href="#5.2.3">5.2.3</a>
+ inequality operator (!=), <a href="#6.5.9">6.5.9</a>                                 INTMAX_C macro, <a href="#7.18.4.2">7.18.4.2</a>
+ INFINITY macro, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                            INTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>
+<!--page 542 indent 0-->
+ INTMAX_MIN macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>            iswalpha function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
+ intmax_t type, <a href="#7.18.1.5">7.18.1.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                  <a href="#7.25.2.2.1">7.25.2.2.1</a>
+     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  iswblank function, <a href="#7.25.2.1.3">7.25.2.1.3</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+ INTN_C macros, <a href="#7.18.4.1">7.18.4.1</a>                                 iswcntrl function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.4">7.25.2.1.4</a>,
+ INTN_MAX macros, <a href="#7.18.2.1">7.18.2.1</a>                                     <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+ INTN_MIN macros, <a href="#7.18.2.1">7.18.2.1</a>                               iswctype function, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
+ intN_t types, <a href="#7.18.1.1">7.18.1.1</a>                                  iswdigit function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
+ INTPTR_MAX macro, <a href="#7.18.2.4">7.18.2.4</a>                                    <a href="#7.25.2.1.5">7.25.2.1.5</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+ INTPTR_MIN macro, <a href="#7.18.2.4">7.18.2.4</a>                              iswgraph function, <a href="#7.25.2.1">7.25.2.1</a>, <a href="#7.25.2.1.6">7.25.2.1.6</a>,
+ intptr_t type, <a href="#7.18.1.4">7.18.1.4</a>                                       <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+ inttypes.h header, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>                          iswlower function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>,
+ isalnum function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>                  <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.1.2">7.25.3.1.2</a>
+ isalpha function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>                      iswprint function, <a href="#7.25.2.1.6">7.25.2.1.6</a>, <a href="#7.25.2.1.8">7.25.2.1.8</a>,
+ isblank function, <a href="#7.4.1.3">7.4.1.3</a>                                     <a href="#7.25.2.2.1">7.25.2.2.1</a>
+ iscntrl function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.4">7.4.1.4</a>, <a href="#7.4.1.7">7.4.1.7</a>,            iswpunct function, <a href="#7.25.2.1">7.25.2.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
+     <a href="#7.4.1.11">7.4.1.11</a>                                                  <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>,
+ isdigit function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.5">7.4.1.5</a>,                  <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+     <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.11.1.1">7.11.1.1</a>                         iswspace function, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,
+ isfinite macro, <a href="#7.12.3.2">7.12.3.2</a>, <a href="#F.3">F.3</a>                                 <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.6">7.25.2.1.6</a>,
+ isgraph function, <a href="#7.4.1.6">7.4.1.6</a>                                     <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>,
+ isgreater macro, <a href="#7.12.14.1">7.12.14.1</a>, <a href="#F.3">F.3</a>                               <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+ isgreaterequal macro, <a href="#7.12.14.2">7.12.14.2</a>, <a href="#F.3">F.3</a>                    iswupper function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>,
+ isinf macro, <a href="#7.12.3.3">7.12.3.3</a>                                         <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.1.2">7.25.3.1.2</a>
+ isless macro, <a href="#7.12.14.3">7.12.14.3</a>, <a href="#F.3">F.3</a>                            iswxdigit function, <a href="#7.25.2.1.12">7.25.2.1.12</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+ islessequal macro, <a href="#7.12.14.4">7.12.14.4</a>, <a href="#F.3">F.3</a>                       isxdigit function, <a href="#7.4.1.12">7.4.1.12</a>, <a href="#7.11.1.1">7.11.1.1</a>
+ islessgreater macro, <a href="#7.12.14.5">7.12.14.5</a>, <a href="#F.3">F.3</a>                     italic type convention, <a href="#3">3</a>, <a href="#6.1">6.1</a>
+ islower function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.2.1">7.4.2.1</a>,            iteration statements, <a href="#6.8.5">6.8.5</a>
+     <a href="#7.4.2.2">7.4.2.2</a>
+ isnan macro, <a href="#7.12.3.4">7.12.3.4</a>, <a href="#F.3">F.3</a>                              jmp_buf type, <a href="#7.13">7.13</a>
+ isnormal macro, <a href="#7.12.3.5">7.12.3.5</a>                                jump statements, <a href="#6.8.6">6.8.6</a>
+ ISO 31-11, <a href="#2">2</a>, <a href="#3">3</a>
+ ISO 4217, <a href="#2">2</a>, <a href="#7.11.2.1">7.11.2.1</a>                                   keywords, <a href="#6.4.1">6.4.1</a>, <a href="#G.2">G.2</a>, <a href="#J.5.9">J.5.9</a>, <a href="#J.5.10">J.5.10</a>
+ ISO 8601, <a href="#2">2</a>, <a href="#7.23.3.5">7.23.3.5</a>                                   known constant size, <a href="#6.2.5">6.2.5</a>
+ ISO/IEC 10646, <a href="#2">2</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.4.3">6.4.3</a>, <a href="#6.10.8">6.10.8</a>
+ ISO/IEC 10976-1, <a href="#H.1">H.1</a>                                    L_tmpnam macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.4">7.19.4.4</a>
+ ISO/IEC 2382-1, <a href="#2">2</a>, <a href="#3">3</a>                                    label name, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.3">6.2.3</a>
+ ISO/IEC 646, <a href="#2">2</a>, <a href="#5.2.1.1">5.2.1.1</a>                                 labeled statement, <a href="#6.8.1">6.8.1</a>
+ ISO/IEC 9945-2, <a href="#7.11">7.11</a>                                    labs function, <a href="#7.20.6.1">7.20.6.1</a>
+ ISO/IEC TR 10176, <a href="#D">D</a>                                     language, <a href="#6">6</a>
+ iso646.h header, <a href="#4">4</a>, <a href="#7.9">7.9</a>                                    future directions, <a href="#6.11">6.11</a>
+ isprint function, <a href="#5.2.2">5.2.2</a>, <a href="#7.4.1.8">7.4.1.8</a>                           syntax summary, <a href="#A">A</a>
+ ispunct function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,            Latin alphabet, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+     <a href="#7.4.1.11">7.4.1.11</a>                                            LC_ALL macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ isspace function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,            LC_COLLATE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.3">7.21.4.3</a>,
+     <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.3">7.20.1.3</a>,                   <a href="#7.24.4.4.2">7.24.4.4.2</a>
+     <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  LC_CTYPE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.20">7.20</a>, <a href="#7.20.7">7.20.7</a>,
+ isunordered macro, <a href="#7.12.14.6">7.12.14.6</a>, <a href="#F.3">F.3</a>                             <a href="#7.20.8">7.20.8</a>, <a href="#7.24.6">7.24.6</a>, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>,
+ isupper function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.4.2.1">7.4.2.1</a>,                 <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+     <a href="#7.4.2.2">7.4.2.2</a>                                             LC_MONETARY macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ iswalnum function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>,              LC_NUMERIC macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+     <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>                             LC_TIME macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.3.5">7.23.3.5</a>
+<!--page 543 indent 0-->
+ lconv structure type, <a href="#7.11">7.11</a>                                 llabs function, <a href="#7.20.6.1">7.20.6.1</a>
+ LDBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                  lldiv function, <a href="#7.20.6.2">7.20.6.2</a>
+ LDBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                              lldiv_t type, <a href="#7.20">7.20</a>
+ LDBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                             LLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,
+ LDBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                       <a href="#7.24.4.1.2">7.24.4.1.2</a>
+ LDBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                           LLONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,
+ LDBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                   <a href="#7.24.4.1.2">7.24.4.1.2</a>
+ LDBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                  llrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.5">F.9.6.5</a>
+ LDBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                           llrint type-generic macro, <a href="#7.22">7.22</a>
+ LDBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                              llround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.7">F.9.6.7</a>
+ ldexp functions, <a href="#7.12.6.6">7.12.6.6</a>, <a href="#F.9.3.6">F.9.3.6</a>                         llround type-generic macro, <a href="#7.22">7.22</a>
+ ldexp type-generic macro, <a href="#7.22">7.22</a>                             local time, <a href="#7.23.1">7.23.1</a>
+ ldiv function, <a href="#7.20.6.2">7.20.6.2</a>                                    locale, <a href="#3.4.2">3.4.2</a>
+ ldiv_t type, <a href="#7.20">7.20</a>                                          locale-specific behavior, <a href="#3.4.2">3.4.2</a>, <a href="#J.4">J.4</a>
+ leading underscore in identifiers, <a href="#7.1.3">7.1.3</a>                    locale.h header, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
+ left-shift assignment operator (&lt;&lt;=), <a href="#6.5.16.2">6.5.16.2</a>             localeconv function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ left-shift operator (&lt;&lt;), <a href="#6.5.7">6.5.7</a>                            localization, <a href="#7.11">7.11</a>
+ length                                                     localtime function, <a href="#7.23.3.4">7.23.3.4</a>
+    external name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                 log functions, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#F.9.3.7">F.9.3.7</a>
+    function name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                 log type-generic macro, <a href="#7.22">7.22</a>
+    identifier, <a href="#6.4.2.1">6.4.2.1</a>                                      log10 functions, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#F.9.3.8">F.9.3.8</a>
+    internal name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>                         log10 type-generic macro, <a href="#7.22">7.22</a>
+ length function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.24.4.6.1">7.24.4.6.1</a>,           log1p functions, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#F.9.3.9">F.9.3.9</a>
+       <a href="#7.24.6.3.1">7.24.6.3.1</a>                                           log1p type-generic macro, <a href="#7.22">7.22</a>
+ length modifier, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>,              log2 functions, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#F.9.3.10">F.9.3.10</a>
+       <a href="#7.24.2.2">7.24.2.2</a>                                             log2 type-generic macro, <a href="#7.22">7.22</a>
+ less-than operator (&lt;), <a href="#6.5.8">6.5.8</a>                              logarithmic functions
+ less-than-or-equal-to operator (&lt;=), <a href="#6.5.8">6.5.8</a>                   complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
+ letter, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                           real, <a href="#7.12.6">7.12.6</a>, <a href="#F.9.3">F.9.3</a>
+ lexical elements, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>                             logb functions, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.11">F.9.3.11</a>
+ lgamma functions, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#F.9.5.3">F.9.5.3</a>                        logb type-generic macro, <a href="#7.22">7.22</a>
+ lgamma type-generic macro, <a href="#7.22">7.22</a>                            logical operators
+ library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7">7</a>                                          AND (&amp;&amp;), <a href="#6.5.13">6.5.13</a>
+    future directions, <a href="#7.26">7.26</a>                                   negation (!), <a href="#6.5.3.3">6.5.3.3</a>
+    summary, <a href="#B">B</a>                                                OR (||), <a href="#6.5.14">6.5.14</a>
+    terms, <a href="#7.1.1">7.1.1</a>                                            logical source lines, <a href="#5.1.1.2">5.1.1.2</a>
+    use of functions, <a href="#7.1.4">7.1.4</a>                                 long double _Complex type, <a href="#6.2.5">6.2.5</a>
+ lifetime, <a href="#6.2.4">6.2.4</a>                                            long double _Complex type conversion,
+ limits                                                          <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+    environmental, see environmental limits                 long double _Imaginary type, <a href="#G.2">G.2</a>
+    implementation, see implementation limits               long double suffix, l or <a href="#L">L</a>, <a href="#6.4.4.2">6.4.4.2</a>
+    numerical, see numerical limits                         long double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>,
+    translation, see translation limits                          <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.2">F.2</a>
+ limits.h header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                 long double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,
+ line buffered stream, <a href="#7.19.3">7.19.3</a>                                    <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+ line number, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8">6.10.8</a>                                long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+ line preprocessing directive, <a href="#6.10.4">6.10.4</a>                            <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
+ lines, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#7.19.2">7.19.2</a>                                     long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+    preprocessing directive, <a href="#6.10">6.10</a>                                <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+ linkage, <a href="#6.2.2">6.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.4">6.7.4</a>, <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.9">6.9</a>, <a href="#6.9.2">6.9.2</a>,           long integer suffix, l or <a href="#L">L</a>, <a href="#6.4.4.1">6.4.4.1</a>
+       <a href="#6.11.2">6.11.2</a>                                               long long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>,
+<!--page 544 indent 0-->
+      <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                    mbsinit function, <a href="#7.24.6.2.1">7.24.6.2.1</a>
+ long long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>,                        mbsrtowcs function, <a href="#7.24.6.4.1">7.24.6.4.1</a>
+      <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                 mbstate_t type, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+ long long integer suffix, ll or LL, <a href="#6.4.4.1">6.4.4.1</a>                          <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.6">7.24.6</a>,
+ LONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                     <a href="#7.24.6.2.1">7.24.6.2.1</a>, <a href="#7.24.6.3">7.24.6.3</a>, <a href="#7.24.6.3.1">7.24.6.3.1</a>, <a href="#7.24.6.4">7.24.6.4</a>
+ LONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                mbstowcs function, <a href="#6.4.5">6.4.5</a>, <a href="#7.20.8.1">7.20.8.1</a>, <a href="#7.24.6.4">7.24.6.4</a>
+ longjmp function, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>, <a href="#7.20.4.3">7.20.4.3</a>                 mbtowc function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.20.7.2">7.20.7.2</a>, <a href="#7.20.8.1">7.20.8.1</a>,
+ loop body, <a href="#6.8.5">6.8.5</a>                                                    <a href="#7.24.6.3">7.24.6.3</a>
+ low-order bit, <a href="#3.6">3.6</a>                                             member access operators (. and -&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+ lowercase letter, <a href="#5.2.1">5.2.1</a>                                        member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+ lrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.5">F.9.6.5</a>                        memchr function, <a href="#7.21.5.1">7.21.5.1</a>
+ lrint type-generic macro, <a href="#7.22">7.22</a>                                 memcmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.1">7.21.4.1</a>
+ lround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.7">F.9.6.7</a>                            memcpy function, <a href="#7.21.2.1">7.21.2.1</a>
+ lround type-generic macro, <a href="#7.22">7.22</a>                                memmove function, <a href="#7.21.2.2">7.21.2.2</a>
+ lvalue, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>, <a href="#6.5.16">6.5.16</a>               memory management functions, <a href="#7.20.3">7.20.3</a>
+                                                                memset function, <a href="#7.21.6.1">7.21.6.1</a>
+ macro argument substitution, <a href="#6.10.3.1">6.10.3.1</a>                          minimum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>
+ macro definition                                                minus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>
+   library function, <a href="#7.1.4">7.1.4</a>                                      miscellaneous functions
+ macro invocation, <a href="#6.10.3">6.10.3</a>                                         string, <a href="#7.21.6">7.21.6</a>
+ macro name, <a href="#6.10.3">6.10.3</a>                                               wide string, <a href="#7.24.4.6">7.24.4.6</a>
+   length, <a href="#5.2.4.1">5.2.4.1</a>                                              mktime function, <a href="#7.23.2.3">7.23.2.3</a>
+   predefined, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>                                    modf functions, <a href="#7.12.6.12">7.12.6.12</a>, <a href="#F.9.3.12">F.9.3.12</a>
+   redefinition, <a href="#6.10.3">6.10.3</a>                                          modifiable lvalue, <a href="#6.3.2.1">6.3.2.1</a>
+   scope, <a href="#6.10.3.5">6.10.3.5</a>                                              modulus functions, <a href="#7.12.6.12">7.12.6.12</a>
+ macro parameter, <a href="#6.10.3">6.10.3</a>                                        modulus, complex, <a href="#7.3.8.1">7.3.8.1</a>
+ macro preprocessor, <a href="#6.10">6.10</a>                                       multibyte character, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+ macro replacement, <a href="#6.10.3">6.10.3</a>                                      multibyte conversion functions
+ magnitude, complex, <a href="#7.3.8.1">7.3.8.1</a>                                      wide character, <a href="#7.20.7">7.20.7</a>
+ main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.4">6.7.4</a>,                extended, <a href="#7.24.6">7.24.6</a>
+      <a href="#7.19.3">7.19.3</a>                                                         restartable, <a href="#7.24.6.3">7.24.6.3</a>
+ malloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.3">7.20.3.3</a>,                     wide string, <a href="#7.20.8">7.20.8</a>
+      <a href="#7.20.3.4">7.20.3.4</a>                                                       restartable, <a href="#7.24.6.4">7.24.6.4</a>
+ manipulation functions                                         multibyte string, <a href="#7.1.1">7.1.1</a>
+   complex, <a href="#7.3.9">7.3.9</a>                                               multibyte/wide character conversion functions,
+   real, <a href="#7.12.11">7.12.11</a>, <a href="#F.9.8">F.9.8</a>                                              <a href="#7.20.7">7.20.7</a>
+ matching failure, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>                  extended, <a href="#7.24.6">7.24.6</a>
+ math.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>, <a href="#F.9">F.9</a>,               restartable, <a href="#7.24.6.3">7.24.6.3</a>
+      <a href="#J.5.17">J.5.17</a>                                                    multibyte/wide string conversion functions, <a href="#7.20.8">7.20.8</a>
+ MATH_ERREXCEPT macro, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                                  restartable, <a href="#7.24.6.4">7.24.6.4</a>
+ math_errhandling macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                       multidimensional array, <a href="#6.5.2.1">6.5.2.1</a>
+ MATH_ERRNO macro, <a href="#7.12">7.12</a>                                         multiplication assignment operator (*=), <a href="#6.5.16.2">6.5.16.2</a>
+ maximum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>                              multiplication operator (*), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
+ MB_CUR_MAX macro, <a href="#7.1.1">7.1.1</a>, <a href="#7.20">7.20</a>, <a href="#7.20.7.2">7.20.7.2</a>,                       multiplicative expressions, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+      <a href="#7.20.7.3">7.20.7.3</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>
+ MB_LEN_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.1.1">7.1.1</a>, <a href="#7.20">7.20</a>                       n-char sequence, <a href="#7.20.1.3">7.20.1.3</a>
+ mblen function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.24.6.3">7.24.6.3</a>                             n-wchar sequence, <a href="#7.24.4.1.1">7.24.4.1.1</a>
+ mbrlen function, <a href="#7.24.6.3.1">7.24.6.3.1</a>                                    name
+ mbrtowc function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                    external, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+      <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.6.3.1">7.24.6.3.1</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>,                 file, <a href="#7.19.3">7.19.3</a>
+      <a href="#7.24.6.4.1">7.24.6.4.1</a>                                                  internal, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+<!--page 545 indent 0-->
+   label, <a href="#6.2.3">6.2.3</a>                                                  octal-character escape sequence (\octal digits),
+   structure/union member, <a href="#6.2.3">6.2.3</a>                                       <a href="#6.4.4.4">6.4.4.4</a>
+ name spaces, <a href="#6.2.3">6.2.3</a>                                              offsetof macro, <a href="#7.17">7.17</a>
+ named label, <a href="#6.8.1">6.8.1</a>                                              on-off switch, <a href="#6.10.6">6.10.6</a>
+ NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                                  ones' complement, <a href="#6.2.6.2">6.2.6.2</a>
+ nan functions, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#F.2.1">F.2.1</a>, <a href="#F.9.8.2">F.9.8.2</a>                        operand, <a href="#6.4.6">6.4.6</a>, <a href="#6.5">6.5</a>
+ NAN macro, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                                          operating system, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#7.20.4.6">7.20.4.6</a>
+ NDEBUG macro, <a href="#7.2">7.2</a>                                               operations on files, <a href="#7.19.4">7.19.4</a>
+ nearbyint functions, <a href="#7.12.9.3">7.12.9.3</a>, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>,                   operator, <a href="#6.4.6">6.4.6</a>
+      <a href="#F.9.6.3">F.9.6.3</a>                                                    operators, <a href="#6.5">6.5</a>
+ nearbyint type-generic macro, <a href="#7.22">7.22</a>                                 assignment, <a href="#6.5.16">6.5.16</a>
+ nearest integer functions, <a href="#7.12.9">7.12.9</a>, <a href="#F.9.6">F.9.6</a>                           associativity, <a href="#6.5">6.5</a>
+ negation operator (!), <a href="#6.5.3.3">6.5.3.3</a>                                     equality, <a href="#6.5.9">6.5.9</a>
+ negative zero, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.12.11.1">7.12.11.1</a>                                  multiplicative, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+ new-line character, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#6.10.4">6.10.4</a>              postfix, <a href="#6.5.2">6.5.2</a>
+ new-line escape sequence (\n), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,                     precedence, <a href="#6.5">6.5</a>
+      <a href="#7.4.1.10">7.4.1.10</a>                                                      preprocessing, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, <a href="#6.10.9">6.10.9</a>
+ nextafter functions, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>,                    relational, <a href="#6.5.8">6.5.8</a>
+      <a href="#F.9.8.3">F.9.8.3</a>                                                       shift, <a href="#6.5.7">6.5.7</a>
+ nextafter type-generic macro, <a href="#7.22">7.22</a>                                 unary, <a href="#6.5.3">6.5.3</a>
+ nexttoward functions, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, <a href="#F.9.8.4">F.9.8.4</a>                      unary arithmetic, <a href="#6.5.3.3">6.5.3.3</a>
+ nexttoward type-generic macro, <a href="#7.22">7.22</a>                             or macro, <a href="#7.9">7.9</a>
+ no linkage, <a href="#6.2.2">6.2.2</a>                                               OR operators
+ non-stop floating-point control mode, <a href="#7.6.4.2">7.6.4.2</a>                       bitwise exclusive (^), <a href="#6.5.11">6.5.11</a>
+ nongraphic characters, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                              bitwise exclusive assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
+ nonlocal jumps header, <a href="#7.13">7.13</a>                                        bitwise inclusive (|), <a href="#6.5.12">6.5.12</a>
+ norm, complex, <a href="#7.3.8.1">7.3.8.1</a>                                             bitwise inclusive assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+ not macro, <a href="#7.9">7.9</a>                                                     logical (||), <a href="#6.5.14">6.5.14</a>
+ not-equal-to operator, see inequality operator                  or_eq macro, <a href="#7.9">7.9</a>
+ not_eq macro, <a href="#7.9">7.9</a>                                               order of allocated storage, <a href="#7.20.3">7.20.3</a>
+ null character (\0), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                      order of evaluation, <a href="#6.5">6.5</a>
+   padding of binary stream, <a href="#7.19.2">7.19.2</a>                              ordinary identifier name space, <a href="#6.2.3">6.2.3</a>
+ NULL macro, <a href="#7.11">7.11</a>, <a href="#7.17">7.17</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.20">7.20</a>, <a href="#7.21.1">7.21.1</a>,                   orientation of stream, <a href="#7.19.2">7.19.2</a>, <a href="#7.24.3.5">7.24.3.5</a>
+      <a href="#7.23.1">7.23.1</a>, <a href="#7.24.1">7.24.1</a>                                             outer scope, <a href="#6.2.1">6.2.1</a>
+ null pointer, <a href="#6.3.2.3">6.3.2.3</a>
+ null pointer constant, <a href="#6.3.2.3">6.3.2.3</a>                                  padding
+ null preprocessing directive, <a href="#6.10.7">6.10.7</a>                              binary stream, <a href="#7.19.2">7.19.2</a>
+ null statement, <a href="#6.8.3">6.8.3</a>                                             bits, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.18.1.1">7.18.1.1</a>
+ null wide character, <a href="#7.1.1">7.1.1</a>                                        structure/union, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+ number classification macros, <a href="#7.12">7.12</a>, <a href="#7.12.3.1">7.12.3.1</a>                     parameter, <a href="#3.15">3.15</a>
+ numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>                     array, <a href="#6.9.1">6.9.1</a>
+   wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1">7.24.4.1</a>                                  ellipsis, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>
+ numerical limits, <a href="#5.2.4.2">5.2.4.2</a>                                         function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
+                                                                   macro, <a href="#6.10.3">6.10.3</a>
+ object, <a href="#3.14">3.14</a>                                                      main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ object representation, <a href="#6.2.6.1">6.2.6.1</a>                                    program, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ object type, <a href="#6.2.5">6.2.5</a>                                              parameter type list, <a href="#6.7.5.3">6.7.5.3</a>
+ object-like macro, <a href="#6.10.3">6.10.3</a>                                       parentheses punctuator (( )), <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
+ obsolescence, <a href="#6.11">6.11</a>, <a href="#7.26">7.26</a>                                        parenthesized expression, <a href="#6.5.1">6.5.1</a>
+ octal constant, <a href="#6.4.4.1">6.4.4.1</a>                                         parse state, <a href="#7.19.2">7.19.2</a>
+ octal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.4">6.4.4.4</a>                                   permitted form of initializer, <a href="#6.6">6.6</a>
+<!--page 546 indent 0-->
+ perror function, <a href="#7.19.10.4">7.19.10.4</a>                                    PRIcPTR macros, <a href="#7.8.1">7.8.1</a>
+ phase angle, complex, <a href="#7.3.9.1">7.3.9.1</a>                                 primary expression, <a href="#6.5.1">6.5.1</a>
+ physical source lines, <a href="#5.1.1.2">5.1.1.2</a>                                printf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.10">7.19.6.10</a>
+ placemarker, <a href="#6.10.3.3">6.10.3.3</a>                                         printing character, <a href="#5.2.2">5.2.2</a>, <a href="#7.4">7.4</a>, <a href="#7.4.1.8">7.4.1.8</a>
+ plus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                                 printing wide character, <a href="#7.25.2">7.25.2</a>
+ pointer arithmetic, <a href="#6.5.6">6.5.6</a>                                     program diagnostics, <a href="#7.2.1">7.2.1</a>
+ pointer comparison, <a href="#6.5.8">6.5.8</a>                                     program execution, <a href="#5.1.2.2.2">5.1.2.2.2</a>, <a href="#5.1.2.3">5.1.2.3</a>
+ pointer declarator, <a href="#6.7.5.1">6.7.5.1</a>                                   program file, <a href="#5.1.1.1">5.1.1.1</a>
+ pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                program image, <a href="#5.1.1.2">5.1.1.2</a>
+ pointer to function, <a href="#6.5.2.2">6.5.2.2</a>                                  program name (argv[0]), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ pointer type, <a href="#6.2.5">6.2.5</a>                                           program parameters, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ pointer type conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                     program startup, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ pointer, null, <a href="#6.3.2.3">6.3.2.3</a>                                        program structure, <a href="#5.1.1.1">5.1.1.1</a>
+ portability, <a href="#4">4</a>, <a href="#J">J</a>                                             program termination, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>,
+ position indicator, file, see file position indicator                 <a href="#5.1.2.3">5.1.2.3</a>
+ positive difference, <a href="#7.12.12.1">7.12.12.1</a>                                program, conforming, <a href="#4">4</a>
+ positive difference functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>                 program, strictly conforming, <a href="#4">4</a>
+ postfix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              promotions
+ postfix expressions, <a href="#6.5.2">6.5.2</a>                                        default argument, <a href="#6.5.2.2">6.5.2.2</a>
+ postfix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>                 integer, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.3.1.1">6.3.1.1</a>
+ pow functions, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#F.9.4.4">F.9.4.4</a>                              prototype, see function prototype
+ pow type-generic macro, <a href="#7.22">7.22</a>                                  pseudo-random sequence functions, <a href="#7.20.2">7.20.2</a>
+ power functions                                               PTRDIFF_MAX macro, <a href="#7.18.3">7.18.3</a>
+   complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                       PTRDIFF_MIN macro, <a href="#7.18.3">7.18.3</a>
+   real, <a href="#7.12.7">7.12.7</a>, <a href="#F.9.4">F.9.4</a>                                         ptrdiff_t type, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+ pp-number, <a href="#6.4.8">6.4.8</a>                                                    <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
+ pragma operator, <a href="#6.10.9">6.10.9</a>                                       punctuators, <a href="#6.4.6">6.4.6</a>
+ pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                putc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.8">7.19.7.8</a>, <a href="#7.19.7.9">7.19.7.9</a>
+ precedence of operators, <a href="#6.5">6.5</a>                                  putchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.9">7.19.7.9</a>
+ precedence of syntax rules, <a href="#5.1.1.2">5.1.1.2</a>                           puts function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.10">7.19.7.10</a>
+ precision, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>               putwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.8">7.24.3.8</a>, <a href="#7.24.3.9">7.24.3.9</a>
+    excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>               putwchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.9">7.24.3.9</a>
+ predefined macro names, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>
+ prefix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               qsort function, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.2">7.20.5.2</a>
+ prefix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               qualified types, <a href="#6.2.5">6.2.5</a>
+ preprocessing concatenation, <a href="#6.10.3.3">6.10.3.3</a>                         qualified version of type, <a href="#6.2.5">6.2.5</a>
+ preprocessing directives, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10">6.10</a>                       question-mark escape sequence (\?), <a href="#6.4.4.4">6.4.4.4</a>
+ preprocessing file, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.10">6.10</a>                              quiet NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ preprocessing numbers, <a href="#6.4">6.4</a>, <a href="#6.4.8">6.4.8</a>
+ preprocessing operators                                       raise function, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>, <a href="#7.20.4.1">7.20.4.1</a>
+    #, <a href="#6.10.3.2">6.10.3.2</a>                                                rand function, <a href="#7.20">7.20</a>, <a href="#7.20.2.1">7.20.2.1</a>, <a href="#7.20.2.2">7.20.2.2</a>
+    ##, <a href="#6.10.3.3">6.10.3.3</a>                                               RAND_MAX macro, <a href="#7.20">7.20</a>, <a href="#7.20.2.1">7.20.2.1</a>
+    _Pragma, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>                                   range
+    defined, <a href="#6.10.1">6.10.1</a>                                              excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>
+ preprocessing tokens, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>                      range error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#7.12.5.5">7.12.5.5</a>,
+ preprocessing translation unit, <a href="#5.1.1.1">5.1.1.1</a>                            <a href="#7.12.6.1">7.12.6.1</a>, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#7.12.6.5">7.12.6.5</a>,
+ preprocessor, <a href="#6.10">6.10</a>                                                 <a href="#7.12.6.6">7.12.6.6</a>, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>,
+ PRIcFASTN macros, <a href="#7.8.1">7.8.1</a>                                            <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#7.12.7.3">7.12.7.3</a>,
+ PRIcLEASTN macros, <a href="#7.8.1">7.8.1</a>                                           <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>,
+ PRIcMAX macros, <a href="#7.8.1">7.8.1</a>                                              <a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.12.1">7.12.12.1</a>,
+ PRIcN macros, <a href="#7.8.1">7.8.1</a>                                                <a href="#7.12.13.1">7.12.13.1</a>
+<!--page 547 indent 0-->
+ rank, see integer conversion rank                         same scope, <a href="#6.2.1">6.2.1</a>
+ real floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,           save calling environment function, <a href="#7.13.1">7.13.1</a>
+       <a href="#6.3.1.7">6.3.1.7</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                   scalar types, <a href="#6.2.5">6.2.5</a>
+ real floating types, <a href="#6.2.5">6.2.5</a>                                 scalbln function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.13">F.9.3.13</a>
+ real type domain, <a href="#6.2.5">6.2.5</a>                                   scalbln type-generic macro, <a href="#7.22">7.22</a>
+ real types, <a href="#6.2.5">6.2.5</a>                                         scalbn function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.13">F.9.3.13</a>
+ real-floating, <a href="#7.12.3">7.12.3</a>                                      scalbn type-generic macro, <a href="#7.22">7.22</a>
+ realloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>              scanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.4">7.19.6.4</a>, <a href="#7.19.6.11">7.19.6.11</a>
+ recommended practice, <a href="#3.16">3.16</a>                                scanlist, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>
+ recursion, <a href="#6.5.2.2">6.5.2.2</a>                                        scanset, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>
+ recursive function call, <a href="#6.5.2.2">6.5.2.2</a>                          SCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ redefinition of macro, <a href="#6.10.3">6.10.3</a>                              SCHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ reentrancy, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>                                SCNcFASTN macros, <a href="#7.8.1">7.8.1</a>
+    library functions, <a href="#7.1.4">7.1.4</a>                               SCNcLEASTN macros, <a href="#7.8.1">7.8.1</a>
+ referenced type, <a href="#6.2.5">6.2.5</a>                                    SCNcMAX macros, <a href="#7.8.1">7.8.1</a>
+ register storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>               SCNcN macros, <a href="#7.8.1">7.8.1</a>
+ relational expressions, <a href="#6.5.8">6.5.8</a>                             SCNcPTR macros, <a href="#7.8.1">7.8.1</a>
+ reliability of data, interrupted, <a href="#5.1.2.3">5.1.2.3</a>                 scope of identifier, <a href="#6.2.1">6.2.1</a>, <a href="#6.9.2">6.9.2</a>
+ remainder assignment operator (%=), <a href="#6.5.16.2">6.5.16.2</a>              search functions
+ remainder functions, <a href="#7.12.10">7.12.10</a>, <a href="#F.9.7">F.9.7</a>                          string, <a href="#7.21.5">7.21.5</a>
+ remainder functions, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>,              utility, <a href="#7.20.5">7.20.5</a>
+       <a href="#F.9.7.2">F.9.7.2</a>                                                wide string, <a href="#7.24.4.5">7.24.4.5</a>
+ remainder operator (%), <a href="#6.5.5">6.5.5</a>                             SEEK_CUR macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
+ remainder type-generic macro, <a href="#7.22">7.22</a>                        SEEK_END macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
+ remove function, <a href="#7.19.4.1">7.19.4.1</a>, <a href="#7.19.4.4">7.19.4.4</a>                       SEEK_SET macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
+ remquo functions, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>, <a href="#F.9.7.3">F.9.7.3</a>                 selection statements, <a href="#6.8.4">6.8.4</a>
+ remquo type-generic macro, <a href="#7.22">7.22</a>                           self-referential structure, <a href="#6.7.2.3">6.7.2.3</a>
+ rename function, <a href="#7.19.4.2">7.19.4.2</a>                                 semicolon punctuator (;), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
+ representations of types, <a href="#6.2.6">6.2.6</a>                                 <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
+    pointer, <a href="#6.2.5">6.2.5</a>                                         separate compilation, <a href="#5.1.1.1">5.1.1.1</a>
+ rescanning and replacement, <a href="#6.10.3.4">6.10.3.4</a>                      separate translation, <a href="#5.1.1.1">5.1.1.1</a>
+ reserved identifiers, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>                         sequence points, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.8">6.8</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.19.6">7.19.6</a>,
+ restartable multibyte/wide character conversion                 <a href="#7.20.5">7.20.5</a>, <a href="#7.24.2">7.24.2</a>, <a href="#C">C</a>
+       functions, <a href="#7.24.6.3">7.24.6.3</a>                                 sequencing of statements, <a href="#6.8">6.8</a>
+ restartable multibyte/wide string conversion              setbuf function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.1">7.19.5.1</a>, <a href="#7.19.5.5">7.19.5.5</a>
+       functions, <a href="#7.24.6.4">7.24.6.4</a>                                 setjmp macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>
+ restore calling environment function, <a href="#7.13.2">7.13.2</a>              setjmp.h header, <a href="#7.13">7.13</a>
+ restrict type qualifier, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>                    setlocale function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ restrict-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>                      setvbuf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.1">7.19.5.1</a>,
+ return statement, <a href="#6.8.6.4">6.8.6.4</a>                                       <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
+ rewind function, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.5">7.19.9.5</a>,           shall, <a href="#4">4</a>
+       <a href="#7.24.3.10">7.24.3.10</a>                                           shift expressions, <a href="#6.5.7">6.5.7</a>
+ right-shift assignment operator (&gt;&gt;=), <a href="#6.5.16.2">6.5.16.2</a>           shift sequence, <a href="#7.1.1">7.1.1</a>
+ right-shift operator (&gt;&gt;), <a href="#6.5.7">6.5.7</a>                          shift states, <a href="#5.2.1.2">5.2.1.2</a>
+ rint functions, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.4">F.9.6.4</a>                    short identifier, character, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.3">6.4.3</a>
+ rint type-generic macro, <a href="#7.22">7.22</a>                             short int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+ round functions, <a href="#7.12.9.6">7.12.9.6</a>, <a href="#F.9.6.6">F.9.6.6</a>                              <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
+ round type-generic macro, <a href="#7.22">7.22</a>                            short int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+ rounding mode, floating point, <a href="#5.2.4.2.2">5.2.4.2.2</a>                         <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+ rvalue, <a href="#6.3.2.1">6.3.2.1</a>                                           SHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+                                                           SHRT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+<!--page 548 indent 0-->
+ side effects, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>                                   source lines, <a href="#5.1.1.2">5.1.1.2</a>
+ SIG_ATOMIC_MAX macro, <a href="#7.18.3">7.18.3</a>                                 source text, <a href="#5.1.1.2">5.1.1.2</a>
+ SIG_ATOMIC_MIN macro, <a href="#7.18.3">7.18.3</a>                                 space character (' '), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,
+ sig_atomic_t type, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.18.3">7.18.3</a>                         <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>
+ SIG_DFL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sprintf function, <a href="#7.19.6.6">7.19.6.6</a>, <a href="#7.19.6.13">7.19.6.13</a>
+ SIG_ERR macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sqrt functions, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.4.5">F.9.4.5</a>
+ SIG_IGN macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sqrt type-generic macro, <a href="#7.22">7.22</a>
+ SIGABRT macro, <a href="#7.14">7.14</a>, <a href="#7.20.4.1">7.20.4.1</a>                                srand function, <a href="#7.20.2.2">7.20.2.2</a>
+ SIGFPE macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.5.17">J.5.17</a>                         sscanf function, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.14">7.19.6.14</a>
+ SIGILL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                 standard error stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.10.4">7.19.10.4</a>
+ SIGINT macro, <a href="#7.14">7.14</a>                                           standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a>
+ sign and magnitude, <a href="#6.2.6.2">6.2.6.2</a>                                     &lt;assert.h&gt;, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
+ sign bit, <a href="#6.2.6.2">6.2.6.2</a>                                               &lt;complex.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>, <a href="#7.26.1">7.26.1</a>,
+ signal function, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.20.4.4">7.20.4.4</a>                                  <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+ signal handler, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>              &lt;ctype.h&gt;, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
+ signal handling functions, <a href="#7.14.1">7.14.1</a>                               &lt;errno.h&gt;, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
+ signal.h header, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>                                   &lt;fenv.h&gt;, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>
+ signaling NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#F.2.1">F.2.1</a>                                 &lt;float.h&gt;, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+ signals, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1">7.14.1</a>                                      <a href="#7.24.4.1.1">7.24.4.1.1</a>
+ signbit macro, <a href="#7.12.3.6">7.12.3.6</a>, <a href="#F.3">F.3</a>                                    &lt;inttypes.h&gt;, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>
+ signed char type, <a href="#6.2.5">6.2.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                    &lt;iso646.h&gt;, <a href="#4">4</a>, <a href="#7.9">7.9</a>
+      <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                         &lt;limits.h&gt;, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
+ signed character, <a href="#6.3.1.1">6.3.1.1</a>                                       &lt;locale.h&gt;, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
+ signed integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>                   &lt;math.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>, <a href="#F.9">F.9</a>,
+ signed type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,                   <a href="#J.5.17">J.5.17</a>
+      <a href="#6.3.1.8">6.3.1.8</a>                                                    &lt;setjmp.h&gt;, <a href="#7.13">7.13</a>
+ signed types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>                                      &lt;signal.h&gt;, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>
+ significand part, <a href="#6.4.4.2">6.4.4.2</a>                                        &lt;stdarg.h&gt;, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>
+ SIGSEGV macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                   &lt;stdbool.h&gt;, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>
+ SIGTERM macro, <a href="#7.14">7.14</a>                                             &lt;stddef.h&gt;, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+ simple assignment operator (=), <a href="#6.5.16.1">6.5.16.1</a>                             <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>
+ sin functions, <a href="#7.12.4.6">7.12.4.6</a>, <a href="#F.9.1.6">F.9.1.6</a>                                &lt;stdint.h&gt;, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.18">7.18</a>,
+ sin type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                    <a href="#7.26.8">7.26.8</a>
+ single-byte character, <a href="#3.7.1">3.7.1</a>, <a href="#5.2.1.2">5.2.1.2</a>                           &lt;stdio.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>
+ single-byte/wide character conversion functions,                &lt;stdlib.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>
+      <a href="#7.24.6.1">7.24.6.1</a>                                                   &lt;string.h&gt;, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>
+ single-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                            &lt;tgmath.h&gt;, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+ single-quote escape sequence (\'), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>               &lt;time.h&gt;, <a href="#7.23">7.23</a>
+ sinh functions, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#F.9.2.5">F.9.2.5</a>                               &lt;wchar.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>, <a href="#7.26.12">7.26.12</a>,
+ sinh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                   <a href="#F">F</a>
+ SIZE_MAX macro, <a href="#7.18.3">7.18.3</a>                                          &lt;wctype.h&gt;, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>
+ size_t type, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.1">7.19.1</a>,                  standard input stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>
+      <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20">7.20</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.23.1">7.23.1</a>,               standard integer types, <a href="#6.2.5">6.2.5</a>
+      <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                              standard output stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>
+ sizeof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>                     standard signed integer types, <a href="#6.2.5">6.2.5</a>
+ snprintf function, <a href="#7.19.6.5">7.19.6.5</a>, <a href="#7.19.6.12">7.19.6.12</a>                       state-dependent encoding, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#7.20.7">7.20.7</a>
+ sorting utility functions, <a href="#7.20.5">7.20.5</a>                            statements, <a href="#6.8">6.8</a>
+ source character set, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>                            break, <a href="#6.8.6.3">6.8.6.3</a>
+ source file, <a href="#5.1.1.1">5.1.1.1</a>                                             compound, <a href="#6.8.2">6.8.2</a>
+    name, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8">6.10.8</a>                                         continue, <a href="#6.8.6.2">6.8.6.2</a>
+ source file inclusion, <a href="#6.10.2">6.10.2</a>                                    do, <a href="#6.8.5.2">6.8.5.2</a>
+<!--page 549 indent 0-->
+    else, <a href="#6.8.4.1">6.8.4.1</a>                                             strictly conforming program, <a href="#4">4</a>
+    expression, <a href="#6.8.3">6.8.3</a>                                         string, <a href="#7.1.1">7.1.1</a>
+    for, <a href="#6.8.5.3">6.8.5.3</a>                                                 comparison functions, <a href="#7.21.4">7.21.4</a>
+    goto, <a href="#6.8.6.1">6.8.6.1</a>                                                concatenation functions, <a href="#7.21.3">7.21.3</a>
+    if, <a href="#6.8.4.1">6.8.4.1</a>                                                  conversion functions, <a href="#7.11.1.1">7.11.1.1</a>
+    iteration, <a href="#6.8.5">6.8.5</a>                                             copying functions, <a href="#7.21.2">7.21.2</a>
+    jump, <a href="#6.8.6">6.8.6</a>                                                  library function conventions, <a href="#7.21.1">7.21.1</a>
+    labeled, <a href="#6.8.1">6.8.1</a>                                               literal, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.7.8">6.7.8</a>
+    null, <a href="#6.8.3">6.8.3</a>                                                  miscellaneous functions, <a href="#7.21.6">7.21.6</a>
+    return, <a href="#6.8.6.4">6.8.6.4</a>                                              numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>
+    selection, <a href="#6.8.4">6.8.4</a>                                             search functions, <a href="#7.21.5">7.21.5</a>
+    sequencing, <a href="#6.8">6.8</a>                                           string handling header, <a href="#7.21">7.21</a>
+    switch, <a href="#6.8.4.2">6.8.4.2</a>                                           string.h header, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>
+    while, <a href="#6.8.5.1">6.8.5.1</a>                                            stringizing, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.9">6.10.9</a>
+ static storage duration, <a href="#6.2.4">6.2.4</a>                               strlen function, <a href="#7.21.6.3">7.21.6.3</a>
+ static storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.7.1">6.7.1</a>           strncat function, <a href="#7.21.3.2">7.21.3.2</a>
+ static, in array declarators, <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.5.3">6.7.5.3</a>               strncmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.4">7.21.4.4</a>
+ stdarg.h header, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>                            strncpy function, <a href="#7.21.2.4">7.21.2.4</a>
+ stdbool.h header, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>                         strpbrk function, <a href="#7.21.5.4">7.21.5.4</a>
+ STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                                         strrchr function, <a href="#7.21.5.5">7.21.5.5</a>
+ stddef.h header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,               strspn function, <a href="#7.21.5.6">7.21.5.6</a>
+       <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>                            strstr function, <a href="#7.21.5.7">7.21.5.7</a>
+ stderr macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>                         strtod function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+ stdin macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.4">7.19.6.4</a>,                     <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.3">F.3</a>
+       <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.24.2.12">7.24.2.12</a>, <a href="#7.24.3.7">7.24.3.7</a>                strtof function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.3">F.3</a>
+ stdint.h header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.18">7.18</a>,              strtoimax function, <a href="#7.8.2.3">7.8.2.3</a>
+       <a href="#7.26.8">7.26.8</a>                                                 strtok function, <a href="#7.21.5.8">7.21.5.8</a>
+ stdio.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>                   strtol function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.2">7.20.1.2</a>,
+ stdlib.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>                       <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>
+ stdout macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.3">7.19.6.3</a>,              strtold function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.3">F.3</a>
+       <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.7.10">7.19.7.10</a>, <a href="#7.24.2.11">7.24.2.11</a>, <a href="#7.24.3.9">7.24.3.9</a>               strtoll function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1.2">7.20.1.2</a>, <a href="#7.20.1.4">7.20.1.4</a>
+ storage duration, <a href="#6.2.4">6.2.4</a>                                      strtoul function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.2">7.20.1.2</a>,
+ storage order of array, <a href="#6.5.2.1">6.5.2.1</a>                                    <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>
+ storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a>                       strtoull function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1.2">7.20.1.2</a>, <a href="#7.20.1.4">7.20.1.4</a>
+ strcat function, <a href="#7.21.3.1">7.21.3.1</a>                                    strtoumax function, <a href="#7.8.2.3">7.8.2.3</a>
+ strchr function, <a href="#7.21.5.2">7.21.5.2</a>                                    struct hack, see flexible array member
+ strcmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.2">7.21.4.2</a>                            structure
+ strcoll function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.5">7.21.4.5</a>                  arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+ strcpy function, <a href="#7.21.2.3">7.21.2.3</a>                                       content, <a href="#6.7.2.3">6.7.2.3</a>
+ strcspn function, <a href="#7.21.5.3">7.21.5.3</a>                                      dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>
+ streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.20.4.3">7.20.4.3</a>                                       initialization, <a href="#6.7.8">6.7.8</a>
+    fully buffered, <a href="#7.19.3">7.19.3</a>                                       member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+    line buffered, <a href="#7.19.3">7.19.3</a>                                        member name space, <a href="#6.2.3">6.2.3</a>
+    orientation, <a href="#7.19.2">7.19.2</a>                                          member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>
+    standard error, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                               pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+    standard input, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                               specifier, <a href="#6.7.2.1">6.7.2.1</a>
+    standard output, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                              tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+    unbuffered, <a href="#7.19.3">7.19.3</a>                                           type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>
+ strerror function, <a href="#7.19.10.4">7.19.10.4</a>, <a href="#7.21.6.2">7.21.6.2</a>                       strxfrm function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.5">7.21.4.5</a>
+ strftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.3">7.23.3</a>, <a href="#7.23.3.5">7.23.3.5</a>,               subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+       <a href="#7.24.5.1">7.24.5.1</a>                                               subtraction assignment operator (-=), <a href="#6.5.16.2">6.5.16.2</a>
+<!--page 550 indent 0-->
+ subtraction operator (-), <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                   tolower function, <a href="#7.4.2.1">7.4.2.1</a>
+ suffix                                                         toupper function, <a href="#7.4.2.2">7.4.2.2</a>
+   floating constant, <a href="#6.4.4.2">6.4.4.2</a>                                   towctrans function, <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+   integer constant, <a href="#6.4.4.1">6.4.4.1</a>                                   towlower function, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.2.1">7.25.3.2.1</a>
+ switch body, <a href="#6.8.4.2">6.8.4.2</a>                                          towupper function, <a href="#7.25.3.1.2">7.25.3.1.2</a>, <a href="#7.25.3.2.1">7.25.3.2.1</a>
+ switch case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                             translation environment, <a href="#5">5</a>, <a href="#5.1.1">5.1.1</a>
+ switch default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                          translation limits, <a href="#5.2.4.1">5.2.4.1</a>
+ switch statement, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                              translation phases, <a href="#5.1.1.2">5.1.1.2</a>
+ swprintf function, <a href="#7.24.2.3">7.24.2.3</a>, <a href="#7.24.2.7">7.24.2.7</a>                         translation unit, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.9">6.9</a>
+ swscanf function, <a href="#7.24.2.4">7.24.2.4</a>, <a href="#7.24.2.8">7.24.2.8</a>                          trap representation, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.2.3">6.3.2.3</a>,
+ symbols, <a href="#3">3</a>                                                          <a href="#6.5.2.3">6.5.2.3</a>
+ syntactic categories, <a href="#6.1">6.1</a>                                     trigonometric functions
+ syntax notation, <a href="#6.1">6.1</a>                                             complex, <a href="#7.3.5">7.3.5</a>, <a href="#G.6.1">G.6.1</a>
+ syntax rule precedence, <a href="#5.1.1.2">5.1.1.2</a>                                  real, <a href="#7.12.4">7.12.4</a>, <a href="#F.9.1">F.9.1</a>
+ syntax summary, language, <a href="#A">A</a>                                   trigraph sequences, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1.1">5.2.1.1</a>
+ system function, <a href="#7.20.4.6">7.20.4.6</a>                                     true macro, <a href="#7.16">7.16</a>
+                                                               trunc functions, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#F.9.6.8">F.9.6.8</a>
+ tab characters, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                                    trunc type-generic macro, <a href="#7.22">7.22</a>
+ tag compatibility, <a href="#6.2.7">6.2.7</a>                                      truncation, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.3">7.19.5.3</a>
+ tag name space, <a href="#6.2.3">6.2.3</a>                                         truncation toward zero, <a href="#6.5.5">6.5.5</a>
+ tags, <a href="#6.7.2.3">6.7.2.3</a>                                                 two's complement, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.18.1.1">7.18.1.1</a>
+ tan functions, <a href="#7.12.4.7">7.12.4.7</a>, <a href="#F.9.1.7">F.9.1.7</a>                              type category, <a href="#6.2.5">6.2.5</a>
+ tan type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                             type conversion, <a href="#6.3">6.3</a>
+ tanh functions, <a href="#7.12.5.6">7.12.5.6</a>, <a href="#F.9.2.6">F.9.2.6</a>                             type definitions, <a href="#6.7.7">6.7.7</a>
+ tanh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            type domain, <a href="#6.2.5">6.2.5</a>, <a href="#G.2">G.2</a>
+ tentative definition, <a href="#6.9.2">6.9.2</a>                                    type names, <a href="#6.7.6">6.7.6</a>
+ terms, <a href="#3">3</a>                                                      type punning, <a href="#6.5.2.3">6.5.2.3</a>
+ text streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>           type qualifiers, <a href="#6.7.3">6.7.3</a>
+ tgamma functions, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#F.9.5.4">F.9.5.4</a>                           type specifiers, <a href="#6.7.2">6.7.2</a>
+ tgamma type-generic macro, <a href="#7.22">7.22</a>                               type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+ tgmath.h header, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                    typedef declaration, <a href="#6.7.7">6.7.7</a>
+ time                                                          typedef storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.7.7">6.7.7</a>
+    broken down, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.3">7.23.3</a>, <a href="#7.23.3.1">7.23.3.1</a>,           types, <a href="#6.2.5">6.2.5</a>
+          <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>, <a href="#7.23.3.5">7.23.3.5</a>                            character, <a href="#6.7.8">6.7.8</a>
+    calendar, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.2">7.23.2.2</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.2.4">7.23.2.4</a>,               compatible, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.5">6.7.5</a>
+          <a href="#7.23.3.2">7.23.3.2</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>                            complex, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>
+    components, <a href="#7.23.1">7.23.1</a>                                            composite, <a href="#6.2.7">6.2.7</a>
+    conversion functions, <a href="#7.23.3">7.23.3</a>                                  const qualified, <a href="#6.7.3">6.7.3</a>
+       wide character, <a href="#7.24.5">7.24.5</a>                                     conversions, <a href="#6.3">6.3</a>
+    local, <a href="#7.23.1">7.23.1</a>                                                 imaginary, <a href="#G">G</a>
+    manipulation functions, <a href="#7.23.2">7.23.2</a>                                restrict qualified, <a href="#6.7.3">6.7.3</a>
+ time function, <a href="#7.23.2.4">7.23.2.4</a>                                          volatile qualified, <a href="#6.7.3">6.7.3</a>
+ time.h header, <a href="#7.23">7.23</a>
+ time_t type, <a href="#7.23.1">7.23.1</a>                                           UCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ tm structure type, <a href="#7.23.1">7.23.1</a>, <a href="#7.24.1">7.24.1</a>                             UINT_FASTN_MAX macros, <a href="#7.18.2.3">7.18.2.3</a>
+ TMP_MAX macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.19.4.4">7.19.4.4</a>                     uint_fastN_t types, <a href="#7.18.1.3">7.18.1.3</a>
+ tmpfile function, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.20.4.3">7.20.4.3</a>                          UINT_LEASTN_MAX macros, <a href="#7.18.2.2">7.18.2.2</a>
+ tmpnam function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.19.4.4">7.19.4.4</a>                   uint_leastN_t types, <a href="#7.18.1.2">7.18.1.2</a>
+ token, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, see also preprocessing tokens            UINT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ token concatenation, <a href="#6.10.3.3">6.10.3.3</a>                                 UINTMAX_C macro, <a href="#7.18.4.2">7.18.4.2</a>
+ token pasting, <a href="#6.10.3.3">6.10.3.3</a>                                       UINTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>
+<!--page 551 indent 0-->
+ uintmax_t type, <a href="#7.18.1.5">7.18.1.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,               USHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+      <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                     usual arithmetic conversions, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.5.5">6.5.5</a>, <a href="#6.5.6">6.5.6</a>,
+ UINTN_C macros, <a href="#7.18.4.1">7.18.4.1</a>                                          <a href="#6.5.8">6.5.8</a>, <a href="#6.5.9">6.5.9</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>, <a href="#6.5.15">6.5.15</a>
+ UINTN_MAX macros, <a href="#7.18.2.1">7.18.2.1</a>                                  utilities, general, <a href="#7.20">7.20</a>
+ uintN_t types, <a href="#7.18.1.1">7.18.1.1</a>                                        wide string, <a href="#7.24.4">7.24.4</a>
+ UINTPTR_MAX macro, <a href="#7.18.2.4">7.18.2.4</a>
+ uintptr_t type, <a href="#7.18.1.4">7.18.1.4</a>                                    va_arg macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.2">7.15.1.2</a>,
+ ULLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,                           <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>,
+      <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                  <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
+ ULONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,                            <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>,
+      <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                  <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
+ unary arithmetic operators, <a href="#6.5.3.3">6.5.3.3</a>                         va_copy macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.2">7.15.1.2</a>,
+ unary expression, <a href="#6.5.3">6.5.3</a>                                          <a href="#7.15.1.3">7.15.1.3</a>
+ unary minus operator (-), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>                      va_end macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.3">7.15.1.3</a>,
+ unary operators, <a href="#6.5.3">6.5.3</a>                                           <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>,
+ unary plus operator (+), <a href="#6.5.3.3">6.5.3.3</a>                                 <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
+ unbuffered stream, <a href="#7.19.3">7.19.3</a>                                        <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>,
+ undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,                  <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
+      <a href="#7.1.4">7.1.4</a>                                                  va_list type, <a href="#7.15">7.15</a>, <a href="#7.15.1.3">7.15.1.3</a>
+ undefined behavior, <a href="#3.4.3">3.4.3</a>, <a href="#4">4</a>, <a href="#J.2">J.2</a>                            va_start macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>,
+ underscore character, <a href="#6.4.2.1">6.4.2.1</a>                                    <a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.3">7.15.1.3</a>, <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>,
+ underscore, leading, in identifier, <a href="#7.1.3">7.1.3</a>                         <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>, <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>,
+ ungetc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,                    <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>, <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>,
+      <a href="#7.19.9.3">7.19.9.3</a>                                                    <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
+ ungetwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.10">7.24.3.10</a>                         value, <a href="#3.17">3.17</a>
+ Unicode required set, <a href="#6.10.8">6.10.8</a>                                value bits, <a href="#6.2.6.2">6.2.6.2</a>
+ union                                                       variable arguments, <a href="#6.10.3">6.10.3</a>, <a href="#7.15">7.15</a>
+   arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                              variable arguments header, <a href="#7.15">7.15</a>
+   content, <a href="#6.7.2.3">6.7.2.3</a>                                          variable length array, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
+   dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                 variably modified type, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
+   initialization, <a href="#6.7.8">6.7.8</a>                                     vertical-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+   member alignment, <a href="#6.7.2.1">6.7.2.1</a>                                 vertical-tab escape sequence (\v), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+   member name space, <a href="#6.2.3">6.2.3</a>                                       <a href="#7.4.1.10">7.4.1.10</a>
+   member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>                     vfprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>
+   pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                            vfscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>
+   specifier, <a href="#6.7.2.1">6.7.2.1</a>                                         vfwprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.5">7.24.2.5</a>
+   tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>                                       vfwscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.3.10">7.24.3.10</a>
+   type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>                                      visibility of identifier, <a href="#6.2.1">6.2.1</a>
+ universal character name, <a href="#6.4.3">6.4.3</a>                             VLA, see variable length array
+ unqualified type, <a href="#6.2.5">6.2.5</a>                                      void expression, <a href="#6.3.2.2">6.3.2.2</a>
+ unqualified version of type, <a href="#6.2.5">6.2.5</a>                           void function parameter, <a href="#6.7.5.3">6.7.5.3</a>
+ unsigned integer suffix, u or <a href="#U">U</a>, <a href="#6.4.4.1">6.4.4.1</a>                     void type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.7.2">6.7.2</a>
+ unsigned integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>             void type conversion, <a href="#6.3.2.2">6.3.2.2</a>
+ unsigned type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,                 volatile storage, <a href="#5.1.2.3">5.1.2.3</a>
+      <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                       volatile type qualifier, <a href="#6.7.3">6.7.3</a>
+ unsigned types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,           volatile-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
+      <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                     vprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.10">7.19.6.10</a>
+ unspecified behavior, <a href="#3.4.4">3.4.4</a>, <a href="#4">4</a>, <a href="#J.1">J.1</a>                          vscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.11">7.19.6.11</a>
+ unspecified value, <a href="#3.17.3">3.17.3</a>                                    vsnprintf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.12">7.19.6.12</a>
+ uppercase letter, <a href="#5.2.1">5.2.1</a>                                     vsprintf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.13">7.19.6.13</a>
+ use of library functions, <a href="#7.1.4">7.1.4</a>                             vsscanf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.14">7.19.6.14</a>
+<!--page 552 indent 0-->
+ vswprintf function, <a href="#7.24.2.7">7.24.2.7</a>                                  wctype.h header, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>
+ vswscanf function, <a href="#7.24.2.8">7.24.2.8</a>                                   wctype_t type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
+ vwprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.9">7.24.2.9</a>                           WEOF macro, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.3.6">7.24.3.6</a>,
+ vwscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.3.10">7.24.3.10</a>                     <a href="#7.24.3.7">7.24.3.7</a>, <a href="#7.24.3.8">7.24.3.8</a>, <a href="#7.24.3.9">7.24.3.9</a>, <a href="#7.24.3.10">7.24.3.10</a>,
+                                                                    <a href="#7.24.6.1.1">7.24.6.1.1</a>, <a href="#7.25.1">7.25.1</a>
+ warnings, <a href="#I">I</a>                                                   while statement, <a href="#6.8.5.1">6.8.5.1</a>
+ wchar.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>, <a href="#7.26.12">7.26.12</a>,             white space, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+     <a href="#F">F</a>                                                              <a href="#7.25.2.1.10">7.25.2.1.10</a>
+ WCHAR_MAX macro, <a href="#7.18.3">7.18.3</a>, <a href="#7.24.1">7.24.1</a>                               white-space characters, <a href="#6.4">6.4</a>
+ WCHAR_MIN macro, <a href="#7.18.3">7.18.3</a>, <a href="#7.24.1">7.24.1</a>                               wide character, <a href="#3.7.3">3.7.3</a>
+ wchar_t type, <a href="#3.7.3">3.7.3</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.8">6.7.8</a>,                     case mapping functions, <a href="#7.25.3.1">7.25.3.1</a>
+     <a href="#6.10.8">6.10.8</a>, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20">7.20</a>,                extensible, <a href="#7.25.3.2">7.25.3.2</a>
+     <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  classification functions, <a href="#7.25.2.1">7.25.2.1</a>
+ wcrtomb function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                      extensible, <a href="#7.25.2.2">7.25.2.2</a>
+     <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                      constant, <a href="#6.4.4.4">6.4.4.4</a>
+ wcscat function, <a href="#7.24.4.3.1">7.24.4.3.1</a>                                     formatted input/output functions, <a href="#7.24.2">7.24.2</a>
+ wcschr function, <a href="#7.24.4.5.1">7.24.4.5.1</a>                                     input functions, <a href="#7.19.1">7.19.1</a>
+ wcscmp function, <a href="#7.24.4.4.1">7.24.4.4.1</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>                         input/output functions, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3">7.24.3</a>
+ wcscoll function, <a href="#7.24.4.4.2">7.24.4.4.2</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>                        output functions, <a href="#7.19.1">7.19.1</a>
+ wcscpy function, <a href="#7.24.4.2.1">7.24.4.2.1</a>                                     single-byte conversion functions, <a href="#7.24.6.1">7.24.6.1</a>
+ wcscspn function, <a href="#7.24.4.5.2">7.24.4.5.2</a>                                  wide string, <a href="#7.1.1">7.1.1</a>
+ wcsftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.24.5.1">7.24.5.1</a>                         wide string comparison functions, <a href="#7.24.4.4">7.24.4.4</a>
+ wcslen function, <a href="#7.24.4.6.1">7.24.4.6.1</a>                                   wide string concatenation functions, <a href="#7.24.4.3">7.24.4.3</a>
+ wcsncat function, <a href="#7.24.4.3.2">7.24.4.3.2</a>                                  wide string copying functions, <a href="#7.24.4.2">7.24.4.2</a>
+ wcsncmp function, <a href="#7.24.4.4.3">7.24.4.4.3</a>                                  wide string literal, see string literal
+ wcsncpy function, <a href="#7.24.4.2.2">7.24.4.2.2</a>                                  wide string miscellaneous functions, <a href="#7.24.4.6">7.24.4.6</a>
+ wcspbrk function, <a href="#7.24.4.5.3">7.24.4.5.3</a>                                  wide string numeric conversion functions, <a href="#7.8.2.4">7.8.2.4</a>,
+ wcsrchr function, <a href="#7.24.4.5.4">7.24.4.5.4</a>                                       <a href="#7.24.4.1">7.24.4.1</a>
+ wcsrtombs function, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                wide string search functions, <a href="#7.24.4.5">7.24.4.5</a>
+ wcsspn function, <a href="#7.24.4.5.5">7.24.4.5.5</a>                                   wide-oriented stream, <a href="#7.19.2">7.19.2</a>
+ wcsstr function, <a href="#7.24.4.5.6">7.24.4.5.6</a>                                   width, <a href="#6.2.6.2">6.2.6.2</a>
+ wcstod function, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>                           WINT_MAX macro, <a href="#7.18.3">7.18.3</a>
+ wcstod function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                   WINT_MIN macro, <a href="#7.18.3">7.18.3</a>
+ wcstof function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                   wint_t type, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>,
+ wcstoimax function, <a href="#7.8.2.4">7.8.2.4</a>                                        <a href="#7.25.1">7.25.1</a>
+ wcstok function, <a href="#7.24.4.5.7">7.24.4.5.7</a>                                   wmemchr function, <a href="#7.24.4.5.8">7.24.4.5.8</a>
+ wcstol function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                 wmemcmp function, <a href="#7.24.4.4.5">7.24.4.4.5</a>
+     <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                wmemcpy function, <a href="#7.24.4.2.3">7.24.4.2.3</a>
+ wcstold function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                  wmemmove function, <a href="#7.24.4.2.4">7.24.4.2.4</a>
+ wcstoll function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                         wmemset function, <a href="#7.24.4.6.2">7.24.4.6.2</a>
+ wcstombs function, <a href="#7.20.8.2">7.20.8.2</a>, <a href="#7.24.6.4">7.24.6.4</a>                         wprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.11">7.24.2.11</a>
+ wcstoul function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                wscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.2.12">7.24.2.12</a>,
+     <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                     <a href="#7.24.3.10">7.24.3.10</a>
+ wcstoull function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>
+ wcstoumax function, <a href="#7.8.2.4">7.8.2.4</a>                                   xor macro, <a href="#7.9">7.9</a>
+ wcsxfrm function, <a href="#7.24.4.4.4">7.24.4.4.4</a>                                  xor_eq macro, <a href="#7.9">7.9</a>
+ wctob function, <a href="#7.24.6.1.2">7.24.6.1.2</a>, <a href="#7.25.2.1">7.25.2.1</a>
+ wctomb function, <a href="#7.20.7.3">7.20.7.3</a>, <a href="#7.20.8.2">7.20.8.2</a>, <a href="#7.24.6.3">7.24.6.3</a>
+ wctrans function, <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+ wctrans_t type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+ wctype function, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
+</pre>
+</body></html>
diff --git a/n1256.pre.html b/n1256.pre.html
new file mode 100644
index 0000000..edd1a81
--- /dev/null
+++ b/n1256.pre.html
@@ -0,0 +1,20761 @@
+<html><head><title>WG14/N1256                Committee Draft -- Septermber 7, 2007                   ISO/IEC 9899:TC3</title></head><body><pre>
+WG14/N1256                Committee Draft -- Septermber 7, 2007                   ISO/IEC 9899:TC3
+
+
+<a name="Contents" href="#Contents">Contents</a>
+<a href="#Foreword">Foreword       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                   xi</a>
+<a href="#Introduction">Introduction     . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                  xiv</a>
+<a href="#1">1. Scope       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                    1</a>
+<a href="#2">2. Normative references      . . . . . . . . . . . . . . . . . . . . . . .                                  2</a>
+<a href="#3">3. Terms, definitions, and symbols     . . . . . . . . . . . . . . . . . . .                                 3</a>
+<a href="#4">4. Conformance       . . . . . . . . . . . . . . . . . . . . . . . . . .                                    7</a>
+<a href="#5">5. Environment    . . . . . . . . . . .        . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9</a>
+<a href="#5.1">   5.1 Conceptual models      . . . . . .      . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9</a>
+<a href="#5.1.1">        5.1.1  Translation environment .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .    9</a>
+<a href="#5.1.2">        5.1.2  Execution environments     .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .   11</a>
+<a href="#5.2">   5.2 Environmental considerations    . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   17</a>
+<a href="#5.2.1">        5.2.1 Character sets     . . . . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   17</a>
+<a href="#5.2.2">        5.2.2  Character display semantics       .   .   .   .   .   .   .   .    .   .   .   .   .   .   19</a>
+<a href="#5.2.3">        5.2.3 Signals and interrupts . .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .   20</a>
+<a href="#5.2.4">        5.2.4  Environmental limits    . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .   20</a>
+<a href="#6">6. Language . . . . . . . . . . . . . . . .              .   .   .   .   .   .    .   .   .   .   .   .   29</a>
+<a href="#6.1">   6.1 Notation . . . . . . . . . . . . . .              .   .   .   .   .   .    .   .   .   .   .   .   29</a>
+<a href="#6.2">   6.2 Concepts      . . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   29</a>
+<a href="#6.2.1">        6.2.1 Scopes of identifiers      . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   29</a>
+<a href="#6.2.2">        6.2.2   Linkages of identifiers . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   30</a>
+<a href="#6.2.3">        6.2.3 Name spaces of identifiers      . . .       .   .   .   .   .   .    .   .   .   .   .   .   31</a>
+<a href="#6.2.4">        6.2.4 Storage durations of objects     . .       .   .   .   .   .   .    .   .   .   .   .   .   32</a>
+<a href="#6.2.5">        6.2.5 Types       . . . . . . . . . . .          .   .   .   .   .   .    .   .   .   .   .   .   33</a>
+<a href="#6.2.6">        6.2.6 Representations of types . . . .           .   .   .   .   .   .    .   .   .   .   .   .   37</a>
+<a href="#6.2.7">        6.2.7 Compatible type and composite type             .   .   .   .   .    .   .   .   .   .   .   40</a>
+<a href="#6.3">   6.3 Conversions     . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   42</a>
+<a href="#6.3.1">        6.3.1 Arithmetic operands       . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   42</a>
+<a href="#6.3.2">        6.3.2 Other operands        . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   46</a>
+<a href="#6.4">   6.4 Lexical elements      . . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   49</a>
+<a href="#6.4.1">        6.4.1 Keywords . . . . . . . . . .               .   .   .   .   .   .    .   .   .   .   .   .   50</a>
+<a href="#6.4.2">        6.4.2 Identifiers . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .   51</a>
+<a href="#6.4.3">        6.4.3 Universal character names      . . .       .   .   .   .   .   .    .   .   .   .   .   .   53</a>
+<a href="#6.4.4">        6.4.4   Constants . . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .   54</a>
+<a href="#6.4.5">        6.4.5 String literals     . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   62</a>
+<a href="#6.4.6">        6.4.6   Punctuators . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .   63</a>
+<a href="#6.4.7">        6.4.7 Header names        . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .   64</a>
+<a href="#6.4.8">        6.4.8 Preprocessing numbers        . . . .       .   .   .   .   .   .    .   .   .   .   .   .   65</a>
+<a href="#6.4.9">        6.4.9 Comments         . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .   66</a>
+<a href="#6.5">   6.5 Expressions     . . . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .   67</a>
+
+[page iii]
+
+<a href="#6.5.1">          6.5.1   Primary expressions      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    69</a>
+<a href="#6.5.2">          6.5.2 Postfix operators . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .    69</a>
+<a href="#6.5.3">          6.5.3   Unary operators      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    78</a>
+<a href="#6.5.4">          6.5.4 Cast operators . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .    81</a>
+<a href="#6.5.5">          6.5.5   Multiplicative operators   . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    82</a>
+<a href="#6.5.6">          6.5.6 Additive operators       . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    82</a>
+<a href="#6.5.7">          6.5.7 Bitwise shift operators . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .    84</a>
+<a href="#6.5.8">          6.5.8   Relational operators . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    85</a>
+<a href="#6.5.9">          6.5.9 Equality operators       . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    86</a>
+<a href="#6.5.10">          6.5.10 Bitwise AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    87</a>
+<a href="#6.5.11">          6.5.11 Bitwise exclusive OR operator         .   .   .   .   .   .   .   .   .   .   .   .   .    88</a>
+<a href="#6.5.12">          6.5.12 Bitwise inclusive OR operator     .   .   .   .   .   .   .   .   .   .   .   .   .   .    88</a>
+<a href="#6.5.13">          6.5.13 Logical AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    89</a>
+<a href="#6.5.14">          6.5.14 Logical OR operator       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    89</a>
+<a href="#6.5.15">          6.5.15 Conditional operator      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    90</a>
+<a href="#6.5.16">          6.5.16 Assignment operators . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    91</a>
+<a href="#6.5.17">          6.5.17 Comma operator . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .    94</a>
+<a href="#6.6">     6.6 Constant expressions . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    95</a>
+<a href="#6.7">     6.7 Declarations     . . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .    97</a>
+<a href="#6.7.1">          6.7.1 Storage-class specifiers      . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    98</a>
+<a href="#6.7.2">          6.7.2   Type specifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    99</a>
+<a href="#6.7.3">          6.7.3 Type qualifiers . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   108</a>
+<a href="#6.7.4">          6.7.4   Function specifiers     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   112</a>
+<a href="#6.7.5">          6.7.5 Declarators        . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   114</a>
+<a href="#6.7.6">          6.7.6 Type names . . . . . . .           .   .   .   .   .   .   .   .   .   .   .   .   .   .   122</a>
+<a href="#6.7.7">          6.7.7   Type definitions      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   123</a>
+<a href="#6.7.8">          6.7.8 Initialization       . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   125</a>
+<a href="#6.8">     6.8 Statements and blocks       . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   131</a>
+<a href="#6.8.1">          6.8.1   Labeled statements     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   131</a>
+<a href="#6.8.2">          6.8.2 Compound statement         . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   132</a>
+<a href="#6.8.3">          6.8.3 Expression and null statements         .   .   .   .   .   .   .   .   .   .   .   .   .   132</a>
+<a href="#6.8.4">          6.8.4 Selection statements       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   133</a>
+<a href="#6.8.5">          6.8.5 Iteration statements . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   135</a>
+<a href="#6.8.6">          6.8.6 Jump statements        . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   136</a>
+<a href="#6.9">     6.9 External definitions       . . . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   140</a>
+<a href="#6.9.1">          6.9.1   Function definitions . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   141</a>
+<a href="#6.9.2">          6.9.2 External object definitions     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   143</a>
+<a href="#6.10">     6.10 Preprocessing directives     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   145</a>
+<a href="#6.10.1">          6.10.1 Conditional inclusion     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147</a>
+<a href="#6.10.2">          6.10.2 Source file inclusion      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   149</a>
+<a href="#6.10.3">          6.10.3 Macro replacement . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   151</a>
+<a href="#6.10.4">          6.10.4 Line control . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   158</a>
+<a href="#6.10.5">          6.10.5 Error directive . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   159</a>
+<a href="#6.10.6">          6.10.6 Pragma directive . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   159</a>
+
+[page iv]
+
+<a href="#6.10.7">       6.10.7 Null directive      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   160</a>
+<a href="#6.10.8">       6.10.8 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   160</a>
+<a href="#6.10.9">       6.10.9 Pragma operator       . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   161</a>
+<a href="#6.11">  6.11 Future language directions     . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.1">       6.11.1 Floating types      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.2">       6.11.2 Linkages of identifiers . .      .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.3">       6.11.3 External names        . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.4">       6.11.4 Character escape sequences          .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.5">       6.11.5 Storage-class specifiers     .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.6">       6.11.6 Function declarators      . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.7">       6.11.7 Function definitions . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.8">       6.11.8 Pragma directives       . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#6.11.9">       6.11.9 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   163</a>
+<a href="#7">7. Library . . . . . . . . . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   164</a>
+<a href="#7.1">   7.1 Introduction     . . . . . . . . . . . . . . .                 . .     .    .   .   .   .   .   .   164</a>
+<a href="#7.1.1">         7.1.1 Definitions of terms . . . . . . . . .                  . .     .    .   .   .   .   .   .   164</a>
+<a href="#7.1.2">         7.1.2 Standard headers . . . . . . . . . .                   . .     .    .   .   .   .   .   .   165</a>
+<a href="#7.1.3">         7.1.3 Reserved identifiers . . . . . . . . .                  . .     .    .   .   .   .   .   .   166</a>
+<a href="#7.1.4">         7.1.4 Use of library functions    . . . . . . .              . .     .    .   .   .   .   .   .   166</a>
+<a href="#7.2">   7.2 Diagnostics &lt;assert.h&gt;          . . . . . . . . .              . .     .    .   .   .   .   .   .   169</a>
+<a href="#7.2.1">         7.2.1 Program diagnostics       . . . . . . . .              . .     .    .   .   .   .   .   .   169</a>
+<a href="#7.3">   7.3 Complex arithmetic &lt;complex.h&gt;           . . . . .             . .     .    .   .   .   .   .   .   170</a>
+<a href="#7.3.1">         7.3.1 Introduction . . . . . . . . . . . .                   . .     .    .   .   .   .   .   .   170</a>
+<a href="#7.3.2">         7.3.2 Conventions . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   171</a>
+<a href="#7.3.3">         7.3.3 Branch cuts . . . . . . . . . . . .                    . .     .    .   .   .   .   .   .   171</a>
+<a href="#7.3.4">         7.3.4 The CX_LIMITED_RANGE pragma              . .           . .     .    .   .   .   .   .   .   171</a>
+<a href="#7.3.5">         7.3.5 Trigonometric functions . . . . . . .                  . .     .    .   .   .   .   .   .   172</a>
+<a href="#7.3.6">         7.3.6 Hyperbolic functions      . . . . . . . .              . .     .    .   .   .   .   .   .   174</a>
+<a href="#7.3.7">         7.3.7 Exponential and logarithmic functions      .           . .     .    .   .   .   .   .   .   176</a>
+<a href="#7.3.8">         7.3.8 Power and absolute-value functions       . .           . .     .    .   .   .   .   .   .   177</a>
+<a href="#7.3.9">         7.3.9 Manipulation functions      . . . . . . .              . .     .    .   .   .   .   .   .   178</a>
+<a href="#7.4">   7.4 Character handling &lt;ctype.h&gt; . . . . . . .                     . .     .    .   .   .   .   .   .   181</a>
+<a href="#7.4.1">         7.4.1 Character classification functions      . . .           . .     .    .   .   .   .   .   .   181</a>
+<a href="#7.4.2">         7.4.2 Character case mapping functions       . . .           . .     .    .   .   .   .   .   .   184</a>
+<a href="#7.5">   7.5 Errors &lt;errno.h&gt;         . . . . . . . . . . . .               . .     .    .   .   .   .   .   .   186</a>
+<a href="#7.6">   7.6 Floating-point environment &lt;fenv.h&gt;         . . . .            . .     .    .   .   .   .   .   .   187</a>
+<a href="#7.6.1">         7.6.1 The FENV_ACCESS pragma           . . . . .             . .     .    .   .   .   .   .   .   189</a>
+<a href="#7.6.2">         7.6.2 Floating-point exceptions      . . . . . .             . .     .    .   .   .   .   .   .   190</a>
+<a href="#7.6.3">         7.6.3 Rounding . . . . . . . . . . . . .                     . .     .    .   .   .   .   .   .   193</a>
+<a href="#7.6.4">         7.6.4 Environment        . . . . . . . . . . .               . .     .    .   .   .   .   .   .   194</a>
+<a href="#7.7">   7.7 Characteristics of floating types &lt;float.h&gt; . .                 . .     .    .   .   .   .   .   .   197</a>
+<a href="#7.8">   7.8 Format conversion of integer types &lt;inttypes.h&gt;                  .     .    .   .   .   .   .   .   198</a>
+<a href="#7.8.1">         7.8.1 Macros for format specifiers      . . . . .             . .     .    .   .   .   .   .   .   198</a>
+<a href="#7.8.2">         7.8.2 Functions for greatest-width integer types             . .     .    .   .   .   .   .   .   199</a>
+
+[page v]
+
+<a href="#7.9">     7.9 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . .         .   .   .   .   202</a>
+<a href="#7.10">     7.10 Sizes of integer types &lt;limits.h&gt;       . . . . . . . . . .   .   .   .   .   203</a>
+<a href="#7.11">     7.11 Localization &lt;locale.h&gt; . . . . . . . . . . . . . .           .   .   .   .   204</a>
+<a href="#7.11.1">          7.11.1 Locale control . . . . . . . . . . . . . . . .         .   .   .   .   205</a>
+<a href="#7.11.2">          7.11.2 Numeric formatting convention inquiry . . . . . .      .   .   .   .   206</a>
+<a href="#7.12">     7.12 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .            .   .   .   .   212</a>
+<a href="#7.12.1">          7.12.1 Treatment of error conditions . . . . . . . . . .      .   .   .   .   214</a>
+<a href="#7.12.2">          7.12.2 The FP_CONTRACT pragma           . . . . . . . . . .   .   .   .   .   215</a>
+<a href="#7.12.3">          7.12.3 Classification macros      . . . . . . . . . . . . .    .   .   .   .   216</a>
+<a href="#7.12.4">          7.12.4 Trigonometric functions . . . . . . . . . . . .        .   .   .   .   218</a>
+<a href="#7.12.5">          7.12.5 Hyperbolic functions      . . . . . . . . . . . . .    .   .   .   .   221</a>
+<a href="#7.12.6">          7.12.6 Exponential and logarithmic functions    . . . . . .   .   .   .   .   223</a>
+<a href="#7.12.7">          7.12.7 Power and absolute-value functions     . . . . . . .   .   .   .   .   228</a>
+<a href="#7.12.8">          7.12.8 Error and gamma functions . . . . . . . . . . .        .   .   .   .   230</a>
+<a href="#7.12.9">          7.12.9 Nearest integer functions . . . . . . . . . . . .      .   .   .   .   231</a>
+<a href="#7.12.10">          7.12.10 Remainder functions      . . . . . . . . . . . . .    .   .   .   .   235</a>
+<a href="#7.12.11">          7.12.11 Manipulation functions      . . . . . . . . . . . .   .   .   .   .   236</a>
+<a href="#7.12.12">          7.12.12 Maximum, minimum, and positive difference functions       .   .   .   238</a>
+<a href="#7.12.13">          7.12.13 Floating multiply-add . . . . . . . . . . . . .       .   .   .   .   239</a>
+<a href="#7.12.14">          7.12.14 Comparison macros . . . . . . . . . . . . . .         .   .   .   .   240</a>
+<a href="#7.13">     7.13 Nonlocal jumps &lt;setjmp.h&gt;           . . . . . . . . . . . .   .   .   .   .   243</a>
+<a href="#7.13.1">          7.13.1 Save calling environment       . . . . . . . . . . .   .   .   .   .   243</a>
+<a href="#7.13.2">          7.13.2 Restore calling environment      . . . . . . . . . .   .   .   .   .   244</a>
+<a href="#7.14">     7.14 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . .          .   .   .   .   246</a>
+<a href="#7.14.1">          7.14.1 Specify signal handling      . . . . . . . . . . . .   .   .   .   .   247</a>
+<a href="#7.14.2">          7.14.2 Send signal       . . . . . . . . . . . . . . . . .    .   .   .   .   248</a>
+<a href="#7.15">     7.15 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . .   .   .   .   .   249</a>
+<a href="#7.15.1">          7.15.1 Variable argument list access macros . . . . . . .     .   .   .   .   249</a>
+<a href="#7.16">     7.16 Boolean type and values &lt;stdbool.h&gt;         . . . . . . . .   .   .   .   .   253</a>
+<a href="#7.17">     7.17 Common definitions &lt;stddef.h&gt; . . . . . . . . . . .            .   .   .   .   254</a>
+<a href="#7.18">     7.18 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . .          .   .   .   .   255</a>
+<a href="#7.18.1">          7.18.1 Integer types       . . . . . . . . . . . . . . . .    .   .   .   .   255</a>
+<a href="#7.18.2">          7.18.2 Limits of specified-width integer types   . . . . . .   .   .   .   .   257</a>
+<a href="#7.18.3">          7.18.3 Limits of other integer types    . . . . . . . . . .   .   .   .   .   259</a>
+<a href="#7.18.4">          7.18.4 Macros for integer constants     . . . . . . . . . .   .   .   .   .   260</a>
+<a href="#7.19">     7.19 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . .    .   .   .   .   262</a>
+<a href="#7.19.1">          7.19.1 Introduction . . . . . . . . . . . . . . . . .         .   .   .   .   262</a>
+<a href="#7.19.2">          7.19.2 Streams         . . . . . . . . . . . . . . . . . .    .   .   .   .   264</a>
+<a href="#7.19.3">          7.19.3 Files . . . . . . . . . . . . . . . . . . . .          .   .   .   .   266</a>
+<a href="#7.19.4">          7.19.4 Operations on files      . . . . . . . . . . . . . .    .   .   .   .   268</a>
+<a href="#7.19.5">          7.19.5 File access functions     . . . . . . . . . . . . .    .   .   .   .   270</a>
+<a href="#7.19.6">          7.19.6 Formatted input/output functions     . . . . . . . .   .   .   .   .   274</a>
+<a href="#7.19.7">          7.19.7 Character input/output functions . . . . . . . . .     .   .   .   .   296</a>
+<a href="#7.19.8">          7.19.8 Direct input/output functions    . . . . . . . . . .   .   .   .   .   301</a>
+
+[page vi]
+
+<a href="#7.19.9">         7.19.9 File positioning functions      . . . . . . . . . . . .     .   .   .   302</a>
+<a href="#7.19.10">         7.19.10 Error-handling functions . . . . . . . . . . . . .         .   .   .   304</a>
+<a href="#7.20">  7.20   General utilities &lt;stdlib.h&gt;         . . . . . . . . . . . . .     .   .   .   306</a>
+<a href="#7.20.1">         7.20.1 Numeric conversion functions . . . . . . . . . . .          .   .   .   307</a>
+<a href="#7.20.2">         7.20.2 Pseudo-random sequence generation functions       . . . .   .   .   .   312</a>
+<a href="#7.20.3">         7.20.3 Memory management functions . . . . . . . . . .             .   .   .   313</a>
+<a href="#7.20.4">         7.20.4 Communication with the environment          . . . . . . .   .   .   .   315</a>
+<a href="#7.20.5">         7.20.5 Searching and sorting utilities . . . . . . . . . . .       .   .   .   318</a>
+<a href="#7.20.6">         7.20.6 Integer arithmetic functions      . . . . . . . . . . .     .   .   .   320</a>
+<a href="#7.20.7">         7.20.7 Multibyte/wide character conversion functions     . . . .   .   .   .   321</a>
+<a href="#7.20.8">         7.20.8 Multibyte/wide string conversion functions      . . . . .   .   .   .   323</a>
+<a href="#7.21">  7.21   String handling &lt;string.h&gt; . . . . . . . . . . . . . .             .   .   .   325</a>
+<a href="#7.21.1">         7.21.1 String function conventions . . . . . . . . . . . .         .   .   .   325</a>
+<a href="#7.21.2">         7.21.2 Copying functions       . . . . . . . . . . . . . . .       .   .   .   325</a>
+<a href="#7.21.3">         7.21.3 Concatenation functions . . . . . . . . . . . . .           .   .   .   327</a>
+<a href="#7.21.4">         7.21.4 Comparison functions . . . . . . . . . . . . . .            .   .   .   328</a>
+<a href="#7.21.5">         7.21.5 Search functions      . . . . . . . . . . . . . . . .       .   .   .   330</a>
+<a href="#7.21.6">         7.21.6 Miscellaneous functions . . . . . . . . . . . . .           .   .   .   333</a>
+<a href="#7.22">  7.22   Type-generic math &lt;tgmath.h&gt;           . . . . . . . . . . . .     .   .   .   335</a>
+<a href="#7.23">  7.23   Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .       .   .   .   338</a>
+<a href="#7.23.1">         7.23.1 Components of time         . . . . . . . . . . . . . .      .   .   .   338</a>
+<a href="#7.23.2">         7.23.2 Time manipulation functions       . . . . . . . . . . .     .   .   .   339</a>
+<a href="#7.23.3">         7.23.3 Time conversion functions       . . . . . . . . . . . .     .   .   .   341</a>
+<a href="#7.24">  7.24   Extended multibyte and wide character utilities &lt;wchar.h&gt; . .      .   .   .   348</a>
+<a href="#7.24.1">         7.24.1 Introduction . . . . . . . . . . . . . . . . . .            .   .   .   348</a>
+<a href="#7.24.2">         7.24.2 Formatted wide character input/output functions     . . .   .   .   .   349</a>
+<a href="#7.24.3">         7.24.3 Wide character input/output functions       . . . . . . .   .   .   .   367</a>
+<a href="#7.24.4">         7.24.4 General wide string utilities     . . . . . . . . . . .     .   .   .   371</a>
+<a href="#7.24.5">         7.24.5 Wide character time conversion functions      . . . . . .   .   .   .   385</a>
+<a href="#7.24.6">         7.24.6 Extended multibyte/wide character conversion utilities .    .   .   .   386</a>
+<a href="#7.25">  7.25   Wide character classification and mapping utilities &lt;wctype.h&gt;      .   .   .   393</a>
+<a href="#7.25.1">         7.25.1 Introduction . . . . . . . . . . . . . . . . . .            .   .   .   393</a>
+<a href="#7.25.2">         7.25.2 Wide character classification utilities . . . . . . . .      .   .   .   394</a>
+<a href="#7.25.3">         7.25.3 Wide character case mapping utilities . . . . . . . .       .   .   .   399</a>
+<a href="#7.26">  7.26   Future library directions    . . . . . . . . . . . . . . . .       .   .   .   401</a>
+<a href="#7.26.1">         7.26.1 Complex arithmetic &lt;complex.h&gt; . . . . . . . .              .   .   .   401</a>
+<a href="#7.26.2">         7.26.2 Character handling &lt;ctype.h&gt;           . . . . . . . . .    .   .   .   401</a>
+<a href="#7.26.3">         7.26.3 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .      .   .   .   401</a>
+<a href="#7.26.4">         7.26.4 Format conversion of integer types &lt;inttypes.h&gt;         .   .   .   .   401</a>
+<a href="#7.26.5">         7.26.5 Localization &lt;locale.h&gt;           . . . . . . . . . . .     .   .   .   401</a>
+<a href="#7.26.6">         7.26.6 Signal handling &lt;signal.h&gt;           . . . . . . . . . .    .   .   .   401</a>
+<a href="#7.26.7">         7.26.7 Boolean type and values &lt;stdbool.h&gt;           . . . . . .   .   .   .   401</a>
+<a href="#7.26.8">         7.26.8 Integer types &lt;stdint.h&gt;          . . . . . . . . . . .     .   .   .   401</a>
+<a href="#7.26.9">         7.26.9 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .     .   .   .   402</a>
+
+[page vii]
+
+<a href="#7.26.10">        7.26.10 General utilities &lt;stdlib.h&gt;      . . . . . . .            . . . . . . 402</a>
+<a href="#7.26.11">        7.26.11 String handling &lt;string.h&gt;        . . . . . . .            . . . . . . 402</a>
+<a href="#7.26.12">        7.26.12 Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;          . . . . . . . . . . . . . .             . . . . . . 402</a>
+<a href="#7.26.13">        7.26.13 Wide character classification and mapping utilities
+                &lt;wctype.h&gt; . . . . . . . . . . . . . .                     . . . . . . 402</a>
+<a href="#A">Annex A (informative) Language syntax summary   . .       .    .   .   .   .   .   .   .   .   .   403</a>
+<a href="#A.1">  A.1 Lexical grammar       . . . . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   403</a>
+<a href="#A.2">  A.2 Phrase structure grammar . . . . . . . . .          .    .   .   .   .   .   .   .   .   .   409</a>
+<a href="#A.3">  A.3 Preprocessing directives    . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   416</a>
+<a href="#B">Annex B (informative) Library summary     . . . . . . . . . . . . .                    .   .   .   419</a>
+<a href="#B.1">  B.1 Diagnostics &lt;assert.h&gt;          . . . . . . . . . . . . . . .                    .   .   .   419</a>
+<a href="#B.2">  B.2 Complex &lt;complex.h&gt; . . . . . . . . . . . . . . . .                              .   .   .   419</a>
+<a href="#B.3">  B.3 Character handling &lt;ctype.h&gt; . . . . . . . . . . . . .                           .   .   .   421</a>
+<a href="#B.4">  B.4 Errors &lt;errno.h&gt;         . . . . . . . . . . . . . . . . . .                     .   .   .   421</a>
+<a href="#B.5">  B.5 Floating-point environment &lt;fenv.h&gt;          . . . . . . . . . .                 .   .   .   421</a>
+<a href="#B.6">  B.6 Characteristics of floating types &lt;float.h&gt; . . . . . . . .                       .   .   .   422</a>
+<a href="#B.7">  B.7 Format conversion of integer types &lt;inttypes.h&gt; . . . . .                        .   .   .   422</a>
+<a href="#B.8">  B.8 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . . .                         .   .   .   423</a>
+<a href="#B.9">  B.9 Sizes of integer types &lt;limits.h&gt;          . . . . . . . . . . .                 .   .   .   423</a>
+<a href="#B.10">  B.10 Localization &lt;locale.h&gt; . . . . . . . . . . . . . . .                           .   .   .   423</a>
+<a href="#B.11">  B.11 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . . .                            .   .   .   423</a>
+<a href="#B.12">  B.12 Nonlocal jumps &lt;setjmp.h&gt;          . . . . . . . . . . . . .                    .   .   .   428</a>
+<a href="#B.13">  B.13 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . . .                          .   .   .   428</a>
+<a href="#B.14">  B.14 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . . .                   .   .   .   428</a>
+<a href="#B.15">  B.15 Boolean type and values &lt;stdbool.h&gt;           . . . . . . . . .                 .   .   .   428</a>
+<a href="#B.16">  B.16 Common definitions &lt;stddef.h&gt; . . . . . . . . . . . .                            .   .   .   429</a>
+<a href="#B.17">  B.17 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . . .                          .   .   .   429</a>
+<a href="#B.18">  B.18 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   429</a>
+<a href="#B.19">  B.19 General utilities &lt;stdlib.h&gt;       . . . . . . . . . . . . .                    .   .   .   431</a>
+<a href="#B.20">  B.20 String handling &lt;string.h&gt; . . . . . . . . . . . . . .                          .   .   .   433</a>
+<a href="#B.21">  B.21 Type-generic math &lt;tgmath.h&gt;          . . . . . . . . . . . .                   .   .   .   434</a>
+<a href="#B.22">  B.22 Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   434</a>
+<a href="#B.23">  B.23 Extended multibyte/wide character utilities &lt;wchar.h&gt;     . . .                 .   .   .   435</a>
+<a href="#B.24">  B.24 Wide character classification and mapping utilities &lt;wctype.h&gt;                   .   .   .   437</a>
+<a href="#C">Annex C (informative) Sequence points     . . . . . . . . . . . . . . . . . 439</a>
+<a href="#D">Annex D (normative) Universal character names for identifiers           . . . . . . . 440</a>
+<a href="#E">Annex E (informative) Implementation limits        . . . . . . . . . . . . . . 442</a>
+<a href="#F">Annex F (normative) IEC 60559 floating-point arithmetic    .    .   .   .   .   .   .   .   .   .   444</a>
+<a href="#F.1">  F.1 Introduction     . . . . . . . . . . . . . .        .    .   .   .   .   .   .   .   .   .   444</a>
+<a href="#F.2">  F.2 Types . . . . . . . . . . . . . . . . .             .    .   .   .   .   .   .   .   .   .   444</a>
+<a href="#F.3">  F.3 Operators and functions     . . . . . . . . .       .    .   .   .   .   .   .   .   .   .   445</a>
+
+[page viii]
+
+<a href="#F.4">   F.4   Floating to integer conversion       .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   447</a>
+<a href="#F.5">   F.5   Binary-decimal conversion        .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   447</a>
+<a href="#F.6">   F.6   Contracted expressions . .       .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   448</a>
+<a href="#F.7">   F.7   Floating-point environment       .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   448</a>
+<a href="#F.8">   F.8   Optimization . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   451</a>
+<a href="#F.9">   F.9   Mathematics &lt;math.h&gt; .           .   .   .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   454</a>
+<a href="#G">Annex G (informative) IEC 60559-compatible complex arithmetic                              .   .   .   .   .   .   467</a>
+<a href="#G.1">  G.1 Introduction      . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   467</a>
+<a href="#G.2">  G.2 Types . . . . . . . . . . . . . . . . . . . .                                   .    .   .   .   .   .   .   467</a>
+<a href="#G.3">  G.3 Conventions       . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   467</a>
+<a href="#G.4">  G.4 Conversions       . . . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   468</a>
+<a href="#G.5">  G.5 Binary operators      . . . . . . . . . . . . . . .                             .    .   .   .   .   .   .   468</a>
+<a href="#G.6">  G.6 Complex arithmetic &lt;complex.h&gt;          . . . . . . .                           .    .   .   .   .   .   .   472</a>
+<a href="#G.7">  G.7 Type-generic math &lt;tgmath.h&gt;          . . . . . . . .                           .    .   .   .   .   .   .   480</a>
+<a href="#H">Annex H (informative) Language independent arithmetic . .                         .   .    .   .   .   .   .   .   481</a>
+<a href="#H.1">  H.1 Introduction     . . . . . . . . . . . . . . . .                            .   .    .   .   .   .   .   .   481</a>
+<a href="#H.2">  H.2 Types . . . . . . . . . . . . . . . . . . .                                 .   .    .   .   .   .   .   .   481</a>
+<a href="#H.3">  H.3 Notification      . . . . . . . . . . . . . . . .                            .   .    .   .   .   .   .   .   485</a>
+<a href="#I">Annex I (informative) Common warnings             . . . . . . . . . . . . . . . . 487</a>
+<a href="#J">Annex J (informative) Portability issues      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   489</a>
+<a href="#J.1">  J.1 Unspecified behavior . . . .             . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   489</a>
+<a href="#J.2">  J.2 Undefined behavior          . . . .      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   492</a>
+<a href="#J.3">  J.3 Implementation-defined behavior            . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   505</a>
+<a href="#J.4">  J.4 Locale-specific behavior         . .     . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   512</a>
+<a href="#J.5">  J.5 Common extensions          . . . .      . . . .         .   .   .   .   .   .   .    .   .   .   .   .   .   513</a>
+<a href="#Bibliography">Bibliography      . . . . . . . . . . . . . . . . . . . . . . . . . . . 516</a>
+<a href="#Index">Index     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519</a>
+
+[<a name="pix" href="#pix">page ix</a>] (<a href="#Contents">Contents</a>)
+
+
+[<a name="px" href="#px">page x</a>] (<a href="#Contents">Contents</a>)
+
+<a name="Foreword" href="#Foreword"><b>    Foreword</b></a>
+1   ISO (the International Organization for Standardization) and IEC (the International
+    Electrotechnical Commission) form the specialized system for worldwide
+    standardization. National bodies that are member of ISO or IEC participate in the
+    development of International Standards through technical committees established by the
+    respective organization to deal with particular fields of technical activity. ISO and IEC
+    technical committees collaborate in fields of mutual interest. Other international
+    organizations, governmental and non-governmental, in liaison with ISO and IEC, also
+    take part in the work.
+2   International Standards are drafted in accordance with the rules given in the ISO/IEC
+    Directives, Part 3.
+3   In the field of information technology, ISO and IEC have established a joint technical
+    committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
+    committee are circulated to national bodies for voting. Publication as an International
+    Standard requires approval by at least 75% of the national bodies casting a vote.
+4   International Standard ISO/IEC 9899 was prepared by Joint Technical Committee
+    ISO/IEC JTC 1, Information technology, Subcommittee SC 22, Programming languages,
+    their environments and system software interfaces. The Working Group responsible for
+    this standard (WG 14) maintains a site on the World Wide Web at
+    http://www.open-std.org/JTC1/SC22/WG14/                        containing      additional
+    information relevant to this standard such as a Rationale for many of the decisions made
+    during its preparation and a log of Defect Reports and Responses.
+5   This second edition cancels and replaces the first edition, ISO/IEC 9899:1990, as
+    amended and corrected by ISO/IEC 9899/COR1:1994, ISO/IEC 9899/AMD1:1995, and
+    ISO/IEC 9899/COR2:1996. Major changes from the previous edition include:
+    -- restricted character set support via digraphs and <a href="#7.9">&lt;iso646.h&gt;</a> (originally specified
+      in AMD1)
+    -- wide character library support in <a href="#7.24">&lt;wchar.h&gt;</a> and <a href="#7.25">&lt;wctype.h&gt;</a> (originally
+      specified in AMD1)
+    -- more precise aliasing rules via effective type
+    -- restricted pointers
+    -- variable length arrays
+    -- flexible array members
+    -- static and type qualifiers in parameter array declarators
+    -- complex (and imaginary) support in <a href="#7.3">&lt;complex.h&gt;</a>
+    -- type-generic math macros in <a href="#7.22">&lt;tgmath.h&gt;</a>
+    -- the long long int type and library functions
+
+[<a name="pxi" href="#pxi">page xi</a>] (<a href="#Contents">Contents</a>)
+
+-- increased minimum translation limits
+-- additional floating-point characteristics in <a href="#7.7">&lt;float.h&gt;</a>
+-- remove implicit int
+-- reliable integer division
+-- universal character names (\u and \U)
+-- extended identifiers
+-- hexadecimal floating-point constants and %a and %A printf/scanf conversion
+  specifiers
+-- compound literals
+-- designated initializers
+-- // comments
+-- extended integer types and library functions in <a href="#7.8">&lt;inttypes.h&gt;</a> and <a href="#7.18">&lt;stdint.h&gt;</a>
+-- remove implicit function declaration
+-- preprocessor arithmetic done in intmax_t/uintmax_t
+-- mixed declarations and code
+-- new block scopes for selection and iteration statements
+-- integer constant type rules
+-- integer promotion rules
+-- macros with a variable number of arguments
+-- the vscanf family of functions in <a href="#7.19">&lt;stdio.h&gt;</a> and <a href="#7.24">&lt;wchar.h&gt;</a>
+-- additional math library functions in <a href="#7.12">&lt;math.h&gt;</a>
+-- treatment of error conditions by math library functions (math_errhandling)
+-- floating-point environment access in <a href="#7.6">&lt;fenv.h&gt;</a>
+-- IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
+-- trailing comma allowed in enum declaration
+-- %lf conversion specifier allowed in printf
+-- inline functions
+-- the snprintf family of functions in <a href="#7.19">&lt;stdio.h&gt;</a>
+-- boolean type in <a href="#7.16">&lt;stdbool.h&gt;</a>
+-- idempotent type qualifiers
+-- empty macro arguments
+
+[<a name="pxii" href="#pxii">page xii</a>] (<a href="#Contents">Contents</a>)
+
+    -- new structure type compatibility rules (tag compatibility)
+    -- additional predefined macro names
+    -- _Pragma preprocessing operator
+    -- standard pragmas
+    -- __func__ predefined identifier
+    -- va_copy macro
+    -- additional strftime conversion specifiers
+    -- LIA compatibility annex
+    -- deprecate ungetc at the beginning of a binary file
+    -- remove deprecation of aliased array parameters
+    -- conversion of array to pointer not limited to lvalues
+    -- relaxed constraints on aggregate and union initialization
+    -- relaxed restrictions on portable header names
+    -- return without expression not permitted in function that returns a value (and vice
+      versa)
+6   Annexes D and F form a normative part of this standard; annexes A, B, C, E, G, H, I, J,
+    the bibliography, and the index are for information only. In accordance with Part 3 of the
+    ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples are
+    also for information only.
+
+[<a name="pxiii" href="#pxiii">page xiii</a>] (<a href="#Contents">Contents</a>)
+
+<a name="Introduction" href="#Introduction"><b>    Introduction</b></a>
+1   With the introduction of new devices and extended character sets, new features may be
+    added to this International Standard. Subclauses in the language and library clauses warn
+    implementors and programmers of usages which, though valid in themselves, may
+    conflict with future additions.
+2   Certain features are obsolescent, which means that they may be considered for
+    withdrawal in future revisions of this International Standard. They are retained because
+    of their widespread use, but their use in new implementations (for implementation
+    features) or new programs (for language [6.11] or library features [7.26]) is discouraged.
+3   This International Standard is divided into four major subdivisions:
+    -- preliminary elements (clauses 1-4);
+    -- the characteristics of environments that translate and execute C programs (clause 5);
+    -- the language syntax, constraints, and semantics (clause 6);
+    -- the library facilities (clause 7).
+4   Examples are provided to illustrate possible forms of the constructions described.
+    Footnotes are provided to emphasize consequences of the rules described in that
+    subclause or elsewhere in this International Standard. References are used to refer to
+    other related subclauses. Recommendations are provided to give advice or guidance to
+    implementors. Annexes provide additional information and summarize the information
+    contained in this International Standard. A bibliography lists documents that were
+    referred to during the preparation of the standard.
+5   The language clause (clause 6) is derived from ''The C Reference Manual''.
+6   The library clause (clause 7) is based on the 1984 /usr/group Standard.
+
+[<a name="pxiv" href="#pxiv">page xiv</a>] (<a href="#Contents">Contents</a>)
+
+
+
+    Programming languages -- C
+
+
+
+
+<a name="1" href="#1"><b>    1. Scope</b></a>
+1   This International Standard specifies the form and establishes the interpretation of
+    programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
+    -- the representation of C programs;
+    -- the syntax and constraints of the C language;
+    -- the semantic rules for interpreting C programs;
+    -- the representation of input data to be processed by C programs;
+    -- the representation of output data produced by C programs;
+    -- the restrictions and limits imposed by a conforming implementation of C.
+2   This International Standard does not specify
+    -- the mechanism by which C programs are transformed for use by a data-processing
+      system;
+    -- the mechanism by which C programs are invoked for use by a data-processing
+      system;
+    -- the mechanism by which input data are transformed for use by a C program;
+    -- the mechanism by which output data are transformed after being produced by a C
+      program;
+    -- the size or complexity of a program and its data that will exceed the capacity of any
+      specific data-processing system or the capacity of a particular processor;
+
+
+    <sup><a name="note1" href="#note1"><b>1)</b></a></sup>   This International Standard is designed to promote the portability of C programs among a variety of
+         data-processing systems. It is intended for use by implementors and programmers.
+
+[<a name="p1" href="#p1">page 1</a>] (<a href="#Contents">Contents</a>)
+
+    -- all minimal requirements of a data-processing system that is capable of supporting a
+      conforming implementation.
+
+<a name="2" href="#2"><b>    2. Normative references</b></a>
+1   The following normative documents contain provisions which, through reference in this
+    text, constitute provisions of this International Standard. For dated references,
+    subsequent amendments to, or revisions of, any of these publications do not apply.
+    However, parties to agreements based on this International Standard are encouraged to
+    investigate the possibility of applying the most recent editions of the normative
+    documents indicated below. For undated references, the latest edition of the normative
+    document referred to applies. Members of ISO and IEC maintain registers of currently
+    valid International Standards.
+2   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and symbols for
+    use in the physical sciences and technology.
+3   ISO/IEC 646, Information technology -- ISO 7-bit coded character set for information
+    interchange.
+4   ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1: Fundamental
+    terms.
+5   ISO 4217, Codes for the representation of currencies and funds.
+6   ISO 8601, Data elements and interchange formats -- Information interchange --
+    Representation of dates and times.
+7   ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
+    Character Set (UCS).
+8   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously
+    designated IEC 559:1989).
+
+[<a name="p2" href="#p2">page 2</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="3" href="#3"><b>    3. Terms, definitions, and symbols</b></a>
+1   For the purposes of this International Standard, the following definitions apply. Other
+    terms are defined where they appear in italic type or on the left side of a syntax rule.
+    Terms explicitly defined in this International Standard are not to be presumed to refer
+    implicitly to similar terms defined elsewhere. Terms not defined in this International
+    Standard are to be interpreted according to ISO/IEC 2382-1. Mathematical symbols not
+    defined in this International Standard are to be interpreted according to ISO 31-11.
+<a name="3.1" href="#3.1"><b>    3.1</b></a>
+1   access
+    &lt;execution-time action&gt; to read or modify the value of an object
+2   NOTE 1   Where only one of these two actions is meant, ''read'' or ''modify'' is used.
+
+3   NOTE 2   "Modify'' includes the case where the new value being stored is the same as the previous value.
+
+4   NOTE 3   Expressions that are not evaluated do not access objects.
+
+<a name="3.2" href="#3.2"><b>    3.2</b></a>
+1   alignment
+    requirement that objects of a particular type be located on storage boundaries with
+    addresses that are particular multiples of a byte address
+<a name="3.3" href="#3.3"><b>    3.3</b></a>
+1   argument
+    actual argument
+    actual parameter (deprecated)
+    expression in the comma-separated list bounded by the parentheses in a function call
+    expression, or a sequence of preprocessing tokens in the comma-separated list bounded
+    by the parentheses in a function-like macro invocation
+<a name="3.4" href="#3.4"><b>    3.4</b></a>
+1   behavior
+    external appearance or action
+<a name="3.4.1" href="#3.4.1"><b>    3.4.1</b></a>
+1   implementation-defined behavior
+    unspecified behavior where each implementation documents how the choice is made
+2   EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
+    when a signed integer is shifted right.
+
+<a name="3.4.2" href="#3.4.2"><b>    3.4.2</b></a>
+1   locale-specific behavior
+    behavior that depends on local conventions of nationality, culture, and language that each
+    implementation documents
+
+[<a name="p3" href="#p3">page 3</a>] (<a href="#Contents">Contents</a>)
+
+2   EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
+    characters other than the 26 lowercase Latin letters.
+
+<a name="3.4.3" href="#3.4.3"><b>    3.4.3</b></a>
+1   undefined behavior
+    behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
+    for which this International Standard imposes no requirements
+2   NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
+    results, to behaving during translation or program execution in a documented manner characteristic of the
+    environment (with or without the issuance of a diagnostic message), to terminating a translation or
+    execution (with the issuance of a diagnostic message).
+
+3   EXAMPLE        An example of undefined behavior is the behavior on integer overflow.
+
+<a name="3.4.4" href="#3.4.4"><b>    3.4.4</b></a>
+1   unspecified behavior
+    use of an unspecified value, or other behavior where this International Standard provides
+    two or more possibilities and imposes no further requirements on which is chosen in any
+    instance
+2   EXAMPLE        An example of unspecified behavior is the order in which the arguments to a function are
+    evaluated.
+
+<a name="3.5" href="#3.5"><b>    3.5</b></a>
+1   bit
+    unit of data storage in the execution environment large enough to hold an object that may
+    have one of two values
+2   NOTE     It need not be possible to express the address of each individual bit of an object.
+
+<a name="3.6" href="#3.6"><b>    3.6</b></a>
+1   byte
+    addressable unit of data storage large enough to hold any member of the basic character
+    set of the execution environment
+2   NOTE 1 It is possible to express the address of each individual byte of an object uniquely.
+
+3   NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
+    defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
+    bit.
+
+<a name="3.7" href="#3.7"><b>    3.7</b></a>
+1   character
+    &lt;abstract&gt; member of a set of elements used for the organization, control, or
+    representation of data
+<a name="3.7.1" href="#3.7.1"><b>    3.7.1</b></a>
+1   character
+    single-byte character
+    &lt;C&gt; bit representation that fits in a byte
+
+[<a name="p4" href="#p4">page 4</a>] (<a href="#Contents">Contents</a>)
+
+<a name="3.7.2" href="#3.7.2"><b>    3.7.2</b></a>
+1   multibyte character
+    sequence of one or more bytes representing a member of the extended character set of
+    either the source or the execution environment
+2   NOTE    The extended character set is a superset of the basic character set.
+
+<a name="3.7.3" href="#3.7.3"><b>    3.7.3</b></a>
+1   wide character
+    bit representation that fits in an object of type wchar_t, capable of representing any
+    character in the current locale
+<a name="3.8" href="#3.8"><b>    3.8</b></a>
+1   constraint
+    restriction, either syntactic or semantic, by which the exposition of language elements is
+    to be interpreted
+<a name="3.9" href="#3.9"><b>    3.9</b></a>
+1   correctly rounded result
+    representation in the result format that is nearest in value, subject to the current rounding
+    mode, to what the result would be given unlimited range and precision
+<a name="3.10" href="#3.10"><b>    3.10</b></a>
+1   diagnostic message
+    message belonging to an implementation-defined subset of the implementation's message
+    output
+<a name="3.11" href="#3.11"><b>    3.11</b></a>
+1   forward reference
+    reference to a later subclause of this International Standard that contains additional
+    information relevant to this subclause
+<a name="3.12" href="#3.12"><b>    3.12</b></a>
+1   implementation
+    particular set of software, running in a particular translation environment under particular
+    control options, that performs translation of programs for, and supports execution of
+    functions in, a particular execution environment
+<a name="3.13" href="#3.13"><b>    3.13</b></a>
+1   implementation limit
+    restriction imposed upon programs by the implementation
+<a name="3.14" href="#3.14"><b>    3.14</b></a>
+1   object
+    region of data storage in the execution environment, the contents of which can represent
+    values
+
+[<a name="p5" href="#p5">page 5</a>] (<a href="#Contents">Contents</a>)
+
+2   NOTE     When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
+
+<a name="3.15" href="#3.15"><b>    3.15</b></a>
+1   parameter
+    formal parameter
+    formal argument (deprecated)
+    object declared as part of a function declaration or definition that acquires a value on
+    entry to the function, or an identifier from the comma-separated list bounded by the
+    parentheses immediately following the macro name in a function-like macro definition
+<a name="3.16" href="#3.16"><b>    3.16</b></a>
+1   recommended practice
+    specification that is strongly recommended as being in keeping with the intent of the
+    standard, but that may be impractical for some implementations
+<a name="3.17" href="#3.17"><b>    3.17</b></a>
+1   value
+    precise meaning of the contents of an object when interpreted as having a specific type
+<a name="3.17.1" href="#3.17.1"><b>    3.17.1</b></a>
+1   implementation-defined value
+    unspecified value where each implementation documents how the choice is made
+<a name="3.17.2" href="#3.17.2"><b>    3.17.2</b></a>
+1   indeterminate value
+    either an unspecified value or a trap representation
+<a name="3.17.3" href="#3.17.3"><b>    3.17.3</b></a>
+1   unspecified value
+    valid value of the relevant type where this International Standard imposes no
+    requirements on which value is chosen in any instance
+2   NOTE     An unspecified value cannot be a trap representation.
+
+<a name="3.18" href="#3.18"><b>    3.18</b></a>
+1   ??? x???
+    ceiling of x: the least integer greater than or equal to x
+2   EXAMPLE       ???2.4??? is 3, ???-2.4??? is -2.
+
+<a name="3.19" href="#3.19"><b>    3.19</b></a>
+1   ??? x???
+    floor of x: the greatest integer less than or equal to x
+2   EXAMPLE       ???2.4??? is 2, ???-2.4??? is -3.
+
+[<a name="p6" href="#p6">page 6</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="4" href="#4"><b>    4. Conformance</b></a>
+1   In this International Standard, ''shall'' is to be interpreted as a requirement on an
+    implementation or on a program; conversely, ''shall not'' is to be interpreted as a
+    prohibition.
+2   If a ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated, the
+    behavior is undefined. Undefined behavior is otherwise indicated in this International
+    Standard by the words ''undefined behavior'' or by the omission of any explicit definition
+    of behavior. There is no difference in emphasis among these three; they all describe
+    ''behavior that is undefined''.
+3   A program that is correct in all other aspects, operating on correct data, containing
+    unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
+4   The implementation shall not successfully translate a preprocessing translation unit
+    containing a #error preprocessing directive unless it is part of a group skipped by
+    conditional inclusion.
+5   A strictly conforming program shall use only those features of the language and library
+    specified in this International Standard.<sup><a href="#note2"><b>2)</b></a></sup> It shall not produce output dependent on any
+    unspecified, undefined, or implementation-defined behavior, and shall not exceed any
+    minimum implementation limit.
+6   The two forms of conforming implementation are hosted and freestanding. A conforming
+    hosted implementation shall accept any strictly conforming program. A conforming
+    freestanding implementation shall accept any strictly conforming program that does not
+    use complex types and in which the use of the features specified in the library clause
+    (clause 7) is confined to the contents of the standard headers <a href="#7.7">&lt;float.h&gt;</a>,
+    <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#7.15">&lt;stdarg.h&gt;</a>, <a href="#7.16">&lt;stdbool.h&gt;</a>, <a href="#7.17">&lt;stddef.h&gt;</a>, and
+    <a href="#7.18">&lt;stdint.h&gt;</a>. A conforming implementation may have extensions (including additional
+    library functions), provided they do not alter the behavior of any strictly conforming
+    program.<sup><a href="#note3"><b>3)</b></a></sup>
+
+
+
+    <sup><a name="note2" href="#note2"><b>2)</b></a></sup>   A strictly conforming program can use conditional features (such as those in <a href="#F">annex F</a>) provided the
+         use is guarded by a #ifdef directive with the appropriate macro. For example:
+                 #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
+                    /* ... */
+                    fesetround(FE_UPWARD);
+                    /* ... */
+                 #endif
+
+    <sup><a name="note3" href="#note3"><b>3)</b></a></sup>   This implies that a conforming implementation reserves no identifiers other than those explicitly
+         reserved in this International Standard.
+
+[<a name="p7" href="#p7">page 7</a>] (<a href="#Contents">Contents</a>)
+
+7   A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note4"><b>4)</b></a></sup>
+8   An implementation shall be accompanied by a document that defines all implementation-
+    defined and locale-specific characteristics and all extensions.
+    Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
+    characteristics of floating types <a href="#7.7">&lt;float.h&gt;</a> (<a href="#7.7">7.7</a>), alternative spellings <a href="#7.9">&lt;iso646.h&gt;</a>
+    (<a href="#7.9">7.9</a>), sizes of integer types <a href="#7.10">&lt;limits.h&gt;</a> (<a href="#7.10">7.10</a>), variable arguments <a href="#7.15">&lt;stdarg.h&gt;</a>
+    (<a href="#7.15">7.15</a>), boolean type and values <a href="#7.16">&lt;stdbool.h&gt;</a> (<a href="#7.16">7.16</a>), common definitions
+    <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), integer types <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#7.18">7.18</a>).
+
+
+
+
+    <sup><a name="note4" href="#note4"><b>4)</b></a></sup>   Strictly conforming programs are intended to be maximally portable among conforming
+         implementations. Conforming programs may depend upon nonportable features of a conforming
+         implementation.
+
+[<a name="p8" href="#p8">page 8</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="5" href="#5"><b>    5. Environment</b></a>
+1   An implementation translates C source files and executes C programs in two data-
+    processing-system environments, which will be called the translation environment and
+    the execution environment in this International Standard. Their characteristics define and
+    constrain the results of executing conforming C programs constructed according to the
+    syntactic and semantic rules for conforming implementations.
+    Forward references: In this clause, only a few of many possible forward references
+    have been noted.
+<a name="5.1" href="#5.1"><b>    5.1 Conceptual models</b></a>
+<a name="5.1.1" href="#5.1.1"><b>    5.1.1 Translation environment</b></a>
+<a name="5.1.1.1" href="#5.1.1.1"><b>    5.1.1.1 Program structure</b></a>
+1   A C program need not all be translated at the same time. The text of the program is kept
+    in units called source files, (or preprocessing files) in this International Standard. A
+    source file together with all the headers and source files included via the preprocessing
+    directive #include is known as a preprocessing translation unit. After preprocessing, a
+    preprocessing translation unit is called a translation unit. Previously translated translation
+    units may be preserved individually or in libraries. The separate translation units of a
+    program communicate by (for example) calls to functions whose identifiers have external
+    linkage, manipulation of objects whose identifiers have external linkage, or manipulation
+    of data files. Translation units may be separately translated and then later linked to
+    produce an executable program.
+    Forward references: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
+    preprocessing directives (<a href="#6.10">6.10</a>).
+<a name="5.1.1.2" href="#5.1.1.2"><b>    5.1.1.2 Translation phases</b></a>
+1   The precedence among the syntax rules of translation is specified by the following
+    phases.<sup><a href="#note5"><b>5)</b></a></sup>
+         1. Physical source file multibyte characters are mapped, in an implementation-
+            defined manner, to the source character set (introducing new-line characters for
+            end-of-line indicators) if necessary. Trigraph sequences are replaced by
+            corresponding single-character internal representations.
+
+
+
+    <sup><a name="note5" href="#note5"><b>5)</b></a></sup>    Implementations shall behave as if these separate phases occur, even though many are typically folded
+          together in practice. Source files, translation units, and translated translation units need not
+          necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
+          and any external representation. The description is conceptual only, and does not specify any
+          particular implementation.
+
+[<a name="p9" href="#p9">page 9</a>] (<a href="#Contents">Contents</a>)
+
+     2. Each instance of a backslash character (\) immediately followed by a new-line
+        character is deleted, splicing physical source lines to form logical source lines.
+        Only the last backslash on any physical source line shall be eligible for being part
+        of such a splice. A source file that is not empty shall end in a new-line character,
+        which shall not be immediately preceded by a backslash character before any such
+        splicing takes place.
+     3. The source file is decomposed into preprocessing tokens<sup><a href="#note6"><b>6)</b></a></sup> and sequences of
+        white-space characters (including comments). A source file shall not end in a
+        partial preprocessing token or in a partial comment. Each comment is replaced by
+        one space character. New-line characters are retained. Whether each nonempty
+        sequence of white-space characters other than new-line is retained or replaced by
+        one space character is implementation-defined.
+     4.   Preprocessing directives are executed, macro invocations are expanded, and
+          _Pragma unary operator expressions are executed. If a character sequence that
+          matches the syntax of a universal character name is produced by token
+          concatenation (<a href="#6.10.3.3">6.10.3.3</a>), the behavior is undefined. A #include preprocessing
+          directive causes the named header or source file to be processed from phase 1
+          through phase 4, recursively. All preprocessing directives are then deleted.
+     5.   Each source character set member and escape sequence in character constants and
+          string literals is converted to the corresponding member of the execution character
+          set; if there is no corresponding member, it is converted to an implementation-
+          defined member other than the null (wide) character.<sup><a href="#note7"><b>7)</b></a></sup>
+     6. Adjacent string literal tokens are concatenated.
+     7. White-space characters separating tokens are no longer significant. Each
+        preprocessing token is converted into a token. The resulting tokens are
+        syntactically and semantically analyzed and translated as a translation unit.
+     8. All external object and function references are resolved. Library components are
+        linked to satisfy external references to functions and objects not defined in the
+        current translation. All such translator output is collected into a program image
+        which contains information needed for execution in its execution environment.
+Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
+preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href="#5.2.1.1">5.2.1.1</a>), external definitions (<a href="#6.9">6.9</a>).
+
+
+
+<sup><a name="note6" href="#note6"><b>6)</b></a></sup>    As described in <a href="#6.4">6.4</a>, the process of dividing a source file's characters into preprocessing tokens is
+      context-dependent. For example, see the handling of &lt; within a #include preprocessing directive.
+<sup><a name="note7" href="#note7"><b>7)</b></a></sup>    An implementation need not convert all non-corresponding source characters to the same execution
+      character.
+
+[<a name="p10" href="#p10">page 10</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.1.1.3" href="#5.1.1.3"><b>    5.1.1.3 Diagnostics</b></a>
+1   A conforming implementation shall produce at least one diagnostic message (identified in
+    an implementation-defined manner) if a preprocessing translation unit or translation unit
+    contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
+    specified as undefined or implementation-defined. Diagnostic messages need not be
+    produced in other circumstances.<sup><a href="#note8"><b>8)</b></a></sup>
+2   EXAMPLE        An implementation shall issue a diagnostic for the translation unit:
+             char i;
+             int i;
+    because in those cases where wording in this International Standard describes the behavior for a construct
+    as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
+
+<a name="5.1.2" href="#5.1.2"><b>    5.1.2 Execution environments</b></a>
+1   Two execution environments are defined: freestanding and hosted. In both cases,
+    program startup occurs when a designated C function is called by the execution
+    environment. All objects with static storage duration shall be initialized (set to their
+    initial values) before program startup. The manner and timing of such initialization are
+    otherwise unspecified. Program termination returns control to the execution
+    environment.
+    Forward references: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+<a name="5.1.2.1" href="#5.1.2.1"><b>    5.1.2.1 Freestanding environment</b></a>
+1   In a freestanding environment (in which C program execution may take place without any
+    benefit of an operating system), the name and type of the function called at program
+    startup are implementation-defined. Any library facilities available to a freestanding
+    program, other than the minimal set required by clause 4, are implementation-defined.
+2   The effect of program termination in a freestanding environment is implementation-
+    defined.
+<a name="5.1.2.2" href="#5.1.2.2"><b>    5.1.2.2 Hosted environment</b></a>
+1   A hosted environment need not be provided, but shall conform to the following
+    specifications if present.
+
+
+
+
+    <sup><a name="note8" href="#note8"><b>8)</b></a></sup>   The intent is that an implementation should identify the nature of, and where possible localize, each
+         violation. Of course, an implementation is free to produce any number of diagnostics as long as a
+         valid program is still correctly translated. It may also successfully translate an invalid program.
+
+[<a name="p11" href="#p11">page 11</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.1.2.2.1" href="#5.1.2.2.1"><b>    5.1.2.2.1 Program startup</b></a>
+1   The function called at program startup is named main. The implementation declares no
+    prototype for this function. It shall be defined with a return type of int and with no
+    parameters:
+            int main(void) { /* ... */ }
+    or with two parameters (referred to here as argc and argv, though any names may be
+    used, as they are local to the function in which they are declared):
+            int main(int argc, char *argv[]) { /* ... */ }
+    or equivalent;<sup><a href="#note9"><b>9)</b></a></sup> or in some other implementation-defined manner.
+2   If they are declared, the parameters to the main function shall obey the following
+    constraints:
+    -- The value of argc shall be nonnegative.
+    -- argv[argc] shall be a null pointer.
+    -- If the value of argc is greater than zero, the array members argv[0] through
+      argv[argc-1] inclusive shall contain pointers to strings, which are given
+      implementation-defined values by the host environment prior to program startup. The
+      intent is to supply to the program information determined prior to program startup
+      from elsewhere in the hosted environment. If the host environment is not capable of
+      supplying strings with letters in both uppercase and lowercase, the implementation
+      shall ensure that the strings are received in lowercase.
+    -- If the value of argc is greater than zero, the string pointed to by argv[0]
+      represents the program name; argv[0][0] shall be the null character if the
+      program name is not available from the host environment. If the value of argc is
+      greater than one, the strings pointed to by argv[1] through argv[argc-1]
+      represent the program parameters.
+    -- The parameters argc and argv and the strings pointed to by the argv array shall
+      be modifiable by the program, and retain their last-stored values between program
+      startup and program termination.
+<a name="5.1.2.2.2" href="#5.1.2.2.2"><b>    5.1.2.2.2 Program execution</b></a>
+1   In a hosted environment, a program may use all the functions, macros, type definitions,
+    and objects described in the library clause (clause 7).
+
+
+
+    <sup><a name="note9" href="#note9"><b>9)</b></a></sup>   Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
+         char ** argv, and so on.
+
+[<a name="p12" href="#p12">page 12</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.1.2.2.3" href="#5.1.2.2.3"><b>    5.1.2.2.3 Program termination</b></a>
+1   If the return type of the main function is a type compatible with int, a return from the
+    initial call to the main function is equivalent to calling the exit function with the value
+    returned by the main function as its argument;<sup><a href="#note10"><b>10)</b></a></sup> reaching the } that terminates the
+    main function returns a value of 0. If the return type is not compatible with int, the
+    termination status returned to the host environment is unspecified.
+    Forward references: definition of terms (<a href="#7.1.1">7.1.1</a>), the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+<a name="5.1.2.3" href="#5.1.2.3"><b>    5.1.2.3 Program execution</b></a>
+1   The semantic descriptions in this International Standard describe the behavior of an
+    abstract machine in which issues of optimization are irrelevant.
+2   Accessing a volatile object, modifying an object, modifying a file, or calling a function
+    that does any of those operations are all side effects,<sup><a href="#note11"><b>11)</b></a></sup> which are changes in the state of
+    the execution environment. Evaluation of an expression may produce side effects. At
+    certain specified points in the execution sequence called sequence points, all side effects
+    of previous evaluations shall be complete and no side effects of subsequent evaluations
+    shall have taken place. (A summary of the sequence points is given in <a href="#C">annex C</a>.)
+3   In the abstract machine, all expressions are evaluated as specified by the semantics. An
+    actual implementation need not evaluate part of an expression if it can deduce that its
+    value is not used and that no needed side effects are produced (including any caused by
+    calling a function or accessing a volatile object).
+4   When the processing of the abstract machine is interrupted by receipt of a signal, only the
+    values of objects as of the previous sequence point may be relied on. Objects that may be
+    modified between the previous sequence point and the next sequence point need not have
+    received their correct values yet.
+5   The least requirements on a conforming implementation are:
+    -- At sequence points, volatile objects are stable in the sense that previous accesses are
+      complete and subsequent accesses have not yet occurred.
+
+
+
+
+    <sup><a name="note10" href="#note10"><b>10)</b></a></sup> In accordance with <a href="#6.2.4">6.2.4</a>, the lifetimes of objects with automatic storage duration declared in main
+        will have ended in the former case, even where they would not have in the latter.
+    <sup><a name="note11" href="#note11"><b>11)</b></a></sup> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
+        flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
+        values of floating-point operations. Implementations that support such floating-point state are
+        required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
+        environment library <a href="#7.6">&lt;fenv.h&gt;</a> provides a programming facility for indicating when these side
+        effects matter, freeing the implementations in other cases.
+
+[<a name="p13" href="#p13">page 13</a>] (<a href="#Contents">Contents</a>)
+
+     -- At program termination, all data written into files shall be identical to the result that
+       execution of the program according to the abstract semantics would have produced.
+     -- The input and output dynamics of interactive devices shall take place as specified in
+<a name="7.19.3" href="#7.19.3"><b>       7.19.3. The intent of these requirements is that unbuffered or line-buffered output</b></a>
+       appear as soon as possible, to ensure that prompting messages actually appear prior to
+       a program waiting for input.
+6    What constitutes an interactive device is implementation-defined.
+7    More stringent correspondences between abstract and actual semantics may be defined by
+     each implementation.
+8    EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
+     semantics: at every sequence point, the values of the actual objects would agree with those specified by the
+     abstract semantics. The keyword volatile would then be redundant.
+9    Alternatively, an implementation might perform various optimizations within each translation unit, such
+     that the actual semantics would agree with the abstract semantics only when making function calls across
+     translation unit boundaries. In such an implementation, at the time of each function entry and function
+     return where the calling function and the called function are in different translation units, the values of all
+     externally linked objects and of all objects accessible via pointers therein would agree with the abstract
+     semantics. Furthermore, at the time of each such function entry the values of the parameters of the called
+     function and of all objects accessible via pointers therein would agree with the abstract semantics. In this
+     type of implementation, objects referred to by interrupt service routines activated by the signal function
+     would require explicit specification of volatile storage, as well as other implementation-defined
+     restrictions.
+
+10   EXAMPLE 2       In executing the fragment
+              char c1, c2;
+              /* ... */
+              c1 = c1 + c2;
+     the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
+     and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
+     overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
+     produce the same result, possibly omitting the promotions.
+
+11   EXAMPLE 3       Similarly, in the fragment
+              float f1, f2;
+              double d;
+              /* ... */
+              f1 = f2 * d;
+     the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
+     that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
+     were replaced by the constant 2.0, which has type double).
+
+[<a name="p14" href="#p14">page 14</a>] (<a href="#Contents">Contents</a>)
+
+12   EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
+     semantics. Values are independent of whether they are represented in a register or in memory. For
+     example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
+     is required to round to the precision of the storage type. In particular, casts and assignments are required to
+     perform their specified conversion. For the fragment
+              double d1, d2;
+              float f;
+              d1 = f = expression;
+              d2 = (float) expression;
+     the values assigned to d1 and d2 are required to have been converted to float.
+
+13   EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
+     precision as well as range. The implementation cannot generally apply the mathematical associative rules
+     for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
+     overflow and underflow. Likewise, implementations cannot generally replace decimal constants in order to
+     rearrange expressions. In the following fragment, rearrangements suggested by mathematical rules for real
+     numbers are often not valid (see <a href="#F.8">F.8</a>).
+              double x, y, z;
+              /* ... */
+              x = (x * y) * z;            //   not equivalent to x   *= y * z;
+              z = (x - y) + y ;           //   not equivalent to z   = x;
+              z = x + x * y;              //   not equivalent to z   = x * (1.0 + y);
+              y = x / 5.0;                //   not equivalent to y   = x * 0.2;
+
+14   EXAMPLE 6 To illustrate the grouping behavior of expressions, in the following fragment
+              int a, b;
+              /* ... */
+              a = a + 32760 + b + 5;
+     the expression statement behaves exactly the same as
+              a = (((a + 32760) + b) + 5);
+     due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
+     next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
+     which overflows produce an explicit trap and in which the range of values representable by an int is
+     [-32768, +32767], the implementation cannot rewrite this expression as
+              a = ((a + b) + 32765);
+     since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
+     while the original expression would not; nor can the expression be rewritten either as
+              a = ((a + 32765) + b);
+     or
+              a = (a + (b + 32765));
+     since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
+     in which overflow silently generates some value and where positive and negative overflows cancel, the
+     above expression statement can be rewritten by the implementation in any of the above ways because the
+     same result will occur.
+
+[<a name="p15" href="#p15">page 15</a>] (<a href="#Contents">Contents</a>)
+
+15   EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
+     following fragment
+              #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              int sum;
+              char *p;
+              /* ... */
+              sum = sum * 10 - '0' + (*p++ = getchar());
+     the expression statement is grouped as if it were written as
+              sum = (((sum * 10) - '0') + ((*(p++)) = (getchar())));
+     but the actual increment of p can occur at any time between the previous sequence point and the next
+     sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
+     value.
+
+     Forward references: expressions (<a href="#6.5">6.5</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>), statements (<a href="#6.8">6.8</a>), the
+     signal function (<a href="#7.14">7.14</a>), files (<a href="#7.19.3">7.19.3</a>).
+
+[<a name="p16" href="#p16">page 16</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.2" href="#5.2"><b>    5.2 Environmental considerations</b></a>
+<a name="5.2.1" href="#5.2.1"><b>    5.2.1 Character sets</b></a>
+1   Two sets of characters and their associated collating sequences shall be defined: the set in
+    which source files are written (the source character set), and the set interpreted in the
+    execution environment (the execution character set). Each set is further divided into a
+    basic character set, whose contents are given by this subclause, and a set of zero or more
+    locale-specific members (which are not members of the basic character set) called
+    extended characters. The combined set is also called the extended character set. The
+    values of the members of the execution character set are implementation-defined.
+2   In a character constant or string literal, members of the execution character set shall be
+    represented by corresponding members of the source character set or by escape
+    sequences consisting of the backslash \ followed by one or more characters. A byte with
+    all bits set to 0, called the null character, shall exist in the basic execution character set; it
+    is used to terminate a character string.
+3   Both the basic source and basic execution character sets shall have the following
+    members: the 26 uppercase letters of the Latin alphabet
+             A   B   C      D   E   F    G    H    I    J    K    L   M
+             N   O   P      Q   R   S    T    U    V    W    X    Y   Z
+    the 26 lowercase letters of the Latin alphabet
+             a   b   c      d   e   f    g    h    i    j    k    l   m
+             n   o   p      q   r   s    t    u    v    w    x    y   z
+    the 10 decimal digits
+             0   1   2      3   4   5    6    7    8    9
+    the following 29 graphic characters
+             !   "   #      %   &amp;   '    (    )    *    +    ,    -   .    /    :
+             ;   &lt;   =      &gt;   ?   [    \    ]    ^    _    {    |   }    ~
+    the space character, and control characters representing horizontal tab, vertical tab, and
+    form feed. The representation of each member of the source and execution basic
+    character sets shall fit in a byte. In both the source and execution basic character sets, the
+    value of each character after 0 in the above list of decimal digits shall be one greater than
+    the value of the previous. In source files, there shall be some way of indicating the end of
+    each line of text; this International Standard treats such an end-of-line indicator as if it
+    were a single new-line character. In the basic execution character set, there shall be
+    control characters representing alert, backspace, carriage return, and new line. If any
+    other characters are encountered in a source file (except in an identifier, a character
+    constant, a string literal, a header name, a comment, or a preprocessing token that is never
+
+[<a name="p17" href="#p17">page 17</a>] (<a href="#Contents">Contents</a>)
+
+    converted to a token), the behavior is undefined.
+4   A letter is an uppercase letter or a lowercase letter as defined above; in this International
+    Standard the term does not include other characters that are letters in other alphabets.
+5   The universal character name construct provides a way to name other characters.
+    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
+    preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
+<a name="5.2.1.1" href="#5.2.1.1"><b>    5.2.1.1 Trigraph sequences</b></a>
+1   Before any other processing takes place, each occurrence of one of the following
+    sequences of three characters (called trigraph sequences<sup><a href="#note12"><b>12)</b></a></sup>) is replaced with the
+    corresponding single character.
+           ??=      #                       ??)      ]                       ??!     |
+           ??(      [                       ??'      ^                       ??&gt;     }
+           ??/      \                       ??&lt;      {                       ??-     ~
+    No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
+    above is not changed.
+2   EXAMPLE 1
+              ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)
+    becomes
+              #define arraycheck(a, b) a[b] || b[a]
+
+3   EXAMPLE 2      The following source line
+              printf("Eh???/n");
+    becomes (after replacement of the trigraph sequence ??/)
+              printf("Eh?\n");
+
+<a name="5.2.1.2" href="#5.2.1.2"><b>    5.2.1.2 Multibyte characters</b></a>
+1   The source character set may contain multibyte characters, used to represent members of
+    the extended character set. The execution character set may also contain multibyte
+    characters, which need not have the same encoding as for the source character set. For
+    both character sets, the following shall hold:
+    -- The basic character set shall be present and each character shall be encoded as a
+      single byte.
+    -- The presence, meaning, and representation of any additional members is locale-
+      specific.
+
+    <sup><a name="note12" href="#note12"><b>12)</b></a></sup> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
+        described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
+
+[<a name="p18" href="#p18">page 18</a>] (<a href="#Contents">Contents</a>)
+
+    -- A multibyte character set may have a state-dependent encoding, wherein each
+      sequence of multibyte characters begins in an initial shift state and enters other
+      locale-specific shift states when specific multibyte characters are encountered in the
+      sequence. While in the initial shift state, all single-byte characters retain their usual
+      interpretation and do not alter the shift state. The interpretation for subsequent bytes
+      in the sequence is a function of the current shift state.
+    -- A byte with all bits zero shall be interpreted as a null character independent of shift
+      state. Such a byte shall not occur as part of any other multibyte character.
+2   For source files, the following shall hold:
+    -- An identifier, comment, string literal, character constant, or header name shall begin
+      and end in the initial shift state.
+    -- An identifier, comment, string literal, character constant, or header name shall consist
+      of a sequence of valid multibyte characters.
+<a name="5.2.2" href="#5.2.2"><b>    5.2.2 Character display semantics</b></a>
+1   The active position is that location on a display device where the next character output by
+    the fputc function would appear. The intent of writing a printing character (as defined
+    by the isprint function) to a display device is to display a graphic representation of
+    that character at the active position and then advance the active position to the next
+    position on the current line. The direction of writing is locale-specific. If the active
+    position is at the final position of a line (if there is one), the behavior of the display device
+    is unspecified.
+2   Alphabetic escape sequences representing nongraphic characters in the execution
+    character set are intended to produce actions on display devices as follows:
+    \a (alert) Produces an audible or visible alert without changing the active position.
+    \b (backspace) Moves the active position to the previous position on the current line. If
+       the active position is at the initial position of a line, the behavior of the display
+       device is unspecified.
+    \f ( form feed) Moves the active position to the initial position at the start of the next
+       logical page.
+    \n (new line) Moves the active position to the initial position of the next line.
+    \r (carriage return) Moves the active position to the initial position of the current line.
+    \t (horizontal tab) Moves the active position to the next horizontal tabulation position
+       on the current line. If the active position is at or past the last defined horizontal
+       tabulation position, the behavior of the display device is unspecified.
+    \v (vertical tab) Moves the active position to the initial position of the next vertical
+        tabulation position. If the active position is at or past the last defined vertical
+
+[<a name="p19" href="#p19">page 19</a>] (<a href="#Contents">Contents</a>)
+
+         tabulation position, the behavior of the display device is unspecified.
+3   Each of these escape sequences shall produce a unique implementation-defined value
+    which can be stored in a single char object. The external representations in a text file
+    need not be identical to the internal representations, and are outside the scope of this
+    International Standard.
+    Forward references: the isprint function (<a href="#7.4.1.8">7.4.1.8</a>), the fputc function (<a href="#7.19.7.3">7.19.7.3</a>).
+<a name="5.2.3" href="#5.2.3"><b>    5.2.3 Signals and interrupts</b></a>
+1   Functions shall be implemented such that they may be interrupted at any time by a signal,
+    or may be called by a signal handler, or both, with no alteration to earlier, but still active,
+    invocations' control flow (after the interruption), function return values, or objects with
+    automatic storage duration. All such objects shall be maintained outside the function
+    image (the instructions that compose the executable representation of a function) on a
+    per-invocation basis.
+<a name="5.2.4" href="#5.2.4"><b>    5.2.4 Environmental limits</b></a>
+1   Both the translation and execution environments constrain the implementation of
+    language translators and libraries. The following summarizes the language-related
+    environmental limits on a conforming implementation; the library-related limits are
+    discussed in clause 7.
+<a name="5.2.4.1" href="#5.2.4.1"><b>    5.2.4.1 Translation limits</b></a>
+1   The implementation shall be able to translate and execute at least one program that
+    contains at least one instance of every one of the following limits:<sup><a href="#note13"><b>13)</b></a></sup>
+    -- 127 nesting levels of blocks
+    -- 63 nesting levels of conditional inclusion
+    -- 12 pointer, array, and function declarators (in any combinations) modifying an
+      arithmetic, structure, union, or incomplete type in a declaration
+    -- 63 nesting levels of parenthesized declarators within a full declarator
+    -- 63 nesting levels of parenthesized expressions within a full expression
+    -- 63 significant initial characters in an internal identifier or a macro name (each
+      universal character name or extended source character is considered a single
+      character)
+    -- 31 significant initial characters in an external identifier (each universal character name
+      specifying a short identifier of 0000FFFF or less is considered 6 characters, each
+
+
+    <sup><a name="note13" href="#note13"><b>13)</b></a></sup> Implementations should avoid imposing fixed translation limits whenever possible.
+
+[<a name="p20" href="#p20">page 20</a>] (<a href="#Contents">Contents</a>)
+
+        universal character name specifying a short identifier of 00010000 or more is
+        considered 10 characters, and each extended source character is considered the same
+        number of characters as the corresponding universal character name, if any)<sup><a href="#note14"><b>14)</b></a></sup>
+    -- 4095 external identifiers in one translation unit
+    -- 511 identifiers with block scope declared in one block
+    -- 4095 macro identifiers simultaneously defined in one preprocessing translation unit
+    -- 127 parameters in one function definition
+    -- 127 arguments in one function call
+    -- 127 parameters in one macro definition
+    -- 127 arguments in one macro invocation
+    -- 4095 characters in a logical source line
+    -- 4095 characters in a character string literal or wide string literal (after concatenation)
+    -- 65535 bytes in an object (in a hosted environment only)
+    -- 15 nesting levels for #included files
+    -- 1023 case labels for a switch statement (excluding those for any nested switch
+      statements)
+    -- 1023 members in a single structure or union
+    -- 1023 enumeration constants in a single enumeration
+    -- 63 levels of nested structure or union definitions in a single struct-declaration-list
+<a name="5.2.4.2" href="#5.2.4.2"><b>    5.2.4.2 Numerical limits</b></a>
+1   An implementation is required to document all the limits specified in this subclause,
+    which are specified in the headers <a href="#7.10">&lt;limits.h&gt;</a> and <a href="#7.7">&lt;float.h&gt;</a>. Additional limits are
+    specified in <a href="#7.18">&lt;stdint.h&gt;</a>.
+    Forward references: integer types <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#7.18">7.18</a>).
+<a name="5.2.4.2.1" href="#5.2.4.2.1"><b>    5.2.4.2.1 Sizes of integer types &lt;limits.h&gt;</b></a>
+1   The values given below shall be replaced by constant expressions suitable for use in #if
+    preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
+    following shall be replaced by expressions that have the same type as would an
+    expression that is an object of the corresponding type converted according to the integer
+    promotions. Their implementation-defined values shall be equal or greater in magnitude
+
+
+    <sup><a name="note14" href="#note14"><b>14)</b></a></sup> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
+
+[<a name="p21" href="#p21">page 21</a>] (<a href="#Contents">Contents</a>)
+
+(absolute value) to those shown, with the same sign.
+-- number of bits for smallest object that is not a bit-field (byte)
+  CHAR_BIT                                            8
+-- minimum value for an object of type signed char
+  SCHAR_MIN                                -127 // -(27 - 1)
+-- maximum value for an object of type signed char
+  SCHAR_MAX                                +127 // 27 - 1
+-- maximum value for an object of type unsigned char
+  UCHAR_MAX                                 255 // 28 - 1
+-- minimum value for an object of type char
+  CHAR_MIN                               see below
+-- maximum value for an object of type char
+  CHAR_MAX                              see below
+-- maximum number of bytes in a multibyte character, for any supported locale
+  MB_LEN_MAX                                    1
+-- minimum value for an object of type short int
+  SHRT_MIN                               -32767 // -(215 - 1)
+-- maximum value for an object of type short int
+  SHRT_MAX                               +32767 // 215 - 1
+-- maximum value for an object of type unsigned short int
+  USHRT_MAX                               65535 // 216 - 1
+-- minimum value for an object of type int
+  INT_MIN                                 -32767 // -(215 - 1)
+-- maximum value for an object of type int
+  INT_MAX                                +32767 // 215 - 1
+-- maximum value for an object of type unsigned int
+  UINT_MAX                                65535 // 216 - 1
+-- minimum value for an object of type long int
+  LONG_MIN                         -2147483647 // -(231 - 1)
+-- maximum value for an object of type long int
+  LONG_MAX                         +2147483647 // 231 - 1
+-- maximum value for an object of type unsigned long int
+  ULONG_MAX                         4294967295 // 232 - 1
+
+[<a name="p22" href="#p22">page 22</a>] (<a href="#Contents">Contents</a>)
+
+    -- minimum value for an object of type long long int
+      LLONG_MIN          -9223372036854775807 // -(263 - 1)
+    -- maximum value for an object of type long long int
+      LLONG_MAX          +9223372036854775807 // 263 - 1
+    -- maximum value for an object of type unsigned long long int
+      ULLONG_MAX         18446744073709551615 // 264 - 1
+2   If the value of an object of type char is treated as a signed integer when used in an
+    expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
+    value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
+    CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
+    UCHAR_MAX.<sup><a href="#note15"><b>15)</b></a></sup> The value UCHAR_MAX shall equal 2CHAR_BIT - 1.
+    Forward references: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
+<a name="5.2.4.2.2" href="#5.2.4.2.2"><b>    5.2.4.2.2 Characteristics of floating types &lt;float.h&gt;</b></a>
+1   The characteristics of floating types are defined in terms of a model that describes a
+    representation of floating-point numbers and values that provide information about an
+    implementation's floating-point arithmetic.<sup><a href="#note16"><b>16)</b></a></sup> The following parameters are used to
+    define the model for each floating-point type:
+           s          sign ((+-)1)
+           b          base or radix of exponent representation (an integer &gt; 1)
+           e          exponent (an integer between a minimum emin and a maximum emax )
+           p          precision (the number of base-b digits in the significand)
+            fk        nonnegative integers less than b (the significand digits)
+2   A floating-point number (x) is defined by the following model:
+                       p
+           x = sb e   (Sum) f k b-k ,
+                      k=1
+                                     emin &lt;= e &lt;= emax
+
+3   In addition to normalized floating-point numbers ( f 1 &gt; 0 if x != 0), floating types may be
+    able to contain other kinds of floating-point numbers, such as subnormal floating-point
+    numbers (x != 0, e = emin , f 1 = 0) and unnormalized floating-point numbers (x != 0,
+    e &gt; emin , f 1 = 0), and values that are not floating-point numbers, such as infinities and
+    NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates
+    through almost every arithmetic operation without raising a floating-point exception; a
+    signaling NaN generally raises a floating-point exception when occurring as an
+
+
+    <sup><a name="note15" href="#note15"><b>15)</b></a></sup> See <a href="#6.2.5">6.2.5</a>.
+    <sup><a name="note16" href="#note16"><b>16)</b></a></sup> The floating-point model is intended to clarify the description of each floating-point characteristic and
+        does not require the floating-point arithmetic of the implementation to be identical.
+
+[<a name="p23" href="#p23">page 23</a>] (<a href="#Contents">Contents</a>)
+
+    arithmetic operand.<sup><a href="#note17"><b>17)</b></a></sup>
+4   An implementation may give zero and non-numeric values (such as infinities and NaNs) a
+    sign or may leave them unsigned. Wherever such values are unsigned, any requirement
+    in this International Standard to retrieve the sign shall produce an unspecified sign, and
+    any requirement to set the sign shall be ignored.
+5   The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
+    <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results is implementation-
+    defined, as is the accuracy of the conversion between floating-point internal
+    representations and string representations performed by the library functions in
+    <a href="#7.19">&lt;stdio.h&gt;</a>, <a href="#7.20">&lt;stdlib.h&gt;</a>, and <a href="#7.24">&lt;wchar.h&gt;</a>. The implementation may state that the
+    accuracy is unknown.
+6   All integer values in the <a href="#7.7">&lt;float.h&gt;</a> header, except FLT_ROUNDS, shall be constant
+    expressions suitable for use in #if preprocessing directives; all floating values shall be
+    constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
+    and FLT_ROUNDS have separate names for all three floating-point types. The floating-
+    point model representation is provided for all values except FLT_EVAL_METHOD and
+    FLT_ROUNDS.
+7   The rounding mode for floating-point addition is characterized by the implementation-
+    defined value of FLT_ROUNDS:<sup><a href="#note18"><b>18)</b></a></sup>
+          -1      indeterminable
+           0      toward zero
+           1      to nearest
+           2      toward positive infinity
+           3      toward negative infinity
+    All other values for FLT_ROUNDS characterize implementation-defined rounding
+    behavior.
+8   Except for assignment and cast (which remove all extra range and precision), the values
+    of operations with floating operands and values subject to the usual arithmetic
+    conversions and of floating constants are evaluated to a format whose range and precision
+    may be greater than required by the type. The use of evaluation formats is characterized
+    by the implementation-defined value of FLT_EVAL_METHOD:<sup><a href="#note19"><b>19)</b></a></sup>
+
+
+
+    <sup><a name="note17" href="#note17"><b>17)</b></a></sup> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
+        IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
+        similar behavior.
+    <sup><a name="note18" href="#note18"><b>18)</b></a></sup> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
+        the function fesetround in <a href="#7.6">&lt;fenv.h&gt;</a>.
+
+[<a name="p24" href="#p24">page 24</a>] (<a href="#Contents">Contents</a>)
+
+           -1        indeterminable;
+            0        evaluate all operations and constants just to the range and precision of the
+                     type;
+            1        evaluate operations and constants of type float and double to the
+                     range and precision of the double type, evaluate long double
+                     operations and constants to the range and precision of the long double
+                     type;
+            2        evaluate all operations and constants to the range and precision of the
+                     long double type.
+    All other negative values for FLT_EVAL_METHOD characterize implementation-defined
+    behavior.
+9   The values given in the following list shall be replaced by constant expressions with
+    implementation-defined values that are greater or equal in magnitude (absolute value) to
+    those shown, with the same sign:
+    -- radix of exponent representation, b
+      FLT_RADIX                                                 2
+    -- number of base-FLT_RADIX digits in the floating-point significand, p
+        FLT_MANT_DIG
+        DBL_MANT_DIG
+        LDBL_MANT_DIG
+    -- number of decimal digits, n, such that any floating-point number in the widest
+      supported floating type with pmax radix b digits can be rounded to a floating-point
+      number with n decimal digits and back again without change to the value,
+           ??? pmax log10 b       if b is a power of 10
+           ???
+           ??? ???1 + pmax log10 b??? otherwise
+        DECIMAL_DIG                                            10
+    -- number of decimal digits, q, such that any floating-point number with q decimal digits
+      can be rounded into a floating-point number with p radix b digits and back again
+      without change to the q decimal digits,
+
+
+
+
+    <sup><a name="note19" href="#note19"><b>19)</b></a></sup> The evaluation method determines evaluation formats of expressions involving all floating types, not
+        just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
+        _Complex operands is represented in the double _Complex format, and its parts are evaluated to
+        double.
+
+[<a name="p25" href="#p25">page 25</a>] (<a href="#Contents">Contents</a>)
+
+            ??? p log10 b          if b is a power of 10
+            ???
+            ??? ???( p - 1) log10 b??? otherwise
+        FLT_DIG                                         6
+        DBL_DIG                                        10
+        LDBL_DIG                                       10
+     -- minimum negative integer such that FLT_RADIX raised to one less than that power is
+       a normalized floating-point number, emin
+        FLT_MIN_EXP
+        DBL_MIN_EXP
+        LDBL_MIN_EXP
+     -- minimum negative integer such that 10 raised to that power is in the range of
+       normalized floating-point numbers, ???log10 b emin -1 ???
+                                         ???                ???
+       FLT_MIN_10_EXP                                 -37
+       DBL_MIN_10_EXP                                 -37
+       LDBL_MIN_10_EXP                                -37
+     -- maximum integer such that FLT_RADIX raised to one less than that power is a
+       representable finite floating-point number, emax
+        FLT_MAX_EXP
+        DBL_MAX_EXP
+        LDBL_MAX_EXP
+     -- maximum integer such that 10 raised to that power is in the range of representable
+       finite floating-point numbers, ???log10 ((1 - b- p )b emax )???
+        FLT_MAX_10_EXP                                 +37
+        DBL_MAX_10_EXP                                 +37
+        LDBL_MAX_10_EXP                                +37
+10   The values given in the following list shall be replaced by constant expressions with
+     implementation-defined values that are greater than or equal to those shown:
+     -- maximum representable finite floating-point number, (1 - b- p )b emax
+        FLT_MAX                                     1E+37
+        DBL_MAX                                     1E+37
+        LDBL_MAX                                    1E+37
+11   The values given in the following list shall be replaced by constant expressions with
+     implementation-defined (positive) values that are less than or equal to those shown:
+     -- the difference between 1 and the least value greater than 1 that is representable in the
+        given floating point type, b1- p
+
+[<a name="p26" href="#p26">page 26</a>] (<a href="#Contents">Contents</a>)
+
+         FLT_EPSILON                                         1E-5
+         DBL_EPSILON                                         1E-9
+         LDBL_EPSILON                                        1E-9
+     -- minimum normalized positive floating-point number, b emin -1
+         FLT_MIN                                            1E-37
+         DBL_MIN                                            1E-37
+         LDBL_MIN                                           1E-37
+     Recommended practice
+12   Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
+     should be the identity function.
+13   EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
+     requirements of this International Standard, and the appropriate values in a <a href="#7.7">&lt;float.h&gt;</a> header for type
+     float:
+                        6
+           x = s16e    (Sum) f k 16-k ,
+                       k=1
+                                       -31 &lt;= e &lt;= +32
+
+             FLT_RADIX                                  16
+             FLT_MANT_DIG                                6
+             FLT_EPSILON                   9.53674316E-07F
+             FLT_DIG                                     6
+             FLT_MIN_EXP                               -31
+             FLT_MIN                       2.93873588E-39F
+             FLT_MIN_10_EXP                            -38
+             FLT_MAX_EXP                               +32
+             FLT_MAX                       3.40282347E+38F
+             FLT_MAX_10_EXP                            +38
+
+14   EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
+     single-precision and double-precision normalized numbers in IEC 60559,<sup><a href="#note20"><b>20)</b></a></sup> and the appropriate values in a
+     <a href="#7.7">&lt;float.h&gt;</a> header for types float and double:
+                       24
+           x f = s2e   (Sum) f k 2-k ,
+                       k=1
+                                      -125 &lt;= e &lt;= +128
+
+                       53
+           x d = s2e   (Sum) f k 2-k ,
+                       k=1
+                                      -1021 &lt;= e &lt;= +1024
+
+             FLT_RADIX                                   2
+             DECIMAL_DIG                                17
+             FLT_MANT_DIG                               24
+             FLT_EPSILON                   1.19209290E-07F // decimal constant
+             FLT_EPSILON                          0X1P-23F // hex constant
+
+
+     <sup><a name="note20" href="#note20"><b>20)</b></a></sup> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
+         limits are one less than shown here.
+
+[<a name="p27" href="#p27">page 27</a>] (<a href="#Contents">Contents</a>)
+
+        FLT_DIG                           6
+        FLT_MIN_EXP                    -125
+        FLT_MIN             1.17549435E-38F               // decimal constant
+        FLT_MIN                   0X1P-126F               // hex constant
+        FLT_MIN_10_EXP                  -37
+        FLT_MAX_EXP                    +128
+        FLT_MAX             3.40282347E+38F               // decimal constant
+        FLT_MAX             0X1.fffffeP127F               // hex constant
+        FLT_MAX_10_EXP                  +38
+        DBL_MANT_DIG                     53
+        DBL_EPSILON 2.2204460492503131E-16                // decimal constant
+        DBL_EPSILON                 0X1P-52               // hex constant
+        DBL_DIG                          15
+        DBL_MIN_EXP                   -1021
+        DBL_MIN     2.2250738585072014E-308               // decimal constant
+        DBL_MIN                   0X1P-1022               // hex constant
+        DBL_MIN_10_EXP                 -307
+        DBL_MAX_EXP                   +1024
+        DBL_MAX     1.7976931348623157E+308               // decimal constant
+        DBL_MAX      0X1.fffffffffffffP1023               // hex constant
+        DBL_MAX_10_EXP                 +308
+If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
+example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
+precision), then DECIMAL_DIG would be 21.
+
+Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
+<a href="#7.3">&lt;complex.h&gt;</a> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <a href="#7.24">&lt;wchar.h&gt;</a>
+(<a href="#7.24">7.24</a>), floating-point environment <a href="#7.6">&lt;fenv.h&gt;</a> (<a href="#7.6">7.6</a>), general utilities <a href="#7.20">&lt;stdlib.h&gt;</a>
+(<a href="#7.20">7.20</a>), input/output <a href="#7.19">&lt;stdio.h&gt;</a> (<a href="#7.19">7.19</a>), mathematics <a href="#7.12">&lt;math.h&gt;</a> (<a href="#7.12">7.12</a>).
+
+[<a name="p28" href="#p28">page 28</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="6" href="#6"><b>    6. Language</b></a>
+<a name="6.1" href="#6.1"><b>    6.1 Notation</b></a>
+1   In the syntax notation used in this clause, syntactic categories (nonterminals) are
+    indicated by italic type, and literal words and character set members (terminals) by bold
+    type. A colon (:) following a nonterminal introduces its definition. Alternative
+    definitions are listed on separate lines, except when prefaced by the words ''one of''. An
+    optional symbol is indicated by the subscript ''opt'', so that
+             { expressionopt }
+    indicates an optional expression enclosed in braces.
+2   When syntactic categories are referred to in the main text, they are not italicized and
+    words are separated by spaces instead of hyphens.
+3   A summary of the language syntax is given in <a href="#A">annex A</a>.
+<a name="6.2" href="#6.2"><b>    6.2 Concepts</b></a>
+<a name="6.2.1" href="#6.2.1"><b>    6.2.1 Scopes of identifiers</b></a>
+1   An identifier can denote an object; a function; a tag or a member of a structure, union, or
+    enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
+    same identifier can denote different entities at different points in the program. A member
+    of an enumeration is called an enumeration constant. Macro names and macro
+    parameters are not considered further here, because prior to the semantic phase of
+    program translation any occurrences of macro names in the source file are replaced by the
+    preprocessing token sequences that constitute their macro definitions.
+2   For each different entity that an identifier designates, the identifier is visible (i.e., can be
+    used) only within a region of program text called its scope. Different entities designated
+    by the same identifier either have different scopes, or are in different name spaces. There
+    are four kinds of scopes: function, file, block, and function prototype. (A function
+    prototype is a declaration of a function that declares the types of its parameters.)
+3   A label name is the only kind of identifier that has function scope. It can be used (in a
+    goto statement) anywhere in the function in which it appears, and is declared implicitly
+    by its syntactic appearance (followed by a : and a statement).
+4   Every other identifier has scope determined by the placement of its declaration (in a
+    declarator or type specifier). If the declarator or type specifier that declares the identifier
+    appears outside of any block or list of parameters, the identifier has file scope, which
+    terminates at the end of the translation unit. If the declarator or type specifier that
+    declares the identifier appears inside a block or within the list of parameter declarations in
+    a function definition, the identifier has block scope, which terminates at the end of the
+    associated block. If the declarator or type specifier that declares the identifier appears
+
+[<a name="p29" href="#p29">page 29</a>] (<a href="#Contents">Contents</a>)
+
+    within the list of parameter declarations in a function prototype (not part of a function
+    definition), the identifier has function prototype scope, which terminates at the end of the
+    function declarator. If an identifier designates two different entities in the same name
+    space, the scopes might overlap. If so, the scope of one entity (the inner scope) will be a
+    strict subset of the scope of the other entity (the outer scope). Within the inner scope, the
+    identifier designates the entity declared in the inner scope; the entity declared in the outer
+    scope is hidden (and not visible) within the inner scope.
+5   Unless explicitly stated otherwise, where this International Standard uses the term
+    ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
+    entity in the relevant name space whose declaration is visible at the point the identifier
+    occurs.
+6   Two identifiers have the same scope if and only if their scopes terminate at the same
+    point.
+7   Structure, union, and enumeration tags have scope that begins just after the appearance of
+    the tag in a type specifier that declares the tag. Each enumeration constant has scope that
+    begins just after the appearance of its defining enumerator in an enumerator list. Any
+    other identifier has scope that begins just after the completion of its declarator.
+    Forward references: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
+    (<a href="#6.9.1">6.9.1</a>), identifiers (<a href="#6.4.2">6.4.2</a>), name spaces of identifiers (<a href="#6.2.3">6.2.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>),
+    source file inclusion (<a href="#6.10.2">6.10.2</a>), statements (<a href="#6.8">6.8</a>).
+<a name="6.2.2" href="#6.2.2"><b>    6.2.2 Linkages of identifiers</b></a>
+1   An identifier declared in different scopes or in the same scope more than once can be
+    made to refer to the same object or function by a process called linkage.<sup><a href="#note21"><b>21)</b></a></sup> There are
+    three kinds of linkage: external, internal, and none.
+2   In the set of translation units and libraries that constitutes an entire program, each
+    declaration of a particular identifier with external linkage denotes the same object or
+    function. Within one translation unit, each declaration of an identifier with internal
+    linkage denotes the same object or function. Each declaration of an identifier with no
+    linkage denotes a unique entity.
+3   If the declaration of a file scope identifier for an object or a function contains the storage-
+    class specifier static, the identifier has internal linkage.<sup><a href="#note22"><b>22)</b></a></sup>
+4   For an identifier declared with the storage-class specifier extern in a scope in which a
+
+
+
+    <sup><a name="note21" href="#note21"><b>21)</b></a></sup> There is no linkage between different identifiers.
+    <sup><a name="note22" href="#note22"><b>22)</b></a></sup> A function declaration can contain the storage-class specifier static only if it is at file scope; see
+        <a href="#6.7.1">6.7.1</a>.
+
+[<a name="p30" href="#p30">page 30</a>] (<a href="#Contents">Contents</a>)
+
+    prior declaration of that identifier is visible,<sup><a href="#note23"><b>23)</b></a></sup> if the prior declaration specifies internal or
+    external linkage, the linkage of the identifier at the later declaration is the same as the
+    linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
+    declaration specifies no linkage, then the identifier has external linkage.
+5   If the declaration of an identifier for a function has no storage-class specifier, its linkage
+    is determined exactly as if it were declared with the storage-class specifier extern. If
+    the declaration of an identifier for an object has file scope and no storage-class specifier,
+    its linkage is external.
+6   The following identifiers have no linkage: an identifier declared to be anything other than
+    an object or a function; an identifier declared to be a function parameter; a block scope
+    identifier for an object declared without the storage-class specifier extern.
+7   If, within a translation unit, the same identifier appears with both internal and external
+    linkage, the behavior is undefined.
+    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
+    statements (<a href="#6.8">6.8</a>).
+<a name="6.2.3" href="#6.2.3"><b>    6.2.3 Name spaces of identifiers</b></a>
+1   If more than one declaration of a particular identifier is visible at any point in a
+    translation unit, the syntactic context disambiguates uses that refer to different entities.
+    Thus, there are separate name spaces for various categories of identifiers, as follows:
+    -- label names (disambiguated by the syntax of the label declaration and use);
+    -- the tags of structures, unions, and enumerations (disambiguated by following any<sup><a href="#note24"><b>24)</b></a></sup>
+      of the keywords struct, union, or enum);
+    -- the members of structures or unions; each structure or union has a separate name
+      space for its members (disambiguated by the type of the expression used to access the
+      member via the . or -&gt; operator);
+    -- all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
+      enumeration constants).
+    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
+    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>), tags
+    (<a href="#6.7.2.3">6.7.2.3</a>), the goto statement (<a href="#6.8.6.1">6.8.6.1</a>).
+
+
+
+
+    <sup><a name="note23" href="#note23"><b>23)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+    <sup><a name="note24" href="#note24"><b>24)</b></a></sup> There is only one name space for tags even though three are possible.
+
+[<a name="p31" href="#p31">page 31</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.2.4" href="#6.2.4"><b>    6.2.4 Storage durations of objects</b></a>
+1   An object has a storage duration that determines its lifetime. There are three storage
+    durations: static, automatic, and allocated. Allocated storage is described in <a href="#7.20.3">7.20.3</a>.
+2   The lifetime of an object is the portion of program execution during which storage is
+    guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note25"><b>25)</b></a></sup> and retains
+    its last-stored value throughout its lifetime.<sup><a href="#note26"><b>26)</b></a></sup> If an object is referred to outside of its
+    lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
+    the object it points to reaches the end of its lifetime.
+3   An object whose identifier is declared with external or internal linkage, or with the
+    storage-class specifier static has static storage duration. Its lifetime is the entire
+    execution of the program and its stored value is initialized only once, prior to program
+    startup.
+4   An object whose identifier is declared with no linkage and without the storage-class
+    specifier static has automatic storage duration.
+5   For such an object that does not have a variable length array type, its lifetime extends
+    from entry into the block with which it is associated until execution of that block ends in
+    any way. (Entering an enclosed block or calling a function suspends, but does not end,
+    execution of the current block.) If the block is entered recursively, a new instance of the
+    object is created each time. The initial value of the object is indeterminate. If an
+    initialization is specified for the object, it is performed each time the declaration is
+    reached in the execution of the block; otherwise, the value becomes indeterminate each
+    time the declaration is reached.
+6   For such an object that does have a variable length array type, its lifetime extends from
+    the declaration of the object until execution of the program leaves the scope of the
+    declaration.<sup><a href="#note27"><b>27)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
+    each time. The initial value of the object is indeterminate.
+    Forward references: statements (<a href="#6.8">6.8</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), declarators (<a href="#6.7.5">6.7.5</a>), array
+    declarators (<a href="#6.7.5.2">6.7.5.2</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+
+
+
+
+    <sup><a name="note25" href="#note25"><b>25)</b></a></sup> The term ''constant address'' means that two pointers to the object constructed at possibly different
+        times will compare equal. The address may be different during two different executions of the same
+        program.
+    <sup><a name="note26" href="#note26"><b>26)</b></a></sup> In the case of a volatile object, the last store need not be explicit in the program.
+    <sup><a name="note27" href="#note27"><b>27)</b></a></sup> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
+        embedded block prior to the declaration, leaves the scope of the declaration.
+
+[<a name="p32" href="#p32">page 32</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.2.5" href="#6.2.5"><b>    6.2.5 Types</b></a>
+1   The meaning of a value stored in an object or returned by a function is determined by the
+    type of the expression used to access it. (An identifier declared to be an object is the
+    simplest such expression; the type is specified in the declaration of the identifier.) Types
+    are partitioned into object types (types that fully describe objects), function types (types
+    that describe functions), and incomplete types (types that describe objects but lack
+    information needed to determine their sizes).
+2   An object declared as type _Bool is large enough to store the values 0 and 1.
+3   An object declared as type char is large enough to store any member of the basic
+    execution character set. If a member of the basic execution character set is stored in a
+    char object, its value is guaranteed to be nonnegative. If any other character is stored in
+    a char object, the resulting value is implementation-defined but shall be within the range
+    of values that can be represented in that type.
+4   There are five standard signed integer types, designated as signed char, short
+    int, int, long int, and long long int. (These and other types may be
+    designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
+    implementation-defined extended signed integer types.<sup><a href="#note28"><b>28)</b></a></sup> The standard and extended
+    signed integer types are collectively called signed integer types.<sup><a href="#note29"><b>29)</b></a></sup>
+5   An object declared as type signed char occupies the same amount of storage as a
+    ''plain'' char object. A ''plain'' int object has the natural size suggested by the
+    architecture of the execution environment (large enough to contain any value in the range
+    INT_MIN to INT_MAX as defined in the header <a href="#7.10">&lt;limits.h&gt;</a>).
+6   For each of the signed integer types, there is a corresponding (but different) unsigned
+    integer type (designated with the keyword unsigned) that uses the same amount of
+    storage (including sign information) and has the same alignment requirements. The type
+    _Bool and the unsigned integer types that correspond to the standard signed integer
+    types are the standard unsigned integer types. The unsigned integer types that
+    correspond to the extended signed integer types are the extended unsigned integer types.
+    The standard and extended unsigned integer types are collectively called unsigned integer
+    types.<sup><a href="#note30"><b>30)</b></a></sup>
+
+
+
+    <sup><a name="note28" href="#note28"><b>28)</b></a></sup> Implementation-defined keywords shall have the form of an identifier reserved for any use as
+        described in <a href="#7.1.3">7.1.3</a>.
+    <sup><a name="note29" href="#note29"><b>29)</b></a></sup> Therefore, any statement in this Standard about signed integer types also applies to the extended
+        signed integer types.
+    <sup><a name="note30" href="#note30"><b>30)</b></a></sup> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
+        unsigned integer types.
+
+[<a name="p33" href="#p33">page 33</a>] (<a href="#Contents">Contents</a>)
+
+7    The standard signed integer types and standard unsigned integer types are collectively
+     called the standard integer types, the extended signed integer types and extended
+     unsigned integer types are collectively called the extended integer types.
+8    For any two integer types with the same signedness and different integer conversion rank
+     (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
+     subrange of the values of the other type.
+9    The range of nonnegative values of a signed integer type is a subrange of the
+     corresponding unsigned integer type, and the representation of the same value in each
+     type is the same.<sup><a href="#note31"><b>31)</b></a></sup> A computation involving unsigned operands can never overflow,
+     because a result that cannot be represented by the resulting unsigned integer type is
+     reduced modulo the number that is one greater than the largest value that can be
+     represented by the resulting type.
+10   There are three real floating types, designated as float, double, and long
+     double.<sup><a href="#note32"><b>32)</b></a></sup> The set of values of the type float is a subset of the set of values of the
+     type double; the set of values of the type double is a subset of the set of values of the
+     type long double.
+11   There are three complex types, designated as float _Complex, double
+     _Complex, and long double _Complex.<sup><a href="#note33"><b>33)</b></a></sup> The real floating and complex types
+     are collectively called the floating types.
+12   For each floating type there is a corresponding real type, which is always a real floating
+     type. For real floating types, it is the same type. For complex types, it is the type given
+     by deleting the keyword _Complex from the type name.
+13   Each complex type has the same representation and alignment requirements as an array
+     type containing exactly two elements of the corresponding real type; the first element is
+     equal to the real part, and the second element to the imaginary part, of the complex
+     number.
+14   The type char, the signed and unsigned integer types, and the floating types are
+     collectively called the basic types. Even if the implementation defines two or more basic
+     types to have the same representation, they are nevertheless different types.<sup><a href="#note34"><b>34)</b></a></sup>
+
+     <sup><a name="note31" href="#note31"><b>31)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
+         arguments to functions, return values from functions, and members of unions.
+     <sup><a name="note32" href="#note32"><b>32)</b></a></sup> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
+     <sup><a name="note33" href="#note33"><b>33)</b></a></sup> A specification for imaginary types is in informative <a href="#G">annex G</a>.
+     <sup><a name="note34" href="#note34"><b>34)</b></a></sup> An implementation may define new keywords that provide alternative ways to designate a basic (or
+         any other) type; this does not violate the requirement that all basic types be different.
+         Implementation-defined keywords shall have the form of an identifier reserved for any use as
+         described in <a href="#7.1.3">7.1.3</a>.
+
+[<a name="p34" href="#p34">page 34</a>] (<a href="#Contents">Contents</a>)
+
+15   The three types char, signed char, and unsigned char are collectively called
+     the character types. The implementation shall define char to have the same range,
+     representation, and behavior as either signed char or unsigned char.<sup><a href="#note35"><b>35)</b></a></sup>
+16   An enumeration comprises a set of named integer constant values. Each distinct
+     enumeration constitutes a different enumerated type.
+17   The type char, the signed and unsigned integer types, and the enumerated types are
+     collectively called integer types. The integer and real floating types are collectively called
+     real types.
+18   Integer and floating types are collectively called arithmetic types. Each arithmetic type
+     belongs to one type domain: the real type domain comprises the real types, the complex
+     type domain comprises the complex types.
+19   The void type comprises an empty set of values; it is an incomplete type that cannot be
+     completed.
+20   Any number of derived types can be constructed from the object, function, and
+     incomplete types, as follows:
+     -- An array type describes a contiguously allocated nonempty set of objects with a
+       particular member object type, called the element type.<sup><a href="#note36"><b>36)</b></a></sup> Array types are
+       characterized by their element type and by the number of elements in the array. An
+       array type is said to be derived from its element type, and if its element type is T , the
+       array type is sometimes called ''array of T ''. The construction of an array type from
+       an element type is called ''array type derivation''.
+     -- A structure type describes a sequentially allocated nonempty set of member objects
+       (and, in certain circumstances, an incomplete array), each of which has an optionally
+       specified name and possibly distinct type.
+     -- A union type describes an overlapping nonempty set of member objects, each of
+       which has an optionally specified name and possibly distinct type.
+     -- A function type describes a function with specified return type. A function type is
+       characterized by its return type and the number and types of its parameters. A
+       function type is said to be derived from its return type, and if its return type is T , the
+       function type is sometimes called ''function returning T ''. The construction of a
+       function type from a return type is called ''function type derivation''.
+
+
+
+     <sup><a name="note35" href="#note35"><b>35)</b></a></sup> CHAR_MIN, defined in <a href="#7.10">&lt;limits.h&gt;</a>, will have one of the values 0 or SCHAR_MIN, and this can be
+         used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
+         other two and is not compatible with either.
+     <sup><a name="note36" href="#note36"><b>36)</b></a></sup> Since object types do not include incomplete types, an array of incomplete type cannot be constructed.
+
+[<a name="p35" href="#p35">page 35</a>] (<a href="#Contents">Contents</a>)
+
+     -- A pointer type may be derived from a function type, an object type, or an incomplete
+       type, called the referenced type. A pointer type describes an object whose value
+       provides a reference to an entity of the referenced type. A pointer type derived from
+       the referenced type T is sometimes called ''pointer to T ''. The construction of a
+       pointer type from a referenced type is called ''pointer type derivation''.
+     These methods of constructing derived types can be applied recursively.
+21   Arithmetic types and pointer types are collectively called scalar types. Array and
+     structure types are collectively called aggregate types.<sup><a href="#note37"><b>37)</b></a></sup>
+22   An array type of unknown size is an incomplete type. It is completed, for an identifier of
+     that type, by specifying the size in a later declaration (with internal or external linkage).
+     A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
+     type. It is completed, for all declarations of that type, by declaring the same structure or
+     union tag with its defining content later in the same scope.
+23   A type has known constant size if the type is not incomplete and is not a variable length
+     array type.
+24   Array, function, and pointer types are collectively called derived declarator types. A
+     declarator type derivation from a type T is the construction of a derived declarator type
+     from T by the application of an array-type, a function-type, or a pointer-type derivation to
+     T.
+25   A type is characterized by its type category, which is either the outermost derivation of a
+     derived type (as noted above in the construction of derived types), or the type itself if the
+     type consists of no derived types.
+26   Any type so far mentioned is an unqualified type. Each unqualified type has several
+     qualified versions of its type,<sup><a href="#note38"><b>38)</b></a></sup> corresponding to the combinations of one, two, or all
+     three of the const, volatile, and restrict qualifiers. The qualified or unqualified
+     versions of a type are distinct types that belong to the same type category and have the
+     same representation and alignment requirements.<sup><a href="#note39"><b>39)</b></a></sup> A derived type is not qualified by the
+     qualifiers (if any) of the type from which it is derived.
+27   A pointer to void shall have the same representation and alignment requirements as a
+     pointer to a character type.39) Similarly, pointers to qualified or unqualified versions of
+     compatible types shall have the same representation and alignment requirements. All
+
+
+     <sup><a name="note37" href="#note37"><b>37)</b></a></sup> Note that aggregate type does not include union type because an object with union type can only
+         contain one member at a time.
+     <sup><a name="note38" href="#note38"><b>38)</b></a></sup> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
+     <sup><a name="note39" href="#note39"><b>39)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
+         arguments to functions, return values from functions, and members of unions.
+
+[<a name="p36" href="#p36">page 36</a>] (<a href="#Contents">Contents</a>)
+
+     pointers to structure types shall have the same representation and alignment requirements
+     as each other. All pointers to union types shall have the same representation and
+     alignment requirements as each other. Pointers to other types need not have the same
+     representation or alignment requirements.
+28   EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
+     pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
+     whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
+     qualified float'' and is a pointer to a qualified type.
+
+29   EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
+     function returning struct tag''. The array has length five and the function has a single parameter of type
+     float. Its type category is array.
+
+     Forward references: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
+<a name="6.2.6" href="#6.2.6"><b>     6.2.6 Representations of types</b></a>
+<a name="6.2.6.1" href="#6.2.6.1"><b>     6.2.6.1 General</b></a>
+1    The representations of all types are unspecified except as stated in this subclause.
+2    Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
+     the number, order, and encoding of which are either explicitly specified or
+     implementation-defined.
+3    Values stored in unsigned bit-fields and objects of type unsigned char shall be
+     represented using a pure binary notation.<sup><a href="#note40"><b>40)</b></a></sup>
+4    Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
+     bits, where n is the size of an object of that type, in bytes. The value may be copied into
+     an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
+     called the object representation of the value. Values stored in bit-fields consist of m bits,
+     where m is the size specified for the bit-field. The object representation is the set of m
+     bits the bit-field comprises in the addressable storage unit holding it. Two values (other
+     than NaNs) with the same object representation compare equal, but values that compare
+     equal may have different object representations.
+5    Certain object representations need not represent a value of the object type. If the stored
+     value of an object has such a representation and is read by an lvalue expression that does
+     not have character type, the behavior is undefined. If such a representation is produced
+     by a side effect that modifies all or any part of the object by an lvalue expression that
+     does not have character type, the behavior is undefined.<sup><a href="#note41"><b>41)</b></a></sup> Such a representation is called
+
+     <sup><a name="note40" href="#note40"><b>40)</b></a></sup> A positional representation for integers that uses the binary digits 0 and 1, in which the values
+         represented by successive bits are additive, begin with 1, and are multiplied by successive integral
+         powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
+         Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
+         type unsigned char range from 0 to 2
+                                                   CHAR_BIT
+                                                             - 1.
+
+[<a name="p37" href="#p37">page 37</a>] (<a href="#Contents">Contents</a>)
+
+    a trap representation.
+6   When a value is stored in an object of structure or union type, including in a member
+    object, the bytes of the object representation that correspond to any padding bytes take
+    unspecified values.<sup><a href="#note42"><b>42)</b></a></sup> The value of a structure or union object is never a trap
+    representation, even though the value of a member of the structure or union object may be
+    a trap representation.
+7   When a value is stored in a member of an object of union type, the bytes of the object
+    representation that do not correspond to that member but do correspond to other members
+    take unspecified values.
+8   Where an operator is applied to a value that has more than one object representation,
+    which object representation is used shall not affect the value of the result.<sup><a href="#note43"><b>43)</b></a></sup> Where a
+    value is stored in an object using a type that has more than one object representation for
+    that value, it is unspecified which representation is used, but a trap representation shall
+    not be generated.
+    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
+    designators (<a href="#6.3.2.1">6.3.2.1</a>).
+<a name="6.2.6.2" href="#6.2.6.2"><b>    6.2.6.2 Integer types</b></a>
+1   For unsigned integer types other than unsigned char, the bits of the object
+    representation shall be divided into two groups: value bits and padding bits (there need
+    not be any of the latter). If there are N value bits, each bit shall represent a different
+    power of 2 between 1 and 2 N -1 , so that objects of that type shall be capable of
+    representing values from 0 to 2 N - 1 using a pure binary representation; this shall be
+    known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note44"><b>44)</b></a></sup>
+2   For signed integer types, the bits of the object representation shall be divided into three
+    groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
+
+    <sup><a name="note41" href="#note41"><b>41)</b></a></sup> Thus, an automatic variable can be initialized to a trap representation without causing undefined
+        behavior, but the value of the variable cannot be used until a proper value is stored in it.
+    <sup><a name="note42" href="#note42"><b>42)</b></a></sup> Thus, for example, structure assignment need not copy any padding bits.
+    <sup><a name="note43" href="#note43"><b>43)</b></a></sup> It is possible for objects x and y with the same effective type T to have the same value when they are
+        accessed as objects of type T, but to have different values in other contexts. In particular, if == is
+        defined for type T, then x == y does not imply that memcmp(&amp;x, &amp;y, sizeof (T)) == 0.
+        Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
+        on values of type T may distinguish between them.
+    <sup><a name="note44" href="#note44"><b>44)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
+        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+        representation other than as part of an exceptional condition such as an overflow, and this cannot occur
+        with unsigned types. All other combinations of padding bits are alternative object representations of
+        the value specified by the value bits.
+
+[<a name="p38" href="#p38">page 38</a>] (<a href="#Contents">Contents</a>)
+
+    there shall be exactly one sign bit. Each bit that is a value bit shall have the same value as
+    the same bit in the object representation of the corresponding unsigned type (if there are
+    M value bits in the signed type and N in the unsigned type, then M &lt;= N ). If the sign bit
+    is zero, it shall not affect the resulting value. If the sign bit is one, the value shall be
+    modified in one of the following ways:
+    -- the corresponding value with sign bit 0 is negated (sign and magnitude);
+    -- the sign bit has the value -(2 N ) (two's complement);
+    -- the sign bit has the value -(2 N - 1) (ones' complement ).
+    Which of these applies is implementation-defined, as is whether the value with sign bit 1
+    and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones'
+    complement), is a trap representation or a normal value. In the case of sign and
+    magnitude and ones' complement, if this representation is a normal value it is called a
+    negative zero.
+3   If the implementation supports negative zeros, they shall be generated only by:
+    -- the &amp;, |, ^, ~, &lt;&lt;, and &gt;&gt; operators with arguments that produce such a value;
+    -- the +, -, *, /, and % operators where one argument is a negative zero and the result is
+      zero;
+    -- compound assignment operators based on the above cases.
+    It is unspecified whether these cases actually generate a negative zero or a normal zero,
+    and whether a negative zero becomes a normal zero when stored in an object.
+4   If the implementation does not support negative zeros, the behavior of the &amp;, |, ^, ~, &lt;&lt;,
+    and &gt;&gt; operators with arguments that would produce such a value is undefined.
+5   The values of any padding bits are unspecified.<sup><a href="#note45"><b>45)</b></a></sup> A valid (non-trap) object representation
+    of a signed integer type where the sign bit is zero is a valid object representation of the
+    corresponding unsigned type, and shall represent the same value. For any integer type,
+    the object representation where all the bits are zero shall be a representation of the value
+    zero in that type.
+6   The precision of an integer type is the number of bits it uses to represent values,
+    excluding any sign and padding bits. The width of an integer type is the same but
+    including any sign bit; thus for unsigned integer types the two values are the same, while
+
+
+    <sup><a name="note45" href="#note45"><b>45)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
+        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+        representation other than as part of an exceptional condition such as an overflow. All other
+        combinations of padding bits are alternative object representations of the value specified by the value
+        bits.
+
+[<a name="p39" href="#p39">page 39</a>] (<a href="#Contents">Contents</a>)
+
+    for signed integer types the width is one greater than the precision.
+<a name="6.2.7" href="#6.2.7"><b>    6.2.7 Compatible type and composite type</b></a>
+1   Two types have compatible type if their types are the same. Additional rules for
+    determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
+    in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.5">6.7.5</a> for declarators.<sup><a href="#note46"><b>46)</b></a></sup> Moreover, two structure,
+    union, or enumerated types declared in separate translation units are compatible if their
+    tags and members satisfy the following requirements: If one is declared with a tag, the
+    other shall be declared with the same tag. If both are complete types, then the following
+    additional requirements apply: there shall be a one-to-one correspondence between their
+    members such that each pair of corresponding members are declared with compatible
+    types, and such that if one member of a corresponding pair is declared with a name, the
+    other member is declared with the same name. For two structures, corresponding
+    members shall be declared in the same order. For two structures or unions, corresponding
+    bit-fields shall have the same widths. For two enumerations, corresponding members
+    shall have the same values.
+2   All declarations that refer to the same object or function shall have compatible type;
+    otherwise, the behavior is undefined.
+3   A composite type can be constructed from two types that are compatible; it is a type that
+    is compatible with both of the two types and satisfies the following conditions:
+    -- If one type is an array of known constant size, the composite type is an array of that
+      size; otherwise, if one type is a variable length array, the composite type is that type.
+    -- If only one type is a function type with a parameter type list (a function prototype),
+      the composite type is a function prototype with the parameter type list.
+    -- If both types are function types with parameter type lists, the type of each parameter
+      in the composite parameter type list is the composite type of the corresponding
+      parameters.
+    These rules apply recursively to the types from which the two types are derived.
+4   For an identifier with internal or external linkage declared in a scope in which a prior
+    declaration of that identifier is visible,<sup><a href="#note47"><b>47)</b></a></sup> if the prior declaration specifies internal or
+    external linkage, the type of the identifier at the later declaration becomes the composite
+    type.
+
+
+
+
+    <sup><a name="note46" href="#note46"><b>46)</b></a></sup> Two types need not be identical to be compatible.
+    <sup><a name="note47" href="#note47"><b>47)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+
+[<a name="p40" href="#p40">page 40</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE        Given the following two file scope declarations:
+             int f(int (*)(), double (*)[3]);
+             int f(int (*)(char *), double (*)[]);
+    The resulting composite type for the function is:
+             int f(int (*)(char *), double (*)[3]);
+
+[<a name="p41" href="#p41">page 41</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.3" href="#6.3"><b>    6.3 Conversions</b></a>
+1   Several operators convert operand values from one type to another automatically. This
+    subclause specifies the result required from such an implicit conversion, as well as those
+    that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
+    the conversions performed by most ordinary operators; it is supplemented as required by
+    the discussion of each operator in <a href="#6.5">6.5</a>.
+2   Conversion of an operand value to a compatible type causes no change to the value or the
+    representation.
+    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>).
+<a name="6.3.1" href="#6.3.1"><b>    6.3.1 Arithmetic operands</b></a>
+<a name="6.3.1.1" href="#6.3.1.1"><b>    6.3.1.1 Boolean, characters, and integers</b></a>
+1   Every integer type has an integer conversion rank defined as follows:
+    -- No two signed integer types shall have the same rank, even if they have the same
+      representation.
+    -- The rank of a signed integer type shall be greater than the rank of any signed integer
+      type with less precision.
+    -- The rank of long long int shall be greater than the rank of long int, which
+      shall be greater than the rank of int, which shall be greater than the rank of short
+      int, which shall be greater than the rank of signed char.
+    -- The rank of any unsigned integer type shall equal the rank of the corresponding
+      signed integer type, if any.
+    -- The rank of any standard integer type shall be greater than the rank of any extended
+      integer type with the same width.
+    -- The rank of char shall equal the rank of signed char and unsigned char.
+    -- The rank of _Bool shall be less than the rank of all other standard integer types.
+    -- The rank of any enumerated type shall equal the rank of the compatible integer type
+      (see <a href="#6.7.2.2">6.7.2.2</a>).
+    -- The rank of any extended signed integer type relative to another extended signed
+      integer type with the same precision is implementation-defined, but still subject to the
+      other rules for determining the integer conversion rank.
+    -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
+      greater rank than T3, then T1 has greater rank than T3.
+2   The following may be used in an expression wherever an int or unsigned int may
+    be used:
+
+[<a name="p42" href="#p42">page 42</a>] (<a href="#Contents">Contents</a>)
+
+    -- An object or expression with an integer type whose integer conversion rank is less
+      than or equal to the rank of int and unsigned int.
+    -- A bit-field of type _Bool, int, signed int, or unsigned int.
+    If an int can represent all values of the original type, the value is converted to an int;
+    otherwise, it is converted to an unsigned int. These are called the integer
+    promotions.<sup><a href="#note48"><b>48)</b></a></sup> All other types are unchanged by the integer promotions.
+3   The integer promotions preserve value including sign. As discussed earlier, whether a
+    ''plain'' char is treated as signed is implementation-defined.
+    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
+    (<a href="#6.7.2.1">6.7.2.1</a>).
+<a name="6.3.1.2" href="#6.3.1.2"><b>    6.3.1.2 Boolean type</b></a>
+1   When any scalar value is converted to _Bool, the result is 0 if the value compares equal
+    to 0; otherwise, the result is 1.
+<a name="6.3.1.3" href="#6.3.1.3"><b>    6.3.1.3 Signed and unsigned integers</b></a>
+1   When a value with integer type is converted to another integer type other than _Bool, if
+    the value can be represented by the new type, it is unchanged.
+2   Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
+    subtracting one more than the maximum value that can be represented in the new type
+    until the value is in the range of the new type.<sup><a href="#note49"><b>49)</b></a></sup>
+3   Otherwise, the new type is signed and the value cannot be represented in it; either the
+    result is implementation-defined or an implementation-defined signal is raised.
+<a name="6.3.1.4" href="#6.3.1.4"><b>    6.3.1.4 Real floating and integer</b></a>
+1   When a finite value of real floating type is converted to an integer type other than _Bool,
+    the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
+    the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup>
+2   When a value of integer type is converted to a real floating type, if the value being
+    converted can be represented exactly in the new type, it is unchanged. If the value being
+    converted is in the range of values that can be represented but cannot be represented
+
+    <sup><a name="note48" href="#note48"><b>48)</b></a></sup> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
+        argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
+        shift operators, as specified by their respective subclauses.
+    <sup><a name="note49" href="#note49"><b>49)</b></a></sup> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
+    <sup><a name="note50" href="#note50"><b>50)</b></a></sup> The remaindering operation performed when a value of integer type is converted to unsigned type
+        need not be performed when a value of real floating type is converted to unsigned type. Thus, the
+        range of portable real floating values is (-1, Utype_MAX+1).
+
+[<a name="p43" href="#p43">page 43</a>] (<a href="#Contents">Contents</a>)
+
+    exactly, the result is either the nearest higher or nearest lower representable value, chosen
+    in an implementation-defined manner. If the value being converted is outside the range of
+    values that can be represented, the behavior is undefined.
+<a name="6.3.1.5" href="#6.3.1.5"><b>    6.3.1.5 Real floating types</b></a>
+1   When a float is promoted to double or long double, or a double is promoted
+    to long double, its value is unchanged (if the source value is represented in the
+    precision and range of its type).
+2   When a double is demoted to float, a long double is demoted to double or
+    float, or a value being represented in greater precision and range than required by its
+    semantic type (see <a href="#6.3.1.8">6.3.1.8</a>) is explicitly converted (including to its own type), if the value
+    being converted can be represented exactly in the new type, it is unchanged. If the value
+    being converted is in the range of values that can be represented but cannot be
+    represented exactly, the result is either the nearest higher or nearest lower representable
+    value, chosen in an implementation-defined manner. If the value being converted is
+    outside the range of values that can be represented, the behavior is undefined.
+<a name="6.3.1.6" href="#6.3.1.6"><b>    6.3.1.6 Complex types</b></a>
+1   When a value of complex type is converted to another complex type, both the real and
+    imaginary parts follow the conversion rules for the corresponding real types.
+<a name="6.3.1.7" href="#6.3.1.7"><b>    6.3.1.7 Real and complex</b></a>
+1   When a value of real type is converted to a complex type, the real part of the complex
+    result value is determined by the rules of conversion to the corresponding real type and
+    the imaginary part of the complex result value is a positive zero or an unsigned zero.
+2   When a value of complex type is converted to a real type, the imaginary part of the
+    complex value is discarded and the value of the real part is converted according to the
+    conversion rules for the corresponding real type.
+<a name="6.3.1.8" href="#6.3.1.8"><b>    6.3.1.8 Usual arithmetic conversions</b></a>
+1   Many operators that expect operands of arithmetic type cause conversions and yield result
+    types in a similar way. The purpose is to determine a common real type for the operands
+    and result. For the specified operands, each operand is converted, without change of type
+    domain, to a type whose corresponding real type is the common real type. Unless
+    explicitly stated otherwise, the common real type is also the corresponding real type of
+    the result, whose type domain is the type domain of the operands if they are the same,
+    and complex otherwise. This pattern is called the usual arithmetic conversions:
+          First, if the corresponding real type of either operand is long double, the other
+          operand is converted, without change of type domain, to a type whose
+          corresponding real type is long double.
+
+[<a name="p44" href="#p44">page 44</a>] (<a href="#Contents">Contents</a>)
+
+          Otherwise, if the corresponding real type of either operand is double, the other
+          operand is converted, without change of type domain, to a type whose
+          corresponding real type is double.
+          Otherwise, if the corresponding real type of either operand is float, the other
+          operand is converted, without change of type domain, to a type whose
+          corresponding real type is float.<sup><a href="#note51"><b>51)</b></a></sup>
+          Otherwise, the integer promotions are performed on both operands. Then the
+          following rules are applied to the promoted operands:
+                 If both operands have the same type, then no further conversion is needed.
+                 Otherwise, if both operands have signed integer types or both have unsigned
+                 integer types, the operand with the type of lesser integer conversion rank is
+                 converted to the type of the operand with greater rank.
+                 Otherwise, if the operand that has unsigned integer type has rank greater or
+                 equal to the rank of the type of the other operand, then the operand with
+                 signed integer type is converted to the type of the operand with unsigned
+                 integer type.
+                 Otherwise, if the type of the operand with signed integer type can represent
+                 all of the values of the type of the operand with unsigned integer type, then
+                 the operand with unsigned integer type is converted to the type of the
+                 operand with signed integer type.
+                 Otherwise, both operands are converted to the unsigned integer type
+                 corresponding to the type of the operand with signed integer type.
+2   The values of floating operands and of the results of floating expressions may be
+    represented in greater precision and range than that required by the type; the types are not
+    changed thereby.<sup><a href="#note52"><b>52)</b></a></sup>
+
+
+
+
+    <sup><a name="note51" href="#note51"><b>51)</b></a></sup> For example, addition of a double _Complex and a float entails just the conversion of the
+        float operand to double (and yields a double _Complex result).
+    <sup><a name="note52" href="#note52"><b>52)</b></a></sup> The cast and assignment operators are still required to perform their specified conversions as
+        described in <a href="#6.3.1.4">6.3.1.4</a> and <a href="#6.3.1.5">6.3.1.5</a>.
+
+[<a name="p45" href="#p45">page 45</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.3.2" href="#6.3.2"><b>    6.3.2 Other operands</b></a>
+<a name="6.3.2.1" href="#6.3.2.1"><b>    6.3.2.1 Lvalues, arrays, and function designators</b></a>
+1   An lvalue is an expression with an object type or an incomplete type other than void;<sup><a href="#note53"><b>53)</b></a></sup>
+    if an lvalue does not designate an object when it is evaluated, the behavior is undefined.
+    When an object is said to have a particular type, the type is specified by the lvalue used to
+    designate the object. A modifiable lvalue is an lvalue that does not have array type, does
+    not have an incomplete type, does not have a const-qualified type, and if it is a structure
+    or union, does not have any member (including, recursively, any member or element of
+    all contained aggregates or unions) with a const-qualified type.
+2   Except when it is the operand of the sizeof operator, the unary &amp; operator, the ++
+    operator, the -- operator, or the left operand of the . operator or an assignment operator,
+    an lvalue that does not have array type is converted to the value stored in the designated
+    object (and is no longer an lvalue). If the lvalue has qualified type, the value has the
+    unqualified version of the type of the lvalue; otherwise, the value has the type of the
+    lvalue. If the lvalue has an incomplete type and does not have array type, the behavior is
+    undefined.
+3   Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a
+    string literal used to initialize an array, an expression that has type ''array of type'' is
+    converted to an expression with type ''pointer to type'' that points to the initial element of
+    the array object and is not an lvalue. If the array object has register storage class, the
+    behavior is undefined.
+4   A function designator is an expression that has function type. Except when it is the
+    operand of the sizeof operator<sup><a href="#note54"><b>54)</b></a></sup> or the unary &amp; operator, a function designator with
+    type ''function returning type'' is converted to an expression that has type ''pointer to
+    function returning type''.
+    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
+    (<a href="#6.5.16">6.5.16</a>), common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), initialization (<a href="#6.7.8">6.7.8</a>), postfix
+    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+    (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>).
+
+
+    <sup><a name="note53" href="#note53"><b>53)</b></a></sup> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
+        operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
+        object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
+        as the ''value of an expression''.
+         An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
+         expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
+    <sup><a name="note54" href="#note54"><b>54)</b></a></sup> Because this conversion does not occur, the operand of the sizeof operator remains a function
+        designator and violates the constraint in <a href="#6.5.3.4">6.5.3.4</a>.
+
+[<a name="p46" href="#p46">page 46</a>] (<a href="#Contents">Contents</a>)
+
+    <a href="#6.3.2.2">6.3.2.2</a> void
+1   The (nonexistent) value of a void expression (an expression that has type void) shall not
+    be used in any way, and implicit or explicit conversions (except to void) shall not be
+    applied to such an expression. If an expression of any other type is evaluated as a void
+    expression, its value or designator is discarded. (A void expression is evaluated for its
+    side effects.)
+<a name="6.3.2.3" href="#6.3.2.3"><b>    6.3.2.3 Pointers</b></a>
+1   A pointer to void may be converted to or from a pointer to any incomplete or object
+    type. A pointer to any incomplete or object type may be converted to a pointer to void
+    and back again; the result shall compare equal to the original pointer.
+2   For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
+    the q-qualified version of the type; the values stored in the original and converted pointers
+    shall compare equal.
+3   An integer constant expression with the value 0, or such an expression cast to type
+    void *, is called a null pointer constant.<sup><a href="#note55"><b>55)</b></a></sup> If a null pointer constant is converted to a
+    pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
+    to a pointer to any object or function.
+4   Conversion of a null pointer to another pointer type yields a null pointer of that type.
+    Any two null pointers shall compare equal.
+5   An integer may be converted to any pointer type. Except as previously specified, the
+    result is implementation-defined, might not be correctly aligned, might not point to an
+    entity of the referenced type, and might be a trap representation.<sup><a href="#note56"><b>56)</b></a></sup>
+6   Any pointer type may be converted to an integer type. Except as previously specified, the
+    result is implementation-defined. If the result cannot be represented in the integer type,
+    the behavior is undefined. The result need not be in the range of values of any integer
+    type.
+7   A pointer to an object or incomplete type may be converted to a pointer to a different
+    object or incomplete type. If the resulting pointer is not correctly aligned<sup><a href="#note57"><b>57)</b></a></sup> for the
+    pointed-to type, the behavior is undefined. Otherwise, when converted back again, the
+    result shall compare equal to the original pointer. When a pointer to an object is
+
+
+    <sup><a name="note55" href="#note55"><b>55)</b></a></sup> The macro NULL is defined in <a href="#7.17">&lt;stddef.h&gt;</a> (and other headers) as a null pointer constant; see <a href="#7.17">7.17</a>.
+    <sup><a name="note56" href="#note56"><b>56)</b></a></sup> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
+        be consistent with the addressing structure of the execution environment.
+    <sup><a name="note57" href="#note57"><b>57)</b></a></sup> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
+        pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
+        correctly aligned for a pointer to type C.
+
+[<a name="p47" href="#p47">page 47</a>] (<a href="#Contents">Contents</a>)
+
+    converted to a pointer to a character type, the result points to the lowest addressed byte of
+    the object. Successive increments of the result, up to the size of the object, yield pointers
+    to the remaining bytes of the object.
+8   A pointer to a function of one type may be converted to a pointer to a function of another
+    type and back again; the result shall compare equal to the original pointer. If a converted
+    pointer is used to call a function whose type is not compatible with the pointed-to type,
+    the behavior is undefined.
+    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
+    capable of holding object pointers (<a href="#7.18.1.4">7.18.1.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+
+[<a name="p48" href="#p48">page 48</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4" href="#6.4"><b>    6.4 Lexical elements</b></a>
+<b>    Syntax</b>
+1            token:
+                      keyword
+                      identifier
+                      constant
+                      string-literal
+                      punctuator
+             preprocessing-token:
+                    header-name
+                    identifier
+                    pp-number
+                    character-constant
+                    string-literal
+                    punctuator
+                    each non-white-space character that cannot be one of the above
+<b>    Constraints</b>
+2   Each preprocessing token that is converted to a token shall have the lexical form of a
+    keyword, an identifier, a constant, a string literal, or a punctuator.
+<b>    Semantics</b>
+3   A token is the minimal lexical element of the language in translation phases 7 and 8. The
+    categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
+    A preprocessing token is the minimal lexical element of the language in translation
+    phases 3 through 6. The categories of preprocessing tokens are: header names,
+    identifiers, preprocessing numbers, character constants, string literals, punctuators, and
+    single non-white-space characters that do not lexically match the other preprocessing
+    token categories.<sup><a href="#note58"><b>58)</b></a></sup> If a ' or a " character matches the last category, the behavior is
+    undefined. Preprocessing tokens can be separated by white space; this consists of
+    comments (described later), or white-space characters (space, horizontal tab, new-line,
+    vertical tab, and form-feed), or both. As described in <a href="#6.10">6.10</a>, in certain circumstances
+    during translation phase 4, white space (or the absence thereof) serves as more than
+    preprocessing token separation. White space may appear within a preprocessing token
+    only as part of a header name or between the quotation characters in a character constant
+    or string literal.
+
+
+
+    <sup><a name="note58" href="#note58"><b>58)</b></a></sup> An additional category, placemarkers, is used internally in translation phase 4 (see <a href="#6.10.3.3">6.10.3.3</a>); it cannot
+        occur in source files.
+
+[<a name="p49" href="#p49">page 49</a>] (<a href="#Contents">Contents</a>)
+
+4   If the input stream has been parsed into preprocessing tokens up to a given character, the
+    next preprocessing token is the longest sequence of characters that could constitute a
+    preprocessing token. There is one exception to this rule: header name preprocessing
+    tokens are recognized only within #include preprocessing directives and in
+    implementation-defined locations within #pragma directives. In such contexts, a
+    sequence of characters that could be either a header name or a string literal is recognized
+    as the former.
+5   EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
+    valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
+    might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
+    fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
+    not E is a macro name.
+
+6   EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
+    increment operators, even though the parse x ++ + ++ y might yield a correct expression.
+
+    Forward references: character constants (<a href="#6.4.4.4">6.4.4.4</a>), comments (<a href="#6.4.9">6.4.9</a>), expressions (<a href="#6.5">6.5</a>),
+    floating constants (<a href="#6.4.4.2">6.4.4.2</a>), header names (<a href="#6.4.7">6.4.7</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), postfix
+    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+    (<a href="#6.5.3.1">6.5.3.1</a>), preprocessing directives (<a href="#6.10">6.10</a>), preprocessing numbers (<a href="#6.4.8">6.4.8</a>), string literals
+    (<a href="#6.4.5">6.4.5</a>).
+<a name="6.4.1" href="#6.4.1"><b>    6.4.1 Keywords</b></a>
+<b>    Syntax</b>
+1            keyword: one of
+                   auto                    enum                  restrict              unsigned
+                   break                   extern                return                void
+                   case                    float                 short                 volatile
+                   char                    for                   signed                while
+                   const                   goto                  sizeof                _Bool
+                   continue                if                    static                _Complex
+                   default                 inline                struct                _Imaginary
+                   do                      int                   switch
+                   double                  long                  typedef
+                   else                    register              union
+<b>    Semantics</b>
+2   The above tokens (case sensitive) are reserved (in translation phases 7 and 8) for use as
+    keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
+    specifying imaginary types.<sup><a href="#note59"><b>59)</b></a></sup>
+
+
+
+    <sup><a name="note59" href="#note59"><b>59)</b></a></sup> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
+
+[<a name="p50" href="#p50">page 50</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.2" href="#6.4.2"><b>    6.4.2 Identifiers</b></a>
+<a name="6.4.2.1" href="#6.4.2.1"><b>    6.4.2.1 General</b></a>
+<b>    Syntax</b>
+1            identifier:
+                    identifier-nondigit
+                     identifier identifier-nondigit
+                    identifier digit
+             identifier-nondigit:
+                     nondigit
+                     universal-character-name
+                    other implementation-defined characters
+             nondigit: one of
+                    _ a b            c    d    e    f     g    h    i    j     k    l    m
+                        n o          p    q    r    s     t    u    v    w     x    y    z
+                        A B          C    D    E    F     G    H    I    J     K    L    M
+                        N O          P    Q    R    S     T    U    V    W     X    Y    Z
+             digit: one of
+                    0 1        2     3    4    5    6     7    8    9
+<b>    Semantics</b>
+2   An identifier is a sequence of nondigit characters (including the underscore _, the
+    lowercase and uppercase Latin letters, and other characters) and digits, which designates
+    one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
+    There is no specific limit on the maximum length of an identifier.
+3   Each universal character name in an identifier shall designate a character whose encoding
+    in ISO/IEC 10646 falls into one of the ranges specified in <a href="#D">annex D</a>.<sup><a href="#note60"><b>60)</b></a></sup> The initial
+    character shall not be a universal character name designating a digit. An implementation
+    may allow multibyte characters that are not part of the basic source character set to
+    appear in identifiers; which characters and their correspondence to universal character
+    names is implementation-defined.
+4   When preprocessing tokens are converted to tokens during translation phase 7, if a
+    preprocessing token could be converted to either a keyword or an identifier, it is converted
+    to a keyword.
+
+
+    <sup><a name="note60" href="#note60"><b>60)</b></a></sup> On systems in which linkers cannot accept extended characters, an encoding of the universal character
+        name may be used in forming valid external identifiers. For example, some otherwise unused
+        character or sequence of characters may be used to encode the \u in a universal character name.
+        Extended characters may produce a long external identifier.
+
+[<a name="p51" href="#p51">page 51</a>] (<a href="#Contents">Contents</a>)
+
+    Implementation limits
+5   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
+    characters in an identifier; the limit for an external name (an identifier that has external
+    linkage) may be more restrictive than that for an internal name (a macro name or an
+    identifier that does not have external linkage). The number of significant characters in an
+    identifier is implementation-defined.
+6   Any identifiers that differ in a significant character are different identifiers. If two
+    identifiers differ only in nonsignificant characters, the behavior is undefined.
+    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
+<a name="6.4.2.2" href="#6.4.2.2"><b>    6.4.2.2 Predefined identifiers</b></a>
+<b>    Semantics</b>
+1   The identifier __func__ shall be implicitly declared by the translator as if,
+    immediately following the opening brace of each function definition, the declaration
+             static const char __func__[] = "function-name";
+    appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note61"><b>61)</b></a></sup>
+2   This name is encoded as if the implicit declaration had been written in the source
+    character set and then translated into the execution character set as indicated in translation
+    phase 5.
+3   EXAMPLE        Consider the code fragment:
+             #include <a href="#7.19">&lt;stdio.h&gt;</a>
+             void myfunc(void)
+             {
+                   printf("%s\n", __func__);
+                   /* ... */
+             }
+    Each time the function is called, it will print to the standard output stream:
+             myfunc
+
+    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+
+
+
+
+    <sup><a name="note61" href="#note61"><b>61)</b></a></sup> Since the name __func__ is reserved for any use by the implementation (<a href="#7.1.3">7.1.3</a>), if any other
+        identifier is explicitly declared using the name __func__, the behavior is undefined.
+
+[<a name="p52" href="#p52">page 52</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.3" href="#6.4.3"><b>    6.4.3 Universal character names</b></a>
+<b>    Syntax</b>
+1            universal-character-name:
+                    \u hex-quad
+                    \U hex-quad hex-quad
+             hex-quad:
+                    hexadecimal-digit hexadecimal-digit
+                                 hexadecimal-digit hexadecimal-digit
+<b>    Constraints</b>
+2   A universal character name shall not specify a character whose short identifier is less than
+    00A0 other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through
+    DFFF inclusive.<sup><a href="#note62"><b>62)</b></a></sup>
+<b>    Description</b>
+3   Universal character names may be used in identifiers, character constants, and string
+    literals to designate characters that are not in the basic character set.
+<b>    Semantics</b>
+4   The universal character name \Unnnnnnnn designates the character whose eight-digit
+    short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note63"><b>63)</b></a></sup> Similarly, the universal
+    character name \unnnn designates the character whose four-digit short identifier is nnnn
+    (and whose eight-digit short identifier is 0000nnnn).
+
+
+
+
+    <sup><a name="note62" href="#note62"><b>62)</b></a></sup> The disallowed characters are the characters in the basic character set and the code positions reserved
+        by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
+        UTF-16).
+    <sup><a name="note63" href="#note63"><b>63)</b></a></sup> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
+
+[<a name="p53" href="#p53">page 53</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.4" href="#6.4.4"><b>    6.4.4 Constants</b></a>
+<b>    Syntax</b>
+1            constant:
+                    integer-constant
+                    floating-constant
+                    enumeration-constant
+                    character-constant
+<b>    Constraints</b>
+2   Each constant shall have a type and the value of a constant shall be in the range of
+    representable values for its type.
+<b>    Semantics</b>
+3   Each constant has a type, determined by its form and value, as detailed later.
+<a name="6.4.4.1" href="#6.4.4.1"><b>    6.4.4.1 Integer constants</b></a>
+<b>    Syntax</b>
+1            integer-constant:
+                     decimal-constant integer-suffixopt
+                     octal-constant integer-suffixopt
+                     hexadecimal-constant integer-suffixopt
+             decimal-constant:
+                   nonzero-digit
+                   decimal-constant digit
+             octal-constant:
+                    0
+                    octal-constant octal-digit
+             hexadecimal-constant:
+                   hexadecimal-prefix hexadecimal-digit
+                   hexadecimal-constant hexadecimal-digit
+             hexadecimal-prefix: one of
+                   0x 0X
+             nonzero-digit: one of
+                    1 2 3 4          5     6     7   8    9
+             octal-digit: one of
+                     0 1 2 3         4     5     6   7
+
+[<a name="p54" href="#p54">page 54</a>] (<a href="#Contents">Contents</a>)
+
+           hexadecimal-digit:   one of
+                 0 1 2           3 4      5    6   7     8   9
+                 a b c           d e      f
+                 A B C           D E      F
+           integer-suffix:
+                   unsigned-suffix long-suffixopt
+                   unsigned-suffix long-long-suffix
+                   long-suffix unsigned-suffixopt
+                   long-long-suffix unsigned-suffixopt
+           unsigned-suffix: one of
+                  u U
+           long-suffix: one of
+                  l L
+           long-long-suffix: one of
+                  ll LL
+<b>    Description</b>
+2   An integer constant begins with a digit, but has no period or exponent part. It may have a
+    prefix that specifies its base and a suffix that specifies its type.
+3   A decimal constant begins with a nonzero digit and consists of a sequence of decimal
+    digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
+    digits 0 through 7 only. A hexadecimal constant consists of the prefix 0x or 0X followed
+    by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
+    10 through 15 respectively.
+<b>    Semantics</b>
+4   The value of a decimal constant is computed base 10; that of an octal constant, base 8;
+    that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
+5   The type of an integer constant is the first of the corresponding list in which its value can
+    be represented.
+
+[<a name="p55" href="#p55">page 55</a>] (<a href="#Contents">Contents</a>)
+
+                                                                     Octal or Hexadecimal
+    Suffix                       Decimal Constant                           Constant
+
+    none                int                                    int
+                        long int                               unsigned int
+                        long long int                          long int
+                                                               unsigned long int
+                                                               long long int
+                                                               unsigned long long int
+
+    u or U              unsigned int                           unsigned int
+                        unsigned long int                      unsigned long int
+                        unsigned long long int                 unsigned long long int
+
+    l or L              long int                               long int
+                        long long int                          unsigned long int
+                                                               long long int
+                                                               unsigned long long int
+
+    Both u or U         unsigned long int                      unsigned long int
+    and l or L          unsigned long long int                 unsigned long long int
+
+    ll or LL            long long int                          long long int
+                                                               unsigned long long int
+
+    Both u or U         unsigned long long int                 unsigned long long int
+    and ll or LL
+6   If an integer constant cannot be represented by any type in its list, it may have an
+    extended integer type, if the extended integer type can represent its value. If all of the
+    types in the list for the constant are signed, the extended integer type shall be signed. If
+    all of the types in the list for the constant are unsigned, the extended integer type shall be
+    unsigned. If the list contains both signed and unsigned types, the extended integer type
+    may be signed or unsigned. If an integer constant cannot be represented by any type in
+    its list and has no extended integer type, then the integer constant has no type.
+
+[<a name="p56" href="#p56">page 56</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.4.2" href="#6.4.4.2"><b>    6.4.4.2 Floating constants</b></a>
+<b>    Syntax</b>
+1            floating-constant:
+                    decimal-floating-constant
+                    hexadecimal-floating-constant
+             decimal-floating-constant:
+                   fractional-constant exponent-partopt floating-suffixopt
+                   digit-sequence exponent-part floating-suffixopt
+             hexadecimal-floating-constant:
+                   hexadecimal-prefix hexadecimal-fractional-constant
+                                  binary-exponent-part floating-suffixopt
+                   hexadecimal-prefix hexadecimal-digit-sequence
+                                  binary-exponent-part floating-suffixopt
+             fractional-constant:
+                     digit-sequenceopt . digit-sequence
+                     digit-sequence .
+             exponent-part:
+                   e signopt digit-sequence
+                   E signopt digit-sequence
+             sign: one of
+                    + -
+             digit-sequence:
+                     digit
+                     digit-sequence digit
+             hexadecimal-fractional-constant:
+                   hexadecimal-digit-sequenceopt .
+                                  hexadecimal-digit-sequence
+                   hexadecimal-digit-sequence .
+             binary-exponent-part:
+                    p signopt digit-sequence
+                    P signopt digit-sequence
+             hexadecimal-digit-sequence:
+                   hexadecimal-digit
+                   hexadecimal-digit-sequence hexadecimal-digit
+             floating-suffix: one of
+                    f l F L
+
+[<a name="p57" href="#p57">page 57</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   A floating constant has a significand part that may be followed by an exponent part and a
+    suffix that specifies its type. The components of the significand part may include a digit
+    sequence representing the whole-number part, followed by a period (.), followed by a
+    digit sequence representing the fraction part. The components of the exponent part are an
+    e, E, p, or P followed by an exponent consisting of an optionally signed digit sequence.
+    Either the whole-number part or the fraction part has to be present; for decimal floating
+    constants, either the period or the exponent part has to be present.
+<b>    Semantics</b>
+3   The significand part is interpreted as a (decimal or hexadecimal) rational number; the
+    digit sequence in the exponent part is interpreted as a decimal integer. For decimal
+    floating constants, the exponent indicates the power of 10 by which the significand part is
+    to be scaled. For hexadecimal floating constants, the exponent indicates the power of 2
+    by which the significand part is to be scaled. For decimal floating constants, and also for
+    hexadecimal floating constants when FLT_RADIX is not a power of 2, the result is either
+    the nearest representable value, or the larger or smaller representable value immediately
+    adjacent to the nearest representable value, chosen in an implementation-defined manner.
+    For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
+    correctly rounded.
+4   An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
+    type float. If suffixed by the letter l or L, it has type long double.
+5   Floating constants are converted to internal format as if at translation-time. The
+    conversion of a floating constant shall not raise an exceptional condition or a floating-
+    point exception at execution time.
+    Recommended practice
+6   The implementation should produce a diagnostic message if a hexadecimal constant
+    cannot be represented exactly in its evaluation format; the implementation should then
+    proceed with the translation of the program.
+7   The translation-time conversion of floating constants should match the execution-time
+    conversion of character strings by library functions, such as strtod, given matching
+    inputs suitable for both conversions, the same result format, and default execution-time
+    rounding.<sup><a href="#note64"><b>64)</b></a></sup>
+
+
+
+
+    <sup><a name="note64" href="#note64"><b>64)</b></a></sup> The specification for the library functions recommends more accurate conversion than required for
+        floating constants (see <a href="#7.20.1.3">7.20.1.3</a>).
+
+[<a name="p58" href="#p58">page 58</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.4.3" href="#6.4.4.3"><b>    6.4.4.3 Enumeration constants</b></a>
+<b>    Syntax</b>
+1            enumeration-constant:
+                   identifier
+<b>    Semantics</b>
+2   An identifier declared as an enumeration constant has type int.
+    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
+<a name="6.4.4.4" href="#6.4.4.4"><b>    6.4.4.4 Character constants</b></a>
+<b>    Syntax</b>
+1            character-constant:
+                    ' c-char-sequence '
+                    L' c-char-sequence '
+             c-char-sequence:
+                    c-char
+                    c-char-sequence c-char
+             c-char:
+                       any member of the source character set except
+                                    the single-quote ', backslash \, or new-line character
+                       escape-sequence
+             escape-sequence:
+                    simple-escape-sequence
+                    octal-escape-sequence
+                    hexadecimal-escape-sequence
+                    universal-character-name
+             simple-escape-sequence: one of
+                    \' \" \? \\
+                    \a \b \f \n \r                  \t    \v
+             octal-escape-sequence:
+                     \ octal-digit
+                     \ octal-digit octal-digit
+                     \ octal-digit octal-digit octal-digit
+             hexadecimal-escape-sequence:
+                   \x hexadecimal-digit
+                   hexadecimal-escape-sequence hexadecimal-digit
+
+[<a name="p59" href="#p59">page 59</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   An integer character constant is a sequence of one or more multibyte characters enclosed
+    in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
+    letter L. With a few exceptions detailed later, the elements of the sequence are any
+    members of the source character set; they are mapped in an implementation-defined
+    manner to members of the execution character set.
+3   The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
+    arbitrary integer values are representable according to the following table of escape
+    sequences:
+           single quote '                 \'
+           double quote "                 \"
+           question mark ?                \?
+           backslash \                    \\
+           octal character                \octal digits
+           hexadecimal character          \x hexadecimal digits
+4   The double-quote " and question-mark ? are representable either by themselves or by the
+    escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
+    shall be represented, respectively, by the escape sequences \' and \\.
+5   The octal digits that follow the backslash in an octal escape sequence are taken to be part
+    of the construction of a single character for an integer character constant or of a single
+    wide character for a wide character constant. The numerical value of the octal integer so
+    formed specifies the value of the desired character or wide character.
+6   The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
+    sequence are taken to be part of the construction of a single character for an integer
+    character constant or of a single wide character for a wide character constant. The
+    numerical value of the hexadecimal integer so formed specifies the value of the desired
+    character or wide character.
+7   Each octal or hexadecimal escape sequence is the longest sequence of characters that can
+    constitute the escape sequence.
+8   In addition, characters not in the basic character set are representable by universal
+    character names and certain nongraphic characters are representable by escape sequences
+    consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
+    and \v.<sup><a href="#note65"><b>65)</b></a></sup>
+
+
+
+
+    <sup><a name="note65" href="#note65"><b>65)</b></a></sup> The semantics of these characters were discussed in <a href="#5.2.2">5.2.2</a>. If any other character follows a backslash,
+        the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
+
+[<a name="p60" href="#p60">page 60</a>] (<a href="#Contents">Contents</a>)
+
+<b>     Constraints</b>
+9    The value of an octal or hexadecimal escape sequence shall be in the range of
+     representable values for the type unsigned char for an integer character constant, or
+     the unsigned type corresponding to wchar_t for a wide character constant.
+<b>     Semantics</b>
+10   An integer character constant has type int. The value of an integer character constant
+     containing a single character that maps to a single-byte execution character is the
+     numerical value of the representation of the mapped character interpreted as an integer.
+     The value of an integer character constant containing more than one character (e.g.,
+     'ab'), or containing a character or escape sequence that does not map to a single-byte
+     execution character, is implementation-defined. If an integer character constant contains
+     a single character or escape sequence, its value is the one that results when an object with
+     type char whose value is that of the single character or escape sequence is converted to
+     type int.
+11   A wide character constant has type wchar_t, an integer type defined in the
+     <a href="#7.17">&lt;stddef.h&gt;</a> header. The value of a wide character constant containing a single
+     multibyte character that maps to a member of the extended execution character set is the
+     wide character corresponding to that multibyte character, as defined by the mbtowc
+     function, with an implementation-defined current locale. The value of a wide character
+     constant containing more than one multibyte character, or containing a multibyte
+     character or escape sequence not represented in the extended execution character set, is
+     implementation-defined.
+12   EXAMPLE 1      The construction '\0' is commonly used to represent the null character.
+
+13   EXAMPLE 2 Consider implementations that use two's-complement representation for integers and eight
+     bits for objects that have type char. In an implementation in which type char has the same range of
+     values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
+     same range of values as unsigned char, the character constant '\xFF' has the value +255.
+
+14   EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
+     specifies an integer character constant containing only one character, since a hexadecimal escape sequence
+     is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
+     two characters whose values are '\x12' and '3', the construction '\0223' may be used, since an octal
+     escape sequence is terminated after three octal digits. (The value of this two-character integer character
+     constant is implementation-defined.)
+
+15   EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
+     L'\1234' specifies the implementation-defined value that results from the combination of the values
+     0123 and '4'.
+
+     Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), the mbtowc function
+     (<a href="#7.20.7.2">7.20.7.2</a>).
+
+[<a name="p61" href="#p61">page 61</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.5" href="#6.4.5"><b>    6.4.5 String literals</b></a>
+<b>    Syntax</b>
+1            string-literal:
+                     " s-char-sequenceopt "
+                     L" s-char-sequenceopt "
+             s-char-sequence:
+                    s-char
+                    s-char-sequence s-char
+             s-char:
+                       any member of the source character set except
+                                    the double-quote ", backslash \, or new-line character
+                       escape-sequence
+<b>    Description</b>
+2   A character string literal is a sequence of zero or more multibyte characters enclosed in
+    double-quotes, as in "xyz". A wide string literal is the same, except prefixed by the
+    letter L.
+3   The same considerations apply to each element of the sequence in a character string
+    literal or a wide string literal as if it were in an integer character constant or a wide
+    character constant, except that the single-quote ' is representable either by itself or by the
+    escape sequence \', but the double-quote " shall be represented by the escape sequence
+    \".
+<b>    Semantics</b>
+4   In translation phase 6, the multibyte character sequences specified by any sequence of
+    adjacent character and wide string literal tokens are concatenated into a single multibyte
+    character sequence. If any of the tokens are wide string literal tokens, the resulting
+    multibyte character sequence is treated as a wide string literal; otherwise, it is treated as a
+    character string literal.
+5   In translation phase 7, a byte or code of value zero is appended to each multibyte
+    character sequence that results from a string literal or literals.<sup><a href="#note66"><b>66)</b></a></sup> The multibyte character
+    sequence is then used to initialize an array of static storage duration and length just
+    sufficient to contain the sequence. For character string literals, the array elements have
+    type char, and are initialized with the individual bytes of the multibyte character
+    sequence; for wide string literals, the array elements have type wchar_t, and are
+    initialized with the sequence of wide characters corresponding to the multibyte character
+
+    <sup><a name="note66" href="#note66"><b>66)</b></a></sup> A character string literal need not be a string (see <a href="#7.1.1">7.1.1</a>), because a null character may be embedded in
+        it by a \0 escape sequence.
+
+[<a name="p62" href="#p62">page 62</a>] (<a href="#Contents">Contents</a>)
+
+    sequence, as defined by the mbstowcs function with an implementation-defined current
+    locale. The value of a string literal containing a multibyte character or escape sequence
+    not represented in the execution character set is implementation-defined.
+6   It is unspecified whether these arrays are distinct provided their elements have the
+    appropriate values. If the program attempts to modify such an array, the behavior is
+    undefined.
+7   EXAMPLE       This pair of adjacent character string literals
+             "\x12" "3"
+    produces a single character string literal containing the two characters whose values are '\x12' and '3',
+    because escape sequences are converted into single members of the execution character set just prior to
+    adjacent string literal concatenation.
+
+    Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), the mbstowcs
+    function (<a href="#7.20.8.1">7.20.8.1</a>).
+<a name="6.4.6" href="#6.4.6"><b>    6.4.6 Punctuators</b></a>
+<b>    Syntax</b>
+1            punctuator: one of
+                    [ ] ( ) { } . -&gt;
+                    ++ -- &amp; * + - ~ !
+                    / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                               ==     !=     ^    |     &amp;&amp;     ||
+                    ? : ; ...
+                    = *= /= %= += -= &lt;&lt;=                              &gt;&gt;=      &amp;=       ^=   |=
+                    , # ##
+                    &lt;: :&gt; &lt;% %&gt; %: %:%:
+<b>    Semantics</b>
+2   A punctuator is a symbol that has independent syntactic and semantic significance.
+    Depending on context, it may specify an operation to be performed (which in turn may
+    yield a value or a function designator, produce a side effect, or some combination thereof)
+    in which case it is known as an operator (other forms of operator also exist in some
+    contexts). An operand is an entity on which an operator acts.
+
+[<a name="p63" href="#p63">page 63</a>] (<a href="#Contents">Contents</a>)
+
+3   In all aspects of the language, the six tokens<sup><a href="#note67"><b>67)</b></a></sup>
+             &lt;:    :&gt;      &lt;%    %&gt;     %:     %:%:
+    behave, respectively, the same as the six tokens
+             [     ]       {     }      #      ##
+    except for their spelling.<sup><a href="#note68"><b>68)</b></a></sup>
+    Forward references: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
+    (<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
+<a name="6.4.7" href="#6.4.7"><b>    6.4.7 Header names</b></a>
+<b>    Syntax</b>
+1            header-name:
+                    &lt; h-char-sequence &gt;
+                    " q-char-sequence "
+             h-char-sequence:
+                    h-char
+                    h-char-sequence h-char
+             h-char:
+                       any member of the source character set except
+                                    the new-line character and &gt;
+             q-char-sequence:
+                    q-char
+                    q-char-sequence q-char
+             q-char:
+                       any member of the source character set except
+                                    the new-line character and "
+<b>    Semantics</b>
+2   The sequences in both forms of header names are mapped in an implementation-defined
+    manner to headers or external source file names as specified in <a href="#6.10.2">6.10.2</a>.
+3   If the characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt; delimiters,
+    the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
+
+
+
+
+    <sup><a name="note67" href="#note67"><b>67)</b></a></sup> These tokens are sometimes called ''digraphs''.
+    <sup><a name="note68" href="#note68"><b>68)</b></a></sup> Thus [ and &lt;: behave differently when ''stringized'' (see <a href="#6.10.3.2">6.10.3.2</a>), but can otherwise be freely
+        interchanged.
+
+[<a name="p64" href="#p64">page 64</a>] (<a href="#Contents">Contents</a>)
+
+    sequence between the " delimiters, the behavior is undefined.<sup><a href="#note69"><b>69)</b></a></sup> Header name
+    preprocessing tokens are recognized only within #include preprocessing directives and
+    in implementation-defined locations within #pragma directives.<sup><a href="#note70"><b>70)</b></a></sup>
+4   EXAMPLE       The following sequence of characters:
+             0x3&lt;1/a.h&gt;1e2
+             #include &lt;1/a.h&gt;
+             #define const.member@$
+    forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
+    by a { on the left and a } on the right).
+             {0x3}{&lt;}{1}{/}{a}{.}{h}{&gt;}{1e2}
+             {#}{include} {&lt;1/a.h&gt;}
+             {#}{define} {const}{.}{member}{@}{$}
+
+    Forward references: source file inclusion (<a href="#6.10.2">6.10.2</a>).
+<a name="6.4.8" href="#6.4.8"><b>    6.4.8 Preprocessing numbers</b></a>
+<b>    Syntax</b>
+1            pp-number:
+                   digit
+                   . digit
+                   pp-number       digit
+                   pp-number       identifier-nondigit
+                   pp-number       e sign
+                   pp-number       E sign
+                   pp-number       p sign
+                   pp-number       P sign
+                   pp-number       .
+<b>    Description</b>
+2   A preprocessing number begins with a digit optionally preceded by a period (.) and may
+    be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
+    p+, p-, P+, or P-.
+3   Preprocessing number tokens lexically include all floating and integer constant tokens.
+<b>    Semantics</b>
+4   A preprocessing number does not have type or a value; it acquires both after a successful
+    conversion (as part of translation phase 7) to a floating constant token or an integer
+    constant token.
+
+
+    <sup><a name="note69" href="#note69"><b>69)</b></a></sup> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
+    <sup><a name="note70" href="#note70"><b>70)</b></a></sup> For an example of a header name preprocessing token used in a #pragma directive, see <a href="#6.10.9">6.10.9</a>.
+
+[<a name="p65" href="#p65">page 65</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.9" href="#6.4.9"><b>    6.4.9 Comments</b></a>
+1   Except within a character constant, a string literal, or a comment, the characters /*
+    introduce a comment. The contents of such a comment are examined only to identify
+    multibyte characters and to find the characters */ that terminate it.<sup><a href="#note71"><b>71)</b></a></sup>
+2   Except within a character constant, a string literal, or a comment, the characters //
+    introduce a comment that includes all multibyte characters up to, but not including, the
+    next new-line character. The contents of such a comment are examined only to identify
+    multibyte characters and to find the terminating new-line character.
+3   EXAMPLE
+            "a//b"                              //   four-character string literal
+            #include "//e"                      //   undefined behavior
+            // */                               //   comment, not syntax error
+            f = g/**//h;                        //   equivalent to f = g / h;
+            //\
+            i();                                // part of a two-line comment
+            /\
+            / j();                              // part of a two-line comment
+            #define glue(x,y) x##y
+            glue(/,/) k();                      // syntax error, not comment
+            /*//*/ l();                         // equivalent to l();
+            m = n//**/o
+               + p;                             // equivalent to m = n + p;
+
+
+
+
+    <sup><a name="note71" href="#note71"><b>71)</b></a></sup> Thus, /* ... */ comments do not nest.
+
+[<a name="p66" href="#p66">page 66</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5" href="#6.5"><b>    6.5 Expressions</b></a>
+1   An expression is a sequence of operators and operands that specifies computation of a
+    value, or that designates an object or a function, or that generates side effects, or that
+    performs a combination thereof.
+2   Between the previous and next sequence point an object shall have its stored value
+    modified at most once by the evaluation of an expression.<sup><a href="#note72"><b>72)</b></a></sup> Furthermore, the prior value
+    shall be read only to determine the value to be stored.<sup><a href="#note73"><b>73)</b></a></sup>
+3   The grouping of operators and operands is indicated by the syntax.<sup><a href="#note74"><b>74)</b></a></sup> Except as specified
+    later (for the function-call (), &amp;&amp;, ||, ?:, and comma operators), the order of evaluation
+    of subexpressions and the order in which side effects take place are both unspecified.
+4   Some operators (the unary operator ~, and the binary operators &lt;&lt;, &gt;&gt;, &amp;, ^, and |,
+    collectively described as bitwise operators) are required to have operands that have
+    integer type. These operators yield values that depend on the internal representations of
+    integers, and have implementation-defined and undefined aspects for signed types.
+5   If an exceptional condition occurs during the evaluation of an expression (that is, if the
+    result is not mathematically defined or not in the range of representable values for its
+    type), the behavior is undefined.
+6   The effective type of an object for an access to its stored value is the declared type of the
+    object, if any.<sup><a href="#note75"><b>75)</b></a></sup> If a value is stored into an object having no declared type through an
+    lvalue having a type that is not a character type, then the type of the lvalue becomes the
+
+
+    <sup><a name="note72" href="#note72"><b>72)</b></a></sup> A floating-point status flag is not an object and can be set more than once within an expression.
+    <sup><a name="note73" href="#note73"><b>73)</b></a></sup> This paragraph renders undefined statement expressions such as
+                   i = ++i + 1;
+                   a[i++] = i;
+           while allowing
+                   i = i + 1;
+                   a[i] = i;
+
+    <sup><a name="note74" href="#note74"><b>74)</b></a></sup> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
+        as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
+        expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
+        <a href="#6.5.1">6.5.1</a> through <a href="#6.5.6">6.5.6</a>. The exceptions are cast expressions (<a href="#6.5.4">6.5.4</a>) as operands of unary operators
+        (<a href="#6.5.3">6.5.3</a>), and an operand contained between any of the following pairs of operators: grouping
+        parentheses () (<a href="#6.5.1">6.5.1</a>), subscripting brackets [] (<a href="#6.5.2.1">6.5.2.1</a>), function-call parentheses () (<a href="#6.5.2.2">6.5.2.2</a>), and
+        the conditional operator ?: (<a href="#6.5.15">6.5.15</a>).
+           Within each major subclause, the operators have the same precedence. Left- or right-associativity is
+           indicated in each subclause by the syntax for the expressions discussed therein.
+    <sup><a name="note75" href="#note75"><b>75)</b></a></sup> Allocated objects have no declared type.
+
+[<a name="p67" href="#p67">page 67</a>] (<a href="#Contents">Contents</a>)
+
+    effective type of the object for that access and for subsequent accesses that do not modify
+    the stored value. If a value is copied into an object having no declared type using
+    memcpy or memmove, or is copied as an array of character type, then the effective type
+    of the modified object for that access and for subsequent accesses that do not modify the
+    value is the effective type of the object from which the value is copied, if it has one. For
+    all other accesses to an object having no declared type, the effective type of the object is
+    simply the type of the lvalue used for the access.
+7   An object shall have its stored value accessed only by an lvalue expression that has one of
+    the following types:<sup><a href="#note76"><b>76)</b></a></sup>
+    -- a type compatible with the effective type of the object,
+    -- a qualified version of a type compatible with the effective type of the object,
+    -- a type that is the signed or unsigned type corresponding to the effective type of the
+      object,
+    -- a type that is the signed or unsigned type corresponding to a qualified version of the
+      effective type of the object,
+    -- an aggregate or union type that includes one of the aforementioned types among its
+      members (including, recursively, a member of a subaggregate or contained union), or
+    -- a character type.
+8   A floating expression may be contracted, that is, evaluated as though it were an atomic
+    operation, thereby omitting rounding errors implied by the source code and the
+    expression evaluation method.<sup><a href="#note77"><b>77)</b></a></sup> The FP_CONTRACT pragma in <a href="#7.12">&lt;math.h&gt;</a> provides a
+    way to disallow contracted expressions. Otherwise, whether and how expressions are
+    contracted is implementation-defined.<sup><a href="#note78"><b>78)</b></a></sup>
+    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.21.2">7.21.2</a>).
+
+
+
+
+    <sup><a name="note76" href="#note76"><b>76)</b></a></sup> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
+    <sup><a name="note77" href="#note77"><b>77)</b></a></sup> A contracted expression might also omit the raising of floating-point exceptions.
+    <sup><a name="note78" href="#note78"><b>78)</b></a></sup> This license is specifically intended to allow implementations to exploit fast machine instructions that
+        combine multiple C operators. As contractions potentially undermine predictability, and can even
+        decrease accuracy for containing expressions, their use needs to be well-defined and clearly
+        documented.
+
+[<a name="p68" href="#p68">page 68</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.1" href="#6.5.1"><b>    6.5.1 Primary expressions</b></a>
+<b>    Syntax</b>
+1            primary-expression:
+                    identifier
+                    constant
+                    string-literal
+                    ( expression )
+<b>    Semantics</b>
+2   An identifier is a primary expression, provided it has been declared as designating an
+    object (in which case it is an lvalue) or a function (in which case it is a function
+    designator).<sup><a href="#note79"><b>79)</b></a></sup>
+3   A constant is a primary expression. Its type depends on its form and value, as detailed in
+    <a href="#6.4.4">6.4.4</a>.
+4   A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
+5   A parenthesized expression is a primary expression. Its type and value are identical to
+    those of the unparenthesized expression. It is an lvalue, a function designator, or a void
+    expression if the unparenthesized expression is, respectively, an lvalue, a function
+    designator, or a void expression.
+    Forward references: declarations (<a href="#6.7">6.7</a>).
+<a name="6.5.2" href="#6.5.2"><b>    6.5.2 Postfix operators</b></a>
+<b>    Syntax</b>
+1            postfix-expression:
+                    primary-expression
+                    postfix-expression [ expression ]
+                    postfix-expression ( argument-expression-listopt )
+                    postfix-expression . identifier
+                    postfix-expression -&gt; identifier
+                    postfix-expression ++
+                    postfix-expression --
+                    ( type-name ) { initializer-list }
+                    ( type-name ) { initializer-list , }
+
+
+
+
+    <sup><a name="note79" href="#note79"><b>79)</b></a></sup> Thus, an undeclared identifier is a violation of the syntax.
+
+[<a name="p69" href="#p69">page 69</a>] (<a href="#Contents">Contents</a>)
+
+             argument-expression-list:
+                   assignment-expression
+                   argument-expression-list , assignment-expression
+<a name="6.5.2.1" href="#6.5.2.1"><b>    6.5.2.1 Array subscripting</b></a>
+<b>    Constraints</b>
+1   One of the expressions shall have type ''pointer to object type'', the other expression shall
+    have integer type, and the result has type ''type''.
+<b>    Semantics</b>
+2   A postfix expression followed by an expression in square brackets [] is a subscripted
+    designation of an element of an array object. The definition of the subscript operator []
+    is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
+    apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
+    initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
+    element of E1 (counting from zero).
+3   Successive subscript operators designate an element of a multidimensional array object.
+    If E is an n-dimensional array (n &gt;= 2) with dimensions i x j x . . . x k, then E (used as
+    other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
+    dimensions j x . . . x k. If the unary * operator is applied to this pointer explicitly, or
+    implicitly as a result of subscripting, the result is the pointed-to (n - 1)-dimensional array,
+    which itself is converted into a pointer if used as other than an lvalue. It follows from this
+    that arrays are stored in row-major order (last subscript varies fastest).
+4   EXAMPLE        Consider the array object defined by the declaration
+             int x[3][5];
+    Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
+    array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
+    a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
+    entails multiplying i by the size of the object to which the pointer points, namely an array of five int
+    objects. The results are added and indirection is applied to yield an array of five ints. When used in the
+    expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
+    yields an int.
+
+    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
+    (<a href="#6.5.3.2">6.5.3.2</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
+
+[<a name="p70" href="#p70">page 70</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.2.2" href="#6.5.2.2"><b>    6.5.2.2 Function calls</b></a>
+<b>    Constraints</b>
+1   The expression that denotes the called function<sup><a href="#note80"><b>80)</b></a></sup> shall have type pointer to function
+    returning void or returning an object type other than an array type.
+2   If the expression that denotes the called function has a type that includes a prototype, the
+    number of arguments shall agree with the number of parameters. Each argument shall
+    have a type such that its value may be assigned to an object with the unqualified version
+    of the type of its corresponding parameter.
+<b>    Semantics</b>
+3   A postfix expression followed by parentheses () containing a possibly empty, comma-
+    separated list of expressions is a function call. The postfix expression denotes the called
+    function. The list of expressions specifies the arguments to the function.
+4   An argument may be an expression of any object type. In preparing for the call to a
+    function, the arguments are evaluated, and each parameter is assigned the value of the
+    corresponding argument.<sup><a href="#note81"><b>81)</b></a></sup>
+5   If the expression that denotes the called function has type pointer to function returning an
+    object type, the function call expression has the same type as that object type, and has the
+    value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void. If
+    an attempt is made to modify the result of a function call or to access it after the next
+    sequence point, the behavior is undefined.
+6   If the expression that denotes the called function has a type that does not include a
+    prototype, the integer promotions are performed on each argument, and arguments that
+    have type float are promoted to double. These are called the default argument
+    promotions. If the number of arguments does not equal the number of parameters, the
+    behavior is undefined. If the function is defined with a type that includes a prototype, and
+    either the prototype ends with an ellipsis (, ...) or the types of the arguments after
+    promotion are not compatible with the types of the parameters, the behavior is undefined.
+    If the function is defined with a type that does not include a prototype, and the types of
+    the arguments after promotion are not compatible with those of the parameters after
+    promotion, the behavior is undefined, except for the following cases:
+
+
+
+
+    <sup><a name="note80" href="#note80"><b>80)</b></a></sup> Most often, this is the result of converting an identifier that is a function designator.
+    <sup><a name="note81" href="#note81"><b>81)</b></a></sup> A function may change the values of its parameters, but these changes cannot affect the values of the
+        arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
+        change the value of the object pointed to. A parameter declared to have array or function type is
+        adjusted to have a pointer type as described in <a href="#6.9.1">6.9.1</a>.
+
+[<a name="p71" href="#p71">page 71</a>] (<a href="#Contents">Contents</a>)
+
+     -- one promoted type is a signed integer type, the other promoted type is the
+       corresponding unsigned integer type, and the value is representable in both types;
+     -- both types are pointers to qualified or unqualified versions of a character type or
+       void.
+7    If the expression that denotes the called function has a type that does include a prototype,
+     the arguments are implicitly converted, as if by assignment, to the types of the
+     corresponding parameters, taking the type of each parameter to be the unqualified version
+     of its declared type. The ellipsis notation in a function prototype declarator causes
+     argument type conversion to stop after the last declared parameter. The default argument
+     promotions are performed on trailing arguments.
+8    No other conversions are performed implicitly; in particular, the number and types of
+     arguments are not compared with those of the parameters in a function definition that
+     does not include a function prototype declarator.
+9    If the function is defined with a type that is not compatible with the type (of the
+     expression) pointed to by the expression that denotes the called function, the behavior is
+     undefined.
+10   The order of evaluation of the function designator, the actual arguments, and
+     subexpressions within the actual arguments is unspecified, but there is a sequence point
+     before the actual call.
+11   Recursive function calls shall be permitted, both directly and indirectly through any chain
+     of other functions.
+12   EXAMPLE       In the function call
+             (*pf[f1()]) (f2(), f3() + f4())
+     the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
+     the function pointed to by pf[f1()] is called.
+
+     Forward references: function declarators (including prototypes) (<a href="#6.7.5.3">6.7.5.3</a>), function
+     definitions (<a href="#6.9.1">6.9.1</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+<a name="6.5.2.3" href="#6.5.2.3"><b>     6.5.2.3 Structure and union members</b></a>
+<b>     Constraints</b>
+1    The first operand of the . operator shall have a qualified or unqualified structure or union
+     type, and the second operand shall name a member of that type.
+2    The first operand of the -&gt; operator shall have type ''pointer to qualified or unqualified
+     structure'' or ''pointer to qualified or unqualified union'', and the second operand shall
+     name a member of the type pointed to.
+
+[<a name="p72" href="#p72">page 72</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Semantics</b>
+3   A postfix expression followed by the . operator and an identifier designates a member of
+    a structure or union object. The value is that of the named member,<sup><a href="#note82"><b>82)</b></a></sup> and is an lvalue if
+    the first expression is an lvalue. If the first expression has qualified type, the result has
+    the so-qualified version of the type of the designated member.
+4   A postfix expression followed by the -&gt; operator and an identifier designates a member
+    of a structure or union object. The value is that of the named member of the object to
+    which the first expression points, and is an lvalue.<sup><a href="#note83"><b>83)</b></a></sup> If the first expression is a pointer to
+    a qualified type, the result has the so-qualified version of the type of the designated
+    member.
+5   One special guarantee is made in order to simplify the use of unions: if a union contains
+    several structures that share a common initial sequence (see below), and if the union
+    object currently contains one of these structures, it is permitted to inspect the common
+    initial part of any of them anywhere that a declaration of the complete type of the union is
+    visible. Two structures share a common initial sequence if corresponding members have
+    compatible types (and, for bit-fields, the same widths) for a sequence of one or more
+    initial members.
+6   EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
+    union, f().x is a valid postfix expression but is not an lvalue.
+
+7   EXAMPLE 2 In:
+             struct s { int i; const int ci; };
+             struct s s;
+             const struct s cs;
+             volatile struct s vs;
+    the various members have the types:
+             s.i        int
+             s.ci       const int
+             cs.i       const int
+             cs.ci      const int
+             vs.i       volatile int
+             vs.ci      volatile const int
+
+
+
+
+    <sup><a name="note82" href="#note82"><b>82)</b></a></sup> If the member used to access the contents of a union object is not the same as the member last used to
+        store a value in the object, the appropriate part of the object representation of the value is reinterpreted
+        as an object representation in the new type as described in <a href="#6.2.6">6.2.6</a> (a process sometimes called "type
+        punning"). This might be a trap representation.
+    <sup><a name="note83" href="#note83"><b>83)</b></a></sup> If &amp;E is a valid pointer expression (where &amp; is the ''address-of '' operator, which generates a pointer to
+        its operand), the expression (&amp;E)-&gt;MOS is the same as E.MOS.
+
+[<a name="p73" href="#p73">page 73</a>] (<a href="#Contents">Contents</a>)
+
+8   EXAMPLE 3       The following is a valid fragment:
+             union {
+                     struct {
+                           int      alltypes;
+                     } n;
+                     struct {
+                           int      type;
+                           int      intnode;
+                     } ni;
+                     struct {
+                           int      type;
+                           double doublenode;
+                     } nf;
+             } u;
+             u.nf.type = 1;
+             u.nf.doublenode = <a href="#3.14">3.14</a>;
+             /* ... */
+             if (u.n.alltypes == 1)
+                     if (sin(u.nf.doublenode) == 0.0)
+                           /* ... */
+    The following is not a valid fragment (because the union type is not visible within function f):
+             struct t1 { int m; };
+             struct t2 { int m; };
+             int f(struct t1 *p1, struct t2 *p2)
+             {
+                   if (p1-&gt;m &lt; 0)
+                           p2-&gt;m = -p2-&gt;m;
+                   return p1-&gt;m;
+             }
+             int g()
+             {
+                   union {
+                           struct t1 s1;
+                           struct t2 s2;
+                   } u;
+                   /* ... */
+                   return f(&amp;u.s1, &amp;u.s2);
+             }
+
+    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
+    specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
+
+[<a name="p74" href="#p74">page 74</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.2.4" href="#6.5.2.4"><b>    6.5.2.4 Postfix increment and decrement operators</b></a>
+<b>    Constraints</b>
+1   The operand of the postfix increment or decrement operator shall have qualified or
+    unqualified real or pointer type and shall be a modifiable lvalue.
+<b>    Semantics</b>
+2   The result of the postfix ++ operator is the value of the operand. After the result is
+    obtained, the value of the operand is incremented. (That is, the value 1 of the appropriate
+    type is added to it.) See the discussions of additive operators and compound assignment
+    for information on constraints, types, and conversions and the effects of operations on
+    pointers. The side effect of updating the stored value of the operand shall occur between
+    the previous and the next sequence point.
+3   The postfix -- operator is analogous to the postfix ++ operator, except that the value of
+    the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
+    it).
+    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+<a name="6.5.2.5" href="#6.5.2.5"><b>    6.5.2.5 Compound literals</b></a>
+<b>    Constraints</b>
+1   The type name shall specify an object type or an array of unknown size, but not a variable
+    length array type.
+2   No initializer shall attempt to provide a value for an object not contained within the entire
+    unnamed object specified by the compound literal.
+3   If the compound literal occurs outside the body of a function, the initializer list shall
+    consist of constant expressions.
+<b>    Semantics</b>
+4   A postfix expression that consists of a parenthesized type name followed by a brace-
+    enclosed list of initializers is a compound literal. It provides an unnamed object whose
+    value is given by the initializer list.<sup><a href="#note84"><b>84)</b></a></sup>
+5   If the type name specifies an array of unknown size, the size is determined by the
+    initializer list as specified in <a href="#6.7.8">6.7.8</a>, and the type of the compound literal is that of the
+    completed array type. Otherwise (when the type name specifies an object type), the type
+    of the compound literal is that specified by the type name. In either case, the result is an
+    lvalue.
+
+
+    <sup><a name="note84" href="#note84"><b>84)</b></a></sup> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
+        or void only, and the result of a cast expression is not an lvalue.
+
+[<a name="p75" href="#p75">page 75</a>] (<a href="#Contents">Contents</a>)
+
+6    The value of the compound literal is that of an unnamed object initialized by the
+     initializer list. If the compound literal occurs outside the body of a function, the object
+     has static storage duration; otherwise, it has automatic storage duration associated with
+     the enclosing block.
+7    All the semantic rules and constraints for initializer lists in <a href="#6.7.8">6.7.8</a> are applicable to
+     compound literals.<sup><a href="#note85"><b>85)</b></a></sup>
+8    String literals, and compound literals with const-qualified types, need not designate
+     distinct objects.<sup><a href="#note86"><b>86)</b></a></sup>
+9    EXAMPLE 1       The file scope definition
+              int *p = (int []){2, 4};
+     initializes p to point to the first element of an array of two ints, the first having the value two and the
+     second, four. The expressions in this compound literal are required to be constant. The unnamed object
+     has static storage duration.
+
+10   EXAMPLE 2       In contrast, in
+              void f(void)
+              {
+                    int *p;
+                    /*...*/
+                    p = (int [2]){*p};
+                    /*...*/
+              }
+     p is assigned the address of the first element of an array of two ints, the first having the value previously
+     pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
+     unnamed object has automatic storage duration.
+
+11   EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
+     created using compound literals can be passed to functions without depending on member order:
+              drawline((struct point){.x=1, .y=1},
+                    (struct point){.x=3, .y=4});
+     Or, if drawline instead expected pointers to struct point:
+              drawline(&amp;(struct point){.x=1, .y=1},
+                    &amp;(struct point){.x=3, .y=4});
+
+12   EXAMPLE 4       A read-only compound literal can be specified through constructions like:
+              (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}
+
+
+
+
+     <sup><a name="note85" href="#note85"><b>85)</b></a></sup> For example, subobjects without explicit initializers are initialized to zero.
+     <sup><a name="note86" href="#note86"><b>86)</b></a></sup> This allows implementations to share storage for string literals and constant compound literals with
+         the same or overlapping representations.
+
+[<a name="p76" href="#p76">page 76</a>] (<a href="#Contents">Contents</a>)
+
+13   EXAMPLE 5        The following three expressions have different meanings:
+              "/tmp/fileXXXXXX"
+              (char []){"/tmp/fileXXXXXX"}
+              (const char []){"/tmp/fileXXXXXX"}
+     The first always has static storage duration and has type array of char, but need not be modifiable; the last
+     two have automatic storage duration when they occur within the body of a function, and the first of these
+     two is modifiable.
+
+14   EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
+     and can even be shared. For example,
+              (const char []){"abc"} == "abc"
+     might yield 1 if the literals' storage is shared.
+
+15   EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
+     linked object. For example, there is no way to write a self-referential compound literal that could be used
+     as the function argument in place of the named object endless_zeros below:
+              struct int_list { int car; struct int_list *cdr; };
+              struct int_list endless_zeros = {0, &amp;endless_zeros};
+              eval(endless_zeros);
+
+16   EXAMPLE 8        Each compound literal creates only a single object in a given scope:
+              struct s { int i; };
+              int f (void)
+              {
+                    struct s *p = 0, *q;
+                    int j = 0;
+              again:
+                    q = p, p = &amp;((struct s){ j++ });
+                    if (j &lt; 2) goto again;
+                        return p == q &amp;&amp; q-&gt;i == 1;
+              }
+     The function f() always returns the value 1.
+17   Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
+     lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
+     have an indeterminate value, which would result in undefined behavior.
+
+     Forward references: type names (<a href="#6.7.6">6.7.6</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+
+[<a name="p77" href="#p77">page 77</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.3" href="#6.5.3"><b>    6.5.3 Unary operators</b></a>
+<b>    Syntax</b>
+1            unary-expression:
+                    postfix-expression
+                    ++ unary-expression
+                    -- unary-expression
+                    unary-operator cast-expression
+                    sizeof unary-expression
+                    sizeof ( type-name )
+             unary-operator: one of
+                    &amp; * + - ~             !
+<a name="6.5.3.1" href="#6.5.3.1"><b>    6.5.3.1 Prefix increment and decrement operators</b></a>
+<b>    Constraints</b>
+1   The operand of the prefix increment or decrement operator shall have qualified or
+    unqualified real or pointer type and shall be a modifiable lvalue.
+<b>    Semantics</b>
+2   The value of the operand of the prefix ++ operator is incremented. The result is the new
+    value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
+    See the discussions of additive operators and compound assignment for information on
+    constraints, types, side effects, and conversions and the effects of operations on pointers.
+3   The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
+    operand is decremented.
+    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+<a name="6.5.3.2" href="#6.5.3.2"><b>    6.5.3.2 Address and indirection operators</b></a>
+<b>    Constraints</b>
+1   The operand of the unary &amp; operator shall be either a function designator, the result of a
+    [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
+    not declared with the register storage-class specifier.
+2   The operand of the unary * operator shall have pointer type.
+<b>    Semantics</b>
+3   The unary &amp; operator yields the address of its operand. If the operand has type ''type'',
+    the result has type ''pointer to type''. If the operand is the result of a unary * operator,
+    neither that operator nor the &amp; operator is evaluated and the result is as if both were
+    omitted, except that the constraints on the operators still apply and the result is not an
+    lvalue. Similarly, if the operand is the result of a [] operator, neither the &amp; operator nor
+
+[<a name="p78" href="#p78">page 78</a>] (<a href="#Contents">Contents</a>)
+
+    the unary * that is implied by the [] is evaluated and the result is as if the &amp; operator
+    were removed and the [] operator were changed to a + operator. Otherwise, the result is
+    a pointer to the object or function designated by its operand.
+4   The unary * operator denotes indirection. If the operand points to a function, the result is
+    a function designator; if it points to an object, the result is an lvalue designating the
+    object. If the operand has type ''pointer to type'', the result has type ''type''. If an
+    invalid value has been assigned to the pointer, the behavior of the unary * operator is
+    undefined.<sup><a href="#note87"><b>87)</b></a></sup>
+    Forward references: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
+    (<a href="#6.7.2.1">6.7.2.1</a>).
+<a name="6.5.3.3" href="#6.5.3.3"><b>    6.5.3.3 Unary arithmetic operators</b></a>
+<b>    Constraints</b>
+1   The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
+    integer type; of the ! operator, scalar type.
+<b>    Semantics</b>
+2   The result of the unary + operator is the value of its (promoted) operand. The integer
+    promotions are performed on the operand, and the result has the promoted type.
+3   The result of the unary - operator is the negative of its (promoted) operand. The integer
+    promotions are performed on the operand, and the result has the promoted type.
+4   The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
+    each bit in the result is set if and only if the corresponding bit in the converted operand is
+    not set). The integer promotions are performed on the operand, and the result has the
+    promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
+    to the maximum value representable in that type minus E.
+5   The result of the logical negation operator ! is 0 if the value of its operand compares
+    unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int.
+    The expression !E is equivalent to (0==E).
+
+
+
+
+    <sup><a name="note87" href="#note87"><b>87)</b></a></sup> Thus, &amp;*E is equivalent to E (even if E is a null pointer), and &amp;(E1[E2]) to ((E1)+(E2)). It is
+        always true that if E is a function designator or an lvalue that is a valid operand of the unary &amp;
+        operator, *&amp;E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
+        an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
+         Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
+         address inappropriately aligned for the type of object pointed to, and the address of an object after the
+         end of its lifetime.
+
+[<a name="p79" href="#p79">page 79</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.3.4" href="#6.5.3.4"><b>    6.5.3.4 The sizeof operator</b></a>
+<b>    Constraints</b>
+1   The sizeof operator shall not be applied to an expression that has function type or an
+    incomplete type, to the parenthesized name of such a type, or to an expression that
+    designates a bit-field member.
+<b>    Semantics</b>
+2   The sizeof operator yields the size (in bytes) of its operand, which may be an
+    expression or the parenthesized name of a type. The size is determined from the type of
+    the operand. The result is an integer. If the type of the operand is a variable length array
+    type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
+    integer constant.
+3   When applied to an operand that has type char, unsigned char, or signed char,
+    (or a qualified version thereof) the result is 1. When applied to an operand that has array
+    type, the result is the total number of bytes in the array.<sup><a href="#note88"><b>88)</b></a></sup> When applied to an operand
+    that has structure or union type, the result is the total number of bytes in such an object,
+    including internal and trailing padding.
+4   The value of the result is implementation-defined, and its type (an unsigned integer type)
+    is size_t, defined in <a href="#7.17">&lt;stddef.h&gt;</a> (and other headers).
+5   EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
+    allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
+    allocate and return a pointer to void. For example:
+            extern void *alloc(size_t);
+            double *dp = alloc(sizeof *dp);
+    The implementation of the alloc function should ensure that its return value is aligned suitably for
+    conversion to a pointer to double.
+
+6   EXAMPLE 2      Another use of the sizeof operator is to compute the number of elements in an array:
+            sizeof array / sizeof array[0]
+
+7   EXAMPLE 3      In this example, the size of a variable length array is computed and returned from a
+    function:
+            #include <a href="#7.17">&lt;stddef.h&gt;</a>
+            size_t fsize3(int n)
+            {
+                  char b[n+3];                  // variable length array
+                  return sizeof b;              // execution time sizeof
+            }
+
+
+
+    <sup><a name="note88" href="#note88"><b>88)</b></a></sup> When applied to a parameter declared to have array or function type, the sizeof operator yields the
+        size of the adjusted (pointer) type (see <a href="#6.9.1">6.9.1</a>).
+
+[<a name="p80" href="#p80">page 80</a>] (<a href="#Contents">Contents</a>)
+
+             int main()
+             {
+                   size_t size;
+                   size = fsize3(10); // fsize3 returns 13
+                   return 0;
+             }
+
+    Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>), declarations (<a href="#6.7">6.7</a>),
+    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.6">6.7.6</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>).
+<a name="6.5.4" href="#6.5.4"><b>    6.5.4 Cast operators</b></a>
+<b>    Syntax</b>
+1            cast-expression:
+                    unary-expression
+                    ( type-name ) cast-expression
+<b>    Constraints</b>
+2   Unless the type name specifies a void type, the type name shall specify qualified or
+    unqualified scalar type and the operand shall have scalar type.
+3   Conversions that involve pointers, other than where permitted by the constraints of
+    <a href="#6.5.16.1">6.5.16.1</a>, shall be specified by means of an explicit cast.
+<b>    Semantics</b>
+4   Preceding an expression by a parenthesized type name converts the value of the
+    expression to the named type. This construction is called a cast.<sup><a href="#note89"><b>89)</b></a></sup> A cast that specifies
+    no conversion has no effect on the type or value of an expression.
+5   If the value of the expression is represented with greater precision or range than required
+    by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
+    type of the expression is the same as the named type.
+    Forward references: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
+    prototypes) (<a href="#6.7.5.3">6.7.5.3</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>), type names (<a href="#6.7.6">6.7.6</a>).
+
+
+
+
+    <sup><a name="note89" href="#note89"><b>89)</b></a></sup> A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the
+        unqualified version of the type.
+
+[<a name="p81" href="#p81">page 81</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.5" href="#6.5.5"><b>    6.5.5 Multiplicative operators</b></a>
+<b>    Syntax</b>
+1            multiplicative-expression:
+                     cast-expression
+                     multiplicative-expression * cast-expression
+                     multiplicative-expression / cast-expression
+                     multiplicative-expression % cast-expression
+<b>    Constraints</b>
+2   Each of the operands shall have arithmetic type. The operands of the % operator shall
+    have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the binary * operator is the product of the operands.
+5   The result of the / operator is the quotient from the division of the first operand by the
+    second; the result of the % operator is the remainder. In both operations, if the value of
+    the second operand is zero, the behavior is undefined.
+6   When integers are divided, the result of the / operator is the algebraic quotient with any
+    fractional part discarded.<sup><a href="#note90"><b>90)</b></a></sup> If the quotient a/b is representable, the expression
+    (a/b)*b + a%b shall equal a.
+<a name="6.5.6" href="#6.5.6"><b>    6.5.6 Additive operators</b></a>
+<b>    Syntax</b>
+1            additive-expression:
+                     multiplicative-expression
+                     additive-expression + multiplicative-expression
+                     additive-expression - multiplicative-expression
+<b>    Constraints</b>
+2   For addition, either both operands shall have arithmetic type, or one operand shall be a
+    pointer to an object type and the other shall have integer type. (Incrementing is
+    equivalent to adding 1.)
+3   For subtraction, one of the following shall hold:
+    -- both operands have arithmetic type;
+
+
+
+    <sup><a name="note90" href="#note90"><b>90)</b></a></sup> This is often called ''truncation toward zero''.
+
+[<a name="p82" href="#p82">page 82</a>] (<a href="#Contents">Contents</a>)
+
+    -- both operands are pointers to qualified or unqualified versions of compatible object
+      types; or
+    -- the left operand is a pointer to an object type and the right operand has integer type.
+    (Decrementing is equivalent to subtracting 1.)
+<b>    Semantics</b>
+4   If both operands have arithmetic type, the usual arithmetic conversions are performed on
+    them.
+5   The result of the binary + operator is the sum of the operands.
+6   The result of the binary - operator is the difference resulting from the subtraction of the
+    second operand from the first.
+7   For the purposes of these operators, a pointer to an object that is not an element of an
+    array behaves the same as a pointer to the first element of an array of length one with the
+    type of the object as its element type.
+8   When an expression that has integer type is added to or subtracted from a pointer, the
+    result has the type of the pointer operand. If the pointer operand points to an element of
+    an array object, and the array is large enough, the result points to an element offset from
+    the original element such that the difference of the subscripts of the resulting and original
+    array elements equals the integer expression. In other words, if the expression P points to
+    the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and
+    (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of
+    the array object, provided they exist. Moreover, if the expression P points to the last
+    element of an array object, the expression (P)+1 points one past the last element of the
+    array object, and if the expression Q points one past the last element of an array object,
+    the expression (Q)-1 points to the last element of the array object. If both the pointer
+    operand and the result point to elements of the same array object, or one past the last
+    element of the array object, the evaluation shall not produce an overflow; otherwise, the
+    behavior is undefined. If the result points one past the last element of the array object, it
+    shall not be used as the operand of a unary * operator that is evaluated.
+9   When two pointers are subtracted, both shall point to elements of the same array object,
+    or one past the last element of the array object; the result is the difference of the
+    subscripts of the two array elements. The size of the result is implementation-defined,
+    and its type (a signed integer type) is ptrdiff_t defined in the <a href="#7.17">&lt;stddef.h&gt;</a> header.
+    If the result is not representable in an object of that type, the behavior is undefined. In
+    other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
+    an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
+    object of type ptrdiff_t. Moreover, if the expression P points either to an element of
+    an array object or one past the last element of an array object, and the expression Q points
+    to the last element of the same array object, the expression ((Q)+1)-(P) has the same
+
+[<a name="p83" href="#p83">page 83</a>] (<a href="#Contents">Contents</a>)
+
+     value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the
+     expression P points one past the last element of the array object, even though the
+     expression (Q)+1 does not point to an element of the array object.<sup><a href="#note91"><b>91)</b></a></sup>
+10   EXAMPLE        Pointer arithmetic is well defined with pointers to variable length array types.
+              {
+                       int n = 4, m = 3;
+                       int a[n][m];
+                       int (*p)[m] = a;            //   p == &amp;a[0]
+                       p += 1;                     //   p == &amp;a[1]
+                       (*p)[2] = 99;               //   a[1][2] == 99
+                       n = p - a;                  //   n == 1
+              }
+11   If array a in the above example were declared to be an array of known constant size, and pointer p were
+     declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
+     the same.
+
+     Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), common definitions <a href="#7.17">&lt;stddef.h&gt;</a>
+     (<a href="#7.17">7.17</a>).
+<a name="6.5.7" href="#6.5.7"><b>     6.5.7 Bitwise shift operators</b></a>
+<b>     Syntax</b>
+1             shift-expression:
+                      additive-expression
+                      shift-expression &lt;&lt; additive-expression
+                      shift-expression &gt;&gt; additive-expression
+<b>     Constraints</b>
+2    Each of the operands shall have integer type.
+<b>     Semantics</b>
+3    The integer promotions are performed on each of the operands. The type of the result is
+     that of the promoted left operand. If the value of the right operand is negative or is
+     greater than or equal to the width of the promoted left operand, the behavior is undefined.
+
+
+
+
+     <sup><a name="note91" href="#note91"><b>91)</b></a></sup> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
+         this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
+         by the size of the object originally pointed to, and the resulting pointer is converted back to the
+         original type. For pointer subtraction, the result of the difference between the character pointers is
+         similarly divided by the size of the object originally pointed to.
+          When viewed in this way, an implementation need only provide one extra byte (which may overlap
+          another object in the program) just after the end of the object in order to satisfy the ''one past the last
+          element'' requirements.
+
+[<a name="p84" href="#p84">page 84</a>] (<a href="#Contents">Contents</a>)
+
+4   The result of E1 &lt;&lt; E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
+    zeros. If E1 has an unsigned type, the value of the result is E1 x 2E2 , reduced modulo
+    one more than the maximum value representable in the result type. If E1 has a signed
+    type and nonnegative value, and E1 x 2E2 is representable in the result type, then that is
+    the resulting value; otherwise, the behavior is undefined.
+5   The result of E1 &gt;&gt; E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
+    or if E1 has a signed type and a nonnegative value, the value of the result is the integral
+    part of the quotient of E1 / 2E2 . If E1 has a signed type and a negative value, the
+    resulting value is implementation-defined.
+<a name="6.5.8" href="#6.5.8"><b>    6.5.8 Relational operators</b></a>
+<b>    Syntax</b>
+1            relational-expression:
+                     shift-expression
+                     relational-expression   &lt;    shift-expression
+                     relational-expression   &gt;    shift-expression
+                     relational-expression   &lt;=   shift-expression
+                     relational-expression   &gt;=   shift-expression
+<b>    Constraints</b>
+2   One of the following shall hold:
+    -- both operands have real type;
+    -- both operands are pointers to qualified or unqualified versions of compatible object
+      types; or
+    -- both operands are pointers to qualified or unqualified versions of compatible
+      incomplete types.
+<b>    Semantics</b>
+3   If both of the operands have arithmetic type, the usual arithmetic conversions are
+    performed.
+4   For the purposes of these operators, a pointer to an object that is not an element of an
+    array behaves the same as a pointer to the first element of an array of length one with the
+    type of the object as its element type.
+5   When two pointers are compared, the result depends on the relative locations in the
+    address space of the objects pointed to. If two pointers to object or incomplete types both
+    point to the same object, or both point one past the last element of the same array object,
+    they compare equal. If the objects pointed to are members of the same aggregate object,
+    pointers to structure members declared later compare greater than pointers to members
+    declared earlier in the structure, and pointers to array elements with larger subscript
+
+[<a name="p85" href="#p85">page 85</a>] (<a href="#Contents">Contents</a>)
+
+    values compare greater than pointers to elements of the same array with lower subscript
+    values. All pointers to members of the same union object compare equal. If the
+    expression P points to an element of an array object and the expression Q points to the
+    last element of the same array object, the pointer expression Q+1 compares greater than
+    P. In all other cases, the behavior is undefined.
+6   Each of the operators &lt; (less than), &gt; (greater than), &lt;= (less than or equal to), and &gt;=
+    (greater than or equal to) shall yield 1 if the specified relation is true and 0 if it is false.<sup><a href="#note92"><b>92)</b></a></sup>
+    The result has type int.
+<a name="6.5.9" href="#6.5.9"><b>    6.5.9 Equality operators</b></a>
+<b>    Syntax</b>
+1            equality-expression:
+                     relational-expression
+                    equality-expression == relational-expression
+                    equality-expression != relational-expression
+<b>    Constraints</b>
+2   One of the following shall hold:
+    -- both operands have arithmetic type;
+    -- both operands are pointers to qualified or unqualified versions of compatible types;
+    -- one operand is a pointer to an object or incomplete type and the other is a pointer to a
+      qualified or unqualified version of void; or
+    -- one operand is a pointer and the other is a null pointer constant.
+<b>    Semantics</b>
+3   The == (equal to) and != (not equal to) operators are analogous to the relational
+    operators except for their lower precedence.<sup><a href="#note93"><b>93)</b></a></sup> Each of the operators yields 1 if the
+    specified relation is true and 0 if it is false. The result has type int. For any pair of
+    operands, exactly one of the relations is true.
+4   If both of the operands have arithmetic type, the usual arithmetic conversions are
+    performed. Values of complex types are equal if and only if both their real parts are equal
+    and also their imaginary parts are equal. Any two values of arithmetic types from
+    different type domains are equal if and only if the results of their conversions to the
+    (complex) result type determined by the usual arithmetic conversions are equal.
+
+
+    <sup><a name="note92" href="#note92"><b>92)</b></a></sup> The expression a&lt;b&lt;c is not interpreted as in ordinary mathematics. As the syntax indicates, it
+        means (a&lt;b)&lt;c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
+    <sup><a name="note93" href="#note93"><b>93)</b></a></sup> Because of the precedences, a&lt;b == c&lt;d is 1 whenever a&lt;b and c&lt;d have the same truth-value.
+
+[<a name="p86" href="#p86">page 86</a>] (<a href="#Contents">Contents</a>)
+
+5   Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
+    null pointer constant, the null pointer constant is converted to the type of the pointer. If
+    one operand is a pointer to an object or incomplete type and the other is a pointer to a
+    qualified or unqualified version of void, the former is converted to the type of the latter.
+6   Two pointers compare equal if and only if both are null pointers, both are pointers to the
+    same object (including a pointer to an object and a subobject at its beginning) or function,
+    both are pointers to one past the last element of the same array object, or one is a pointer
+    to one past the end of one array object and the other is a pointer to the start of a different
+    array object that happens to immediately follow the first array object in the address
+    space.<sup><a href="#note94"><b>94)</b></a></sup>
+7   For the purposes of these operators, a pointer to an object that is not an element of an
+    array behaves the same as a pointer to the first element of an array of length one with the
+    type of the object as its element type.
+<a name="6.5.10" href="#6.5.10"><b>    6.5.10 Bitwise AND operator</b></a>
+<b>    Syntax</b>
+1            AND-expression:
+                   equality-expression
+                   AND-expression &amp; equality-expression
+<b>    Constraints</b>
+2   Each of the operands shall have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the binary &amp; operator is the bitwise AND of the operands (that is, each bit in
+    the result is set if and only if each of the corresponding bits in the converted operands is
+    set).
+
+
+
+
+    <sup><a name="note94" href="#note94"><b>94)</b></a></sup> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
+        adjacent members of a structure with no padding between them, or because the implementation chose
+        to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
+        outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
+        behavior.
+
+[<a name="p87" href="#p87">page 87</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.11" href="#6.5.11"><b>    6.5.11 Bitwise exclusive OR operator</b></a>
+<b>    Syntax</b>
+1            exclusive-OR-expression:
+                     AND-expression
+                     exclusive-OR-expression ^ AND-expression
+<b>    Constraints</b>
+2   Each of the operands shall have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
+    in the result is set if and only if exactly one of the corresponding bits in the converted
+    operands is set).
+<a name="6.5.12" href="#6.5.12"><b>    6.5.12 Bitwise inclusive OR operator</b></a>
+<b>    Syntax</b>
+1            inclusive-OR-expression:
+                     exclusive-OR-expression
+                     inclusive-OR-expression | exclusive-OR-expression
+<b>    Constraints</b>
+2   Each of the operands shall have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
+    the result is set if and only if at least one of the corresponding bits in the converted
+    operands is set).
+
+[<a name="p88" href="#p88">page 88</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.13" href="#6.5.13"><b>    6.5.13 Logical AND operator</b></a>
+<b>    Syntax</b>
+1             logical-AND-expression:
+                      inclusive-OR-expression
+                      logical-AND-expression &amp;&amp; inclusive-OR-expression
+<b>    Constraints</b>
+2   Each of the operands shall have scalar type.
+<b>    Semantics</b>
+3   The &amp;&amp; operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
+    yields 0. The result has type int.
+4   Unlike the bitwise binary &amp; operator, the &amp;&amp; operator guarantees left-to-right evaluation;
+    there is a sequence point after the evaluation of the first operand. If the first operand
+    compares equal to 0, the second operand is not evaluated.
+<a name="6.5.14" href="#6.5.14"><b>    6.5.14 Logical OR operator</b></a>
+<b>    Syntax</b>
+1             logical-OR-expression:
+                      logical-AND-expression
+                      logical-OR-expression || logical-AND-expression
+<b>    Constraints</b>
+2   Each of the operands shall have scalar type.
+<b>    Semantics</b>
+3   The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
+    yields 0. The result has type int.
+4   Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; there is
+    a sequence point after the evaluation of the first operand. If the first operand compares
+    unequal to 0, the second operand is not evaluated.
+
+[<a name="p89" href="#p89">page 89</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.15" href="#6.5.15"><b>    6.5.15 Conditional operator</b></a>
+<b>    Syntax</b>
+1            conditional-expression:
+                    logical-OR-expression
+                    logical-OR-expression ? expression : conditional-expression
+<b>    Constraints</b>
+2   The first operand shall have scalar type.
+3   One of the following shall hold for the second and third operands:
+    -- both operands have arithmetic type;
+    -- both operands have the same structure or union type;
+    -- both operands have void type;
+    -- both operands are pointers to qualified or unqualified versions of compatible types;
+    -- one operand is a pointer and the other is a null pointer constant; or
+    -- one operand is a pointer to an object or incomplete type and the other is a pointer to a
+      qualified or unqualified version of void.
+<b>    Semantics</b>
+4   The first operand is evaluated; there is a sequence point after its evaluation. The second
+    operand is evaluated only if the first compares unequal to 0; the third operand is evaluated
+    only if the first compares equal to 0; the result is the value of the second or third operand
+    (whichever is evaluated), converted to the type described below.<sup><a href="#note95"><b>95)</b></a></sup> If an attempt is made
+    to modify the result of a conditional operator or to access it after the next sequence point,
+    the behavior is undefined.
+5   If both the second and third operands have arithmetic type, the result type that would be
+    determined by the usual arithmetic conversions, were they applied to those two operands,
+    is the type of the result. If both the operands have structure or union type, the result has
+    that type. If both operands have void type, the result has void type.
+6   If both the second and third operands are pointers or one is a null pointer constant and the
+    other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
+    of the types pointed-to by both operands. Furthermore, if both operands are pointers to
+    compatible types or to differently qualified versions of compatible types, the result type is
+    a pointer to an appropriately qualified version of the composite type; if one operand is a
+    null pointer constant, the result has the type of the other operand; otherwise, one operand
+    is a pointer to void or a qualified version of void, in which case the result type is a
+
+    <sup><a name="note95" href="#note95"><b>95)</b></a></sup> A conditional expression does not yield an lvalue.
+
+[<a name="p90" href="#p90">page 90</a>] (<a href="#Contents">Contents</a>)
+
+    pointer to an appropriately qualified version of void.
+7   EXAMPLE The common type that results when the second and third operands are pointers is determined
+    in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
+    pointers have compatible types.
+8   Given the declarations
+             const void *c_vp;
+             void *vp;
+             const int *c_ip;
+             volatile int *v_ip;
+             int *ip;
+             const char *c_cp;
+    the third column in the following table is the common type that is the result of a conditional expression in
+    which the first two columns are the second and third operands (in either order):
+             c_vp     c_ip      const void *
+             v_ip     0         volatile int *
+             c_ip     v_ip      const volatile int *
+             vp       c_cp      const void *
+             ip       c_ip      const int *
+             vp       ip        void *
+
+<a name="6.5.16" href="#6.5.16"><b>    6.5.16 Assignment operators</b></a>
+<b>    Syntax</b>
+1            assignment-expression:
+                    conditional-expression
+                    unary-expression assignment-operator assignment-expression
+             assignment-operator: one of
+                    = *= /= %= +=                       -=     &lt;&lt;=      &gt;&gt;=      &amp;=     ^=     |=
+<b>    Constraints</b>
+2   An assignment operator shall have a modifiable lvalue as its left operand.
+<b>    Semantics</b>
+3   An assignment operator stores a value in the object designated by the left operand. An
+    assignment expression has the value of the left operand after the assignment, but is not an
+    lvalue. The type of an assignment expression is the type of the left operand unless the
+    left operand has qualified type, in which case it is the unqualified version of the type of
+    the left operand. The side effect of updating the stored value of the left operand shall
+    occur between the previous and the next sequence point.
+4   The order of evaluation of the operands is unspecified. If an attempt is made to modify
+    the result of an assignment operator or to access it after the next sequence point, the
+    behavior is undefined.
+
+[<a name="p91" href="#p91">page 91</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.16.1" href="#6.5.16.1"><b>    6.5.16.1 Simple assignment</b></a>
+<b>    Constraints</b>
+1   One of the following shall hold:<sup><a href="#note96"><b>96)</b></a></sup>
+    -- the left operand has qualified or unqualified arithmetic type and the right has
+      arithmetic type;
+    -- the left operand has a qualified or unqualified version of a structure or union type
+      compatible with the type of the right;
+    -- both operands are pointers to qualified or unqualified versions of compatible types,
+      and the type pointed to by the left has all the qualifiers of the type pointed to by the
+      right;
+    -- one operand is a pointer to an object or incomplete type and the other is a pointer to a
+      qualified or unqualified version of void, and the type pointed to by the left has all
+      the qualifiers of the type pointed to by the right;
+    -- the left operand is a pointer and the right is a null pointer constant; or
+    -- the left operand has type _Bool and the right is a pointer.
+<b>    Semantics</b>
+2   In simple assignment (=), the value of the right operand is converted to the type of the
+    assignment expression and replaces the value stored in the object designated by the left
+    operand.
+3   If the value being stored in an object is read from another object that overlaps in any way
+    the storage of the first object, then the overlap shall be exact and the two objects shall
+    have qualified or unqualified versions of a compatible type; otherwise, the behavior is
+    undefined.
+4   EXAMPLE 1       In the program fragment
+            int f(void);
+            char c;
+            /* ... */
+            if ((c = f()) == -1)
+                    /* ... */
+    the int value returned by the function may be truncated when stored in the char, and then converted back
+    to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
+    values as unsigned char (and char is narrower than int), the result of the conversion cannot be
+
+
+
+    <sup><a name="note96" href="#note96"><b>96)</b></a></sup> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
+        (specified in <a href="#6.3.2.1">6.3.2.1</a>) that changes lvalues to ''the value of the expression'' and thus removes any type
+        qualifiers that were applied to the type category of the expression (for example, it removes const but
+        not volatile from the type int volatile * const).
+
+[<a name="p92" href="#p92">page 92</a>] (<a href="#Contents">Contents</a>)
+
+    negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
+    variable c should be declared as int.
+
+5   EXAMPLE 2       In the fragment:
+            char c;
+            int i;
+            long l;
+            l = (c = i);
+    the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
+    of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
+    that is, long int type.
+
+6   EXAMPLE 3       Consider the fragment:
+            const char **cpp;
+            char *p;
+            const char c = 'A';
+            cpp = &amp;p;                  // constraint violation
+            *cpp = &amp;c;                 // valid
+            *p = 0;                    // valid
+    The first assignment is unsafe because it would allow the following valid code to attempt to change the
+    value of the const object c.
+
+<a name="6.5.16.2" href="#6.5.16.2"><b>    6.5.16.2 Compound assignment</b></a>
+<b>    Constraints</b>
+1   For the operators += and -= only, either the left operand shall be a pointer to an object
+    type and the right shall have integer type, or the left operand shall have qualified or
+    unqualified arithmetic type and the right shall have arithmetic type.
+2   For the other operators, each operand shall have arithmetic type consistent with those
+    allowed by the corresponding binary operator.
+<b>    Semantics</b>
+3   A compound assignment of the form E1 op = E2 differs from the simple assignment
+    expression E1 = E1 op (E2) only in that the lvalue E1 is evaluated only once.
+
+[<a name="p93" href="#p93">page 93</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.17" href="#6.5.17"><b>    6.5.17 Comma operator</b></a>
+<b>    Syntax</b>
+1            expression:
+                    assignment-expression
+                    expression , assignment-expression
+<b>    Semantics</b>
+2   The left operand of a comma operator is evaluated as a void expression; there is a
+    sequence point after its evaluation. Then the right operand is evaluated; the result has its
+    type and value.<sup><a href="#note97"><b>97)</b></a></sup> If an attempt is made to modify the result of a comma operator or to
+    access it after the next sequence point, the behavior is undefined.
+3   EXAMPLE As indicated by the syntax, the comma operator (as described in this subclause) cannot
+    appear in contexts where a comma is used to separate items in a list (such as arguments to functions or lists
+    of initializers). On the other hand, it can be used within a parenthesized expression or within the second
+    expression of a conditional operator in such contexts. In the function call
+             f(a, (t=3, t+2), c)
+    the function has three arguments, the second of which has the value 5.
+
+    Forward references: initialization (<a href="#6.7.8">6.7.8</a>).
+
+
+
+
+    <sup><a name="note97" href="#note97"><b>97)</b></a></sup> A comma operator does not yield an lvalue.
+
+[<a name="p94" href="#p94">page 94</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.6" href="#6.6"><b>    6.6 Constant expressions</b></a>
+<b>    Syntax</b>
+1            constant-expression:
+                    conditional-expression
+<b>    Description</b>
+2   A constant expression can be evaluated during translation rather than runtime, and
+    accordingly may be used in any place that a constant may be.
+<b>    Constraints</b>
+3   Constant expressions shall not contain assignment, increment, decrement, function-call,
+    or comma operators, except when they are contained within a subexpression that is not
+    evaluated.<sup><a href="#note98"><b>98)</b></a></sup>
+4   Each constant expression shall evaluate to a constant that is in the range of representable
+    values for its type.
+<b>    Semantics</b>
+5   An expression that evaluates to a constant is required in several contexts. If a floating
+    expression is evaluated in the translation environment, the arithmetic precision and range
+    shall be at least as great as if the expression were being evaluated in the execution
+    environment.
+6   An integer constant expression<sup><a href="#note99"><b>99)</b></a></sup> shall have integer type and shall only have operands
+    that are integer constants, enumeration constants, character constants, sizeof
+    expressions whose results are integer constants, and floating constants that are the
+    immediate operands of casts. Cast operators in an integer constant expression shall only
+    convert arithmetic types to integer types, except as part of an operand to the sizeof
+    operator.
+7   More latitude is permitted for constant expressions in initializers. Such a constant
+    expression shall be, or evaluate to, one of the following:
+    -- an arithmetic constant expression,
+    -- a null pointer constant,
+
+
+
+
+    <sup><a name="note98" href="#note98"><b>98)</b></a></sup> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
+    <sup><a name="note99" href="#note99"><b>99)</b></a></sup> An integer constant expression is used to specify the size of a bit-field member of a structure, the
+        value of an enumeration constant, the size of an array, or the value of a case constant. Further
+        constraints that apply to the integer constant expressions used in conditional-inclusion preprocessing
+        directives are discussed in <a href="#6.10.1">6.10.1</a>.
+
+[<a name="p95" href="#p95">page 95</a>] (<a href="#Contents">Contents</a>)
+
+     -- an address constant, or
+     -- an address constant for an object type plus or minus an integer constant expression.
+8    An arithmetic constant expression shall have arithmetic type and shall only have
+     operands that are integer constants, floating constants, enumeration constants, character
+     constants, and sizeof expressions. Cast operators in an arithmetic constant expression
+     shall only convert arithmetic types to arithmetic types, except as part of an operand to a
+     sizeof operator whose result is an integer constant.
+9    An address constant is a null pointer, a pointer to an lvalue designating an object of static
+     storage duration, or a pointer to a function designator; it shall be created explicitly using
+     the unary &amp; operator or an integer constant cast to pointer type, or implicitly by the use of
+     an expression of array or function type. The array-subscript [] and member-access .
+     and -&gt; operators, the address &amp; and indirection * unary operators, and pointer casts may
+     be used in the creation of an address constant, but the value of an object shall not be
+     accessed by use of these operators.
+10   An implementation may accept other forms of constant expressions.
+11   The semantic rules for the evaluation of a constant expression are the same as for
+     nonconstant expressions.<sup><a href="#note100"><b>100)</b></a></sup>
+     Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), initialization (<a href="#6.7.8">6.7.8</a>).
+
+
+
+
+     <sup><a name="note100" href="#note100"><b>100)</b></a></sup> Thus, in the following initialization,
+                   static int i = 2 || 1 / 0;
+          the expression is a valid integer constant expression with value one.
+
+[<a name="p96" href="#p96">page 96</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7" href="#6.7"><b>    6.7 Declarations</b></a>
+<b>    Syntax</b>
+1            declaration:
+                    declaration-specifiers init-declarator-listopt ;
+             declaration-specifiers:
+                    storage-class-specifier declaration-specifiersopt
+                    type-specifier declaration-specifiersopt
+                    type-qualifier declaration-specifiersopt
+                    function-specifier declaration-specifiersopt
+             init-declarator-list:
+                     init-declarator
+                     init-declarator-list , init-declarator
+             init-declarator:
+                     declarator
+                     declarator = initializer
+<b>    Constraints</b>
+2   A declaration shall declare at least a declarator (other than the parameters of a function or
+    the members of a structure or union), a tag, or the members of an enumeration.
+3   If an identifier has no linkage, there shall be no more than one declaration of the identifier
+    (in a declarator or type specifier) with the same scope and in the same name space, except
+    for tags as specified in <a href="#6.7.2.3">6.7.2.3</a>.
+4   All declarations in the same scope that refer to the same object or function shall specify
+    compatible types.
+<b>    Semantics</b>
+5   A declaration specifies the interpretation and attributes of a set of identifiers. A definition
+    of an identifier is a declaration for that identifier that:
+    -- for an object, causes storage to be reserved for that object;
+    -- for a function, includes the function body;<sup><a href="#note101"><b>101)</b></a></sup>
+    -- for an enumeration constant or typedef name, is the (only) declaration of the
+      identifier.
+6   The declaration specifiers consist of a sequence of specifiers that indicate the linkage,
+    storage duration, and part of the type of the entities that the declarators denote. The init-
+    declarator-list is a comma-separated sequence of declarators, each of which may have
+
+    <sup><a name="note101" href="#note101"><b>101)</b></a></sup> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
+
+[<a name="p97" href="#p97">page 97</a>] (<a href="#Contents">Contents</a>)
+
+    additional type information, or an initializer, or both. The declarators contain the
+    identifiers (if any) being declared.
+7   If an identifier for an object is declared with no linkage, the type for the object shall be
+    complete by the end of its declarator, or by the end of its init-declarator if it has an
+    initializer; in the case of function parameters (including in prototypes), it is the adjusted
+    type (see <a href="#6.7.5.3">6.7.5.3</a>) that is required to be complete.
+    Forward references: declarators (<a href="#6.7.5">6.7.5</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
+    (<a href="#6.7.8">6.7.8</a>).
+<a name="6.7.1" href="#6.7.1"><b>    6.7.1 Storage-class specifiers</b></a>
+<b>    Syntax</b>
+1            storage-class-specifier:
+                    typedef
+                    extern
+                    static
+                    auto
+                    register
+<b>    Constraints</b>
+2   At most, one storage-class specifier may be given in the declaration specifiers in a
+    declaration.<sup><a href="#note102"><b>102)</b></a></sup>
+<b>    Semantics</b>
+3   The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
+    only; it is discussed in <a href="#6.7.7">6.7.7</a>. The meanings of the various linkages and storage durations
+    were discussed in <a href="#6.2.2">6.2.2</a> and <a href="#6.2.4">6.2.4</a>.
+4   A declaration of an identifier for an object with storage-class specifier register
+    suggests that access to the object be as fast as possible. The extent to which such
+    suggestions are effective is implementation-defined.<sup><a href="#note103"><b>103)</b></a></sup>
+5   The declaration of an identifier for a function that has block scope shall have no explicit
+    storage-class specifier other than extern.
+
+
+
+    <sup><a name="note102" href="#note102"><b>102)</b></a></sup> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
+    <sup><a name="note103" href="#note103"><b>103)</b></a></sup> The implementation may treat any register declaration simply as an auto declaration. However,
+         whether or not addressable storage is actually used, the address of any part of an object declared with
+         storage-class specifier register cannot be computed, either explicitly (by use of the unary &amp;
+         operator as discussed in <a href="#6.5.3.2">6.5.3.2</a>) or implicitly (by converting an array name to a pointer as discussed in
+         <a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operator that can be applied to an array declared with storage-class specifier
+         register is sizeof.
+
+[<a name="p98" href="#p98">page 98</a>] (<a href="#Contents">Contents</a>)
+
+6   If an aggregate or union object is declared with a storage-class specifier other than
+    typedef, the properties resulting from the storage-class specifier, except with respect to
+    linkage, also apply to the members of the object, and so on recursively for any aggregate
+    or union member objects.
+    Forward references: type definitions (<a href="#6.7.7">6.7.7</a>).
+<a name="6.7.2" href="#6.7.2"><b>    6.7.2 Type specifiers</b></a>
+<b>    Syntax</b>
+1            type-specifier:
+                    void
+                    char
+                    short
+                    int
+                    long
+                    float
+                    double
+                    signed
+                    unsigned
+                    _Bool
+                    _Complex
+                    struct-or-union-specifier                                                      *
+                    enum-specifier
+                    typedef-name
+<b>    Constraints</b>
+2   At least one type specifier shall be given in the declaration specifiers in each declaration,
+    and in the specifier-qualifier list in each struct declaration and type name. Each list of
+    type specifiers shall be one of the following sets (delimited by commas, when there is
+    more than one set on a line); the type specifiers may occur in any order, possibly
+    intermixed with the other declaration specifiers.
+    -- void
+    -- char
+    -- signed char
+    -- unsigned char
+    -- short, signed short, short int, or signed short int
+    -- unsigned short, or unsigned short int
+    -- int, signed, or signed int
+
+[<a name="p99" href="#p99">page 99</a>] (<a href="#Contents">Contents</a>)
+
+    -- unsigned, or unsigned int
+    -- long, signed long, long int, or signed long int
+    -- unsigned long, or unsigned long int
+    -- long long, signed long long, long long int, or
+      signed long long int
+    -- unsigned long long, or unsigned long long int
+    -- float
+    -- double
+    -- long double
+    -- _Bool
+    -- float _Complex
+    -- double _Complex
+    -- long double _Complex
+    -- struct or union specifier                                                                    *
+    -- enum specifier
+    -- typedef name
+3   The type specifier _Complex shall not be used if the implementation does not provide
+    complex types.<sup><a href="#note104"><b>104)</b></a></sup>
+<b>    Semantics</b>
+4   Specifiers for structures, unions, and enumerations are discussed in <a href="#6.7.2.1">6.7.2.1</a> through
+<a name="6.7.2.3" href="#6.7.2.3"><b>    6.7.2.3. Declarations of typedef names are discussed in 6.7.7. The characteristics of the</b></a>
+    other types are discussed in <a href="#6.2.5">6.2.5</a>.
+5   Each of the comma-separated sets designates the same type, except that for bit-fields, it is
+    implementation-defined whether the specifier int designates the same type as signed
+    int or the same type as unsigned int.
+    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
+    (<a href="#6.7.2.1">6.7.2.1</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>), type definitions (<a href="#6.7.7">6.7.7</a>).
+
+
+
+
+    <sup><a name="note104" href="#note104"><b>104)</b></a></sup> Freestanding implementations are not required to provide complex types.                  *
+
+[<a name="p100" href="#p100">page 100</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.2.1" href="#6.7.2.1"><b>    6.7.2.1 Structure and union specifiers</b></a>
+<b>    Syntax</b>
+1            struct-or-union-specifier:
+                     struct-or-union identifieropt { struct-declaration-list }
+                     struct-or-union identifier
+             struct-or-union:
+                     struct
+                     union
+             struct-declaration-list:
+                     struct-declaration
+                     struct-declaration-list struct-declaration
+             struct-declaration:
+                     specifier-qualifier-list struct-declarator-list ;
+             specifier-qualifier-list:
+                    type-specifier specifier-qualifier-listopt
+                    type-qualifier specifier-qualifier-listopt
+             struct-declarator-list:
+                     struct-declarator
+                     struct-declarator-list , struct-declarator
+             struct-declarator:
+                     declarator
+                     declaratoropt : constant-expression
+<b>    Constraints</b>
+2   A structure or union shall not contain a member with incomplete or function type (hence,
+    a structure shall not contain an instance of itself, but may contain a pointer to an instance
+    of itself), except that the last member of a structure with more than one named member
+    may have incomplete array type; such a structure (and any union containing, possibly
+    recursively, a member that is such a structure) shall not be a member of a structure or an
+    element of an array.
+3   The expression that specifies the width of a bit-field shall be an integer constant
+    expression with a nonnegative value that does not exceed the width of an object of the
+    type that would be specified were the colon and expression omitted. If the value is zero,
+    the declaration shall have no declarator.
+4   A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
+    int, unsigned int, or some other implementation-defined type.
+
+[<a name="p101" href="#p101">page 101</a>] (<a href="#Contents">Contents</a>)
+
+<b>     Semantics</b>
+5    As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
+     storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
+     of members whose storage overlap.
+6    Structure and union specifiers have the same form. The keywords struct and union
+     indicate that the type being specified is, respectively, a structure type or a union type.
+7    The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
+     within a translation unit. The struct-declaration-list is a sequence of declarations for the
+     members of the structure or union. If the struct-declaration-list contains no named
+     members, the behavior is undefined. The type is incomplete until after the } that
+     terminates the list.
+8    A member of a structure or union may have any object type other than a variably
+     modified type.<sup><a href="#note105"><b>105)</b></a></sup> In addition, a member may be declared to consist of a specified
+     number of bits (including a sign bit, if any). Such a member is called a bit-field;<sup><a href="#note106"><b>106)</b></a></sup> its
+     width is preceded by a colon.
+9    A bit-field is interpreted as a signed or unsigned integer type consisting of the specified
+     number of bits.<sup><a href="#note107"><b>107)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of type
+     _Bool, the value of the bit-field shall compare equal to the value stored.
+10   An implementation may allocate any addressable storage unit large enough to hold a bit-
+     field. If enough space remains, a bit-field that immediately follows another bit-field in a
+     structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
+     whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is
+     implementation-defined. The order of allocation of bit-fields within a unit (high-order to
+     low-order or low-order to high-order) is implementation-defined. The alignment of the
+     addressable storage unit is unspecified.
+11   A bit-field declaration with no declarator, but only a colon and a width, indicates an
+     unnamed bit-field.<sup><a href="#note108"><b>108)</b></a></sup> As a special case, a bit-field structure member with a width of 0
+     indicates that no further bit-field is to be packed into the unit in which the previous bit-
+     field, if any, was placed.
+
+
+     <sup><a name="note105" href="#note105"><b>105)</b></a></sup> A structure or union can not contain a member with a variably modified type because member names
+          are not ordinary identifiers as defined in <a href="#6.2.3">6.2.3</a>.
+     <sup><a name="note106" href="#note106"><b>106)</b></a></sup> The unary &amp; (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
+          or arrays of bit-field objects.
+     <sup><a name="note107" href="#note107"><b>107)</b></a></sup> As specified in <a href="#6.7.2">6.7.2</a> above, if the actual type specifier used is int or a typedef-name defined as int,
+          then it is implementation-defined whether the bit-field is signed or unsigned.
+     <sup><a name="note108" href="#note108"><b>108)</b></a></sup> An unnamed bit-field structure member is useful for padding to conform to externally imposed
+          layouts.
+
+[<a name="p102" href="#p102">page 102</a>] (<a href="#Contents">Contents</a>)
+
+12   Each non-bit-field member of a structure or union object is aligned in an implementation-
+     defined manner appropriate to its type.
+13   Within a structure object, the non-bit-field members and the units in which bit-fields
+     reside have addresses that increase in the order in which they are declared. A pointer to a
+     structure object, suitably converted, points to its initial member (or if that member is a
+     bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
+     padding within a structure object, but not at its beginning.
+14   The size of a union is sufficient to contain the largest of its members. The value of at
+     most one of the members can be stored in a union object at any time. A pointer to a
+     union object, suitably converted, points to each of its members (or if a member is a bit-
+     field, then to the unit in which it resides), and vice versa.
+15   There may be unnamed padding at the end of a structure or union.
+16   As a special case, the last element of a structure with more than one named member may
+     have an incomplete array type; this is called a flexible array member. In most situations,
+     the flexible array member is ignored. In particular, the size of the structure is as if the
+     flexible array member were omitted except that it may have more trailing padding than
+     the omission would imply. However, when a . (or -&gt;) operator has a left operand that is
+     (a pointer to) a structure with a flexible array member and the right operand names that
+     member, it behaves as if that member were replaced with the longest array (with the same
+     element type) that would not make the structure larger than the object being accessed; the
+     offset of the array shall remain that of the flexible array member, even if this would differ
+     from that of the replacement array. If this array would have no elements, it behaves as if
+     it had one element but the behavior is undefined if any attempt is made to access that
+     element or to generate a pointer one past it.
+17   EXAMPLE       After the declaration:
+             struct s { int n; double d[]; };
+     the structure struct s has a flexible array member d. A typical way to use this is:
+             int m = /* some value */;
+             struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));
+     and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
+     p had been declared as:
+             struct { int n; double d[m]; } *p;
+     (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
+     not be the same).
+18   Following the above declaration:
+
+[<a name="p103" href="#p103">page 103</a>] (<a href="#Contents">Contents</a>)
+
+              struct s t1 = { 0 };                        //   valid
+              struct s t2 = { 1, { <a href="#4.2">4.2</a> }};                //   invalid
+              t1.n = 4;                                   //   valid
+              t1.d[0] = <a href="#4.2">4.2</a>;                              //   might be undefined behavior
+     The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
+     contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
+              sizeof (struct s) &gt;= offsetof(struct s, d) + sizeof (double)
+     in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
+     code.
+19   After the further declaration:
+              struct ss { int n; };
+     the expressions:
+              sizeof (struct s) &gt;= sizeof (struct ss)
+              sizeof (struct s) &gt;= offsetof(struct s, d)
+     are always equal to 1.
+20   If sizeof (double) is 8, then after the following code is executed:
+              struct s *s1;
+              struct s *s2;
+              s1 = malloc(sizeof (struct s) + 64);
+              s2 = malloc(sizeof (struct s) + 46);
+     and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
+     purposes, as if the identifiers had been declared as:
+              struct { int n; double d[8]; } *s1;
+              struct { int n; double d[5]; } *s2;
+21   Following the further successful assignments:
+              s1 = malloc(sizeof (struct s) + 10);
+              s2 = malloc(sizeof (struct s) + 6);
+     they then behave as if the declarations were:
+              struct { int n; double d[1]; } *s1, *s2;
+     and:
+              double *dp;
+              dp = &amp;(s1-&gt;d[0]);           //   valid
+              *dp = 42;                   //   valid
+              dp = &amp;(s2-&gt;d[0]);           //   valid
+              *dp = 42;                   //   undefined behavior
+22   The assignment:
+              *s1 = *s2;
+     only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
+     of the structure, they might be copied or simply overwritten with indeterminate values.
+
+     Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
+
+[<a name="p104" href="#p104">page 104</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.2.2" href="#6.7.2.2"><b>    6.7.2.2 Enumeration specifiers</b></a>
+<b>    Syntax</b>
+1            enum-specifier:
+                   enum identifieropt { enumerator-list }
+                   enum identifieropt { enumerator-list , }
+                   enum identifier
+             enumerator-list:
+                   enumerator
+                   enumerator-list , enumerator
+             enumerator:
+                   enumeration-constant
+                   enumeration-constant = constant-expression
+<b>    Constraints</b>
+2   The expression that defines the value of an enumeration constant shall be an integer
+    constant expression that has a value representable as an int.
+<b>    Semantics</b>
+3   The identifiers in an enumerator list are declared as constants that have type int and
+    may appear wherever such are permitted.<sup><a href="#note109"><b>109)</b></a></sup> An enumerator with = defines its
+    enumeration constant as the value of the constant expression. If the first enumerator has
+    no =, the value of its enumeration constant is 0. Each subsequent enumerator with no =
+    defines its enumeration constant as the value of the constant expression obtained by
+    adding 1 to the value of the previous enumeration constant. (The use of enumerators with
+    = may produce enumeration constants with values that duplicate other values in the same
+    enumeration.) The enumerators of an enumeration are also known as its members.
+4   Each enumerated type shall be compatible with char, a signed integer type, or an
+    unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note110"><b>110)</b></a></sup> but shall be
+    capable of representing the values of all the members of the enumeration. The
+    enumerated type is incomplete until after the } that terminates the list of enumerator
+    declarations.
+
+
+
+
+    <sup><a name="note109" href="#note109"><b>109)</b></a></sup> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
+         each other and from other identifiers declared in ordinary declarators.
+    <sup><a name="note110" href="#note110"><b>110)</b></a></sup> An implementation may delay the choice of which integer type until all enumeration constants have
+         been seen.
+
+[<a name="p105" href="#p105">page 105</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE       The following fragment:
+            enum hue { chartreuse, burgundy, claret=20, winedark };
+            enum hue col, *cp;
+            col = claret;
+            cp = &amp;col;
+            if (*cp != burgundy)
+                  /* ... */
+    makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
+    pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
+
+    Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
+<a name="6.7.2.3" href="#6.7.2.3"><b>    6.7.2.3 Tags</b></a>
+<b>    Constraints</b>
+1   A specific type shall have its content defined at most once.
+2   Where two declarations that use the same tag declare the same type, they shall both use
+    the same choice of struct, union, or enum.
+3   A type specifier of the form
+            enum identifier
+    without an enumerator list shall only appear after the type it specifies is complete.
+<b>    Semantics</b>
+4   All declarations of structure, union, or enumerated types that have the same scope and
+    use the same tag declare the same type. The type is incomplete<sup><a href="#note111"><b>111)</b></a></sup> until the closing brace
+    of the list defining the content, and complete thereafter.
+5   Two declarations of structure, union, or enumerated types which are in different scopes or
+    use different tags declare distinct types. Each declaration of a structure, union, or
+    enumerated type which does not include a tag declares a distinct type.
+6   A type specifier of the form
+            struct-or-union identifieropt { struct-declaration-list }
+    or
+            enum identifier { enumerator-list }
+    or
+            enum identifier { enumerator-list , }
+    declares a structure, union, or enumerated type. The list defines the structure content,
+
+    <sup><a name="note111" href="#note111"><b>111)</b></a></sup> An incomplete type may only by used when the size of an object of that type is not needed. It is not
+         needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
+         when a pointer to or a function returning a structure or union is being declared. (See incomplete types
+         in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
+
+[<a name="p106" href="#p106">page 106</a>] (<a href="#Contents">Contents</a>)
+
+     union content, or enumeration content. If an identifier is provided,<sup><a href="#note112"><b>112)</b></a></sup> the type specifier
+     also declares the identifier to be the tag of that type.
+7    A declaration of the form
+              struct-or-union identifier ;
+     specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note113"><b>113)</b></a></sup>
+8    If a type specifier of the form
+              struct-or-union identifier
+     occurs other than as part of one of the above forms, and no other declaration of the
+     identifier as a tag is visible, then it declares an incomplete structure or union type, and
+     declares the identifier as the tag of that type.113)
+9    If a type specifier of the form
+              struct-or-union identifier
+     or
+              enum identifier
+     occurs other than as part of one of the above forms, and a declaration of the identifier as a
+     tag is visible, then it specifies the same type as that other declaration, and does not
+     redeclare the tag.
+10   EXAMPLE 1       This mechanism allows declaration of a self-referential structure.
+              struct tnode {
+                    int count;
+                    struct tnode *left, *right;
+              };
+     specifies a structure that contains an integer and two pointers to objects of the same type. Once this
+     declaration has been given, the declaration
+              struct tnode s, *sp;
+     declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
+     these declarations, the expression sp-&gt;left refers to the left struct tnode pointer of the object to
+     which sp points; the expression s.right-&gt;count designates the count member of the right struct
+     tnode pointed to from s.
+11   The following alternative formulation uses the typedef mechanism:
+
+
+
+
+     <sup><a name="note112" href="#note112"><b>112)</b></a></sup> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
+          of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
+          can make use of that typedef name to declare objects having the specified structure, union, or
+          enumerated type.
+     <sup><a name="note113" href="#note113"><b>113)</b></a></sup> A similar construction with enum does not exist.
+
+[<a name="p107" href="#p107">page 107</a>] (<a href="#Contents">Contents</a>)
+
+              typedef struct tnode TNODE;
+              struct tnode {
+                    int count;
+                    TNODE *left, *right;
+              };
+              TNODE s, *sp;
+
+12   EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
+     structures, the declarations
+              struct s1 { struct s2 *s2p; /* ... */ }; // D1
+              struct s2 { struct s1 *s1p; /* ... */ }; // D2
+     specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
+     declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
+     D2. To eliminate this context sensitivity, the declaration
+              struct s2;
+     may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
+     completes the specification of the new type.
+
+     Forward references: declarators (<a href="#6.7.5">6.7.5</a>), array declarators (<a href="#6.7.5.2">6.7.5.2</a>), type definitions
+     (<a href="#6.7.7">6.7.7</a>).
+<a name="6.7.3" href="#6.7.3"><b>     6.7.3 Type qualifiers</b></a>
+<b>     Syntax</b>
+1             type-qualifier:
+                     const
+                     restrict
+                     volatile
+<b>     Constraints</b>
+2    Types other than pointer types derived from object or incomplete types shall not be
+     restrict-qualified.
+<b>     Semantics</b>
+3    The properties associated with qualified types are meaningful only for expressions that
+     are lvalues.<sup><a href="#note114"><b>114)</b></a></sup>
+4    If the same qualifier appears more than once in the same specifier-qualifier-list, either
+     directly or via one or more typedefs, the behavior is the same as if it appeared only
+     once.
+
+
+
+
+     <sup><a name="note114" href="#note114"><b>114)</b></a></sup> The implementation may place a const object that is not volatile in a read-only region of
+          storage. Moreover, the implementation need not allocate storage for such an object if its address is
+          never used.
+
+[<a name="p108" href="#p108">page 108</a>] (<a href="#Contents">Contents</a>)
+
+5    If an attempt is made to modify an object defined with a const-qualified type through use
+     of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
+     made to refer to an object defined with a volatile-qualified type through use of an lvalue
+     with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note115"><b>115)</b></a></sup>
+6    An object that has volatile-qualified type may be modified in ways unknown to the
+     implementation or have other unknown side effects. Therefore any expression referring
+     to such an object shall be evaluated strictly according to the rules of the abstract machine,
+     as described in <a href="#5.1.2.3">5.1.2.3</a>. Furthermore, at every sequence point the value last stored in the
+     object shall agree with that prescribed by the abstract machine, except as modified by the
+     unknown factors mentioned previously.<sup><a href="#note116"><b>116)</b></a></sup> What constitutes an access to an object that
+     has volatile-qualified type is implementation-defined.
+7    An object that is accessed through a restrict-qualified pointer has a special association
+     with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
+     that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note117"><b>117)</b></a></sup> The intended
+     use of the restrict qualifier (like the register storage class) is to promote
+     optimization, and deleting all instances of the qualifier from all preprocessing translation
+     units composing a conforming program does not change its meaning (i.e., observable
+     behavior).
+8    If the specification of an array type includes any type qualifiers, the element type is so-
+     qualified, not the array type. If the specification of a function type includes any type
+     qualifiers, the behavior is undefined.<sup><a href="#note118"><b>118)</b></a></sup>
+9    For two qualified types to be compatible, both shall have the identically qualified version
+     of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
+     does not affect the specified type.
+10   EXAMPLE 1       An object declared
+              extern const volatile int real_time_clock;
+     may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
+
+
+
+
+     <sup><a name="note115" href="#note115"><b>115)</b></a></sup> This applies to those objects that behave as if they were defined with qualified types, even if they are
+          never actually defined as objects in the program (such as an object at a memory-mapped input/output
+          address).
+     <sup><a name="note116" href="#note116"><b>116)</b></a></sup> A volatile declaration may be used to describe an object corresponding to a memory-mapped
+          input/output port or an object accessed by an asynchronously interrupting function. Actions on
+          objects so declared shall not be ''optimized out'' by an implementation or reordered except as
+          permitted by the rules for evaluating expressions.
+     <sup><a name="note117" href="#note117"><b>117)</b></a></sup> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
+          association between the allocated object and the pointer.
+     <sup><a name="note118" href="#note118"><b>118)</b></a></sup> Both of these can occur through the use of typedefs.
+
+[<a name="p109" href="#p109">page 109</a>] (<a href="#Contents">Contents</a>)
+
+11   EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
+     modify an aggregate type:
+             const struct s { int mem; } cs = { 1 };
+             struct s ncs; // the object ncs is modifiable
+             typedef int A[2][3];
+             const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
+             int *pi;
+             const int *pci;
+             ncs = cs;             //   valid
+             cs = ncs;             //   violates modifiable lvalue constraint for =
+             pi = &amp;ncs.mem;        //   valid
+             pi = &amp;cs.mem;         //   violates type constraints for =
+             pci = &amp;cs.mem;        //   valid
+             pi = a[0];            //   invalid: a[0] has type ''const int *''
+
+<a name="6.7.3.1" href="#6.7.3.1"><b>     6.7.3.1 Formal definition of restrict</b></a>
+1    Let D be a declaration of an ordinary identifier that provides a means of designating an
+     object P as a restrict-qualified pointer to type T.
+2    If D appears inside a block and does not have storage class extern, let B denote the
+     block. If D appears in the list of parameter declarations of a function definition, let B
+     denote the associated block. Otherwise, let B denote the block of main (or the block of
+     whatever function is called at program startup in a freestanding environment).
+3    In what follows, a pointer expression E is said to be based on object P if (at some
+     sequence point in the execution of B prior to the evaluation of E) modifying P to point to
+     a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note119"><b>119)</b></a></sup>
+     Note that ''based'' is defined only for expressions with pointer types.
+4    During each execution of B, let L be any lvalue that has &amp;L based on P. If L is used to
+     access the value of the object X that it designates, and X is also modified (by any means),
+     then the following requirements apply: T shall not be const-qualified. Every other lvalue
+     used to access the value of X shall also have its address based on P. Every access that
+     modifies X shall be considered also to modify P, for the purposes of this subclause. If P
+     is assigned the value of a pointer expression E that is based on another restricted pointer
+     object P2, associated with block B2, then either the execution of B2 shall begin before
+     the execution of B, or the execution of B2 shall end prior to the assignment. If these
+     requirements are not met, then the behavior is undefined.
+5    Here an execution of B means that portion of the execution of the program that would
+     correspond to the lifetime of an object with scalar type and automatic storage duration
+
+     <sup><a name="note119" href="#note119"><b>119)</b></a></sup> In other words, E depends on the value of P itself rather than on the value of an object referenced
+          indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
+          expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
+          expressions *p and p[1] are not.
+
+[<a name="p110" href="#p110">page 110</a>] (<a href="#Contents">Contents</a>)
+
+     associated with B.
+6    A translator is free to ignore any or all aliasing implications of uses of restrict.
+7    EXAMPLE 1       The file scope declarations
+              int * restrict a;
+              int * restrict b;
+              extern int c[];
+     assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
+     program, then it is never accessed using either of the other two.
+
+8    EXAMPLE 2 The function parameter declarations in the following example
+             void f(int n, int * restrict p, int * restrict q)
+             {
+                   while (n-- &gt; 0)
+                         *p++ = *q++;
+             }
+     assert that, during each execution of the function, if an object is accessed through one of the pointer
+     parameters, then it is not also accessed through the other.
+9    The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
+     analysis of function f without examining any of the calls of f in the program. The cost is that the
+     programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
+     second call of f in g has undefined behavior because each of d[1] through d[49] is accessed through
+     both p and q.
+             void g(void)
+             {
+                   extern int d[100];
+                   f(50, d + 50, d); // valid
+                   f(50, d + 1, d); // undefined behavior
+             }
+
+10   EXAMPLE 3       The function parameter declarations
+             void h(int n, int * restrict p, int * restrict q, int * restrict r)
+             {
+                   int i;
+                   for (i = 0; i &lt; n; i++)
+                          p[i] = q[i] + r[i];
+             }
+     illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
+     are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
+     modified within function h.
+
+11   EXAMPLE 4 The rule limiting assignments between restricted pointers does not distinguish between a
+     function call and an equivalent nested block. With one exception, only ''outer-to-inner'' assignments
+     between restricted pointers declared in nested blocks have defined behavior.
+
+[<a name="p111" href="#p111">page 111</a>] (<a href="#Contents">Contents</a>)
+
+              {
+                       int * restrict p1;
+                       int * restrict q1;
+                       p1 = q1; // undefined behavior
+                       {
+                             int * restrict p2 = p1; // valid
+                             int * restrict q2 = q1; // valid
+                             p1 = q2;                // undefined behavior
+                             p2 = q2;                // undefined behavior
+                       }
+              }
+12   The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
+     precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
+     example, this permits new_vector to return a vector.
+              typedef struct { int n; float * restrict v; } vector;
+              vector new_vector(int n)
+              {
+                    vector t;
+                    t.n = n;
+                    t.v = malloc(n * sizeof (float));
+                    return t;
+              }
+
+<a name="6.7.4" href="#6.7.4"><b>     6.7.4 Function specifiers</b></a>
+<b>     Syntax</b>
+1             function-specifier:
+                     inline
+<b>     Constraints</b>
+2    Function specifiers shall be used only in the declaration of an identifier for a function.
+3    An inline definition of a function with external linkage shall not contain a definition of a
+     modifiable object with static storage duration, and shall not contain a reference to an
+     identifier with internal linkage.
+4    In a hosted environment, the inline function specifier shall not appear in a declaration
+     of main.
+<b>     Semantics</b>
+5    A function declared with an inline function specifier is an inline function. The
+     function specifier may appear more than once; the behavior is the same as if it appeared
+     only once. Making a function an inline function suggests that calls to the function be as
+     fast as possible.<sup><a href="#note120"><b>120)</b></a></sup> The extent to which such suggestions are effective is
+     implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
+6    Any function with internal linkage can be an inline function. For a function with external
+     linkage, the following restrictions apply: If a function is declared with an inline
+
+[<a name="p112" href="#p112">page 112</a>] (<a href="#Contents">Contents</a>)
+
+    function specifier, then it shall also be defined in the same translation unit. If all of the
+    file scope declarations for a function in a translation unit include the inline function
+    specifier without extern, then the definition in that translation unit is an inline
+    definition. An inline definition does not provide an external definition for the function,
+    and does not forbid an external definition in another translation unit. An inline definition
+    provides an alternative to an external definition, which a translator may use to implement
+    any call to the function in the same translation unit. It is unspecified whether a call to the
+    function uses the inline definition or the external definition.<sup><a href="#note122"><b>122)</b></a></sup>
+7   EXAMPLE The declaration of an inline function with external linkage can result in either an external
+    definition, or a definition available for use only within the translation unit. A file scope declaration with
+    extern creates an external definition. The following example shows an entire translation unit.
+             inline double fahr(double t)
+             {
+                   return (9.0 * t) / 5.0 + 32.0;
+             }
+             inline double cels(double t)
+             {
+                   return (5.0 * (t - 32.0)) / 9.0;
+             }
+             extern double fahr(double);                  // creates an external definition
+             double convert(int is_fahr, double temp)
+             {
+                   /* A translator may perform inline substitutions */
+                   return is_fahr ? cels(temp) : fahr(temp);
+             }
+8   Note that the definition of fahr is an external definition because fahr is also declared with extern, but
+    the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
+    external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
+    definition are distinct and either may be used for the call.
+
+    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+
+
+    <sup><a name="note120" href="#note120"><b>120)</b></a></sup> By using, for example, an alternative to the usual function call mechanism, such as ''inline
+         substitution''. Inline substitution is not textual substitution, nor does it create a new function.
+         Therefore, for example, the expansion of a macro used within the body of the function uses the
+         definition it had at the point the function body appears, and not where the function is called; and
+         identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
+         single address, regardless of the number of inline definitions that occur in addition to the external
+         definition.
+    <sup><a name="note121" href="#note121"><b>121)</b></a></sup> For example, an implementation might never perform inline substitution, or might only perform inline
+         substitutions to calls in the scope of an inline declaration.
+    <sup><a name="note122" href="#note122"><b>122)</b></a></sup> Since an inline definition is distinct from the corresponding external definition and from any other
+         corresponding inline definitions in other translation units, all corresponding objects with static storage
+         duration are also distinct in each of the definitions.
+
+[<a name="p113" href="#p113">page 113</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.5" href="#6.7.5"><b>    6.7.5 Declarators</b></a>
+<b>    Syntax</b>
+1            declarator:
+                    pointeropt direct-declarator
+             direct-declarator:
+                     identifier
+                     ( declarator )
+                     direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+                     direct-declarator [ static type-qualifier-listopt assignment-expression ]
+                     direct-declarator [ type-qualifier-list static assignment-expression ]
+                     direct-declarator [ type-qualifier-listopt * ]
+                     direct-declarator ( parameter-type-list )
+                     direct-declarator ( identifier-listopt )
+             pointer:
+                    * type-qualifier-listopt
+                    * type-qualifier-listopt pointer
+             type-qualifier-list:
+                    type-qualifier
+                    type-qualifier-list type-qualifier
+             parameter-type-list:
+                   parameter-list
+                   parameter-list , ...
+             parameter-list:
+                   parameter-declaration
+                   parameter-list , parameter-declaration
+             parameter-declaration:
+                   declaration-specifiers declarator
+                   declaration-specifiers abstract-declaratoropt
+             identifier-list:
+                     identifier
+                     identifier-list , identifier
+<b>    Semantics</b>
+2   Each declarator declares one identifier, and asserts that when an operand of the same
+    form as the declarator appears in an expression, it designates a function or object with the
+    scope, storage duration, and type indicated by the declaration specifiers.
+3   A full declarator is a declarator that is not part of another declarator. The end of a full
+    declarator is a sequence point. If, in the nested sequence of declarators in a full
+
+[<a name="p114" href="#p114">page 114</a>] (<a href="#Contents">Contents</a>)
+
+    declarator, there is a declarator specifying a variable length array type, the type specified
+    by the full declarator is said to be variably modified. Furthermore, any type derived by
+    declarator type derivation from a variably modified type is itself variably modified.
+4   In the following subclauses, consider a declaration
+            T D1
+    where T contains the declaration specifiers that specify a type T (such as int) and D1 is
+    a declarator that contains an identifier ident. The type specified for the identifier ident in
+    the various forms of declarator is described inductively using this notation.
+5   If, in the declaration ''T D1'', D1 has the form
+            identifier
+    then the type specified for ident is T .
+6   If, in the declaration ''T D1'', D1 has the form
+            ( D )
+    then ident has the type specified by the declaration ''T D''. Thus, a declarator in
+    parentheses is identical to the unparenthesized declarator, but the binding of complicated
+    declarators may be altered by parentheses.
+    Implementation limits
+7   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
+    function declarators that modify an arithmetic, structure, union, or incomplete type, either
+    directly or via one or more typedefs.
+    Forward references: array declarators (<a href="#6.7.5.2">6.7.5.2</a>), type definitions (<a href="#6.7.7">6.7.7</a>).
+<a name="6.7.5.1" href="#6.7.5.1"><b>    6.7.5.1 Pointer declarators</b></a>
+<b>    Semantics</b>
+1   If, in the declaration ''T D1'', D1 has the form
+            * type-qualifier-listopt D
+    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+    T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
+    pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
+2   For two pointer types to be compatible, both shall be identically qualified and both shall
+    be pointers to compatible types.
+3   EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
+    to a constant value'' and a ''constant pointer to a variable value''.
+
+[<a name="p115" href="#p115">page 115</a>] (<a href="#Contents">Contents</a>)
+
+             const int *ptr_to_constant;
+             int *const constant_ptr;
+    The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
+    but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
+    int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
+    same location.
+4   The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
+    type ''pointer to int''.
+             typedef int *int_ptr;
+             const int_ptr constant_ptr;
+    declares constant_ptr as an object that has type ''const-qualified pointer to int''.
+
+<a name="6.7.5.2" href="#6.7.5.2"><b>    6.7.5.2 Array declarators</b></a>
+<b>    Constraints</b>
+1   In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
+    an expression or *. If they delimit an expression (which specifies the size of an array), the
+    expression shall have an integer type. If the expression is a constant expression, it shall
+    have a value greater than zero. The element type shall not be an incomplete or function
+    type. The optional type qualifiers and the keyword static shall appear only in a
+    declaration of a function parameter with an array type, and then only in the outermost
+    array type derivation.
+2   An ordinary identifier (as defined in <a href="#6.2.3">6.2.3</a>) that has a variably modified type shall have
+    either block scope and no linkage or function prototype scope. If an identifier is declared
+    to be an object with static storage duration, it shall not have a variable length array type.
+<b>    Semantics</b>
+3   If, in the declaration ''T D1'', D1 has one of the forms:
+             D[ type-qualifier-listopt assignment-expressionopt ]
+             D[ static type-qualifier-listopt assignment-expression ]
+             D[ type-qualifier-list static assignment-expression ]
+             D[ type-qualifier-listopt * ]
+    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+    T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note123"><b>123)</b></a></sup>
+    (See <a href="#6.7.5.3">6.7.5.3</a> for the meaning of the optional type qualifiers and the keyword static.)
+4   If the size is not present, the array type is an incomplete type. If the size is * instead of
+    being an expression, the array type is a variable length array type of unspecified size,
+    which can only be used in declarations with function prototype scope;<sup><a href="#note124"><b>124)</b></a></sup> such arrays are
+    nonetheless complete types. If the size is an integer constant expression and the element
+
+    <sup><a name="note123" href="#note123"><b>123)</b></a></sup> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
+
+[<a name="p116" href="#p116">page 116</a>] (<a href="#Contents">Contents</a>)
+
+    type has a known constant size, the array type is not a variable length array type;
+    otherwise, the array type is a variable length array type.
+5   If the size is an expression that is not an integer constant expression: if it occurs in a
+    declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
+    each time it is evaluated it shall have a value greater than zero. The size of each instance
+    of a variable length array type does not change during its lifetime. Where a size
+    expression is part of the operand of a sizeof operator and changing the value of the
+    size expression would not affect the result of the operator, it is unspecified whether or not
+    the size expression is evaluated.
+6   For two array types to be compatible, both shall have compatible element types, and if
+    both size specifiers are present, and are integer constant expressions, then both size
+    specifiers shall have the same constant value. If the two array types are used in a context
+    which requires them to be compatible, it is undefined behavior if the two size specifiers
+    evaluate to unequal values.
+7   EXAMPLE 1
+             float fa[11], *afp[17];
+    declares an array of float numbers and an array of pointers to float numbers.
+
+8   EXAMPLE 2       Note the distinction between the declarations
+             extern int *x;
+             extern int y[];
+    The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
+    (an incomplete type), the storage for which is defined elsewhere.
+
+9   EXAMPLE 3       The following declarations demonstrate the compatibility rules for variably modified types.
+             extern int n;
+             extern int m;
+             void fcompat(void)
+             {
+                   int a[n][6][m];
+                   int (*p)[4][n+1];
+                   int c[n][n][6][m];
+                   int (*r)[n][n][n+1];
+                   p = a;      // invalid: not compatible because 4 != 6
+                   r = c;      // compatible, but defined behavior only if
+                               // n == 6 and m == n+1
+             }
+
+
+
+
+    <sup><a name="note124" href="#note124"><b>124)</b></a></sup> Thus, * can be used only in function declarations that are not definitions (see <a href="#6.7.5.3">6.7.5.3</a>).
+
+[<a name="p117" href="#p117">page 117</a>] (<a href="#Contents">Contents</a>)
+
+10   EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
+     function prototype scope. Array objects declared with the static or extern storage-class specifier
+     cannot have a variable length array (VLA) type. However, an object declared with the static storage-
+     class specifier can have a VM type (that is, a pointer to a VLA type). Finally, all identifiers declared with a
+     VM type have to be ordinary identifiers and cannot, therefore, be members of structures or unions.
+              extern int n;
+              int A[n];                                             // invalid: file scope VLA
+              extern int (*p2)[n];                                  // invalid: file scope VM
+              int B[100];                                           // valid: file scope but not VM
+              void fvla(int m, int C[m][m]);                        // valid: VLA with prototype scope
+              void fvla(int m, int C[m][m])                         // valid: adjusted to auto pointer to VLA
+              {
+                    typedef int VLA[m][m];                          // valid: block scope typedef VLA
+                       struct tag {
+                             int (*y)[n];                           // invalid: y not ordinary identifier
+                             int z[n];                              // invalid: z not ordinary identifier
+                       };
+                       int D[m];                                    //   valid: auto VLA
+                       static int E[m];                             //   invalid: static block scope VLA
+                       extern int F[m];                             //   invalid: F has linkage and is VLA
+                       int (*s)[m];                                 //   valid: auto pointer to VLA
+                       extern int (*r)[m];                          //   invalid: r has linkage and points to VLA
+                       static int (*q)[m] = &amp;B;                     //   valid: q is a static block pointer to VLA
+              }
+
+     Forward references:            function declarators (<a href="#6.7.5.3">6.7.5.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
+     initialization (<a href="#6.7.8">6.7.8</a>).
+<a name="6.7.5.3" href="#6.7.5.3"><b>     6.7.5.3 Function declarators (including prototypes)</b></a>
+<b>     Constraints</b>
+1    A function declarator shall not specify a return type that is a function type or an array
+     type.
+2    The only storage-class specifier that shall occur in a parameter declaration is register.
+3    An identifier list in a function declarator that is not part of a definition of that function
+     shall be empty.
+4    After adjustment, the parameters in a parameter type list in a function declarator that is
+     part of a definition of that function shall not have incomplete type.
+<b>     Semantics</b>
+5    If, in the declaration ''T D1'', D1 has the form
+              D( parameter-type-list )
+     or
+              D( identifier-listopt )
+
+[<a name="p118" href="#p118">page 118</a>] (<a href="#Contents">Contents</a>)
+
+     and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+     T '', then the type specified for ident is ''derived-declarator-type-list function returning
+     T ''.
+6    A parameter type list specifies the types of, and may declare identifiers for, the
+     parameters of the function.
+7    A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
+     type'', where the type qualifiers (if any) are those specified within the [ and ] of the
+     array type derivation. If the keyword static also appears within the [ and ] of the
+     array type derivation, then for each call to the function, the value of the corresponding
+     actual argument shall provide access to the first element of an array with at least as many
+     elements as specified by the size expression.
+8    A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
+     function returning type'', as in <a href="#6.3.2.1">6.3.2.1</a>.
+9    If the list terminates with an ellipsis (, ...), no information about the number or types
+     of the parameters after the comma is supplied.<sup><a href="#note125"><b>125)</b></a></sup>
+10   The special case of an unnamed parameter of type void as the only item in the list
+     specifies that the function has no parameters.
+11   If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
+     parameter name, it shall be taken as a typedef name.
+12   If the function declarator is not part of a definition of that function, parameters may have
+     incomplete type and may use the [*] notation in their sequences of declarator specifiers
+     to specify variable length array types.
+13   The storage-class specifier in the declaration specifiers for a parameter declaration, if
+     present, is ignored unless the declared parameter is one of the members of the parameter
+     type list for a function definition.
+14   An identifier list declares only the identifiers of the parameters of the function. An empty
+     list in a function declarator that is part of a definition of that function specifies that the
+     function has no parameters. The empty list in a function declarator that is not part of a
+     definition of that function specifies that no information about the number or types of the
+     parameters is supplied.<sup><a href="#note126"><b>126)</b></a></sup>
+15   For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note127"><b>127)</b></a></sup>
+
+
+     <sup><a name="note125" href="#note125"><b>125)</b></a></sup> The macros defined in the <a href="#7.15">&lt;stdarg.h&gt;</a> header (<a href="#7.15">7.15</a>) may be used to access arguments that
+          correspond to the ellipsis.
+     <sup><a name="note126" href="#note126"><b>126)</b></a></sup> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
+     <sup><a name="note127" href="#note127"><b>127)</b></a></sup> If both function types are ''old style'', parameter types are not compared.
+
+[<a name="p119" href="#p119">page 119</a>] (<a href="#Contents">Contents</a>)
+
+     Moreover, the parameter type lists, if both are present, shall agree in the number of
+     parameters and in use of the ellipsis terminator; corresponding parameters shall have
+     compatible types. If one type has a parameter type list and the other type is specified by a
+     function declarator that is not part of a function definition and that contains an empty
+     identifier list, the parameter list shall not have an ellipsis terminator and the type of each
+     parameter shall be compatible with the type that results from the application of the
+     default argument promotions. If one type has a parameter type list and the other type is
+     specified by a function definition that contains a (possibly empty) identifier list, both shall
+     agree in the number of parameters, and the type of each prototype parameter shall be
+     compatible with the type that results from the application of the default argument
+     promotions to the type of the corresponding identifier. (In the determination of type
+     compatibility and of a composite type, each parameter declared with function or array
+     type is taken as having the adjusted type and each parameter declared with qualified type
+     is taken as having the unqualified version of its declared type.)
+16   EXAMPLE 1       The declaration
+              int f(void), *fip(), (*pfi)();
+     declares a function f with no parameters returning an int, a function fip with no parameter specification
+     returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
+     int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
+     declaration suggests, and the same construction in an expression requires, the calling of a function fip,
+     and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
+     extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
+     designator, which is then used to call the function; it returns an int.
+17   If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
+     declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
+     internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
+     the identifier of the pointer pfi has block scope and no linkage.
+
+18   EXAMPLE 2       The declaration
+              int (*apfi[3])(int *x, int *y);
+     declares an array apfi of three pointers to functions returning int. Each of these functions has two
+     parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
+     go out of scope at the end of the declaration of apfi.
+
+19   EXAMPLE 3       The declaration
+              int (*fpfi(int (*)(long), int))(int, ...);
+     declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
+     parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
+     The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
+     additional arguments of any type.
+
+[<a name="p120" href="#p120">page 120</a>] (<a href="#Contents">Contents</a>)
+
+20   EXAMPLE 4        The following prototype has a variably modified parameter.
+               void addscalar(int n, int m,
+                     double a[n][n*m+300], double x);
+               int main()
+               {
+                     double b[4][308];
+                     addscalar(4, 2, b, <a href="#2.17">2.17</a>);
+                     return 0;
+               }
+               void addscalar(int n, int m,
+                     double a[n][n*m+300], double x)
+               {
+                     for (int i = 0; i &lt; n; i++)
+                           for (int j = 0, k = n*m+300; j &lt; k; j++)
+                                 // a is a pointer to a VLA with n*m+300 elements
+                                 a[i][j] += x;
+               }
+
+21   EXAMPLE 5        The following are all compatible function prototype declarators.
+               double    maximum(int       n,   int   m,   double   a[n][m]);
+               double    maximum(int       n,   int   m,   double   a[*][*]);
+               double    maximum(int       n,   int   m,   double   a[ ][*]);
+               double    maximum(int       n,   int   m,   double   a[ ][m]);
+     as are:
+               void   f(double     (* restrict a)[5]);
+               void   f(double     a[restrict][5]);
+               void   f(double     a[restrict 3][5]);
+               void   f(double     a[restrict static 3][5]);
+     (Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
+     non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
+
+     Forward references: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.6">6.7.6</a>).
+
+[<a name="p121" href="#p121">page 121</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.6" href="#6.7.6"><b>    6.7.6 Type names</b></a>
+<b>    Syntax</b>
+1            type-name:
+                    specifier-qualifier-list abstract-declaratoropt
+             abstract-declarator:
+                    pointer
+                    pointeropt direct-abstract-declarator
+             direct-abstract-declarator:
+                     ( abstract-declarator )
+                     direct-abstract-declaratoropt [ type-qualifier-listopt
+                                    assignment-expressionopt ]
+                     direct-abstract-declaratoropt [ static type-qualifier-listopt
+                                    assignment-expression ]
+                     direct-abstract-declaratoropt [ type-qualifier-list static
+                                    assignment-expression ]
+                     direct-abstract-declaratoropt [ * ]
+                     direct-abstract-declaratoropt ( parameter-type-listopt )
+<b>    Semantics</b>
+2   In several contexts, it is necessary to specify a type. This is accomplished using a type
+    name, which is syntactically a declaration for a function or an object of that type that
+    omits the identifier.<sup><a href="#note128"><b>128)</b></a></sup>
+3   EXAMPLE        The constructions
+             (a)      int
+             (b)      int   *
+             (c)      int   *[3]
+             (d)      int   (*)[3]
+             (e)      int   (*)[*]
+             (f)      int   *()
+             (g)      int   (*)(void)
+             (h)      int   (*const [])(unsigned int, ...)
+    name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
+    array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
+    with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
+    returning an int, and (h) array of an unspecified number of constant pointers to functions, each with one
+    parameter that has type unsigned int and an unspecified number of other parameters, returning an
+    int.
+
+
+
+
+    <sup><a name="note128" href="#note128"><b>128)</b></a></sup> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
+         parameter specification'', rather than redundant parentheses around the omitted identifier.
+
+[<a name="p122" href="#p122">page 122</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.7" href="#6.7.7"><b>    6.7.7 Type definitions</b></a>
+<b>    Syntax</b>
+1            typedef-name:
+                    identifier
+<b>    Constraints</b>
+2   If a typedef name specifies a variably modified type then it shall have block scope.
+<b>    Semantics</b>
+3   In a declaration whose storage-class specifier is typedef, each declarator defines an
+    identifier to be a typedef name that denotes the type specified for the identifier in the way
+    described in <a href="#6.7.5">6.7.5</a>. Any array size expressions associated with variable length array
+    declarators are evaluated each time the declaration of the typedef name is reached in the
+    order of execution. A typedef declaration does not introduce a new type, only a
+    synonym for the type so specified. That is, in the following declarations:
+             typedef T type_ident;
+             type_ident D;
+    type_ident is defined as a typedef name with the type specified by the declaration
+    specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
+    type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
+    typedef name shares the same name space as other identifiers declared in ordinary
+    declarators.
+4   EXAMPLE 1       After
+             typedef int MILES, KLICKSP();
+             typedef struct { double hi, lo; } range;
+    the constructions
+             MILES distance;
+             extern KLICKSP *metricp;
+             range x;
+             range z, *zp;
+    are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
+    parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
+    such a structure. The object distance has a type compatible with any other int object.
+
+5   EXAMPLE 2       After the declarations
+             typedef struct s1 { int x; } t1, *tp1;
+             typedef struct s2 { int x; } t2, *tp2;
+    type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
+    s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
+
+[<a name="p123" href="#p123">page 123</a>] (<a href="#Contents">Contents</a>)
+
+6   EXAMPLE 3       The following obscure constructions
+            typedef signed int t;
+            typedef int plain;
+            struct tag {
+                  unsigned t:4;
+                  const t:5;
+                  plain r:5;
+            };
+    declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
+    with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
+    qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
+    [-16, +15], and one named r that contains values in one of the ranges [0, 31], [-15, +15], or [-16, +15].
+    (The choice of range is implementation-defined.) The first two bit-field declarations differ in that
+    unsigned is a type specifier (which forces t to be the name of a structure member), while const is a
+    type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed
+    in an inner scope by
+            t f(t (t));
+            long t;
+    then a function f is declared with type ''function returning signed int with one unnamed parameter
+    with type pointer to function returning signed int with one unnamed parameter with type signed
+    int'', and an identifier t with type long int.
+
+7   EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
+    following declarations of the signal function specify exactly the same type, the first without making use
+    of any typedef names.
+            typedef void fv(int), (*pfv)(int);
+            void (*signal(int, void (*)(int)))(int);
+            fv *signal(int, fv *);
+            pfv signal(int, pfv);
+
+8   EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
+    time the typedef name is defined, not each time it is used:
+            void copyt(int n)
+            {
+                  typedef int B[n];    //               B is n ints, n evaluated now
+                  n += 1;
+                  B a;                //                a is n ints, n without += 1
+                  int b[n];           //                a and b are different sizes
+                  for (int i = 1; i &lt; n;                i++)
+                        a[i-1] = b[i];
+            }
+
+[<a name="p124" href="#p124">page 124</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.8" href="#6.7.8"><b>    6.7.8 Initialization</b></a>
+<b>    Syntax</b>
+1            initializer:
+                      assignment-expression
+                      { initializer-list }
+                      { initializer-list , }
+             initializer-list:
+                      designationopt initializer
+                      initializer-list , designationopt initializer
+             designation:
+                    designator-list =
+             designator-list:
+                    designator
+                    designator-list designator
+             designator:
+                    [ constant-expression ]
+                    . identifier
+<b>    Constraints</b>
+2   No initializer shall attempt to provide a value for an object not contained within the entity
+    being initialized.
+3   The type of the entity to be initialized shall be an array of unknown size or an object type
+    that is not a variable length array type.
+4   All the expressions in an initializer for an object that has static storage duration shall be
+    constant expressions or string literals.
+5   If the declaration of an identifier has block scope, and the identifier has external or
+    internal linkage, the declaration shall have no initializer for the identifier.
+6   If a designator has the form
+             [ constant-expression ]
+    then the current object (defined below) shall have array type and the expression shall be
+    an integer constant expression. If the array is of unknown size, any nonnegative value is
+    valid.
+7   If a designator has the form
+             . identifier
+    then the current object (defined below) shall have structure or union type and the
+    identifier shall be the name of a member of that type.
+
+[<a name="p125" href="#p125">page 125</a>] (<a href="#Contents">Contents</a>)
+
+<b>     Semantics</b>
+8    An initializer specifies the initial value stored in an object.
+9    Except where explicitly stated otherwise, for the purposes of this subclause unnamed
+     members of objects of structure and union type do not participate in initialization.
+     Unnamed members of structure objects have indeterminate value even after initialization.
+10   If an object that has automatic storage duration is not initialized explicitly, its value is
+     indeterminate. If an object that has static storage duration is not initialized explicitly,
+     then:
+     -- if it has pointer type, it is initialized to a null pointer;
+     -- if it has arithmetic type, it is initialized to (positive or unsigned) zero;
+     -- if it is an aggregate, every member is initialized (recursively) according to these rules;
+     -- if it is a union, the first named member is initialized (recursively) according to these
+       rules.
+11   The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
+     initial value of the object is that of the expression (after conversion); the same type
+     constraints and conversions as for simple assignment apply, taking the type of the scalar
+     to be the unqualified version of its declared type.
+12   The rest of this subclause deals with initializers for objects that have aggregate or union
+     type.
+13   The initializer for a structure or union object that has automatic storage duration shall be
+     either an initializer list as described below, or a single expression that has compatible
+     structure or union type. In the latter case, the initial value of the object, including
+     unnamed members, is that of the expression.
+14   An array of character type may be initialized by a character string literal, optionally
+     enclosed in braces. Successive characters of the character string literal (including the
+     terminating null character if there is room or if the array is of unknown size) initialize the
+     elements of the array.
+15   An array with element type compatible with wchar_t may be initialized by a wide
+     string literal, optionally enclosed in braces. Successive wide characters of the wide string
+     literal (including the terminating null wide character if there is room or if the array is of
+     unknown size) initialize the elements of the array.
+16   Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
+     enclosed list of initializers for the elements or named members.
+17   Each brace-enclosed initializer list has an associated current object. When no
+     designations are present, subobjects of the current object are initialized in order according
+     to the type of the current object: array elements in increasing subscript order, structure
+
+[<a name="p126" href="#p126">page 126</a>] (<a href="#Contents">Contents</a>)
+
+     members in declaration order, and the first named member of a union.<sup><a href="#note129"><b>129)</b></a></sup> In contrast, a
+     designation causes the following initializer to begin initialization of the subobject
+     described by the designator. Initialization then continues forward in order, beginning
+     with the next subobject after that described by the designator.<sup><a href="#note130"><b>130)</b></a></sup>
+18   Each designator list begins its description with the current object associated with the
+     closest surrounding brace pair. Each item in the designator list (in order) specifies a
+     particular member of its current object and changes the current object for the next
+     designator (if any) to be that member.<sup><a href="#note131"><b>131)</b></a></sup> The current object that results at the end of the
+     designator list is the subobject to be initialized by the following initializer.
+19   The initialization shall occur in initializer list order, each initializer provided for a
+     particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note132"><b>132)</b></a></sup>
+     all subobjects that are not initialized explicitly shall be initialized implicitly the same as
+     objects that have static storage duration.
+20   If the aggregate or union contains elements or members that are aggregates or unions,
+     these rules apply recursively to the subaggregates or contained unions. If the initializer of
+     a subaggregate or contained union begins with a left brace, the initializers enclosed by
+     that brace and its matching right brace initialize the elements or members of the
+     subaggregate or the contained union. Otherwise, only enough initializers from the list are
+     taken to account for the elements or members of the subaggregate or the first member of
+     the contained union; any remaining initializers are left to initialize the next element or
+     member of the aggregate of which the current subaggregate or contained union is a part.
+21   If there are fewer initializers in a brace-enclosed list than there are elements or members
+     of an aggregate, or fewer characters in a string literal used to initialize an array of known
+     size than there are elements in the array, the remainder of the aggregate shall be
+     initialized implicitly the same as objects that have static storage duration.
+22   If an array of unknown size is initialized, its size is determined by the largest indexed
+     element with an explicit initializer. At the end of its initializer list, the array no longer
+     has incomplete type.
+
+
+
+     <sup><a name="note129" href="#note129"><b>129)</b></a></sup> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
+          subobjects are initialized as usual, but the subaggregate or contained union does not become the
+          current object: current objects are associated only with brace-enclosed initializer lists.
+     <sup><a name="note130" href="#note130"><b>130)</b></a></sup> After a union member is initialized, the next object is not the next member of the union; instead, it is
+          the next subobject of an object containing the union.
+     <sup><a name="note131" href="#note131"><b>131)</b></a></sup> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
+          the surrounding brace pair. Note, too, that each separate designator list is independent.
+     <sup><a name="note132" href="#note132"><b>132)</b></a></sup> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
+          not be evaluated at all.
+
+[<a name="p127" href="#p127">page 127</a>] (<a href="#Contents">Contents</a>)
+
+23   The order in which any side effects occur among the initialization list expressions is
+     unspecified.<sup><a href="#note133"><b>133)</b></a></sup>
+24   EXAMPLE 1       Provided that <a href="#7.3">&lt;complex.h&gt;</a> has been #included, the declarations
+              int i = <a href="#3.5">3.5</a>;
+              double complex c = 5 + 3 * I;
+     define and initialize i with the value 3 and c with the value 5.0 + i3.0.
+
+25   EXAMPLE 2 The declaration
+              int x[] = { 1, 3, 5 };
+     defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
+     and there are three initializers.
+
+26   EXAMPLE 3       The declaration
+              int y[4][3] =         {
+                    { 1, 3,         5 },
+                    { 2, 4,         6 },
+                    { 3, 5,         7 },
+              };
+     is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
+     y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
+     y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
+     been achieved by
+              int y[4][3] = {
+                    1, 3, 5, 2, 4, 6, 3, 5, 7
+              };
+     The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
+     next three are taken successively for y[1] and y[2].
+
+27   EXAMPLE 4       The declaration
+              int z[4][3] = {
+                    { 1 }, { 2 }, { 3 }, { 4 }
+              };
+     initializes the first column of z as specified and initializes the rest with zeros.
+
+28   EXAMPLE 5       The declaration
+              struct { int a[3], b; } w[] = { { 1 }, 2 };
+     is a definition with an inconsistently bracketed initialization. It defines an array with two element
+     structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
+
+
+
+
+     <sup><a name="note133" href="#note133"><b>133)</b></a></sup> In particular, the evaluation order need not be the same as the order of subobject initialization.
+
+[<a name="p128" href="#p128">page 128</a>] (<a href="#Contents">Contents</a>)
+
+29   EXAMPLE 6         The declaration
+               short q[4][3][2] = {
+                     { 1 },
+                     { 2, 3 },
+                     { 4, 5, 6 }
+               };
+     contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
+     object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
+     q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
+     q[0][0] does not begin with a left brace, so up to six items from the current list may be used. There is
+     only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers
+     for q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their
+     respective two-dimensional subaggregates. If there had been more than six items in any of the lists, a
+     diagnostic message would have been issued. The same initialization result could have been achieved by:
+               short q[4][3][2] = {
+                     1, 0, 0, 0, 0, 0,
+                     2, 3, 0, 0, 0, 0,
+                     4, 5, 6
+               };
+     or by:
+               short q[4][3][2] = {
+                     {
+                           { 1 },
+                     },
+                     {
+                           { 2, 3 },
+                     },
+                     {
+                           { 4, 5 },
+                           { 6 },
+                     }
+               };
+     in a fully bracketed form.
+30   Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
+     cause confusion.
+
+31   EXAMPLE 7         One form of initialization that completes array types involves typedef names. Given the
+     declaration
+               typedef int A[];          // OK - declared with block scope
+     the declaration
+               A a = { 1, 2 }, b = { 3, 4, 5 };
+     is identical to
+               int a[] = { 1, 2 }, b[] = { 3, 4, 5 };
+     due to the rules for incomplete types.
+
+[<a name="p129" href="#p129">page 129</a>] (<a href="#Contents">Contents</a>)
+
+32   EXAMPLE 8       The declaration
+              char s[] = "abc", t[3] = "abc";
+     defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
+     This declaration is identical to
+              char s[] = { 'a', 'b', 'c', '\0' },
+                   t[] = { 'a', 'b', 'c' };
+     The contents of the arrays are modifiable. On the other hand, the declaration
+              char *p = "abc";
+     defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
+     with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
+     modify the contents of the array, the behavior is undefined.
+
+33   EXAMPLE 9       Arrays can be initialized to correspond to the elements of an enumeration by using
+     designators:
+              enum { member_one,           member_two };
+              const char *nm[] =           {
+                    [member_two]           = "member two",
+                    [member_one]           = "member one",
+              };
+
+34   EXAMPLE 10       Structure members can be initialized to nonzero values without depending on their order:
+              div_t answer = { .quot = 2, .rem = -1 };
+
+35   EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
+     might be misunderstood:
+              struct { int a[3], b; } w[] =
+                    { [0].a = {1}, [1].a[0] = 2 };
+
+36   EXAMPLE 12       Space can be ''allocated'' from both ends of an array by using a single designator:
+              int a[MAX] = {
+                    1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
+              };
+37   In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
+     than ten, some of the values provided by the first five initializers will be overridden by the second five.
+
+38   EXAMPLE 13       Any member of a union can be initialized:
+              union { /* ... */ } u = { .any_member = 42 };
+
+     Forward references: common definitions <a href="#7.17">&lt;stddef.h&gt;</a> (<a href="#7.17">7.17</a>).
+
+[<a name="p130" href="#p130">page 130</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.8" href="#6.8"><b>    6.8 Statements and blocks</b></a>
+<b>    Syntax</b>
+1            statement:
+                    labeled-statement
+                    compound-statement
+                    expression-statement
+                    selection-statement
+                    iteration-statement
+                    jump-statement
+<b>    Semantics</b>
+2   A statement specifies an action to be performed. Except as indicated, statements are
+    executed in sequence.
+3   A block allows a set of declarations and statements to be grouped into one syntactic unit.
+    The initializers of objects that have automatic storage duration, and the variable length
+    array declarators of ordinary identifiers with block scope, are evaluated and the values are
+    stored in the objects (including storing an indeterminate value in objects without an
+    initializer) each time the declaration is reached in the order of execution, as if it were a
+    statement, and within each declaration in the order that declarators appear.
+4   A full expression is an expression that is not part of another expression or of a declarator.
+    Each of the following is a full expression: an initializer; the expression in an expression
+    statement; the controlling expression of a selection statement (if or switch); the
+    controlling expression of a while or do statement; each of the (optional) expressions of
+    a for statement; the (optional) expression in a return statement. The end of a full
+    expression is a sequence point.
+    Forward references: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
+    (<a href="#6.8.4">6.8.4</a>), iteration statements (<a href="#6.8.5">6.8.5</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>).
+<a name="6.8.1" href="#6.8.1"><b>    6.8.1 Labeled statements</b></a>
+<b>    Syntax</b>
+1            labeled-statement:
+                    identifier : statement
+                    case constant-expression : statement
+                    default : statement
+<b>    Constraints</b>
+2   A case or default label shall appear only in a switch statement. Further
+    constraints on such labels are discussed under the switch statement.
+
+[<a name="p131" href="#p131">page 131</a>] (<a href="#Contents">Contents</a>)
+
+3   Label names shall be unique within a function.
+<b>    Semantics</b>
+4   Any statement may be preceded by a prefix that declares an identifier as a label name.
+    Labels in themselves do not alter the flow of control, which continues unimpeded across
+    them.
+    Forward references: the goto statement (<a href="#6.8.6.1">6.8.6.1</a>), the switch statement (<a href="#6.8.4.2">6.8.4.2</a>).
+<a name="6.8.2" href="#6.8.2"><b>    6.8.2 Compound statement</b></a>
+<b>    Syntax</b>
+1            compound-statement:
+                   { block-item-listopt }
+             block-item-list:
+                     block-item
+                     block-item-list block-item
+             block-item:
+                     declaration
+                     statement
+<b>    Semantics</b>
+2   A compound statement is a block.
+<a name="6.8.3" href="#6.8.3"><b>    6.8.3 Expression and null statements</b></a>
+<b>    Syntax</b>
+1            expression-statement:
+                    expressionopt ;
+<b>    Semantics</b>
+2   The expression in an expression statement is evaluated as a void expression for its side
+    effects.<sup><a href="#note134"><b>134)</b></a></sup>
+3   A null statement (consisting of just a semicolon) performs no operations.
+4   EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
+    discarding of its value may be made explicit by converting the expression to a void expression by means of
+    a cast:
+             int p(int);
+             /* ... */
+             (void)p(0);
+
+
+
+    <sup><a name="note134" href="#note134"><b>134)</b></a></sup> Such as assignments, and function calls which have side effects.
+
+[<a name="p132" href="#p132">page 132</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE 2       In the program fragment
+             char *s;
+             /* ... */
+             while (*s++ != '\0')
+                     ;
+    a null statement is used to supply an empty loop body to the iteration statement.
+
+6   EXAMPLE 3       A null statement may also be used to carry a label just before the closing } of a compound
+    statement.
+             while (loop1) {
+                   /* ... */
+                   while (loop2) {
+                           /* ... */
+                           if (want_out)
+                                   goto end_loop1;
+                           /* ... */
+                   }
+                   /* ... */
+             end_loop1: ;
+             }
+
+    Forward references: iteration statements (<a href="#6.8.5">6.8.5</a>).
+<a name="6.8.4" href="#6.8.4"><b>    6.8.4 Selection statements</b></a>
+<b>    Syntax</b>
+1            selection-statement:
+                     if ( expression ) statement
+                     if ( expression ) statement else statement
+                     switch ( expression ) statement
+<b>    Semantics</b>
+2   A selection statement selects among a set of statements depending on the value of a
+    controlling expression.
+3   A selection statement is a block whose scope is a strict subset of the scope of its
+    enclosing block. Each associated substatement is also a block whose scope is a strict
+    subset of the scope of the selection statement.
+<a name="6.8.4.1" href="#6.8.4.1"><b>    6.8.4.1 The if statement</b></a>
+<b>    Constraints</b>
+1   The controlling expression of an if statement shall have scalar type.
+<b>    Semantics</b>
+2   In both forms, the first substatement is executed if the expression compares unequal to 0.
+    In the else form, the second substatement is executed if the expression compares equal
+
+[<a name="p133" href="#p133">page 133</a>] (<a href="#Contents">Contents</a>)
+
+    to 0. If the first substatement is reached via a label, the second substatement is not
+    executed.
+3   An else is associated with the lexically nearest preceding if that is allowed by the
+    syntax.
+<a name="6.8.4.2" href="#6.8.4.2"><b>    6.8.4.2 The switch statement</b></a>
+<b>    Constraints</b>
+1   The controlling expression of a switch statement shall have integer type.
+2   If a switch statement has an associated case or default label within the scope of an
+    identifier with a variably modified type, the entire switch statement shall be within the
+    scope of that identifier.<sup><a href="#note135"><b>135)</b></a></sup>
+3   The expression of each case label shall be an integer constant expression and no two of
+    the case constant expressions in the same switch statement shall have the same value
+    after conversion. There may be at most one default label in a switch statement.
+    (Any enclosed switch statement may have a default label or case constant
+    expressions with values that duplicate case constant expressions in the enclosing
+    switch statement.)
+<b>    Semantics</b>
+4   A switch statement causes control to jump to, into, or past the statement that is the
+    switch body, depending on the value of a controlling expression, and on the presence of a
+    default label and the values of any case labels on or in the switch body. A case or
+    default label is accessible only within the closest enclosing switch statement.
+5   The integer promotions are performed on the controlling expression. The constant
+    expression in each case label is converted to the promoted type of the controlling
+    expression. If a converted value matches that of the promoted controlling expression,
+    control jumps to the statement following the matched case label. Otherwise, if there is
+    a default label, control jumps to the labeled statement. If no converted case constant
+    expression matches and there is no default label, no part of the switch body is
+    executed.
+    Implementation limits
+6   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
+    switch statement.
+
+
+
+
+    <sup><a name="note135" href="#note135"><b>135)</b></a></sup> That is, the declaration either precedes the switch statement, or it follows the last case or
+         default label associated with the switch that is in the block containing the declaration.
+
+[<a name="p134" href="#p134">page 134</a>] (<a href="#Contents">Contents</a>)
+
+7   EXAMPLE        In the artificial program fragment
+             switch (expr)
+             {
+                   int i = 4;
+                   f(i);
+             case 0:
+                   i = 17;
+                   /* falls through into default code */
+             default:
+                   printf("%d\n", i);
+             }
+    the object whose identifier is i exists with automatic storage duration (within the block) but is never
+    initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
+    access an indeterminate value. Similarly, the call to the function f cannot be reached.
+
+<a name="6.8.5" href="#6.8.5"><b>    6.8.5 Iteration statements</b></a>
+<b>    Syntax</b>
+1            iteration-statement:
+                     while ( expression ) statement
+                     do statement while ( expression ) ;
+                     for ( expressionopt ; expressionopt ; expressionopt ) statement
+                     for ( declaration expressionopt ; expressionopt ) statement
+<b>    Constraints</b>
+2   The controlling expression of an iteration statement shall have scalar type.
+3   The declaration part of a for statement shall only declare identifiers for objects having
+    storage class auto or register.
+<b>    Semantics</b>
+4   An iteration statement causes a statement called the loop body to be executed repeatedly
+    until the controlling expression compares equal to 0. The repetition occurs regardless of
+    whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note136"><b>136)</b></a></sup>
+5   An iteration statement is a block whose scope is a strict subset of the scope of its
+    enclosing block. The loop body is also a block whose scope is a strict subset of the scope
+    of the iteration statement.
+
+
+
+
+    <sup><a name="note136" href="#note136"><b>136)</b></a></sup> Code jumped over is not executed. In particular, the controlling expression of a for or while
+         statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
+
+[<a name="p135" href="#p135">page 135</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.8.5.1" href="#6.8.5.1"><b>    6.8.5.1 The while statement</b></a>
+1   The evaluation of the controlling expression takes place before each execution of the loop
+    body.
+<a name="6.8.5.2" href="#6.8.5.2"><b>    6.8.5.2 The do statement</b></a>
+1   The evaluation of the controlling expression takes place after each execution of the loop
+    body.
+<a name="6.8.5.3" href="#6.8.5.3"><b>    6.8.5.3 The for statement</b></a>
+1   The statement
+             for ( clause-1 ; expression-2 ; expression-3 ) statement
+    behaves as follows: The expression expression-2 is the controlling expression that is
+    evaluated before each execution of the loop body. The expression expression-3 is
+    evaluated as a void expression after each execution of the loop body. If clause-1 is a
+    declaration, the scope of any identifiers it declares is the remainder of the declaration and
+    the entire loop, including the other two expressions; it is reached in the order of execution
+    before the first evaluation of the controlling expression. If clause-1 is an expression, it is
+    evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note137"><b>137)</b></a></sup>
+2   Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a
+    nonzero constant.
+<a name="6.8.6" href="#6.8.6"><b>    6.8.6 Jump statements</b></a>
+<b>    Syntax</b>
+1            jump-statement:
+                    goto identifier ;
+                    continue ;
+                    break ;
+                    return expressionopt ;
+<b>    Semantics</b>
+2   A jump statement causes an unconditional jump to another place.
+
+
+
+
+    <sup><a name="note137" href="#note137"><b>137)</b></a></sup> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
+         the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
+         such that execution of the loop continues until the expression compares equal to 0; and expression-3
+         specifies an operation (such as incrementing) that is performed after each iteration.
+
+[<a name="p136" href="#p136">page 136</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.8.6.1" href="#6.8.6.1"><b>    6.8.6.1 The goto statement</b></a>
+<b>    Constraints</b>
+1   The identifier in a goto statement shall name a label located somewhere in the enclosing
+    function. A goto statement shall not jump from outside the scope of an identifier having
+    a variably modified type to inside the scope of that identifier.
+<b>    Semantics</b>
+2   A goto statement causes an unconditional jump to the statement prefixed by the named
+    label in the enclosing function.
+3   EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
+    following outline presents one possible approach to a problem based on these three assumptions:
+      1.   The general initialization code accesses objects only visible to the current function.
+      2.   The general initialization code is too large to warrant duplication.
+      3.   The code to determine the next operation is at the head of the loop. (To allow it to be reached by
+           continue statements, for example.)
+            /* ... */
+            goto first_time;
+            for (;;) {
+                    // determine next operation
+                    /* ... */
+                    if (need to reinitialize) {
+                            // reinitialize-only code
+                            /* ... */
+                    first_time:
+                            // general initialization code
+                            /* ... */
+                            continue;
+                    }
+                    // handle other operations
+                    /* ... */
+            }
+
+[<a name="p137" href="#p137">page 137</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
+    modified types. A jump within the scope, however, is permitted.
+            goto lab3;                         // invalid: going INTO scope of VLA.
+            {
+                  double a[n];
+                  a[j] = <a href="#4.4">4.4</a>;
+            lab3:
+                  a[j] = <a href="#3.3">3.3</a>;
+                  goto lab4;                   // valid: going WITHIN scope of VLA.
+                  a[j] = <a href="#5.5">5.5</a>;
+            lab4:
+                  a[j] = <a href="#6.6">6.6</a>;
+            }
+            goto lab4;                         // invalid: going INTO scope of VLA.
+
+<a name="6.8.6.2" href="#6.8.6.2"><b>    6.8.6.2 The continue statement</b></a>
+<b>    Constraints</b>
+1   A continue statement shall appear only in or as a loop body.
+<b>    Semantics</b>
+2   A continue statement causes a jump to the loop-continuation portion of the smallest
+    enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
+    of the statements
+    while (/* ... */) {                  do {                                 for (/* ... */) {
+       /* ... */                            /* ... */                            /* ... */
+       continue;                            continue;                            continue;
+       /* ... */                            /* ... */                            /* ... */
+    contin: ;                            contin: ;                            contin: ;
+    }                                    } while (/* ... */);                 }
+    unless the continue statement shown is in an enclosed iteration statement (in which
+    case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note138"><b>138)</b></a></sup>
+<a name="6.8.6.3" href="#6.8.6.3"><b>    6.8.6.3 The break statement</b></a>
+<b>    Constraints</b>
+1   A break statement shall appear only in or as a switch body or loop body.
+<b>    Semantics</b>
+2   A break statement terminates execution of the smallest enclosing switch or iteration
+    statement.
+
+
+
+    <sup><a name="note138" href="#note138"><b>138)</b></a></sup> Following the contin: label is a null statement.
+
+[<a name="p138" href="#p138">page 138</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.8.6.4" href="#6.8.6.4"><b>    6.8.6.4 The return statement</b></a>
+<b>    Constraints</b>
+1   A return statement with an expression shall not appear in a function whose return type
+    is void. A return statement without an expression shall only appear in a function
+    whose return type is void.
+<b>    Semantics</b>
+2   A return statement terminates execution of the current function and returns control to
+    its caller. A function may have any number of return statements.
+3   If a return statement with an expression is executed, the value of the expression is
+    returned to the caller as the value of the function call expression. If the expression has a
+    type different from the return type of the function in which it appears, the value is
+    converted as if by assignment to an object having the return type of the function.<sup><a href="#note139"><b>139)</b></a></sup>
+4   EXAMPLE       In:
+            struct s { double i; } f(void);
+            union {
+                  struct {
+                        int f1;
+                        struct s f2;
+                  } u1;
+                  struct {
+                        struct s f3;
+                        int f4;
+                  } u2;
+            } g;
+            struct s f(void)
+            {
+                  return g.u1.f2;
+            }
+            /* ... */
+            g.u2.f3 = f();
+    there is no undefined behavior, although there would be if the assignment were done directly (without using
+    a function call to fetch the value).
+
+
+
+
+    <sup><a name="note139" href="#note139"><b>139)</b></a></sup> The return statement is not an assignment. The overlap restriction of subclause <a href="#6.5.16.1">6.5.16.1</a> does not
+         apply to the case of function return. The representation of floating-point values may have wider range
+         or precision and is determined by FLT_EVAL_METHOD. A cast may be used to remove this extra
+         range and precision.
+
+[<a name="p139" href="#p139">page 139</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.9" href="#6.9"><b>    6.9 External definitions</b></a>
+<b>    Syntax</b>
+1            translation-unit:
+                     external-declaration
+                     translation-unit external-declaration
+             external-declaration:
+                    function-definition
+                    declaration
+<b>    Constraints</b>
+2   The storage-class specifiers auto and register shall not appear in the declaration
+    specifiers in an external declaration.
+3   There shall be no more than one external definition for each identifier declared with
+    internal linkage in a translation unit. Moreover, if an identifier declared with internal
+    linkage is used in an expression (other than as a part of the operand of a sizeof
+    operator whose result is an integer constant), there shall be exactly one external definition
+    for the identifier in the translation unit.
+<b>    Semantics</b>
+4   As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
+    which consists of a sequence of external declarations. These are described as ''external''
+    because they appear outside any function (and hence have file scope). As discussed in
+    <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
+    by the identifier is a definition.
+5   An external definition is an external declaration that is also a definition of a function
+    (other than an inline definition) or an object. If an identifier declared with external
+    linkage is used in an expression (other than as part of the operand of a sizeof operator
+    whose result is an integer constant), somewhere in the entire program there shall be
+    exactly one external definition for the identifier; otherwise, there shall be no more than
+    one.<sup><a href="#note140"><b>140)</b></a></sup>
+
+
+
+
+    <sup><a name="note140" href="#note140"><b>140)</b></a></sup> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
+         external definition for it.
+
+[<a name="p140" href="#p140">page 140</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.9.1" href="#6.9.1"><b>    6.9.1 Function definitions</b></a>
+<b>    Syntax</b>
+1            function-definition:
+                    declaration-specifiers declarator declaration-listopt compound-statement
+             declaration-list:
+                    declaration
+                    declaration-list declaration
+<b>    Constraints</b>
+2   The identifier declared in a function definition (which is the name of the function) shall
+    have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note141"><b>141)</b></a></sup>
+3   The return type of a function shall be void or an object type other than array type.
+4   The storage-class specifier, if any, in the declaration specifiers shall be either extern or
+    static.
+5   If the declarator includes a parameter type list, the declaration of each parameter shall
+    include an identifier, except for the special case of a parameter list consisting of a single
+    parameter of type void, in which case there shall not be an identifier. No declaration list
+    shall follow.
+6   If the declarator includes an identifier list, each declaration in the declaration list shall
+    have at least one declarator, those declarators shall declare only identifiers from the
+    identifier list, and every identifier in the identifier list shall be declared. An identifier
+    declared as a typedef name shall not be redeclared as a parameter. The declarations in the
+    declaration list shall contain no storage-class specifier other than register and no
+    initializations.
+
+
+
+
+    <sup><a name="note141" href="#note141"><b>141)</b></a></sup> The intent is that the type category in a function definition cannot be inherited from a typedef:
+                  typedef int F(void);                          //   type F is ''function with no parameters
+                                                                //                  returning int''
+                  F f, g;                                       //   f and g both have type compatible with F
+                  F f { /* ... */ }                             //   WRONG: syntax/constraint error
+                  F g() { /* ... */ }                           //   WRONG: declares that g returns a function
+                  int f(void) { /* ... */ }                     //   RIGHT: f has type compatible with F
+                  int g() { /* ... */ }                         //   RIGHT: g has type compatible with F
+                  F *e(void) { /* ... */ }                      //   e returns a pointer to a function
+                  F *((e))(void) { /* ... */ }                  //   same: parentheses irrelevant
+                  int (*fp)(void);                              //   fp points to a function that has type F
+                  F *Fp;                                        //   Fp points to a function that has type F
+
+[<a name="p141" href="#p141">page 141</a>] (<a href="#Contents">Contents</a>)
+
+<b>     Semantics</b>
+7    The declarator in a function definition specifies the name of the function being defined
+     and the identifiers of its parameters. If the declarator includes a parameter type list, the
+     list also specifies the types of all the parameters; such a declarator also serves as a
+     function prototype for later calls to the same function in the same translation unit. If the
+     declarator includes an identifier list,<sup><a href="#note142"><b>142)</b></a></sup> the types of the parameters shall be declared in a
+     following declaration list. In either case, the type of each parameter is adjusted as
+     described in <a href="#6.7.5.3">6.7.5.3</a> for a parameter type list; the resulting type shall be an object type.
+8    If a function that accepts a variable number of arguments is defined without a parameter
+     type list that ends with the ellipsis notation, the behavior is undefined.
+9    Each parameter has automatic storage duration. Its identifier is an lvalue, which is in
+     effect declared at the head of the compound statement that constitutes the function body
+     (and therefore cannot be redeclared in the function body except in an enclosed block).
+     The layout of the storage for parameters is unspecified.
+10   On entry to the function, the size expressions of each variably modified parameter are
+     evaluated and the value of each argument expression is converted to the type of the
+     corresponding parameter as if by assignment. (Array expressions and function
+     designators as arguments were converted to pointers before the call.)
+11   After all parameters have been assigned, the compound statement that constitutes the
+     body of the function definition is executed.
+12   If the } that terminates a function is reached, and the value of the function call is used by
+     the caller, the behavior is undefined.
+13   EXAMPLE 1       In the following:
+              extern int max(int a, int b)
+              {
+                    return a &gt; b ? a : b;
+              }
+     extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
+     function declarator; and
+              { return a &gt; b ? a : b; }
+     is the function body. The following similar definition uses the identifier-list form for the parameter
+     declarations:
+
+
+
+
+     <sup><a name="note142" href="#note142"><b>142)</b></a></sup> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
+
+[<a name="p142" href="#p142">page 142</a>] (<a href="#Contents">Contents</a>)
+
+              extern int max(a, b)
+              int a, b;
+              {
+                    return a &gt; b ? a : b;
+              }
+     Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
+     that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
+     to the function, whereas the second form does not.
+
+14   EXAMPLE 2           To pass one function to another, one might say
+                          int f(void);
+                          /* ... */
+                          g(f);
+     Then the definition of g might read
+              void g(int (*funcp)(void))
+              {
+                    /* ... */
+                    (*funcp)(); /* or funcp(); ...                    */
+              }
+     or, equivalently,
+              void g(int func(void))
+              {
+                    /* ... */
+                    func(); /* or (*func)(); ...                   */
+              }
+
+<a name="6.9.2" href="#6.9.2"><b>     6.9.2 External object definitions</b></a>
+<b>     Semantics</b>
+1    If the declaration of an identifier for an object has file scope and an initializer, the
+     declaration is an external definition for the identifier.
+2    A declaration of an identifier for an object that has file scope without an initializer, and
+     without a storage-class specifier or with the storage-class specifier static, constitutes a
+     tentative definition. If a translation unit contains one or more tentative definitions for an
+     identifier, and the translation unit contains no external definition for that identifier, then
+     the behavior is exactly as if the translation unit contains a file scope declaration of that
+     identifier, with the composite type as of the end of the translation unit, with an initializer
+     equal to 0.
+3    If the declaration of an identifier for an object is a tentative definition and has internal
+     linkage, the declared type shall not be an incomplete type.
+
+[<a name="p143" href="#p143">page 143</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE 1
+             int i1 = 1;                    // definition, external linkage
+             static int i2 = 2;             // definition, internal linkage
+             extern int i3 = 3;             // definition, external linkage
+             int i4;                        // tentative definition, external linkage
+             static int i5;                 // tentative definition, internal linkage
+             int   i1;                      // valid tentative definition, refers to previous
+             int   i2;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+             int   i3;                      // valid tentative definition, refers to previous
+             int   i4;                      // valid tentative definition, refers to previous
+             int   i5;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+             extern    int   i1;            // refers to previous, whose linkage is external
+             extern    int   i2;            // refers to previous, whose linkage is internal
+             extern    int   i3;            // refers to previous, whose linkage is external
+             extern    int   i4;            // refers to previous, whose linkage is external
+             extern    int   i5;            // refers to previous, whose linkage is internal
+
+5   EXAMPLE 2       If at the end of the translation unit containing
+             int i[];
+    the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
+    zero on program startup.
+
+[<a name="p144" href="#p144">page 144</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10" href="#6.10"><b>    6.10 Preprocessing directives</b></a>
+<b>    Syntax</b>
+1            preprocessing-file:
+                    groupopt
+             group:
+                      group-part
+                      group group-part
+             group-part:
+                    if-section
+                    control-line
+                    text-line
+                    # non-directive
+             if-section:
+                      if-group elif-groupsopt else-groupopt endif-line
+             if-group:
+                     # if     constant-expression new-line groupopt
+                     # ifdef identifier new-line groupopt
+                     # ifndef identifier new-line groupopt
+             elif-groups:
+                     elif-group
+                     elif-groups elif-group
+             elif-group:
+                     # elif       constant-expression new-line groupopt
+             else-group:
+                     # else       new-line groupopt
+             endif-line:
+                     # endif      new-line
+
+[<a name="p145" href="#p145">page 145</a>] (<a href="#Contents">Contents</a>)
+
+             control-line:
+                    # include pp-tokens new-line
+                    # define identifier replacement-list new-line
+                    # define identifier lparen identifier-listopt )
+                                                    replacement-list new-line
+                    # define identifier lparen ... ) replacement-list new-line
+                    # define identifier lparen identifier-list , ... )
+                                                    replacement-list new-line
+                    # undef   identifier new-line
+                    # line    pp-tokens new-line
+                    # error   pp-tokensopt new-line
+                    # pragma pp-tokensopt new-line
+                    #         new-line
+             text-line:
+                     pp-tokensopt new-line
+             non-directive:
+                    pp-tokens new-line
+             lparen:
+                       a ( character not immediately preceded by white-space
+             replacement-list:
+                    pp-tokensopt
+             pp-tokens:
+                    preprocessing-token
+                    pp-tokens preprocessing-token
+             new-line:
+                    the new-line character
+<b>    Description</b>
+2   A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
+    following constraints: The first token in the sequence is a # preprocessing token that (at
+    the start of translation phase 4) is either the first character in the source file (optionally
+    after white space containing no new-line characters) or that follows white space
+    containing at least one new-line character. The last token in the sequence is the first new-
+    line character that follows the first token in the sequence.<sup><a href="#note143"><b>143)</b></a></sup> A new-line character ends
+    the preprocessing directive even if it occurs within what would otherwise be an
+
+    <sup><a name="note143" href="#note143"><b>143)</b></a></sup> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
+         significance, as all white space is equivalent except in certain situations during preprocessing (see the
+         # character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
+
+[<a name="p146" href="#p146">page 146</a>] (<a href="#Contents">Contents</a>)
+
+    invocation of a function-like macro.
+3   A text line shall not begin with a # preprocessing token. A non-directive shall not begin
+    with any of the directive names appearing in the syntax.
+4   When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
+    sequence of preprocessing tokens to occur between the directive name and the following
+    new-line character.
+<b>    Constraints</b>
+5   The only white-space characters that shall appear between preprocessing tokens within a
+    preprocessing directive (from just after the introducing # preprocessing token through
+    just before the terminating new-line character) are space and horizontal-tab (including
+    spaces that have replaced comments or possibly other white-space characters in
+    translation phase 3).
+<b>    Semantics</b>
+6   The implementation can process and skip sections of source files conditionally, include
+    other source files, and replace macros. These capabilities are called preprocessing,
+    because conceptually they occur before translation of the resulting translation unit.
+7   The preprocessing tokens within a preprocessing directive are not subject to macro
+    expansion unless otherwise stated.
+8   EXAMPLE        In:
+             #define EMPTY
+             EMPTY # include &lt;file.h&gt;
+    the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
+    begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
+    replaced.
+
+<a name="6.10.1" href="#6.10.1"><b>    6.10.1 Conditional inclusion</b></a>
+<b>    Constraints</b>
+1   The expression that controls conditional inclusion shall be an integer constant expression
+    except that: it shall not contain a cast; identifiers (including those lexically identical to
+    keywords) are interpreted as described below;<sup><a href="#note144"><b>144)</b></a></sup> and it may contain unary operator
+    expressions of the form
+
+
+
+
+    <sup><a name="note144" href="#note144"><b>144)</b></a></sup> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
+         either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
+
+[<a name="p147" href="#p147">page 147</a>] (<a href="#Contents">Contents</a>)
+
+         defined identifier
+    or
+         defined ( identifier )
+    which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
+    predefined or if it has been the subject of a #define preprocessing directive without an
+    intervening #undef directive with the same subject identifier), 0 if it is not.
+2   Each preprocessing token that remains (in the list of preprocessing tokens that will
+    become the controlling expression) after all macro replacements have occurred shall be in
+    the lexical form of a token (<a href="#6.4">6.4</a>).
+<b>    Semantics</b>
+3   Preprocessing directives of the forms
+         # if   constant-expression new-line groupopt
+         # elif constant-expression new-line groupopt
+    check whether the controlling constant expression evaluates to nonzero.
+4   Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
+    the controlling constant expression are replaced (except for those macro names modified
+    by the defined unary operator), just as in normal text. If the token defined is
+    generated as a result of this replacement process or use of the defined unary operator
+    does not match one of the two specified forms prior to macro replacement, the behavior is
+    undefined. After all replacements due to macro expansion and the defined unary
+    operator have been performed, all remaining identifiers (including those lexically
+    identical to keywords) are replaced with the pp-number 0, and then each preprocessing
+    token is converted into a token. The resulting tokens compose the controlling constant
+    expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
+    token conversion and evaluation, all signed integer types and all unsigned integer types
+    act as if they have the same representation as, respectively, the types intmax_t and
+    uintmax_t defined in the header <a href="#7.18">&lt;stdint.h&gt;</a>.<sup><a href="#note145"><b>145)</b></a></sup> This includes interpreting
+    character constants, which may involve converting escape sequences into execution
+    character set members. Whether the numeric value for these character constants matches
+    the value obtained when an identical character constant occurs in an expression (other
+    than within a #if or #elif directive) is implementation-defined.<sup><a href="#note146"><b>146)</b></a></sup> Also, whether a
+    single-character character constant may have a negative value is implementation-defined.
+5   Preprocessing directives of the forms
+
+
+
+    <sup><a name="note145" href="#note145"><b>145)</b></a></sup> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
+         0x8000 is signed and positive within a #if expression even though it would be unsigned in
+         translation phase 7.
+
+[<a name="p148" href="#p148">page 148</a>] (<a href="#Contents">Contents</a>)
+
+       # ifdef identifier new-line groupopt
+       # ifndef identifier new-line groupopt
+    check whether the identifier is or is not currently defined as a macro name. Their
+    conditions are equivalent to #if defined identifier and #if !defined identifier
+    respectively.
+6   Each directive's condition is checked in order. If it evaluates to false (zero), the group
+    that it controls is skipped: directives are processed only through the name that determines
+    the directive in order to keep track of the level of nested conditionals; the rest of the
+    directives' preprocessing tokens are ignored, as are the other preprocessing tokens in the
+    group. Only the first group whose control condition evaluates to true (nonzero) is
+    processed. If none of the conditions evaluates to true, and there is a #else directive, the
+    group controlled by the #else is processed; lacking a #else directive, all the groups
+    until the #endif are skipped.<sup><a href="#note147"><b>147)</b></a></sup>
+    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
+    integer types (<a href="#7.18.1.5">7.18.1.5</a>).
+<a name="6.10.2" href="#6.10.2"><b>    6.10.2 Source file inclusion</b></a>
+<b>    Constraints</b>
+1   A #include directive shall identify a header or source file that can be processed by the
+    implementation.
+<b>    Semantics</b>
+2   A preprocessing directive of the form
+       # include &lt;h-char-sequence&gt; new-line
+    searches a sequence of implementation-defined places for a header identified uniquely by
+    the specified sequence between the &lt; and &gt; delimiters, and causes the replacement of that
+    directive by the entire contents of the header. How the places are specified or the header
+    identified is implementation-defined.
+3   A preprocessing directive of the form
+
+
+
+    <sup><a name="note146" href="#note146"><b>146)</b></a></sup> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
+         evaluate to the same value in these two contexts.
+           #if 'z' - 'a' == 25
+           if ('z' - 'a' == 25)
+
+    <sup><a name="note147" href="#note147"><b>147)</b></a></sup> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
+         before the terminating new-line character. However, comments may appear anywhere in a source file,
+         including within a preprocessing directive.
+
+[<a name="p149" href="#p149">page 149</a>] (<a href="#Contents">Contents</a>)
+
+       # include "q-char-sequence" new-line
+    causes the replacement of that directive by the entire contents of the source file identified
+    by the specified sequence between the " delimiters. The named source file is searched
+    for in an implementation-defined manner. If this search is not supported, or if the search
+    fails, the directive is reprocessed as if it read
+       # include &lt;h-char-sequence&gt; new-line
+    with the identical contained sequence (including &gt; characters, if any) from the original
+    directive.
+4   A preprocessing directive of the form
+       # include pp-tokens new-line
+    (that does not match one of the two previous forms) is permitted. The preprocessing
+    tokens after include in the directive are processed just as in normal text. (Each
+    identifier currently defined as a macro name is replaced by its replacement list of
+    preprocessing tokens.) The directive resulting after all replacements shall match one of
+    the two previous forms.<sup><a href="#note148"><b>148)</b></a></sup> The method by which a sequence of preprocessing tokens
+    between a &lt; and a &gt; preprocessing token pair or a pair of " characters is combined into a
+    single header name preprocessing token is implementation-defined.
+5   The implementation shall provide unique mappings for sequences consisting of one or
+    more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
+    first character shall not be a digit. The implementation may ignore distinctions of
+    alphabetical case and restrict the mapping to eight significant characters before the
+    period.
+6   A #include preprocessing directive may appear in a source file that has been read
+    because of a #include directive in another file, up to an implementation-defined
+    nesting limit (see <a href="#5.2.4.1">5.2.4.1</a>).
+7   EXAMPLE 1       The most common uses of #include preprocessing directives are as in the following:
+             #include <a href="#7.19">&lt;stdio.h&gt;</a>
+             #include "myprog.h"
+
+8   EXAMPLE 2       This illustrates macro-replaced #include directives:
+
+
+
+
+    <sup><a name="note148" href="#note148"><b>148)</b></a></sup> Note that adjacent string literals are not concatenated into a single string literal (see the translation
+         phases in <a href="#5.1.1.2">5.1.1.2</a>); thus, an expansion that results in two string literals is an invalid directive.
+
+[<a name="p150" href="#p150">page 150</a>] (<a href="#Contents">Contents</a>)
+
+           #if VERSION == 1
+                 #define INCFILE        "vers1.h"
+           #elif VERSION == 2
+                 #define INCFILE        "vers2.h"      // and so on
+           #else
+                 #define INCFILE        "versN.h"
+           #endif
+           #include INCFILE
+
+    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>).
+<a name="6.10.3" href="#6.10.3"><b>    6.10.3 Macro replacement</b></a>
+<b>    Constraints</b>
+1   Two replacement lists are identical if and only if the preprocessing tokens in both have
+    the same number, ordering, spelling, and white-space separation, where all white-space
+    separations are considered identical.
+2   An identifier currently defined as an object-like macro shall not be redefined by another
+    #define preprocessing directive unless the second definition is an object-like macro
+    definition and the two replacement lists are identical. Likewise, an identifier currently
+    defined as a function-like macro shall not be redefined by another #define
+    preprocessing directive unless the second definition is a function-like macro definition
+    that has the same number and spelling of parameters, and the two replacement lists are
+    identical.
+3   There shall be white-space between the identifier and the replacement list in the definition
+    of an object-like macro.
+4   If the identifier-list in the macro definition does not end with an ellipsis, the number of
+    arguments (including those arguments consisting of no preprocessing tokens) in an
+    invocation of a function-like macro shall equal the number of parameters in the macro
+    definition. Otherwise, there shall be more arguments in the invocation than there are
+    parameters in the macro definition (excluding the ...). There shall exist a )
+    preprocessing token that terminates the invocation.
+5   The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
+    macro that uses the ellipsis notation in the parameters.
+6   A parameter identifier in a function-like macro shall be uniquely declared within its
+    scope.
+<b>    Semantics</b>
+7   The identifier immediately following the define is called the macro name. There is one
+    name space for macro names. Any white-space characters preceding or following the
+    replacement list of preprocessing tokens are not considered part of the replacement list
+    for either form of macro.
+
+[<a name="p151" href="#p151">page 151</a>] (<a href="#Contents">Contents</a>)
+
+8    If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
+     a preprocessing directive could begin, the identifier is not subject to macro replacement.
+9    A preprocessing directive of the form
+        # define identifier replacement-list new-line
+     defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note149"><b>149)</b></a></sup>
+     to be replaced by the replacement list of preprocessing tokens that constitute the
+     remainder of the directive. The replacement list is then rescanned for more macro names
+     as specified below.
+10   A preprocessing directive of the form
+        # define identifier lparen identifier-listopt ) replacement-list new-line
+        # define identifier lparen ... ) replacement-list new-line
+        # define identifier lparen identifier-list , ... ) replacement-list new-line
+     defines a function-like macro with parameters, whose use is similar syntactically to a
+     function call. The parameters are specified by the optional list of identifiers, whose scope
+     extends from their declaration in the identifier list until the new-line character that
+     terminates the #define preprocessing directive. Each subsequent instance of the
+     function-like macro name followed by a ( as the next preprocessing token introduces the
+     sequence of preprocessing tokens that is replaced by the replacement list in the definition
+     (an invocation of the macro). The replaced sequence of preprocessing tokens is
+     terminated by the matching ) preprocessing token, skipping intervening matched pairs of
+     left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
+     tokens making up an invocation of a function-like macro, new-line is considered a normal
+     white-space character.
+11   The sequence of preprocessing tokens bounded by the outside-most matching parentheses
+     forms the list of arguments for the function-like macro. The individual arguments within
+     the list are separated by comma preprocessing tokens, but comma preprocessing tokens
+     between matching inner parentheses do not separate arguments. If there are sequences of
+     preprocessing tokens within the list of arguments that would otherwise act as
+     preprocessing directives,<sup><a href="#note150"><b>150)</b></a></sup> the behavior is undefined.
+12   If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
+     including any separating comma preprocessing tokens, are merged to form a single item:
+     the variable arguments. The number of arguments so combined is such that, following
+
+
+     <sup><a name="note149" href="#note149"><b>149)</b></a></sup> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
+          not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
+          are never scanned for macro names or parameters.
+     <sup><a name="note150" href="#note150"><b>150)</b></a></sup> Despite the name, a non-directive is a preprocessing directive.
+
+[<a name="p152" href="#p152">page 152</a>] (<a href="#Contents">Contents</a>)
+
+    merger, the number of arguments is one more than the number of parameters in the macro
+    definition (excluding the ...).
+<a name="6.10.3.1" href="#6.10.3.1"><b>    6.10.3.1 Argument substitution</b></a>
+1   After the arguments for the invocation of a function-like macro have been identified,
+    argument substitution takes place. A parameter in the replacement list, unless preceded
+    by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
+    replaced by the corresponding argument after all macros contained therein have been
+    expanded. Before being substituted, each argument's preprocessing tokens are
+    completely macro replaced as if they formed the rest of the preprocessing file; no other
+    preprocessing tokens are available.
+2   An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
+    were a parameter, and the variable arguments shall form the preprocessing tokens used to
+    replace it.
+<a name="6.10.3.2" href="#6.10.3.2"><b>    6.10.3.2 The # operator</b></a>
+<b>    Constraints</b>
+1   Each # preprocessing token in the replacement list for a function-like macro shall be
+    followed by a parameter as the next preprocessing token in the replacement list.
+<b>    Semantics</b>
+2   If, in the replacement list, a parameter is immediately preceded by a # preprocessing
+    token, both are replaced by a single character string literal preprocessing token that
+    contains the spelling of the preprocessing token sequence for the corresponding
+    argument. Each occurrence of white space between the argument's preprocessing tokens
+    becomes a single space character in the character string literal. White space before the
+    first preprocessing token and after the last preprocessing token composing the argument
+    is deleted. Otherwise, the original spelling of each preprocessing token in the argument
+    is retained in the character string literal, except for special handling for producing the
+    spelling of string literals and character constants: a \ character is inserted before each "
+    and \ character of a character constant or string literal (including the delimiting "
+    characters), except that it is implementation-defined whether a \ character is inserted
+    before the \ character beginning a universal character name. If the replacement that
+    results is not a valid character string literal, the behavior is undefined. The character
+    string literal corresponding to an empty argument is "". The order of evaluation of # and
+    ## operators is unspecified.
+
+[<a name="p153" href="#p153">page 153</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.3.3" href="#6.10.3.3"><b>    6.10.3.3 The ## operator</b></a>
+<b>    Constraints</b>
+1   A ## preprocessing token shall not occur at the beginning or at the end of a replacement
+    list for either form of macro definition.
+<b>    Semantics</b>
+2   If, in the replacement list of a function-like macro, a parameter is immediately preceded
+    or followed by a ## preprocessing token, the parameter is replaced by the corresponding
+    argument's preprocessing token sequence; however, if an argument consists of no
+    preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
+    instead.<sup><a href="#note151"><b>151)</b></a></sup>
+3   For both object-like and function-like macro invocations, before the replacement list is
+    reexamined for more macro names to replace, each instance of a ## preprocessing token
+    in the replacement list (not from an argument) is deleted and the preceding preprocessing
+    token is concatenated with the following preprocessing token. Placemarker
+    preprocessing tokens are handled specially: concatenation of two placemarkers results in
+    a single placemarker preprocessing token, and concatenation of a placemarker with a
+    non-placemarker preprocessing token results in the non-placemarker preprocessing token.
+    If the result is not a valid preprocessing token, the behavior is undefined. The resulting
+    token is available for further macro replacement. The order of evaluation of ## operators
+    is unspecified.
+4   EXAMPLE       In the following fragment:
+            #define     hash_hash # ## #
+            #define     mkstr(a) # a
+            #define     in_between(a) mkstr(a)
+            #define     join(c, d) in_between(c hash_hash d)
+            char p[] = join(x, y); // equivalent to
+                                   // char p[] = "x ## y";
+    The expansion produces, at various stages:
+            join(x, y)
+            in_between(x hash_hash y)
+            in_between(x ## y)
+            mkstr(x ## y)
+            "x ## y"
+    In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
+    this new token is not the ## operator.
+
+
+    <sup><a name="note151" href="#note151"><b>151)</b></a></sup> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
+         exist only within translation phase 4.
+
+[<a name="p154" href="#p154">page 154</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.3.4" href="#6.10.3.4"><b>    6.10.3.4 Rescanning and further replacement</b></a>
+1   After all parameters in the replacement list have been substituted and # and ##
+    processing has taken place, all placemarker preprocessing tokens are removed. Then, the
+    resulting preprocessing token sequence is rescanned, along with all subsequent
+    preprocessing tokens of the source file, for more macro names to replace.
+2   If the name of the macro being replaced is found during this scan of the replacement list
+    (not including the rest of the source file's preprocessing tokens), it is not replaced.
+    Furthermore, if any nested replacements encounter the name of the macro being replaced,
+    it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
+    available for further replacement even if they are later (re)examined in contexts in which
+    that macro name preprocessing token would otherwise have been replaced.
+3   The resulting completely macro-replaced preprocessing token sequence is not processed
+    as a preprocessing directive even if it resembles one, but all pragma unary operator
+    expressions within it are then processed as specified in <a href="#6.10.9">6.10.9</a> below.
+<a name="6.10.3.5" href="#6.10.3.5"><b>    6.10.3.5 Scope of macro definitions</b></a>
+1   A macro definition lasts (independent of block structure) until a corresponding #undef
+    directive is encountered or (if none is encountered) until the end of the preprocessing
+    translation unit. Macro definitions have no significance after translation phase 4.
+2   A preprocessing directive of the form
+       # undef identifier new-line
+    causes the specified identifier no longer to be defined as a macro name. It is ignored if
+    the specified identifier is not currently defined as a macro name.
+3   EXAMPLE 1      The simplest use of this facility is to define a ''manifest constant'', as in
+            #define TABSIZE 100
+            int table[TABSIZE];
+
+4   EXAMPLE 2 The following defines a function-like macro whose value is the maximum of its arguments.
+    It has the advantages of working for any compatible types of the arguments and of generating in-line code
+    without the overhead of function calling. It has the disadvantages of evaluating one or the other of its
+    arguments a second time (including side effects) and generating more code than a function if invoked
+    several times. It also cannot have its address taken, as it has none.
+            #define max(a, b) ((a) &gt; (b) ? (a) : (b))
+    The parentheses ensure that the arguments and the resulting expression are bound properly.
+
+[<a name="p155" href="#p155">page 155</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE 3     To illustrate the rules for redefinition and reexamination, the sequence
+             #define   x         3
+             #define   f(a)      f(x * (a))
+             #undef    x
+             #define   x         2
+             #define   g         f
+             #define   z         z[0]
+             #define   h         g(~
+             #define   m(a)      a(w)
+             #define   w         0,1
+             #define   t(a)      a
+             #define   p()       int
+             #define   q(x)      x
+             #define   r(x,y)    x ## y
+             #define   str(x)    # x
+             f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);
+             g(x+(3,4)-w) | h 5) &amp; m
+                   (f)^m(m);
+             p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
+             char c[2][6] = { str(hello), str() };
+    results in
+             f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
+             f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) &amp; f(2 * (0,1))^m(0,1);
+             int i[] = { 1, 23, 4, 5, };
+             char c[2][6] = { "hello", "" };
+
+6   EXAMPLE 4     To illustrate the rules for creating character string literals and concatenating tokens, the
+    sequence
+             #define str(s)      # s
+             #define xstr(s)     str(s)
+             #define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
+                                     x ## s, x ## t)
+             #define INCFILE(n) vers ## n
+             #define glue(a, b) a ## b
+             #define xglue(a, b) glue(a, b)
+             #define HIGHLOW     "hello"
+             #define LOW         LOW ", world"
+             debug(1, 2);
+             fputs(str(strncmp("abc\0d", "abc", '\4') // this goes away
+                   == 0) str(: @\n), s);
+             #include xstr(INCFILE(2).h)
+             glue(HIGH, LOW);
+             xglue(HIGH, LOW)
+    results in
+
+[<a name="p156" href="#p156">page 156</a>] (<a href="#Contents">Contents</a>)
+
+             printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
+             fputs(
+               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0" ": @\n",
+               s);
+             #include "vers2.h"    (after macro replacement, before file access)
+             "hello";
+             "hello" ", world"
+    or, after concatenation of the character string literals,
+             printf("x1= %d, x2= %s", x1, x2);
+             fputs(
+               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: @\n",
+               s);
+             #include "vers2.h"    (after macro replacement, before file access)
+             "hello";
+             "hello, world"
+    Space around the # and ## tokens in the macro definition is optional.
+
+7   EXAMPLE 5        To illustrate the rules for placemarker preprocessing tokens, the sequence
+             #define t(x,y,z) x ## y ## z
+             int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
+                        t(10,,), t(,11,), t(,,12), t(,,) };
+    results in
+             int j[] = { 123, 45, 67, 89,
+                         10, 11, 12, };
+
+8   EXAMPLE 6        To demonstrate the redefinition rules, the following sequence is valid.
+             #define      OBJ_LIKE      (1-1)
+             #define      OBJ_LIKE      /* white space */ (1-1) /* other */
+             #define      FUNC_LIKE(a)   ( a )
+             #define      FUNC_LIKE( a )( /* note the white space */ \
+                                          a /* other stuff on this line
+                                              */ )
+    But the following redefinitions are invalid:
+             #define      OBJ_LIKE    (0)     // different token sequence
+             #define      OBJ_LIKE    (1 - 1) // different white space
+             #define      FUNC_LIKE(b) ( a ) // different parameter usage
+             #define      FUNC_LIKE(b) ( b ) // different parameter spelling
+
+9   EXAMPLE 7        Finally, to show the variable argument list macro facilities:
+             #define debug(...)       fprintf(stderr, __VA_ARGS__)
+             #define showlist(...)    puts(#__VA_ARGS__)
+             #define report(test, ...) ((test)?puts(#test):\
+                         printf(__VA_ARGS__))
+             debug("Flag");
+             debug("X = %d\n", x);
+             showlist(The first, second, and third items.);
+             report(x&gt;y, "x is %d but y is %d", x, y);
+
+[<a name="p157" href="#p157">page 157</a>] (<a href="#Contents">Contents</a>)
+
+    results in
+             fprintf(stderr, "Flag" );
+             fprintf(stderr, "X = %d\n", x );
+             puts( "The first, second, and third items." );
+             ((x&gt;y)?puts("x&gt;y"):
+                         printf("x is %d but y is %d", x, y));
+
+<a name="6.10.4" href="#6.10.4"><b>    6.10.4 Line control</b></a>
+<b>    Constraints</b>
+1   The string literal of a #line directive, if present, shall be a character string literal.
+<b>    Semantics</b>
+2   The line number of the current source line is one greater than the number of new-line
+    characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
+    file to the current token.
+3   A preprocessing directive of the form
+       # line digit-sequence new-line
+    causes the implementation to behave as if the following sequence of source lines begins
+    with a source line that has a line number as specified by the digit sequence (interpreted as
+    a decimal integer). The digit sequence shall not specify zero, nor a number greater than
+    2147483647.
+4   A preprocessing directive of the form
+       # line digit-sequence "s-char-sequenceopt" new-line
+    sets the presumed line number similarly and changes the presumed name of the source
+    file to be the contents of the character string literal.
+5   A preprocessing directive of the form
+       # line pp-tokens new-line
+    (that does not match one of the two previous forms) is permitted. The preprocessing
+    tokens after line on the directive are processed just as in normal text (each identifier
+    currently defined as a macro name is replaced by its replacement list of preprocessing
+    tokens). The directive resulting after all replacements shall match one of the two
+    previous forms and is then processed as appropriate.
+
+[<a name="p158" href="#p158">page 158</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.5" href="#6.10.5"><b>    6.10.5 Error directive</b></a>
+<b>    Semantics</b>
+1   A preprocessing directive of the form
+       # error pp-tokensopt new-line
+    causes the implementation to produce a diagnostic message that includes the specified
+    sequence of preprocessing tokens.
+<a name="6.10.6" href="#6.10.6"><b>    6.10.6 Pragma directive</b></a>
+<b>    Semantics</b>
+1   A preprocessing directive of the form
+       # pragma pp-tokensopt new-line
+    where the preprocessing token STDC does not immediately follow pragma in the
+    directive (prior to any macro replacement)<sup><a href="#note152"><b>152)</b></a></sup> causes the implementation to behave in an
+    implementation-defined manner. The behavior might cause translation to fail or cause the
+    translator or the resulting program to behave in a non-conforming manner. Any such
+    pragma that is not recognized by the implementation is ignored.
+2   If the preprocessing token STDC does immediately follow pragma in the directive (prior
+    to any macro replacement), then no macro replacement is performed on the directive, and
+    the directive shall have one of the following forms<sup><a href="#note153"><b>153)</b></a></sup> whose meanings are described
+    elsewhere:
+       #pragma STDC FP_CONTRACT on-off-switch
+       #pragma STDC FENV_ACCESS on-off-switch
+       #pragma STDC CX_LIMITED_RANGE on-off-switch
+       on-off-switch: one of
+                   ON     OFF           DEFAULT
+    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
+    (<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
+
+
+
+
+    <sup><a name="note152" href="#note152"><b>152)</b></a></sup> An implementation is not required to perform macro replacement in pragmas, but it is permitted
+         except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
+         replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
+         implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
+         but is not required to.
+    <sup><a name="note153" href="#note153"><b>153)</b></a></sup> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
+
+[<a name="p159" href="#p159">page 159</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.7" href="#6.10.7"><b>    6.10.7 Null directive</b></a>
+<b>    Semantics</b>
+1   A preprocessing directive of the form
+       # new-line
+    has no effect.
+<a name="6.10.8" href="#6.10.8"><b>    6.10.8 Predefined macro names</b></a>
+1   The following macro names<sup><a href="#note154"><b>154)</b></a></sup> shall be defined by the implementation:
+    __DATE__ The date of translation of the preprocessing translation unit: a character
+               string literal of the form "Mmm dd yyyy", where the names of the
+               months are the same as those generated by the asctime function, and the
+               first character of dd is a space character if the value is less than 10. If the
+               date of translation is not available, an implementation-defined valid date
+               shall be supplied.
+    __FILE__ The presumed name of the current source file (a character string literal).<sup><a href="#note155"><b>155)</b></a></sup>
+    __LINE__ The presumed line number (within the current source file) of the current
+               source line (an integer constant).155)
+    __STDC__ The integer constant 1, intended to indicate a conforming implementation.
+    __STDC_HOSTED__ The integer constant 1 if the implementation is a hosted
+              implementation or the integer constant 0 if it is not.
+    __STDC_MB_MIGHT_NEQ_WC__ The integer constant 1, intended to indicate that, in
+              the encoding for wchar_t, a member of the basic character set need not
+              have a code value equal to its value when used as the lone character in an
+              integer character constant.
+    __STDC_VERSION__ The integer constant 199901L.<sup><a href="#note156"><b>156)</b></a></sup>
+    __TIME__ The time of translation of the preprocessing translation unit: a character
+               string literal of the form "hh:mm:ss" as in the time generated by the
+               asctime function. If the time of translation is not available, an
+               implementation-defined valid time shall be supplied.
+
+
+
+    <sup><a name="note154" href="#note154"><b>154)</b></a></sup> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
+    <sup><a name="note155" href="#note155"><b>155)</b></a></sup> The presumed source file name and line number can be changed by the #line directive.
+    <sup><a name="note156" href="#note156"><b>156)</b></a></sup> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
+         ISO/IEC 9899/AMD1:1995. The intention is that this will remain an integer constant of type long
+         int that is increased with each revision of this International Standard.
+
+[<a name="p160" href="#p160">page 160</a>] (<a href="#Contents">Contents</a>)
+
+2   The following macro names are conditionally defined by the implementation:
+    __STDC_IEC_559__ The integer constant 1, intended to indicate conformance to the
+              specifications in <a href="#F">annex F</a> (IEC 60559 floating-point arithmetic).
+    __STDC_IEC_559_COMPLEX__ The integer constant 1, intended to indicate
+              adherence to the specifications in informative <a href="#G">annex G</a> (IEC 60559
+              compatible complex arithmetic).
+    __STDC_ISO_10646__ An integer constant of the form yyyymmL (for example,
+              199712L). If this symbol is defined, then every character in the Unicode
+              required set, when stored in an object of type wchar_t, has the same
+              value as the short identifier of that character. The Unicode required set
+              consists of all the characters that are defined by ISO/IEC 10646, along with
+              all amendments and technical corrigenda, as of the specified year and
+              month.
+3   The values of the predefined macros (except for __FILE__ and __LINE__) remain
+    constant throughout the translation unit.
+4   None of these macro names, nor the identifier defined, shall be the subject of a
+    #define or a #undef preprocessing directive. Any other predefined macro names
+    shall begin with a leading underscore followed by an uppercase letter or a second
+    underscore.
+5   The implementation shall not predefine the macro __cplusplus, nor shall it define it
+    in any standard header.
+    Forward references: the asctime function (<a href="#7.23.3.1">7.23.3.1</a>), standard headers (<a href="#7.1.2">7.1.2</a>).
+<a name="6.10.9" href="#6.10.9"><b>    6.10.9 Pragma operator</b></a>
+<b>    Semantics</b>
+1   A unary operator expression of the form:
+       _Pragma ( string-literal )
+    is processed as follows: The string literal is destringized by deleting the L prefix, if
+    present, deleting the leading and trailing double-quotes, replacing each escape sequence
+    \" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
+    resulting sequence of characters is processed through translation phase 3 to produce
+    preprocessing tokens that are executed as if they were the pp-tokens in a pragma
+    directive. The original four preprocessing tokens in the unary operator expression are
+    removed.
+2   EXAMPLE       A directive of the form:
+             #pragma listing on "..\listing.dir"
+    can also be expressed as:
+
+[<a name="p161" href="#p161">page 161</a>] (<a href="#Contents">Contents</a>)
+
+        _Pragma ( "listing on \"..\\listing.dir\"" )
+The latter form is processed in the same way whether it appears literally as shown, or results from macro
+replacement, as in:
+        #define LISTING(x) PRAGMA(listing on #x)
+        #define PRAGMA(x) _Pragma(#x)
+        LISTING ( ..\listing.dir )
+
+[<a name="p162" href="#p162">page 162</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.11" href="#6.11"><b>    6.11 Future language directions</b></a>
+<a name="6.11.1" href="#6.11.1"><b>    6.11.1 Floating types</b></a>
+1   Future standardization may include additional floating-point types, including those with
+    greater range, precision, or both than long double.
+<a name="6.11.2" href="#6.11.2"><b>    6.11.2 Linkages of identifiers</b></a>
+1   Declaring an identifier with internal linkage at file scope without the static storage-
+    class specifier is an obsolescent feature.
+<a name="6.11.3" href="#6.11.3"><b>    6.11.3 External names</b></a>
+1   Restriction of the significance of an external name to fewer than 255 characters
+    (considering each universal character name or extended source character as a single
+    character) is an obsolescent feature that is a concession to existing implementations.
+<a name="6.11.4" href="#6.11.4"><b>    6.11.4 Character escape sequences</b></a>
+1   Lowercase letters as escape sequences are reserved for future standardization. Other
+    characters may be used in extensions.
+<a name="6.11.5" href="#6.11.5"><b>    6.11.5 Storage-class specifiers</b></a>
+1   The placement of a storage-class specifier other than at the beginning of the declaration
+    specifiers in a declaration is an obsolescent feature.
+<a name="6.11.6" href="#6.11.6"><b>    6.11.6 Function declarators</b></a>
+1   The use of function declarators with empty parentheses (not prototype-format parameter
+    type declarators) is an obsolescent feature.
+<a name="6.11.7" href="#6.11.7"><b>    6.11.7 Function definitions</b></a>
+1   The use of function definitions with separate parameter identifier and declaration lists
+    (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
+<a name="6.11.8" href="#6.11.8"><b>    6.11.8 Pragma directives</b></a>
+1   Pragmas whose first preprocessing token is STDC are reserved for future standardization.
+<a name="6.11.9" href="#6.11.9"><b>    6.11.9 Predefined macro names</b></a>
+1   Macro names beginning with __STDC_ are reserved for future standardization.
+
+[<a name="p163" href="#p163">page 163</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="7" href="#7"><b>    7. Library</b></a>
+
+<a name="7.1" href="#7.1"><b>    7.1 Introduction</b></a>
+<a name="7.1.1" href="#7.1.1"><b>    7.1.1 Definitions of terms</b></a>
+1   A string is a contiguous sequence of characters terminated by and including the first null
+    character. The term multibyte string is sometimes used instead to emphasize special
+    processing given to multibyte characters contained in the string or to avoid confusion
+    with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
+    character. The length of a string is the number of bytes preceding the null character and
+    the value of a string is the sequence of the values of the contained characters, in order.
+2   The decimal-point character is the character used by functions that convert floating-point
+    numbers to or from character sequences to denote the beginning of the fractional part of
+    such character sequences.<sup><a href="#note157"><b>157)</b></a></sup> It is represented in the text and examples by a period, but
+    may be changed by the setlocale function.
+3   A null wide character is a wide character with code value zero.
+4   A wide string is a contiguous sequence of wide characters terminated by and including
+    the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
+    addressed) wide character. The length of a wide string is the number of wide characters
+    preceding the null wide character and the value of a wide string is the sequence of code
+    values of the contained wide characters, in order.
+5   A shift sequence is a contiguous sequence of bytes within a multibyte string that
+    (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
+    corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
+    character.<sup><a href="#note158"><b>158)</b></a></sup>
+    Forward references: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+
+
+
+
+    <sup><a name="note157" href="#note157"><b>157)</b></a></sup> The functions that make use of the decimal-point character are the numeric conversion functions
+         (<a href="#7.20.1">7.20.1</a>, <a href="#7.24.4.1">7.24.4.1</a>) and the formatted input/output functions (<a href="#7.19.6">7.19.6</a>, <a href="#7.24.2">7.24.2</a>).
+    <sup><a name="note158" href="#note158"><b>158)</b></a></sup> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
+         enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
+         sequence of maximum length. Whether these counts provide for more than one shift sequence is the
+         implementation's choice.
+
+[<a name="p164" href="#p164">page 164</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.1.2" href="#7.1.2"><b>    7.1.2 Standard headers</b></a>
+1   Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note159"><b>159)</b></a></sup>
+    whose contents are made available by the #include preprocessing directive. The
+    header declares a set of related functions, plus any necessary types and additional macros
+    needed to facilitate their use. Declarations of types described in this clause shall not
+    include type qualifiers, unless explicitly stated otherwise.
+2   The standard headers are
+           <a href="#7.2">&lt;assert.h&gt;</a>             <a href="#7.8">&lt;inttypes.h&gt;</a>            <a href="#7.14">&lt;signal.h&gt;</a>              <a href="#7.20">&lt;stdlib.h&gt;</a>
+           <a href="#7.3">&lt;complex.h&gt;</a>            <a href="#7.9">&lt;iso646.h&gt;</a>              <a href="#7.15">&lt;stdarg.h&gt;</a>              <a href="#7.21">&lt;string.h&gt;</a>
+           <a href="#7.4">&lt;ctype.h&gt;</a>              <a href="#7.10">&lt;limits.h&gt;</a>              <a href="#7.16">&lt;stdbool.h&gt;</a>             <a href="#7.22">&lt;tgmath.h&gt;</a>
+           <a href="#7.5">&lt;errno.h&gt;</a>              <a href="#7.11">&lt;locale.h&gt;</a>              <a href="#7.17">&lt;stddef.h&gt;</a>              <a href="#7.23">&lt;time.h&gt;</a>
+           <a href="#7.6">&lt;fenv.h&gt;</a>               <a href="#7.12">&lt;math.h&gt;</a>                <a href="#7.18">&lt;stdint.h&gt;</a>              <a href="#7.24">&lt;wchar.h&gt;</a>
+           <a href="#7.7">&lt;float.h&gt;</a>              <a href="#7.13">&lt;setjmp.h&gt;</a>              <a href="#7.19">&lt;stdio.h&gt;</a>               <a href="#7.25">&lt;wctype.h&gt;</a>
+3   If a file with the same name as one of the above &lt; and &gt; delimited sequences, not
+    provided as part of the implementation, is placed in any of the standard places that are
+    searched for included source files, the behavior is undefined.
+4   Standard headers may be included in any order; each may be included more than once in
+    a given scope, with no effect different from being included only once, except that the
+    effect of including <a href="#7.2">&lt;assert.h&gt;</a> depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
+    used, a header shall be included outside of any external declaration or definition, and it
+    shall first be included before the first reference to any of the functions or objects it
+    declares, or to any of the types or macros it defines. However, if an identifier is declared
+    or defined in more than one header, the second and subsequent associated headers may be
+    included after the initial reference to the identifier. The program shall not have any
+    macros with names lexically identical to keywords currently defined prior to the
+    inclusion.
+5   Any definition of an object-like macro described in this clause shall expand to code that is
+    fully protected by parentheses where necessary, so that it groups in an arbitrary
+    expression as if it were a single identifier.
+6   Any declaration of a library function shall have external linkage.
+7   A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
+    Forward references: diagnostics (<a href="#7.2">7.2</a>).
+
+
+
+
+    <sup><a name="note159" href="#note159"><b>159)</b></a></sup> A header is not necessarily a source file, nor are the &lt; and &gt; delimited sequences in header names
+         necessarily valid source file names.
+
+[<a name="p165" href="#p165">page 165</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.1.3" href="#7.1.3"><b>    7.1.3 Reserved identifiers</b></a>
+1   Each header declares or defines all identifiers listed in its associated subclause, and
+    optionally declares or defines identifiers listed in its associated future library directions
+    subclause and identifiers which are always reserved either for any use or for use as file
+    scope identifiers.
+    -- All identifiers that begin with an underscore and either an uppercase letter or another
+      underscore are always reserved for any use.
+    -- All identifiers that begin with an underscore are always reserved for use as identifiers
+      with file scope in both the ordinary and tag name spaces.
+    -- Each macro name in any of the following subclauses (including the future library
+      directions) is reserved for use as specified if any of its associated headers is included;
+      unless explicitly stated otherwise (see <a href="#7.1.4">7.1.4</a>).
+    -- All identifiers with external linkage in any of the following subclauses (including the
+      future library directions) are always reserved for use as identifiers with external
+      linkage.<sup><a href="#note160"><b>160)</b></a></sup>
+    -- Each identifier with file scope listed in any of the following subclauses (including the
+      future library directions) is reserved for use as a macro name and as an identifier with
+      file scope in the same name space if any of its associated headers is included.
+2   No other identifiers are reserved. If the program declares or defines an identifier in a
+    context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
+    identifier as a macro name, the behavior is undefined.
+3   If the program removes (with #undef) any macro definition of an identifier in the first
+    group listed above, the behavior is undefined.
+<a name="7.1.4" href="#7.1.4"><b>    7.1.4 Use of library functions</b></a>
+1   Each of the following statements applies unless explicitly stated otherwise in the detailed
+    descriptions that follow: If an argument to a function has an invalid value (such as a value
+    outside the domain of the function, or a pointer outside the address space of the program,
+    or a null pointer, or a pointer to non-modifiable storage when the corresponding
+    parameter is not const-qualified) or a type (after promotion) not expected by a function
+    with variable number of arguments, the behavior is undefined. If a function argument is
+    described as being an array, the pointer actually passed to the function shall have a value
+    such that all address computations and accesses to objects (that would be valid if the
+    pointer did point to the first element of such an array) are in fact valid. Any function
+    declared in a header may be additionally implemented as a function-like macro defined in
+
+    <sup><a name="note160" href="#note160"><b>160)</b></a></sup> The list of reserved identifiers with external linkage includes errno, math_errhandling,
+         setjmp, and va_end.
+
+[<a name="p166" href="#p166">page 166</a>] (<a href="#Contents">Contents</a>)
+
+    the header, so if a library function is declared explicitly when its header is included, one
+    of the techniques shown below can be used to ensure the declaration is not affected by
+    such a macro. Any macro definition of a function can be suppressed locally by enclosing
+    the name of the function in parentheses, because the name is then not followed by the left
+    parenthesis that indicates expansion of a macro function name. For the same syntactic
+    reason, it is permitted to take the address of a library function even if it is also defined as
+    a macro.<sup><a href="#note161"><b>161)</b></a></sup> The use of #undef to remove any macro definition will also ensure that an
+    actual function is referred to. Any invocation of a library function that is implemented as
+    a macro shall expand to code that evaluates each of its arguments exactly once, fully
+    protected by parentheses where necessary, so it is generally safe to use arbitrary
+    expressions as arguments.<sup><a href="#note162"><b>162)</b></a></sup> Likewise, those function-like macros described in the
+    following subclauses may be invoked in an expression anywhere a function with a
+    compatible return type could be called.<sup><a href="#note163"><b>163)</b></a></sup> All object-like macros listed as expanding to
+    integer constant expressions shall additionally be suitable for use in #if preprocessing
+    directives.
+2   Provided that a library function can be declared without reference to any type defined in a
+    header, it is also permissible to declare the function and use it without including its
+    associated header.
+3   There is a sequence point immediately before a library function returns.
+4   The functions in the standard library are not guaranteed to be reentrant and may modify
+    objects with static storage duration.<sup><a href="#note164"><b>164)</b></a></sup>
+
+
+
+    <sup><a name="note161" href="#note161"><b>161)</b></a></sup> This means that an implementation shall provide an actual function for each library function, even if it
+         also provides a macro for that function.
+    <sup><a name="note162" href="#note162"><b>162)</b></a></sup> Such macros might not contain the sequence points that the corresponding function calls do.
+    <sup><a name="note163" href="#note163"><b>163)</b></a></sup> Because external identifiers and some macro names beginning with an underscore are reserved,
+         implementations may provide special semantics for such names. For example, the identifier
+         _BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
+         appropriate header could specify
+                  #define abs(x) _BUILTIN_abs(x)
+         for a compiler whose code generator will accept it.
+         In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
+         function may write
+                  #undef abs
+         whether the implementation's header provides a macro implementation of abs or a built-in
+         implementation. The prototype for the function, which precedes and is hidden by any macro
+         definition, is thereby revealed also.
+    <sup><a name="note164" href="#note164"><b>164)</b></a></sup> Thus, a signal handler cannot, in general, call standard library functions.
+
+[<a name="p167" href="#p167">page 167</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE       The function atoi may be used in any of several ways:
+    -- by use of its associated header (possibly generating a macro expansion)
+                #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+                const char *str;
+                /* ... */
+                i = atoi(str);
+    -- by use of its associated header (assuredly generating a true function reference)
+                #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+                #undef atoi
+                const char *str;
+                /* ... */
+                i = atoi(str);
+       or
+                #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+                const char *str;
+                /* ... */
+                i = (atoi)(str);
+    -- by explicit declaration
+                extern int atoi(const char *);
+                const char *str;
+                /* ... */
+                i = atoi(str);
+
+[<a name="p168" href="#p168">page 168</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.2" href="#7.2"><b>    7.2 Diagnostics &lt;assert.h&gt;</b></a>
+1   The header <a href="#7.2">&lt;assert.h&gt;</a> defines the assert macro and refers to another macro,
+            NDEBUG
+    which is not defined by <a href="#7.2">&lt;assert.h&gt;</a>. If NDEBUG is defined as a macro name at the
+    point in the source file where <a href="#7.2">&lt;assert.h&gt;</a> is included, the assert macro is defined
+    simply as
+            #define assert(ignore) ((void)0)
+    The assert macro is redefined according to the current state of NDEBUG each time that
+    <a href="#7.2">&lt;assert.h&gt;</a> is included.
+2   The assert macro shall be implemented as a macro, not as an actual function. If the
+    macro definition is suppressed in order to access an actual function, the behavior is
+    undefined.
+<a name="7.2.1" href="#7.2.1"><b>    7.2.1 Program diagnostics</b></a>
+<a name="7.2.1.1" href="#7.2.1.1"><b>    7.2.1.1 The assert macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.2">&lt;assert.h&gt;</a>
+            void assert(scalar expression);
+<b>    Description</b>
+2   The assert macro puts diagnostic tests into programs; it expands to a void expression.
+    When it is executed, if expression (which shall have a scalar type) is false (that is,
+    compares equal to 0), the assert macro writes information about the particular call that
+    failed (including the text of the argument, the name of the source file, the source line
+    number, and the name of the enclosing function -- the latter are respectively the values of
+    the preprocessing macros __FILE__ and __LINE__ and of the identifier
+    __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note165"><b>165)</b></a></sup> It
+    then calls the abort function.
+<b>    Returns</b>
+3   The assert macro returns no value.
+    Forward references: the abort function (<a href="#7.20.4.1">7.20.4.1</a>).
+
+
+
+
+    <sup><a name="note165" href="#note165"><b>165)</b></a></sup> The message written might be of the form:
+         Assertion failed: expression, function abc, file xyz, line nnn.
+
+[<a name="p169" href="#p169">page 169</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3" href="#7.3"><b>    7.3 Complex arithmetic &lt;complex.h&gt;</b></a>
+<a name="7.3.1" href="#7.3.1"><b>    7.3.1 Introduction</b></a>
+1   The header <a href="#7.3">&lt;complex.h&gt;</a> defines macros and declares functions that support complex
+    arithmetic.<sup><a href="#note166"><b>166)</b></a></sup> Each synopsis specifies a family of functions consisting of a principal
+    function with one or more double complex parameters and a double complex or
+    double return value; and other functions with the same name but with f and l suffixes
+    which are corresponding functions with float and long double parameters and
+    return values.
+2   The macro
+             complex
+    expands to _Complex; the macro
+             _Complex_I
+    expands to a constant expression of type const float _Complex, with the value of
+    the imaginary unit.<sup><a href="#note167"><b>167)</b></a></sup>
+3   The macros
+             imaginary
+    and
+             _Imaginary_I
+    are defined if and only if the implementation supports imaginary types;<sup><a href="#note168"><b>168)</b></a></sup> if defined,
+    they expand to _Imaginary and a constant expression of type const float
+    _Imaginary with the value of the imaginary unit.
+4   The macro
+             I
+    expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
+    defined, I shall expand to _Complex_I.
+5   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+    redefine the macros complex, imaginary, and I.
+    Forward references: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
+
+
+
+    <sup><a name="note166" href="#note166"><b>166)</b></a></sup> See ''future library directions'' (<a href="#7.26.1">7.26.1</a>).
+    <sup><a name="note167" href="#note167"><b>167)</b></a></sup> The imaginary unit is a number i such that i 2   = -1.
+    <sup><a name="note168" href="#note168"><b>168)</b></a></sup> A specification for imaginary types is in informative <a href="#G">annex G</a>.
+
+[<a name="p170" href="#p170">page 170</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.2" href="#7.3.2"><b>    7.3.2 Conventions</b></a>
+1   Values are interpreted as radians, not degrees. An implementation may set errno but is
+    not required to.
+<a name="7.3.3" href="#7.3.3"><b>    7.3.3 Branch cuts</b></a>
+1   Some of the functions below have branch cuts, across which the function is
+    discontinuous. For implementations with a signed zero (including all IEC 60559
+    implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
+    one side of a cut from another so the function is continuous (except for format
+    limitations) as the cut is approached from either side. For example, for the square root
+    function, which has a branch cut along the negative real axis, the top of the cut, with
+    imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
+    imaginary part -0, maps to the negative imaginary axis.
+2   Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
+    sides of branch cuts. These implementations shall map a cut so the function is continuous
+    as the cut is approached coming around the finite endpoint of the cut in a counter
+    clockwise direction. (Branch cuts for the functions specified here have just one finite
+    endpoint.) For example, for the square root function, coming counter clockwise around
+    the finite endpoint of the cut along the negative real axis approaches the cut from above,
+    so the cut maps to the positive imaginary axis.
+<a name="7.3.4" href="#7.3.4"><b>    7.3.4 The CX_LIMITED_RANGE pragma</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.3">&lt;complex.h&gt;</a>
+             #pragma STDC CX_LIMITED_RANGE on-off-switch
+<b>    Description</b>
+2   The usual mathematical formulas for complex multiply, divide, and absolute value are
+    problematic because of their treatment of infinities and because of undue overflow and
+    underflow. The CX_LIMITED_RANGE pragma can be used to inform the
+    implementation that (where the state is ''on'') the usual mathematical formulas are
+    acceptable.<sup><a href="#note169"><b>169)</b></a></sup> The pragma can occur either outside external declarations or preceding all
+    explicit declarations and statements inside a compound statement. When outside external
+
+    <sup><a name="note169" href="#note169"><b>169)</b></a></sup> The purpose of the pragma is to allow the implementation to use the formulas:
+             (x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
+             (x + iy) / (u + iv) = [(xu + yv) + i(yu - xv)]/(u2 + v 2 )
+             | x + iy | = (sqrt) x 2 + y 2
+                          ???????????????
+         where the programmer can determine they are safe.
+
+[<a name="p171" href="#p171">page 171</a>] (<a href="#Contents">Contents</a>)
+
+    declarations, the pragma takes effect from its occurrence until another
+    CX_LIMITED_RANGE pragma is encountered, or until the end of the translation unit.
+    When inside a compound statement, the pragma takes effect from its occurrence until
+    another CX_LIMITED_RANGE pragma is encountered (including within a nested
+    compound statement), or until the end of the compound statement; at the end of a
+    compound statement the state for the pragma is restored to its condition just before the
+    compound statement. If this pragma is used in any other context, the behavior is
+    undefined. The default state for the pragma is ''off''.
+<a name="7.3.5" href="#7.3.5"><b>    7.3.5 Trigonometric functions</b></a>
+<a name="7.3.5.1" href="#7.3.5.1"><b>    7.3.5.1 The cacos functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex cacos(double complex z);
+           float complex cacosf(float complex z);
+           long double complex cacosl(long double complex z);
+<b>    Description</b>
+2   The cacos functions compute the complex arc cosine of z, with branch cuts outside the
+    interval [-1, +1] along the real axis.
+<b>    Returns</b>
+3   The cacos functions return the complex arc cosine value, in the range of a strip
+    mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
+    real axis.
+<a name="7.3.5.2" href="#7.3.5.2"><b>    7.3.5.2 The casin functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex casin(double complex z);
+           float complex casinf(float complex z);
+           long double complex casinl(long double complex z);
+<b>    Description</b>
+2   The casin functions compute the complex arc sine of z, with branch cuts outside the
+    interval [-1, +1] along the real axis.
+<b>    Returns</b>
+3   The casin functions return the complex arc sine value, in the range of a strip
+    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+    along the real axis.
+
+[<a name="p172" href="#p172">page 172</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.5.3" href="#7.3.5.3"><b>    7.3.5.3 The catan functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex catan(double complex z);
+           float complex catanf(float complex z);
+           long double complex catanl(long double complex z);
+<b>    Description</b>
+2   The catan functions compute the complex arc tangent of z, with branch cuts outside the
+    interval [-i, +i] along the imaginary axis.
+<b>    Returns</b>
+3   The catan functions return the complex arc tangent value, in the range of a strip
+    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+    along the real axis.
+<a name="7.3.5.4" href="#7.3.5.4"><b>    7.3.5.4 The ccos functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex ccos(double complex z);
+           float complex ccosf(float complex z);
+           long double complex ccosl(long double complex z);
+<b>    Description</b>
+2   The ccos functions compute the complex cosine of z.
+<b>    Returns</b>
+3   The ccos functions return the complex cosine value.
+<a name="7.3.5.5" href="#7.3.5.5"><b>    7.3.5.5 The csin functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex csin(double complex z);
+           float complex csinf(float complex z);
+           long double complex csinl(long double complex z);
+<b>    Description</b>
+2   The csin functions compute the complex sine of z.
+<b>    Returns</b>
+3   The csin functions return the complex sine value.
+
+[<a name="p173" href="#p173">page 173</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.5.6" href="#7.3.5.6"><b>    7.3.5.6 The ctan functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex ctan(double complex z);
+           float complex ctanf(float complex z);
+           long double complex ctanl(long double complex z);
+<b>    Description</b>
+2   The ctan functions compute the complex tangent of z.
+<b>    Returns</b>
+3   The ctan functions return the complex tangent value.
+<a name="7.3.6" href="#7.3.6"><b>    7.3.6 Hyperbolic functions</b></a>
+<a name="7.3.6.1" href="#7.3.6.1"><b>    7.3.6.1 The cacosh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex cacosh(double complex z);
+           float complex cacoshf(float complex z);
+           long double complex cacoshl(long double complex z);
+<b>    Description</b>
+2   The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
+    cut at values less than 1 along the real axis.
+<b>    Returns</b>
+3   The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
+    half-strip of non-negative values along the real axis and in the interval [-ipi , +ipi ] along
+    the imaginary axis.
+<a name="7.3.6.2" href="#7.3.6.2"><b>    7.3.6.2 The casinh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex casinh(double complex z);
+           float complex casinhf(float complex z);
+           long double complex casinhl(long double complex z);
+<b>    Description</b>
+2   The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
+    outside the interval [-i, +i] along the imaginary axis.
+
+[<a name="p174" href="#p174">page 174</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The casinh functions return the complex arc hyperbolic sine value, in the range of a
+    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+    along the imaginary axis.
+<a name="7.3.6.3" href="#7.3.6.3"><b>    7.3.6.3 The catanh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex catanh(double complex z);
+           float complex catanhf(float complex z);
+           long double complex catanhl(long double complex z);
+<b>    Description</b>
+2   The catanh functions compute the complex arc hyperbolic tangent of z, with branch
+    cuts outside the interval [-1, +1] along the real axis.
+<b>    Returns</b>
+3   The catanh functions return the complex arc hyperbolic tangent value, in the range of a
+    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+    along the imaginary axis.
+<a name="7.3.6.4" href="#7.3.6.4"><b>    7.3.6.4 The ccosh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex ccosh(double complex z);
+           float complex ccoshf(float complex z);
+           long double complex ccoshl(long double complex z);
+<b>    Description</b>
+2   The ccosh functions compute the complex hyperbolic cosine of z.
+<b>    Returns</b>
+3   The ccosh functions return the complex hyperbolic cosine value.
+<a name="7.3.6.5" href="#7.3.6.5"><b>    7.3.6.5 The csinh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex csinh(double complex z);
+           float complex csinhf(float complex z);
+           long double complex csinhl(long double complex z);
+
+[<a name="p175" href="#p175">page 175</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The csinh functions compute the complex hyperbolic sine of z.
+<b>    Returns</b>
+3   The csinh functions return the complex hyperbolic sine value.
+<a name="7.3.6.6" href="#7.3.6.6"><b>    7.3.6.6 The ctanh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex ctanh(double complex z);
+           float complex ctanhf(float complex z);
+           long double complex ctanhl(long double complex z);
+<b>    Description</b>
+2   The ctanh functions compute the complex hyperbolic tangent of z.
+<b>    Returns</b>
+3   The ctanh functions return the complex hyperbolic tangent value.
+<a name="7.3.7" href="#7.3.7"><b>    7.3.7 Exponential and logarithmic functions</b></a>
+<a name="7.3.7.1" href="#7.3.7.1"><b>    7.3.7.1 The cexp functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex cexp(double complex z);
+           float complex cexpf(float complex z);
+           long double complex cexpl(long double complex z);
+<b>    Description</b>
+2   The cexp functions compute the complex base-e exponential of z.
+<b>    Returns</b>
+3   The cexp functions return the complex base-e exponential value.
+<a name="7.3.7.2" href="#7.3.7.2"><b>    7.3.7.2 The clog functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex clog(double complex z);
+           float complex clogf(float complex z);
+           long double complex clogl(long double complex z);
+
+[<a name="p176" href="#p176">page 176</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The clog functions compute the complex natural (base-e) logarithm of z, with a branch
+    cut along the negative real axis.
+<b>    Returns</b>
+3   The clog functions return the complex natural logarithm value, in the range of a strip
+    mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
+    imaginary axis.
+<a name="7.3.8" href="#7.3.8"><b>    7.3.8 Power and absolute-value functions</b></a>
+<a name="7.3.8.1" href="#7.3.8.1"><b>    7.3.8.1 The cabs functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double cabs(double complex z);
+           float cabsf(float complex z);
+           long double cabsl(long double complex z);
+<b>    Description</b>
+2   The cabs functions compute the complex absolute value (also called norm, modulus, or
+    magnitude) of z.
+<b>    Returns</b>
+3   The cabs functions return the complex absolute value.
+<a name="7.3.8.2" href="#7.3.8.2"><b>    7.3.8.2 The cpow functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex cpow(double complex x, double complex y);
+           float complex cpowf(float complex x, float complex y);
+           long double complex cpowl(long double complex x,
+                long double complex y);
+<b>    Description</b>
+2   The cpow functions compute the complex power function xy , with a branch cut for the
+    first parameter along the negative real axis.
+<b>    Returns</b>
+3   The cpow functions return the complex power function value.
+
+[<a name="p177" href="#p177">page 177</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.8.3" href="#7.3.8.3"><b>    7.3.8.3 The csqrt functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex csqrt(double complex z);
+           float complex csqrtf(float complex z);
+           long double complex csqrtl(long double complex z);
+<b>    Description</b>
+2   The csqrt functions compute the complex square root of z, with a branch cut along the
+    negative real axis.
+<b>    Returns</b>
+3   The csqrt functions return the complex square root value, in the range of the right half-
+    plane (including the imaginary axis).
+<a name="7.3.9" href="#7.3.9"><b>    7.3.9 Manipulation functions</b></a>
+<a name="7.3.9.1" href="#7.3.9.1"><b>    7.3.9.1 The carg functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double carg(double complex z);
+           float cargf(float complex z);
+           long double cargl(long double complex z);
+<b>    Description</b>
+2   The carg functions compute the argument (also called phase angle) of z, with a branch
+    cut along the negative real axis.
+<b>    Returns</b>
+3   The carg functions return the value of the argument in the interval [-pi , +pi ].
+<a name="7.3.9.2" href="#7.3.9.2"><b>    7.3.9.2 The cimag functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double cimag(double complex z);
+           float cimagf(float complex z);
+           long double cimagl(long double complex z);
+
+[<a name="p178" href="#p178">page 178</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The cimag functions compute the imaginary part of z.<sup><a href="#note170"><b>170)</b></a></sup>
+<b>    Returns</b>
+3   The cimag functions return the imaginary part value (as a real).
+<a name="7.3.9.3" href="#7.3.9.3"><b>    7.3.9.3 The conj functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex conj(double complex z);
+           float complex conjf(float complex z);
+           long double complex conjl(long double complex z);
+<b>    Description</b>
+2   The conj functions compute the complex conjugate of z, by reversing the sign of its
+    imaginary part.
+<b>    Returns</b>
+3   The conj functions return the complex conjugate value.
+<a name="7.3.9.4" href="#7.3.9.4"><b>    7.3.9.4 The cproj functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex cproj(double complex z);
+           float complex cprojf(float complex z);
+           long double complex cprojl(long double complex z);
+<b>    Description</b>
+2   The cproj functions compute a projection of z onto the Riemann sphere: z projects to
+    z except that all complex infinities (even those with one infinite part and one NaN part)
+    project to positive infinity on the real axis. If z has an infinite part, then cproj(z) is
+    equivalent to
+           INFINITY + I * copysign(0.0, cimag(z))
+<b>    Returns</b>
+3   The cproj functions return the value of the projection onto the Riemann sphere.
+
+
+
+
+    <sup><a name="note170" href="#note170"><b>170)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+[<a name="p179" href="#p179">page 179</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.9.5" href="#7.3.9.5"><b>    7.3.9.5 The creal functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double creal(double complex z);
+           float crealf(float complex z);
+           long double creall(long double complex z);
+<b>    Description</b>
+2   The creal functions compute the real part of z.<sup><a href="#note171"><b>171)</b></a></sup>
+<b>    Returns</b>
+3   The creal functions return the real part value.
+
+
+
+
+    <sup><a name="note171" href="#note171"><b>171)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+[<a name="p180" href="#p180">page 180</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.4" href="#7.4"><b>    7.4 Character handling &lt;ctype.h&gt;</b></a>
+1   The header <a href="#7.4">&lt;ctype.h&gt;</a> declares several functions useful for classifying and mapping
+    characters.<sup><a href="#note172"><b>172)</b></a></sup> In all cases the argument is an int, the value of which shall be
+    representable as an unsigned char or shall equal the value of the macro EOF. If the
+    argument has any other value, the behavior is undefined.
+2   The behavior of these functions is affected by the current locale. Those functions that
+    have locale-specific aspects only when not in the "C" locale are noted below.
+3   The term printing character refers to a member of a locale-specific set of characters, each
+    of which occupies one printing position on a display device; the term control character
+    refers to a member of a locale-specific set of characters that are not printing
+    characters.<sup><a href="#note173"><b>173)</b></a></sup> All letters and digits are printing characters.
+    Forward references: EOF (<a href="#7.19.1">7.19.1</a>), localization (<a href="#7.11">7.11</a>).
+<a name="7.4.1" href="#7.4.1"><b>    7.4.1 Character classification functions</b></a>
+1   The functions in this subclause return nonzero (true) if and only if the value of the
+    argument c conforms to that in the description of the function.
+<a name="7.4.1.1" href="#7.4.1.1"><b>    7.4.1.1 The isalnum function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
+             int isalnum(int c);
+<b>    Description</b>
+2   The isalnum function tests for any character for which isalpha or isdigit is true.
+<a name="7.4.1.2" href="#7.4.1.2"><b>    7.4.1.2 The isalpha function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
+             int isalpha(int c);
+<b>    Description</b>
+2   The isalpha function tests for any character for which isupper or islower is true,
+    or any character that is one of a locale-specific set of alphabetic characters for which
+
+
+
+    <sup><a name="note172" href="#note172"><b>172)</b></a></sup> See ''future library directions'' (<a href="#7.26.2">7.26.2</a>).
+    <sup><a name="note173" href="#note173"><b>173)</b></a></sup> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
+         whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
+         values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
+
+[<a name="p181" href="#p181">page 181</a>] (<a href="#Contents">Contents</a>)
+
+    none of iscntrl, isdigit, ispunct, or isspace is true.<sup><a href="#note174"><b>174)</b></a></sup> In the "C" locale,
+    isalpha returns true only for the characters for which isupper or islower is true.
+<a name="7.4.1.3" href="#7.4.1.3"><b>    7.4.1.3 The isblank function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isblank(int c);
+<b>    Description</b>
+2   The isblank function tests for any character that is a standard blank character or is one
+    of a locale-specific set of characters for which isspace is true and that is used to
+    separate words within a line of text. The standard blank characters are the following:
+    space (' '), and horizontal tab ('\t'). In the "C" locale, isblank returns true only
+    for the standard blank characters.
+<a name="7.4.1.4" href="#7.4.1.4"><b>    7.4.1.4 The iscntrl function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int iscntrl(int c);
+<b>    Description</b>
+2   The iscntrl function tests for any control character.
+<a name="7.4.1.5" href="#7.4.1.5"><b>    7.4.1.5 The isdigit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isdigit(int c);
+<b>    Description</b>
+2   The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.4.1.6" href="#7.4.1.6"><b>    7.4.1.6 The isgraph function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isgraph(int c);
+
+
+
+
+    <sup><a name="note174" href="#note174"><b>174)</b></a></sup> The functions islower and isupper test true or false separately for each of these additional
+         characters; all four combinations are possible.
+
+[<a name="p182" href="#p182">page 182</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The isgraph function tests for any printing character except space (' ').
+<a name="7.4.1.7" href="#7.4.1.7"><b>    7.4.1.7 The islower function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int islower(int c);
+<b>    Description</b>
+2   The islower function tests for any character that is a lowercase letter or is one of a
+    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+    isspace is true. In the "C" locale, islower returns true only for the lowercase
+    letters (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.4.1.8" href="#7.4.1.8"><b>    7.4.1.8 The isprint function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int isprint(int c);
+<b>    Description</b>
+2   The isprint function tests for any printing character including space (' ').
+<a name="7.4.1.9" href="#7.4.1.9"><b>    7.4.1.9 The ispunct function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int ispunct(int c);
+<b>    Description</b>
+2   The ispunct function tests for any printing character that is one of a locale-specific set
+    of punctuation characters for which neither isspace nor isalnum is true. In the "C"
+    locale, ispunct returns true for every printing character for which neither isspace
+    nor isalnum is true.
+<a name="7.4.1.10" href="#7.4.1.10"><b>    7.4.1.10 The isspace function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int isspace(int c);
+<b>    Description</b>
+2   The isspace function tests for any character that is a standard white-space character or
+    is one of a locale-specific set of characters for which isalnum is false. The standard
+
+[<a name="p183" href="#p183">page 183</a>] (<a href="#Contents">Contents</a>)
+
+    white-space characters are the following: space (' '), form feed ('\f'), new-line
+    ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). In the
+    "C" locale, isspace returns true only for the standard white-space characters.
+<a name="7.4.1.11" href="#7.4.1.11"><b>    7.4.1.11 The isupper function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int isupper(int c);
+<b>    Description</b>
+2   The isupper function tests for any character that is an uppercase letter or is one of a
+    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+    isspace is true. In the "C" locale, isupper returns true only for the uppercase
+    letters (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.4.1.12" href="#7.4.1.12"><b>    7.4.1.12 The isxdigit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int isxdigit(int c);
+<b>    Description</b>
+2   The isxdigit function tests for any hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+<a name="7.4.2" href="#7.4.2"><b>    7.4.2 Character case mapping functions</b></a>
+<a name="7.4.2.1" href="#7.4.2.1"><b>    7.4.2.1 The tolower function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int tolower(int c);
+<b>    Description</b>
+2   The tolower function converts an uppercase letter to a corresponding lowercase letter.
+<b>    Returns</b>
+3   If the argument is a character for which isupper is true and there are one or more
+    corresponding characters, as specified by the current locale, for which islower is true,
+    the tolower function returns one of the corresponding characters (always the same one
+    for any given locale); otherwise, the argument is returned unchanged.
+
+[<a name="p184" href="#p184">page 184</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.4.2.2" href="#7.4.2.2"><b>    7.4.2.2 The toupper function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int toupper(int c);
+<b>    Description</b>
+2   The toupper function converts a lowercase letter to a corresponding uppercase letter.
+<b>    Returns</b>
+3   If the argument is a character for which islower is true and there are one or more
+    corresponding characters, as specified by the current locale, for which isupper is true,
+    the toupper function returns one of the corresponding characters (always the same one
+    for any given locale); otherwise, the argument is returned unchanged.
+
+[<a name="p185" href="#p185">page 185</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.5" href="#7.5"><b>    7.5 Errors &lt;errno.h&gt;</b></a>
+1   The header <a href="#7.5">&lt;errno.h&gt;</a> defines several macros, all relating to the reporting of error
+    conditions.
+2   The macros are
+             EDOM
+             EILSEQ
+             ERANGE
+    which expand to integer constant expressions with type int, distinct positive values, and
+    which are suitable for use in #if preprocessing directives; and
+             errno
+    which expands to a modifiable lvalue<sup><a href="#note175"><b>175)</b></a></sup> that has type int, the value of which is set to a
+    positive error number by several library functions. It is unspecified whether errno is a
+    macro or an identifier declared with external linkage. If a macro definition is suppressed
+    in order to access an actual object, or a program defines an identifier with the name
+    errno, the behavior is undefined.
+3   The value of errno is zero at program startup, but is never set to zero by any library
+    function.<sup><a href="#note176"><b>176)</b></a></sup> The value of errno may be set to nonzero by a library function call
+    whether or not there is an error, provided the use of errno is not documented in the
+    description of the function in this International Standard.
+4   Additional macro definitions, beginning with E and a digit or E and an uppercase
+    letter,<sup><a href="#note177"><b>177)</b></a></sup> may also be specified by the implementation.
+
+
+
+
+    <sup><a name="note175" href="#note175"><b>175)</b></a></sup> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
+         resulting from a function call (for example, *errno()).
+    <sup><a name="note176" href="#note176"><b>176)</b></a></sup> Thus, a program that uses errno for error checking should set it to zero before a library function call,
+         then inspect it before a subsequent library function call. Of course, a library function can save the
+         value of errno on entry and then set it to zero, as long as the original value is restored if errno's
+         value is still zero just before the return.
+    <sup><a name="note177" href="#note177"><b>177)</b></a></sup> See ''future library directions'' (<a href="#7.26.3">7.26.3</a>).
+
+[<a name="p186" href="#p186">page 186</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.6" href="#7.6"><b>    7.6 Floating-point environment &lt;fenv.h&gt;</b></a>
+1   The header <a href="#7.6">&lt;fenv.h&gt;</a> declares two types and several macros and functions to provide
+    access to the floating-point environment. The floating-point environment refers
+    collectively to any floating-point status flags and control modes supported by the
+    implementation.<sup><a href="#note178"><b>178)</b></a></sup> A floating-point status flag is a system variable whose value is set
+    (but never cleared) when a floating-point exception is raised, which occurs as a side effect
+    of exceptional floating-point arithmetic to provide auxiliary information.<sup><a href="#note179"><b>179)</b></a></sup> A floating-
+    point control mode is a system variable whose value may be set by the user to affect the
+    subsequent behavior of floating-point arithmetic.
+2   Certain programming conventions support the intended model of use for the floating-
+    point environment:<sup><a href="#note180"><b>180)</b></a></sup>
+    -- a function call does not alter its caller's floating-point control modes, clear its caller's
+      floating-point status flags, nor depend on the state of its caller's floating-point status
+      flags unless the function is so documented;
+    -- a function call is assumed to require default floating-point control modes, unless its
+      documentation promises otherwise;
+    -- a function call is assumed to have the potential for raising floating-point exceptions,
+      unless its documentation promises otherwise.
+3   The type
+            fenv_t
+    represents the entire floating-point environment.
+4   The type
+            fexcept_t
+    represents the floating-point status flags collectively, including any status the
+    implementation associates with the flags.
+
+
+
+
+    <sup><a name="note178" href="#note178"><b>178)</b></a></sup> This header is designed to support the floating-point exception status flags and directed-rounding
+         control modes required by IEC 60559, and other similar floating-point state information. Also it is
+         designed to facilitate code portability among all systems.
+    <sup><a name="note179" href="#note179"><b>179)</b></a></sup> A floating-point status flag is not an object and can be set more than once within an expression.
+    <sup><a name="note180" href="#note180"><b>180)</b></a></sup> With these conventions, a programmer can safely assume default floating-point control modes (or be
+         unaware of them). The responsibilities associated with accessing the floating-point environment fall
+         on the programmer or program that does so explicitly.
+
+[<a name="p187" href="#p187">page 187</a>] (<a href="#Contents">Contents</a>)
+
+5   Each of the macros
+            FE_DIVBYZERO
+            FE_INEXACT
+            FE_INVALID
+            FE_OVERFLOW
+            FE_UNDERFLOW
+    is defined if and only if the implementation supports the floating-point exception by
+    means of the functions in 7.6.2.<sup><a href="#note181"><b>181)</b></a></sup> Additional implementation-defined floating-point
+    exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
+    be specified by the implementation. The defined macros expand to integer constant
+    expressions with values such that bitwise ORs of all combinations of the macros result in
+    distinct values, and furthermore, bitwise ANDs of all combinations of the macros result in
+    zero.<sup><a href="#note182"><b>182)</b></a></sup>
+6   The macro
+            FE_ALL_EXCEPT
+    is simply the bitwise OR of all floating-point exception macros defined by the
+    implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
+7   Each of the macros
+            FE_DOWNWARD
+            FE_TONEAREST
+            FE_TOWARDZERO
+            FE_UPWARD
+    is defined if and only if the implementation supports getting and setting the represented
+    rounding direction by means of the fegetround and fesetround functions.
+    Additional implementation-defined rounding directions, with macro definitions beginning
+    with FE_ and an uppercase letter, may also be specified by the implementation. The
+    defined macros expand to integer constant expressions whose values are distinct
+    nonnegative values.<sup><a href="#note183"><b>183)</b></a></sup>
+8   The macro
+
+
+
+    <sup><a name="note181" href="#note181"><b>181)</b></a></sup> The implementation supports an exception if there are circumstances where a call to at least one of the
+         functions in <a href="#7.6.2">7.6.2</a>, using the macro as the appropriate argument, will succeed. It is not necessary for
+         all the functions to succeed all the time.
+    <sup><a name="note182" href="#note182"><b>182)</b></a></sup> The macros should be distinct powers of two.
+    <sup><a name="note183" href="#note183"><b>183)</b></a></sup> Even though the rounding direction macros may expand to constants corresponding to the values of
+         FLT_ROUNDS, they are not required to do so.
+
+[<a name="p188" href="#p188">page 188</a>] (<a href="#Contents">Contents</a>)
+
+             FE_DFL_ENV
+    represents the default floating-point environment -- the one installed at program startup
+    -- and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
+    <a href="#7.6">&lt;fenv.h&gt;</a> functions that manage the floating-point environment.
+9   Additional implementation-defined environments, with macro definitions beginning with
+    FE_ and an uppercase letter, and having type ''pointer to const-qualified fenv_t'', may
+    also be specified by the implementation.
+<a name="7.6.1" href="#7.6.1"><b>    7.6.1 The FENV_ACCESS pragma</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             #pragma STDC FENV_ACCESS on-off-switch
+<b>    Description</b>
+2   The FENV_ACCESS pragma provides a means to inform the implementation when a
+    program might access the floating-point environment to test floating-point status flags or
+    run under non-default floating-point control modes.<sup><a href="#note184"><b>184)</b></a></sup> The pragma shall occur either
+    outside external declarations or preceding all explicit declarations and statements inside a
+    compound statement. When outside external declarations, the pragma takes effect from
+    its occurrence until another FENV_ACCESS pragma is encountered, or until the end of
+    the translation unit. When inside a compound statement, the pragma takes effect from its
+    occurrence until another FENV_ACCESS pragma is encountered (including within a
+    nested compound statement), or until the end of the compound statement; at the end of a
+    compound statement the state for the pragma is restored to its condition just before the
+    compound statement. If this pragma is used in any other context, the behavior is
+    undefined. If part of a program tests floating-point status flags, sets floating-point control
+    modes, or runs under non-default mode settings, but was translated with the state for the
+    FENV_ACCESS pragma ''off'', the behavior is undefined. The default state (''on'' or
+    ''off'') for the pragma is implementation-defined. (When execution passes from a part of
+    the program translated with FENV_ACCESS ''off'' to a part translated with
+    FENV_ACCESS ''on'', the state of the floating-point status flags is unspecified and the
+    floating-point control modes have their default settings.)
+
+
+
+
+    <sup><a name="note184" href="#note184"><b>184)</b></a></sup> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
+         tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
+         folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
+         modes are in effect and the flags are not tested.
+
+[<a name="p189" href="#p189">page 189</a>] (<a href="#Contents">Contents</a>)
+
+3   EXAMPLE
+            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            void f(double x)
+            {
+                  #pragma STDC FENV_ACCESS ON
+                  void g(double);
+                  void h(double);
+                  /* ... */
+                  g(x + 1);
+                  h(x + 1);
+                  /* ... */
+            }
+4   If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
+    x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
+    contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note185"><b>185)</b></a></sup>
+
+<a name="7.6.2" href="#7.6.2"><b>    7.6.2 Floating-point exceptions</b></a>
+1   The following functions provide access to the floating-point status flags.<sup><a href="#note186"><b>186)</b></a></sup> The int
+    input argument for the functions represents a subset of floating-point exceptions, and can
+    be zero or the bitwise OR of one or more floating-point exception macros, for example
+    FE_OVERFLOW | FE_INEXACT. For other argument values the behavior of these
+    functions is undefined.
+<a name="7.6.2.1" href="#7.6.2.1"><b>    7.6.2.1 The feclearexcept function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int feclearexcept(int excepts);
+<b>    Description</b>
+2   The feclearexcept function attempts to clear the supported floating-point exceptions
+    represented by its argument.
+<b>    Returns</b>
+3   The feclearexcept function returns zero if the excepts argument is zero or if all
+    the specified exceptions were successfully cleared. Otherwise, it returns a nonzero value.
+
+
+    <sup><a name="note185" href="#note185"><b>185)</b></a></sup> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
+         hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
+         ''off'', just one evaluation of x + 1 would suffice.
+    <sup><a name="note186" href="#note186"><b>186)</b></a></sup> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
+         abstraction of flags that are either set or clear. An implementation may endow floating-point status
+         flags with more information -- for example, the address of the code which first raised the floating-
+         point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
+         content of flags.
+
+[<a name="p190" href="#p190">page 190</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.6.2.2" href="#7.6.2.2"><b>    7.6.2.2 The fegetexceptflag function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             int fegetexceptflag(fexcept_t *flagp,
+                  int excepts);
+<b>    Description</b>
+2   The fegetexceptflag function attempts to store an implementation-defined
+    representation of the states of the floating-point status flags indicated by the argument
+    excepts in the object pointed to by the argument flagp.
+<b>    Returns</b>
+3   The fegetexceptflag function returns zero if the representation was successfully
+    stored. Otherwise, it returns a nonzero value.
+<a name="7.6.2.3" href="#7.6.2.3"><b>    7.6.2.3 The feraiseexcept function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             int feraiseexcept(int excepts);
+<b>    Description</b>
+2   The feraiseexcept function attempts to raise the supported floating-point exceptions
+    represented by its argument.<sup><a href="#note187"><b>187)</b></a></sup> The order in which these floating-point exceptions are
+    raised is unspecified, except as stated in <a href="#F.7.6">F.7.6</a>. Whether the feraiseexcept function
+    additionally raises the ''inexact'' floating-point exception whenever it raises the
+    ''overflow'' or ''underflow'' floating-point exception is implementation-defined.
+<b>    Returns</b>
+3   The feraiseexcept function returns zero if the excepts argument is zero or if all
+    the specified exceptions were successfully raised. Otherwise, it returns a nonzero value.
+
+
+
+
+    <sup><a name="note187" href="#note187"><b>187)</b></a></sup> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
+         Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
+         in <a href="#F.7.6">F.7.6</a> is in the same spirit.
+
+[<a name="p191" href="#p191">page 191</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.6.2.4" href="#7.6.2.4"><b>    7.6.2.4 The fesetexceptflag function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fesetexceptflag(const fexcept_t *flagp,
+                 int excepts);
+<b>    Description</b>
+2   The fesetexceptflag function attempts to set the floating-point status flags
+    indicated by the argument excepts to the states stored in the object pointed to by
+    flagp. The value of *flagp shall have been set by a previous call to
+    fegetexceptflag whose second argument represented at least those floating-point
+    exceptions represented by the argument excepts. This function does not raise floating-
+    point exceptions, but only sets the state of the flags.
+<b>    Returns</b>
+3   The fesetexceptflag function returns zero if the excepts argument is zero or if
+    all the specified flags were successfully set to the appropriate state. Otherwise, it returns
+    a nonzero value.
+<a name="7.6.2.5" href="#7.6.2.5"><b>    7.6.2.5 The fetestexcept function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fetestexcept(int excepts);
+<b>    Description</b>
+2   The fetestexcept function determines which of a specified subset of the floating-
+    point exception flags are currently set. The excepts argument specifies the floating-
+    point status flags to be queried.<sup><a href="#note188"><b>188)</b></a></sup>
+<b>    Returns</b>
+3   The fetestexcept function returns the value of the bitwise OR of the floating-point
+    exception macros corresponding to the currently set floating-point exceptions included in
+    excepts.
+4   EXAMPLE       Call f if ''invalid'' is set, then g if ''overflow'' is set:
+
+
+
+
+    <sup><a name="note188" href="#note188"><b>188)</b></a></sup> This mechanism allows testing several floating-point exceptions with just one function call.
+
+[<a name="p192" href="#p192">page 192</a>] (<a href="#Contents">Contents</a>)
+
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           /* ... */
+           {
+                   #pragma STDC FENV_ACCESS ON
+                   int set_excepts;
+                   feclearexcept(FE_INVALID | FE_OVERFLOW);
+                   // maybe raise exceptions
+                   set_excepts = fetestexcept(FE_INVALID | FE_OVERFLOW);
+                   if (set_excepts &amp; FE_INVALID) f();
+                   if (set_excepts &amp; FE_OVERFLOW) g();
+                   /* ... */
+           }
+
+<a name="7.6.3" href="#7.6.3"><b>    7.6.3 Rounding</b></a>
+1   The fegetround and fesetround functions provide control of rounding direction
+    modes.
+<a name="7.6.3.1" href="#7.6.3.1"><b>    7.6.3.1 The fegetround function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           int fegetround(void);
+<b>    Description</b>
+2   The fegetround function gets the current rounding direction.
+<b>    Returns</b>
+3   The fegetround function returns the value of the rounding direction macro
+    representing the current rounding direction or a negative value if there is no such
+    rounding direction macro or the current rounding direction is not determinable.
+<a name="7.6.3.2" href="#7.6.3.2"><b>    7.6.3.2 The fesetround function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           int fesetround(int round);
+<b>    Description</b>
+2   The fesetround function establishes the rounding direction represented by its
+    argument round. If the argument is not equal to the value of a rounding direction macro,
+    the rounding direction is not changed.
+<b>    Returns</b>
+3   The fesetround function returns zero if and only if the requested rounding direction
+    was established.
+
+[<a name="p193" href="#p193">page 193</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
+    rounding direction fails.
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           #include <a href="#7.2">&lt;assert.h&gt;</a>
+           void f(int round_dir)
+           {
+                 #pragma STDC FENV_ACCESS ON
+                 int save_round;
+                 int setround_ok;
+                 save_round = fegetround();
+                 setround_ok = fesetround(round_dir);
+                 assert(setround_ok == 0);
+                 /* ... */
+                 fesetround(save_round);
+                 /* ... */
+           }
+
+<a name="7.6.4" href="#7.6.4"><b>    7.6.4 Environment</b></a>
+1   The functions in this section manage the floating-point environment -- status flags and
+    control modes -- as one entity.
+<a name="7.6.4.1" href="#7.6.4.1"><b>    7.6.4.1 The fegetenv function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           int fegetenv(fenv_t *envp);
+<b>    Description</b>
+2   The fegetenv function attempts to store the current floating-point environment in the
+    object pointed to by envp.
+<b>    Returns</b>
+3   The fegetenv function returns zero if the environment was successfully stored.
+    Otherwise, it returns a nonzero value.
+<a name="7.6.4.2" href="#7.6.4.2"><b>    7.6.4.2 The feholdexcept function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           int feholdexcept(fenv_t *envp);
+<b>    Description</b>
+2   The feholdexcept function saves the current floating-point environment in the object
+    pointed to by envp, clears the floating-point status flags, and then installs a non-stop
+    (continue on floating-point exceptions) mode, if available, for all floating-point
+    exceptions.<sup><a href="#note189"><b>189)</b></a></sup>
+
+[<a name="p194" href="#p194">page 194</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The feholdexcept function returns zero if and only if non-stop floating-point
+    exception handling was successfully installed.
+<a name="7.6.4.3" href="#7.6.4.3"><b>    7.6.4.3 The fesetenv function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fesetenv(const fenv_t *envp);
+<b>    Description</b>
+2   The fesetenv function attempts to establish the floating-point environment represented
+    by the object pointed to by envp. The argument envp shall point to an object set by a
+    call to fegetenv or feholdexcept, or equal a floating-point environment macro.
+    Note that fesetenv merely installs the state of the floating-point status flags
+    represented through its argument, and does not raise these floating-point exceptions.
+<b>    Returns</b>
+3   The fesetenv function returns zero if the environment was successfully established.
+    Otherwise, it returns a nonzero value.
+<a name="7.6.4.4" href="#7.6.4.4"><b>    7.6.4.4 The feupdateenv function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int feupdateenv(const fenv_t *envp);
+<b>    Description</b>
+2   The feupdateenv function attempts to save the currently raised floating-point
+    exceptions in its automatic storage, install the floating-point environment represented by
+    the object pointed to by envp, and then raise the saved floating-point exceptions. The
+    argument envp shall point to an object set by a call to feholdexcept or fegetenv,
+    or equal a floating-point environment macro.
+<b>    Returns</b>
+3   The feupdateenv function returns zero if all the actions were successfully carried out.
+    Otherwise, it returns a nonzero value.
+
+
+
+
+    <sup><a name="note189" href="#note189"><b>189)</b></a></sup> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
+         handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
+         such systems, the feholdexcept function can be used in conjunction with the feupdateenv
+         function to write routines that hide spurious floating-point exceptions from their callers.
+
+[<a name="p195" href="#p195">page 195</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE   Hide spurious underflow floating-point exceptions:
+          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+          double f(double x)
+          {
+                #pragma STDC FENV_ACCESS ON
+                double result;
+                fenv_t save_env;
+                if (feholdexcept(&amp;save_env))
+                      return /* indication of an environmental problem */;
+                // compute result
+                if (/* test spurious underflow */)
+                      if (feclearexcept(FE_UNDERFLOW))
+                               return /* indication of an environmental problem */;
+                if (feupdateenv(&amp;save_env))
+                      return /* indication of an environmental problem */;
+                return result;
+          }
+
+[<a name="p196" href="#p196">page 196</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.7" href="#7.7"><b>    7.7 Characteristics of floating types &lt;float.h&gt;</b></a>
+1   The header <a href="#7.7">&lt;float.h&gt;</a> defines several macros that expand to various limits and
+    parameters of the standard floating-point types.
+2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
+    in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+
+[<a name="p197" href="#p197">page 197</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.8" href="#7.8"><b>    7.8 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
+1   The header <a href="#7.8">&lt;inttypes.h&gt;</a> includes the header <a href="#7.18">&lt;stdint.h&gt;</a> and extends it with
+    additional facilities provided by hosted implementations.
+2   It declares functions for manipulating greatest-width integers and converting numeric
+    character strings to greatest-width integers, and it declares the type
+             imaxdiv_t
+    which is a structure type that is the type of the value returned by the imaxdiv function.
+    For each type declared in <a href="#7.18">&lt;stdint.h&gt;</a>, it defines corresponding macros for conversion
+    specifiers for use with the formatted input/output functions.<sup><a href="#note190"><b>190)</b></a></sup>
+    Forward references: integer types <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#7.18">7.18</a>), formatted input/output
+    functions (<a href="#7.19.6">7.19.6</a>), formatted wide character input/output functions (<a href="#7.24.2">7.24.2</a>).
+<a name="7.8.1" href="#7.8.1"><b>    7.8.1 Macros for format specifiers</b></a>
+1   Each of the following object-like macros<sup><a href="#note191"><b>191)</b></a></sup> expands to a character string literal
+    containing a conversion specifier, possibly modified by a length modifier, suitable for use
+    within the format argument of a formatted input/output function when converting the
+    corresponding integer type. These macro names have the general form of PRI (character
+    string literals for the fprintf and fwprintf family) or SCN (character string literals
+    for the fscanf and fwscanf family),<sup><a href="#note192"><b>192)</b></a></sup> followed by the conversion specifier,
+    followed by a name corresponding to a similar type name in <a href="#7.18.1">7.18.1</a>. In these names, N
+    represents the width of the type as described in <a href="#7.18.1">7.18.1</a>. For example, PRIdFAST32 can
+    be used in a format string to print the value of an integer of type int_fast32_t.
+2   The fprintf macros for signed integers are:
+           PRIdN             PRIdLEASTN                PRIdFASTN          PRIdMAX             PRIdPTR
+           PRIiN             PRIiLEASTN                PRIiFASTN          PRIiMAX             PRIiPTR
+
+
+
+
+    <sup><a name="note190" href="#note190"><b>190)</b></a></sup> See ''future library directions'' (<a href="#7.26.4">7.26.4</a>).
+    <sup><a name="note191" href="#note191"><b>191)</b></a></sup> C++ implementations should define these macros only when __STDC_FORMAT_MACROS is defined
+         before <a href="#7.8">&lt;inttypes.h&gt;</a> is included.
+    <sup><a name="note192" href="#note192"><b>192)</b></a></sup> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
+         different format specifiers may be required for fprintf and fscanf, even when the type is the
+         same.
+
+[<a name="p198" href="#p198">page 198</a>] (<a href="#Contents">Contents</a>)
+
+3   The fprintf macros for unsigned integers are:
+           PRIoN           PRIoLEASTN               PRIoFASTN              PRIoMAX             PRIoPTR
+           PRIuN           PRIuLEASTN               PRIuFASTN              PRIuMAX             PRIuPTR
+           PRIxN           PRIxLEASTN               PRIxFASTN              PRIxMAX             PRIxPTR
+           PRIXN           PRIXLEASTN               PRIXFASTN              PRIXMAX             PRIXPTR
+4   The fscanf macros for signed integers are:
+           SCNdN           SCNdLEASTN               SCNdFASTN              SCNdMAX             SCNdPTR
+           SCNiN           SCNiLEASTN               SCNiFASTN              SCNiMAX             SCNiPTR
+5   The fscanf macros for unsigned integers are:
+           SCNoN           SCNoLEASTN               SCNoFASTN              SCNoMAX             SCNoPTR
+           SCNuN           SCNuLEASTN               SCNuFASTN              SCNuMAX             SCNuPTR
+           SCNxN           SCNxLEASTN               SCNxFASTN              SCNxMAX             SCNxPTR
+6   For each type that the implementation provides in <a href="#7.18">&lt;stdint.h&gt;</a>, the corresponding
+    fprintf macros shall be defined and the corresponding fscanf macros shall be
+    defined unless the implementation does not have a suitable fscanf length modifier for
+    the type.
+7   EXAMPLE
+            #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            int main(void)
+            {
+                  uintmax_t i = UINTMAX_MAX;    // this type always exists
+                  wprintf(L"The largest integer value is %020"
+                        PRIxMAX "\n", i);
+                  return 0;
+            }
+
+<a name="7.8.2" href="#7.8.2"><b>    7.8.2 Functions for greatest-width integer types</b></a>
+<a name="7.8.2.1" href="#7.8.2.1"><b>    7.8.2.1 The imaxabs function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+            intmax_t imaxabs(intmax_t j);
+<b>    Description</b>
+2   The imaxabs function computes the absolute value of an integer j. If the result cannot
+    be represented, the behavior is undefined.<sup><a href="#note193"><b>193)</b></a></sup>
+
+
+
+    <sup><a name="note193" href="#note193"><b>193)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
+
+[<a name="p199" href="#p199">page 199</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The imaxabs function returns the absolute value.
+<a name="7.8.2.2" href="#7.8.2.2"><b>    7.8.2.2 The imaxdiv function</b></a>
+<b>    Synopsis</b>
+1              #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+               imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+<b>    Description</b>
+2   The imaxdiv function computes numer / denom and numer % denom in a single
+    operation.
+<b>    Returns</b>
+3   The imaxdiv function returns a structure of type imaxdiv_t comprising both the
+    quotient and the remainder. The structure shall contain (in either order) the members
+    quot (the quotient) and rem (the remainder), each of which has type intmax_t. If
+    either part of the result cannot be represented, the behavior is undefined.
+<a name="7.8.2.3" href="#7.8.2.3"><b>    7.8.2.3 The strtoimax and strtoumax functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+           intmax_t strtoimax(const char * restrict nptr,
+                char ** restrict endptr, int base);
+           uintmax_t strtoumax(const char * restrict nptr,
+                char ** restrict endptr, int base);
+<b>    Description</b>
+2   The strtoimax and strtoumax functions are equivalent to the strtol, strtoll,
+    strtoul, and strtoull functions, except that the initial portion of the string is
+    converted to intmax_t and uintmax_t representation, respectively.
+<b>    Returns</b>
+3   The strtoimax and strtoumax functions return the converted value, if any. If no
+    conversion could be performed, zero is returned. If the correct value is outside the range
+    of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
+    (according to the return type and sign of the value, if any), and the value of the macro
+    ERANGE is stored in errno.
+    Forward references: the strtol, strtoll, strtoul, and strtoull functions
+    (<a href="#7.20.1.4">7.20.1.4</a>).
+
+[<a name="p200" href="#p200">page 200</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.8.2.4" href="#7.8.2.4"><b>    7.8.2.4 The wcstoimax and wcstoumax functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.17">&lt;stddef.h&gt;</a>           // for wchar_t
+           #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+           intmax_t wcstoimax(const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr, int base);
+           uintmax_t wcstoumax(const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr, int base);
+<b>    Description</b>
+2   The wcstoimax and wcstoumax functions are equivalent to the wcstol, wcstoll,
+    wcstoul, and wcstoull functions except that the initial portion of the wide string is
+    converted to intmax_t and uintmax_t representation, respectively.
+<b>    Returns</b>
+3   The wcstoimax function returns the converted value, if any. If no conversion could be
+    performed, zero is returned. If the correct value is outside the range of representable
+    values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
+    return type and sign of the value, if any), and the value of the macro ERANGE is stored in
+    errno.
+    Forward references: the wcstol, wcstoll, wcstoul, and wcstoull functions
+    (<a href="#7.24.4.1.2">7.24.4.1.2</a>).
+
+[<a name="p201" href="#p201">page 201</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.9" href="#7.9"><b>    7.9 Alternative spellings &lt;iso646.h&gt;</b></a>
+1   The header <a href="#7.9">&lt;iso646.h&gt;</a> defines the following eleven macros (on the left) that expand
+    to the corresponding tokens (on the right):
+          and          &amp;&amp;
+          and_eq       &amp;=
+          bitand       &amp;
+          bitor        |
+          compl        ~
+          not          !
+          not_eq       !=
+          or           ||
+          or_eq        |=
+          xor          ^
+          xor_eq       ^=
+
+[<a name="p202" href="#p202">page 202</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.10" href="#7.10"><b>    7.10 Sizes of integer types &lt;limits.h&gt;</b></a>
+1   The header <a href="#7.10">&lt;limits.h&gt;</a> defines several macros that expand to various limits and
+    parameters of the standard integer types.
+2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
+    in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+
+[<a name="p203" href="#p203">page 203</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.11" href="#7.11"><b>    7.11 Localization &lt;locale.h&gt;</b></a>
+1   The header <a href="#7.11">&lt;locale.h&gt;</a> declares two functions, one type, and defines several macros.
+2   The type is
+           struct lconv
+    which contains members related to the formatting of numeric values. The structure shall
+    contain at least the following members, in any order. The semantics of the members and
+    their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
+    the values specified in the comments.
+           char   *decimal_point;                 //   "."
+           char   *thousands_sep;                 //   ""
+           char   *grouping;                      //   ""
+           char   *mon_decimal_point;             //   ""
+           char   *mon_thousands_sep;             //   ""
+           char   *mon_grouping;                  //   ""
+           char   *positive_sign;                 //   ""
+           char   *negative_sign;                 //   ""
+           char   *currency_symbol;               //   ""
+           char   frac_digits;                    //   CHAR_MAX
+           char   p_cs_precedes;                  //   CHAR_MAX
+           char   n_cs_precedes;                  //   CHAR_MAX
+           char   p_sep_by_space;                 //   CHAR_MAX
+           char   n_sep_by_space;                 //   CHAR_MAX
+           char   p_sign_posn;                    //   CHAR_MAX
+           char   n_sign_posn;                    //   CHAR_MAX
+           char   *int_curr_symbol;               //   ""
+           char   int_frac_digits;                //   CHAR_MAX
+           char   int_p_cs_precedes;              //   CHAR_MAX
+           char   int_n_cs_precedes;              //   CHAR_MAX
+           char   int_p_sep_by_space;             //   CHAR_MAX
+           char   int_n_sep_by_space;             //   CHAR_MAX
+           char   int_p_sign_posn;                //   CHAR_MAX
+           char   int_n_sign_posn;                //   CHAR_MAX
+
+[<a name="p204" href="#p204">page 204</a>] (<a href="#Contents">Contents</a>)
+
+3   The macros defined are NULL (described in <a href="#7.17">7.17</a>); and
+             LC_ALL
+             LC_COLLATE
+             LC_CTYPE
+             LC_MONETARY
+             LC_NUMERIC
+             LC_TIME
+    which expand to integer constant expressions with distinct values, suitable for use as the
+    first argument to the setlocale function.<sup><a href="#note194"><b>194)</b></a></sup> Additional macro definitions, beginning
+    with the characters LC_ and an uppercase letter,<sup><a href="#note195"><b>195)</b></a></sup> may also be specified by the
+    implementation.
+<a name="7.11.1" href="#7.11.1"><b>    7.11.1 Locale control</b></a>
+<a name="7.11.1.1" href="#7.11.1.1"><b>    7.11.1.1 The setlocale function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.11">&lt;locale.h&gt;</a>
+             char *setlocale(int category, const char *locale);
+<b>    Description</b>
+2   The setlocale function selects the appropriate portion of the program's locale as
+    specified by the category and locale arguments. The setlocale function may be
+    used to change or query the program's entire current locale or portions thereof. The value
+    LC_ALL for category names the program's entire locale; the other values for
+    category name only a portion of the program's locale. LC_COLLATE affects the
+    behavior of the strcoll and strxfrm functions. LC_CTYPE affects the behavior of
+    the character handling functions<sup><a href="#note196"><b>196)</b></a></sup> and the multibyte and wide character functions.
+    LC_MONETARY affects the monetary formatting information returned by the
+    localeconv function. LC_NUMERIC affects the decimal-point character for the
+    formatted input/output functions and the string conversion functions, as well as the
+    nonmonetary formatting information returned by the localeconv function. LC_TIME
+    affects the behavior of the strftime and wcsftime functions.
+3   A value of "C" for locale specifies the minimal environment for C translation; a value
+    of "" for locale specifies the locale-specific native environment. Other
+    implementation-defined strings may be passed as the second argument to setlocale.
+
+    <sup><a name="note194" href="#note194"><b>194)</b></a></sup> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
+    <sup><a name="note195" href="#note195"><b>195)</b></a></sup> See ''future library directions'' (<a href="#7.26.5">7.26.5</a>).
+    <sup><a name="note196" href="#note196"><b>196)</b></a></sup> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
+         isxdigit.
+
+[<a name="p205" href="#p205">page 205</a>] (<a href="#Contents">Contents</a>)
+
+4   At program startup, the equivalent of
+            setlocale(LC_ALL, "C");
+    is executed.
+5   The implementation shall behave as if no library function calls the setlocale function.
+<b>    Returns</b>
+6   If a pointer to a string is given for locale and the selection can be honored, the
+    setlocale function returns a pointer to the string associated with the specified
+    category for the new locale. If the selection cannot be honored, the setlocale
+    function returns a null pointer and the program's locale is not changed.
+7   A null pointer for locale causes the setlocale function to return a pointer to the
+    string associated with the category for the program's current locale; the program's
+    locale is not changed.<sup><a href="#note197"><b>197)</b></a></sup>
+8   The pointer to string returned by the setlocale function is such that a subsequent call
+    with that string value and its associated category will restore that part of the program's
+    locale. The string pointed to shall not be modified by the program, but may be
+    overwritten by a subsequent call to the setlocale function.
+    Forward references: formatted input/output functions (<a href="#7.19.6">7.19.6</a>), multibyte/wide
+    character conversion functions (<a href="#7.20.7">7.20.7</a>), multibyte/wide string conversion functions
+    (<a href="#7.20.8">7.20.8</a>), numeric conversion functions (<a href="#7.20.1">7.20.1</a>), the strcoll function (<a href="#7.21.4.3">7.21.4.3</a>), the
+    strftime function (<a href="#7.23.3.5">7.23.3.5</a>), the strxfrm function (<a href="#7.21.4.5">7.21.4.5</a>).
+<a name="7.11.2" href="#7.11.2"><b>    7.11.2 Numeric formatting convention inquiry</b></a>
+<a name="7.11.2.1" href="#7.11.2.1"><b>    7.11.2.1 The localeconv function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.11">&lt;locale.h&gt;</a>
+            struct lconv *localeconv(void);
+<b>    Description</b>
+2   The localeconv function sets the components of an object with type struct lconv
+    with values appropriate for the formatting of numeric quantities (monetary and otherwise)
+    according to the rules of the current locale.
+3   The members of the structure with type char * are pointers to strings, any of which
+    (except decimal_point) can point to "", to indicate that the value is not available in
+    the current locale or is of zero length. Apart from grouping and mon_grouping, the
+
+    <sup><a name="note197" href="#note197"><b>197)</b></a></sup> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
+         locale when category has the value LC_ALL.
+
+[<a name="p206" href="#p206">page 206</a>] (<a href="#Contents">Contents</a>)
+
+strings shall start and end in the initial shift state. The members with type char are
+nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not
+available in the current locale. The members include the following:
+char *decimal_point
+          The decimal-point character used to format nonmonetary quantities.
+char *thousands_sep
+          The character used to separate groups of digits before the decimal-point
+          character in formatted nonmonetary quantities.
+char *grouping
+          A string whose elements indicate the size of each group of digits in
+          formatted nonmonetary quantities.
+char *mon_decimal_point
+          The decimal-point used to format monetary quantities.
+char *mon_thousands_sep
+          The separator for groups of digits before the decimal-point in formatted
+          monetary quantities.
+char *mon_grouping
+          A string whose elements indicate the size of each group of digits in
+          formatted monetary quantities.
+char *positive_sign
+          The string used to indicate a nonnegative-valued formatted monetary
+          quantity.
+char *negative_sign
+          The string used to indicate a negative-valued formatted monetary quantity.
+char *currency_symbol
+          The local currency symbol applicable to the current locale.
+char frac_digits
+          The number of fractional digits (those after the decimal-point) to be
+          displayed in a locally formatted monetary quantity.
+char p_cs_precedes
+          Set to 1 or 0 if the currency_symbol respectively precedes or
+          succeeds the value for a nonnegative locally formatted monetary quantity.
+char n_cs_precedes
+          Set to 1 or 0 if the currency_symbol respectively precedes or
+          succeeds the value for a negative locally formatted monetary quantity.
+
+[<a name="p207" href="#p207">page 207</a>] (<a href="#Contents">Contents</a>)
+
+char p_sep_by_space
+          Set to a value indicating the separation of the currency_symbol, the
+          sign string, and the value for a nonnegative locally formatted monetary
+          quantity.
+char n_sep_by_space
+          Set to a value indicating the separation of the currency_symbol, the
+          sign string, and the value for a negative locally formatted monetary
+          quantity.
+char p_sign_posn
+          Set to a value indicating the positioning of the positive_sign for a
+          nonnegative locally formatted monetary quantity.
+char n_sign_posn
+          Set to a value indicating the positioning of the negative_sign for a
+          negative locally formatted monetary quantity.
+char *int_curr_symbol
+          The international currency symbol applicable to the current locale. The
+          first three characters contain the alphabetic international currency symbol
+          in accordance with those specified in ISO 4217. The fourth character
+          (immediately preceding the null character) is the character used to separate
+          the international currency symbol from the monetary quantity.
+char int_frac_digits
+          The number of fractional digits (those after the decimal-point) to be
+          displayed in an internationally formatted monetary quantity.
+char int_p_cs_precedes
+          Set to 1 or 0 if the int_curr_symbol respectively precedes or
+          succeeds the value for a nonnegative internationally formatted monetary
+          quantity.
+char int_n_cs_precedes
+          Set to 1 or 0 if the int_curr_symbol respectively precedes or
+          succeeds the value for a negative internationally formatted monetary
+          quantity.
+char int_p_sep_by_space
+          Set to a value indicating the separation of the int_curr_symbol, the
+          sign string, and the value for a nonnegative internationally formatted
+          monetary quantity.
+
+[<a name="p208" href="#p208">page 208</a>] (<a href="#Contents">Contents</a>)
+
+    char int_n_sep_by_space
+              Set to a value indicating the separation of the int_curr_symbol, the
+              sign string, and the value for a negative internationally formatted monetary
+              quantity.
+    char int_p_sign_posn
+              Set to a value indicating the positioning of the positive_sign for a
+              nonnegative internationally formatted monetary quantity.
+    char int_n_sign_posn
+              Set to a value indicating the positioning of the negative_sign for a
+              negative internationally formatted monetary quantity.
+4   The elements of grouping and mon_grouping are interpreted according to the
+    following:
+    CHAR_MAX      No further grouping is to be performed.
+    0             The previous element is to be repeatedly used for the remainder of the
+                  digits.
+    other         The integer value is the number of digits that compose the current group.
+                  The next element is examined to determine the size of the next group of
+                  digits before the current group.
+5   The values of p_sep_by_space, n_sep_by_space, int_p_sep_by_space,
+    and int_n_sep_by_space are interpreted according to the following:
+    0   No space separates the currency symbol and value.
+    1   If the currency symbol and sign string are adjacent, a space separates them from the
+        value; otherwise, a space separates the currency symbol from the value.
+    2   If the currency symbol and sign string are adjacent, a space separates them;
+        otherwise, a space separates the sign string from the value.
+    For int_p_sep_by_space and int_n_sep_by_space, the fourth character of
+    int_curr_symbol is used instead of a space.
+6   The values of p_sign_posn, n_sign_posn, int_p_sign_posn,                            and
+    int_n_sign_posn are interpreted according to the following:
+    0   Parentheses surround the quantity and currency symbol.
+    1   The sign string precedes the quantity and currency symbol.
+    2   The sign string succeeds the quantity and currency symbol.
+    3   The sign string immediately precedes the currency symbol.
+    4   The sign string immediately succeeds the currency symbol.
+
+[<a name="p209" href="#p209">page 209</a>] (<a href="#Contents">Contents</a>)
+
+7    The implementation shall behave as if no library function calls the localeconv
+     function.
+<b>     Returns</b>
+8    The localeconv function returns a pointer to the filled-in object. The structure
+     pointed to by the return value shall not be modified by the program, but may be
+     overwritten by a subsequent call to the localeconv function. In addition, calls to the
+     setlocale function with categories LC_ALL, LC_MONETARY, or LC_NUMERIC may
+     overwrite the contents of the structure.
+9    EXAMPLE 1 The following table illustrates rules which may well be used by four countries to format
+     monetary quantities.
+                                   Local format                                     International format
+
+     Country            Positive                  Negative                    Positive               Negative
+
+     Country1     1.234,56 mk             -1.234,56 mk                  FIM   1.234,56         FIM -1.234,56
+     Country2     L.1.234                 -L.1.234                      ITL   1.234            -ITL 1.234
+     Country3     fl. 1.234,56              fl. -1.234,56                   NLG   1.234,56         NLG -1.234,56
+     Country4     SFrs.1,234.56           SFrs.1,234.56C                CHF   1,234.56         CHF 1,234.56C
+10   For these four countries, the respective values for the monetary members of the structure returned by
+     localeconv could be:
+                                       Country1              Country2              Country3            Country4
+
+     mon_decimal_point                 ","                   ""                   ","                 "."
+     mon_thousands_sep                 "."                   "."                  "."                 ","
+     mon_grouping                      "\3"                  "\3"                 "\3"                "\3"
+     positive_sign                     ""                    ""                   ""                  ""
+     negative_sign                     "-"                   "-"                  "-"                 "C"
+     currency_symbol                   "mk"                  "L."                 "\u0192"            "SFrs."
+     frac_digits                       2                     0                    2                   2
+     p_cs_precedes                     0                     1                    1                   1
+     n_cs_precedes                     0                     1                    1                   1
+     p_sep_by_space                    1                     0                    1                   0
+     n_sep_by_space                    1                     0                    2                   0
+     p_sign_posn                       1                     1                    1                   1
+     n_sign_posn                       1                     1                    4                   2
+     int_curr_symbol                   "FIM "                "ITL "               "NLG "              "CHF "
+     int_frac_digits                   2                     0                    2                   2
+     int_p_cs_precedes                 1                     1                    1                   1
+     int_n_cs_precedes                 1                     1                    1                   1
+     int_p_sep_by_space                1                     1                    1                   1
+     int_n_sep_by_space                2                     1                    2                   1
+     int_p_sign_posn                   1                     1                    1                   1
+     int_n_sign_posn                   4                     1                    4                   2
+
+[<a name="p210" href="#p210">page 210</a>] (<a href="#Contents">Contents</a>)
+
+11   EXAMPLE 2 The following table illustrates how the cs_precedes, sep_by_space, and sign_posn members
+     affect the formatted value.
+                                                                   p_sep_by_space
+
+     p_cs_precedes           p_sign_posn                0                   1                  2
+
+                     0                    0         (<a href="#1.25">1.25</a>$)            (<a href="#1.25">1.25</a> $)            (<a href="#1.25">1.25</a>$)
+                                          1         +1.25$             +1.25 $             + <a href="#1.25">1.25</a>$
+                                          2         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
+                                          3         <a href="#1.25">1.25</a>+$             <a href="#1.25">1.25</a> +$             <a href="#1.25">1.25</a>+ $
+                                          4         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
+
+                     1                    0         ($1.25)            ($ <a href="#1.25">1.25</a>)            ($1.25)
+                                          1         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                          2         $1.25+             $ <a href="#1.25">1.25</a>+             $1.25 +
+                                          3         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                          4         $+1.25             $+ <a href="#1.25">1.25</a>             $ +1.25
+
+[<a name="p211" href="#p211">page 211</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12" href="#7.12"><b>    7.12 Mathematics &lt;math.h&gt;</b></a>
+1   The header <a href="#7.12">&lt;math.h&gt;</a> declares two types and many mathematical functions and defines
+    several macros. Most synopses specify a family of functions consisting of a principal
+    function with one or more double parameters, a double return value, or both; and
+    other functions with the same name but with f and l suffixes, which are corresponding
+    functions with float and long double parameters, return values, or both.<sup><a href="#note198"><b>198)</b></a></sup>
+    Integer arithmetic functions and conversion functions are discussed later.
+2   The types
+            float_t
+            double_t
+    are floating types at least as wide as float and double, respectively, and such that
+    double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
+    float_t and double_t are float and double, respectively; if
+    FLT_EVAL_METHOD equals 1, they are both double; if FLT_EVAL_METHOD equals
+    2, they are both long double; and for other values of FLT_EVAL_METHOD, they are
+    otherwise implementation-defined.<sup><a href="#note199"><b>199)</b></a></sup>
+3   The macro
+            HUGE_VAL
+    expands to a positive double constant expression, not necessarily representable as a
+    float. The macros
+            HUGE_VALF
+            HUGE_VALL
+    are respectively float and long double analogs of HUGE_VAL.<sup><a href="#note200"><b>200)</b></a></sup>
+4   The macro
+            INFINITY
+    expands to a constant expression of type float representing positive or unsigned
+    infinity, if available; else to a positive constant of type float that overflows at
+
+
+
+    <sup><a name="note198" href="#note198"><b>198)</b></a></sup> Particularly on systems with wide expression evaluation, a <a href="#7.12">&lt;math.h&gt;</a> function might pass arguments
+         and return values in wider format than the synopsis prototype indicates.
+    <sup><a name="note199" href="#note199"><b>199)</b></a></sup> The types float_t and double_t are intended to be the implementation's most efficient types at
+         least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
+         type float_t is the narrowest type used by the implementation to evaluate floating expressions.
+    <sup><a name="note200" href="#note200"><b>200)</b></a></sup> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
+         supports infinities.
+
+[<a name="p212" href="#p212">page 212</a>] (<a href="#Contents">Contents</a>)
+
+    translation time.<sup><a href="#note201"><b>201)</b></a></sup>
+5   The macro
+             NAN
+    is defined if and only if the implementation supports quiet NaNs for the float type. It
+    expands to a constant expression of type float representing a quiet NaN.
+6   The number classification macros
+             FP_INFINITE
+             FP_NAN
+             FP_NORMAL
+             FP_SUBNORMAL
+             FP_ZERO
+    represent the mutually exclusive kinds of floating-point values. They expand to integer
+    constant expressions with distinct values. Additional implementation-defined floating-
+    point classifications, with macro definitions beginning with FP_ and an uppercase letter,
+    may also be specified by the implementation.
+7   The macro
+             FP_FAST_FMA
+    is optionally defined. If defined, it indicates that the fma function generally executes
+    about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note202"><b>202)</b></a></sup> The
+    macros
+             FP_FAST_FMAF
+             FP_FAST_FMAL
+    are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
+    these macros expand to the integer constant 1.
+8   The macros
+             FP_ILOGB0
+             FP_ILOGBNAN
+    expand to integer constant expressions whose values are returned by ilogb(x) if x is
+    zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
+    -INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
+
+
+    <sup><a name="note201" href="#note201"><b>201)</b></a></sup> In this case, using INFINITY will violate the constraint in <a href="#6.4.4">6.4.4</a> and thus require a diagnostic.
+    <sup><a name="note202" href="#note202"><b>202)</b></a></sup> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
+         directly with a hardware multiply-add instruction. Software implementations are expected to be
+         substantially slower.
+
+[<a name="p213" href="#p213">page 213</a>] (<a href="#Contents">Contents</a>)
+
+9   The macros
+            MATH_ERRNO
+            MATH_ERREXCEPT
+    expand to the integer constants 1 and 2, respectively; the macro
+            math_errhandling
+    expands to an expression that has type int and the value MATH_ERRNO,
+    MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
+    constant for the duration of the program. It is unspecified whether
+    math_errhandling is a macro or an identifier with external linkage. If a macro
+    definition is suppressed or a program defines an identifier with the name
+    math_errhandling, the behavior is undefined.               If the expression
+    math_errhandling &amp; MATH_ERREXCEPT can be nonzero, the implementation
+    shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
+    <a href="#7.6">&lt;fenv.h&gt;</a>.
+<a name="7.12.1" href="#7.12.1"><b>    7.12.1 Treatment of error conditions</b></a>
+1   The behavior of each of the functions in <a href="#7.12">&lt;math.h&gt;</a> is specified for all representable
+    values of its input arguments, except where stated otherwise. Each function shall execute
+    as if it were a single operation without generating any externally visible exceptional
+    conditions.
+2   For all functions, a domain error occurs if an input argument is outside the domain over
+    which the mathematical function is defined. The description of each function lists any
+    required domain errors; an implementation may define additional domain errors, provided
+    that such errors are consistent with the mathematical definition of the function.<sup><a href="#note203"><b>203)</b></a></sup> On a
+    domain error, the function returns an implementation-defined value; if the integer
+    expression math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression
+    errno acquires the value EDOM; if the integer expression math_errhandling &amp;
+    MATH_ERREXCEPT is nonzero, the ''invalid'' floating-point exception is raised.
+3   Similarly, a range error occurs if the mathematical result of the function cannot be
+    represented in an object of the specified type, due to extreme magnitude.
+4   A floating result overflows if the magnitude of the mathematical result is finite but so
+    large that the mathematical result cannot be represented without extraordinary roundoff
+    error in an object of the specified type. If a floating result overflows and default rounding
+    is in effect, or if the mathematical result is an exact infinity from finite arguments (for
+    example log(0.0)), then the function returns the value of the macro HUGE_VAL,
+
+
+    <sup><a name="note203" href="#note203"><b>203)</b></a></sup> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
+         error if the mathematical domain of the function does not include the infinity.
+
+[<a name="p214" href="#p214">page 214</a>] (<a href="#Contents">Contents</a>)
+
+    HUGE_VALF, or HUGE_VALL according to the return type, with the same sign as the
+    correct value of the function; if the integer expression math_errhandling &amp;
+    MATH_ERRNO is nonzero, the integer expression errno acquires the value ERANGE; if
+    the integer expression math_errhandling &amp; MATH_ERREXCEPT is nonzero, the
+    ''divide-by-zero'' floating-point exception is raised if the mathematical result is an exact
+    infinity and the ''overflow'' floating-point exception is raised otherwise.
+5   The result underflows if the magnitude of the mathematical result is so small that the
+    mathematical result cannot be represented, without extraordinary roundoff error, in an
+    object of the specified type.<sup><a href="#note204"><b>204)</b></a></sup> If the result underflows, the function returns an
+    implementation-defined value whose magnitude is no greater than the smallest
+    normalized positive number in the specified type; if the integer expression
+    math_errhandling &amp; MATH_ERRNO is nonzero, whether errno acquires the
+    value    ERANGE       is    implementation-defined;     if   the  integer   expression
+    math_errhandling &amp; MATH_ERREXCEPT is nonzero, whether the ''underflow''
+    floating-point exception is raised is implementation-defined.
+<a name="7.12.2" href="#7.12.2"><b>    7.12.2 The FP_CONTRACT pragma</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            #pragma STDC FP_CONTRACT on-off-switch
+<b>    Description</b>
+2   The FP_CONTRACT pragma can be used to allow (if the state is ''on'') or disallow (if the
+    state is ''off'') the implementation to contract expressions (<a href="#6.5">6.5</a>). Each pragma can occur
+    either outside external declarations or preceding all explicit declarations and statements
+    inside a compound statement. When outside external declarations, the pragma takes
+    effect from its occurrence until another FP_CONTRACT pragma is encountered, or until
+    the end of the translation unit. When inside a compound statement, the pragma takes
+    effect from its occurrence until another FP_CONTRACT pragma is encountered
+    (including within a nested compound statement), or until the end of the compound
+    statement; at the end of a compound statement the state for the pragma is restored to its
+    condition just before the compound statement. If this pragma is used in any other
+    context, the behavior is undefined. The default state (''on'' or ''off'') for the pragma is
+    implementation-defined.
+
+
+
+
+    <sup><a name="note204" href="#note204"><b>204)</b></a></sup> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
+         also ''flush-to-zero'' underflow.
+
+[<a name="p215" href="#p215">page 215</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.3" href="#7.12.3"><b>    7.12.3 Classification macros</b></a>
+1   In the synopses in this subclause, real-floating indicates that the argument shall be an
+    expression of real floating type.
+<a name="7.12.3.1" href="#7.12.3.1"><b>    7.12.3.1 The fpclassify macro</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             int fpclassify(real-floating x);
+<b>    Description</b>
+2   The fpclassify macro classifies its argument value as NaN, infinite, normal,
+    subnormal, zero, or into another implementation-defined category. First, an argument
+    represented in a format wider than its semantic type is converted to its semantic type.
+    Then classification is based on the type of the argument.<sup><a href="#note205"><b>205)</b></a></sup>
+<b>    Returns</b>
+3   The fpclassify macro returns the value of the number classification macro
+    appropriate to the value of its argument.
+4   EXAMPLE        The fpclassify macro might be implemented in terms of ordinary functions as
+             #define fpclassify(x) \
+                   ((sizeof (x) == sizeof (float)) ? __fpclassifyf(x) : \
+                    (sizeof (x) == sizeof (double)) ? __fpclassifyd(x) : \
+                                                      __fpclassifyl(x))
+
+<a name="7.12.3.2" href="#7.12.3.2"><b>    7.12.3.2 The isfinite macro</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             int isfinite(real-floating x);
+<b>    Description</b>
+2   The isfinite macro determines whether its argument has a finite value (zero,
+    subnormal, or normal, and not infinite or NaN). First, an argument represented in a
+    format wider than its semantic type is converted to its semantic type. Then determination
+    is based on the type of the argument.
+
+
+
+
+    <sup><a name="note205" href="#note205"><b>205)</b></a></sup> Since an expression can be evaluated with more range and precision than its type has, it is important to
+         know the type that classification is based on. For example, a normal long double value might
+         become subnormal when converted to double, and zero when converted to float.
+
+[<a name="p216" href="#p216">page 216</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The isfinite macro returns a nonzero value if and only if its argument has a finite
+    value.
+<a name="7.12.3.3" href="#7.12.3.3"><b>    7.12.3.3 The isinf macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isinf(real-floating x);
+<b>    Description</b>
+2   The isinf macro determines whether its argument value is an infinity (positive or
+    negative). First, an argument represented in a format wider than its semantic type is
+    converted to its semantic type. Then determination is based on the type of the argument.
+<b>    Returns</b>
+3   The isinf macro returns a nonzero value if and only if its argument has an infinite
+    value.
+<a name="7.12.3.4" href="#7.12.3.4"><b>    7.12.3.4 The isnan macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isnan(real-floating x);
+<b>    Description</b>
+2   The isnan macro determines whether its argument value is a NaN. First, an argument
+    represented in a format wider than its semantic type is converted to its semantic type.
+    Then determination is based on the type of the argument.<sup><a href="#note206"><b>206)</b></a></sup>
+<b>    Returns</b>
+3   The isnan macro returns a nonzero value if and only if its argument has a NaN value.
+<a name="7.12.3.5" href="#7.12.3.5"><b>    7.12.3.5 The isnormal macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isnormal(real-floating x);
+
+
+
+
+    <sup><a name="note206" href="#note206"><b>206)</b></a></sup> For the isnan macro, the type for determination does not matter unless the implementation supports
+         NaNs in the evaluation type but not in the semantic type.
+
+[<a name="p217" href="#p217">page 217</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The isnormal macro determines whether its argument value is normal (neither zero,
+    subnormal, infinite, nor NaN). First, an argument represented in a format wider than its
+    semantic type is converted to its semantic type. Then determination is based on the type
+    of the argument.
+<b>    Returns</b>
+3   The isnormal macro returns a nonzero value if and only if its argument has a normal
+    value.
+<a name="7.12.3.6" href="#7.12.3.6"><b>    7.12.3.6 The signbit macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int signbit(real-floating x);
+<b>    Description</b>
+2   The signbit macro determines whether the sign of its argument value is negative.<sup><a href="#note207"><b>207)</b></a></sup>
+<b>    Returns</b>
+3   The signbit macro returns a nonzero value if and only if the sign of its argument value
+    is negative.
+<a name="7.12.4" href="#7.12.4"><b>    7.12.4 Trigonometric functions</b></a>
+<a name="7.12.4.1" href="#7.12.4.1"><b>    7.12.4.1 The acos functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double acos(double x);
+            float acosf(float x);
+            long double acosl(long double x);
+<b>    Description</b>
+2   The acos functions compute the principal value of the arc cosine of x. A domain error
+    occurs for arguments not in the interval [-1, +1].
+<b>    Returns</b>
+3   The acos functions return arccos x in the interval [0, pi ] radians.
+
+
+
+
+    <sup><a name="note207" href="#note207"><b>207)</b></a></sup> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
+         unsigned, it is treated as positive.
+
+[<a name="p218" href="#p218">page 218</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.4.2" href="#7.12.4.2"><b>    7.12.4.2 The asin functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double asin(double x);
+           float asinf(float x);
+           long double asinl(long double x);
+<b>    Description</b>
+2   The asin functions compute the principal value of the arc sine of x. A domain error
+    occurs for arguments not in the interval [-1, +1].
+<b>    Returns</b>
+3   The asin functions return arcsin x in the interval [-pi /2, +pi /2] radians.
+<a name="7.12.4.3" href="#7.12.4.3"><b>    7.12.4.3 The atan functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double atan(double x);
+           float atanf(float x);
+           long double atanl(long double x);
+<b>    Description</b>
+2   The atan functions compute the principal value of the arc tangent of x.
+<b>    Returns</b>
+3   The atan functions return arctan x in the interval [-pi /2, +pi /2] radians.
+<a name="7.12.4.4" href="#7.12.4.4"><b>    7.12.4.4 The atan2 functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double atan2(double y, double x);
+           float atan2f(float y, float x);
+           long double atan2l(long double y, long double x);
+<b>    Description</b>
+2   The atan2 functions compute the value of the arc tangent of y/x, using the signs of both
+    arguments to determine the quadrant of the return value. A domain error may occur if
+    both arguments are zero.
+<b>    Returns</b>
+3   The atan2 functions return arctan y/x in the interval [-pi , +pi ] radians.
+
+[<a name="p219" href="#p219">page 219</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.4.5" href="#7.12.4.5"><b>    7.12.4.5 The cos functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double cos(double x);
+           float cosf(float x);
+           long double cosl(long double x);
+<b>    Description</b>
+2   The cos functions compute the cosine of x (measured in radians).
+<b>    Returns</b>
+3   The cos functions return cos x.
+<a name="7.12.4.6" href="#7.12.4.6"><b>    7.12.4.6 The sin functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double sin(double x);
+           float sinf(float x);
+           long double sinl(long double x);
+<b>    Description</b>
+2   The sin functions compute the sine of x (measured in radians).
+<b>    Returns</b>
+3   The sin functions return sin x.
+<a name="7.12.4.7" href="#7.12.4.7"><b>    7.12.4.7 The tan functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double tan(double x);
+           float tanf(float x);
+           long double tanl(long double x);
+<b>    Description</b>
+2   The tan functions return the tangent of x (measured in radians).
+<b>    Returns</b>
+3   The tan functions return tan x.
+
+[<a name="p220" href="#p220">page 220</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.5" href="#7.12.5"><b>    7.12.5 Hyperbolic functions</b></a>
+<a name="7.12.5.1" href="#7.12.5.1"><b>    7.12.5.1 The acosh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double acosh(double x);
+           float acoshf(float x);
+           long double acoshl(long double x);
+<b>    Description</b>
+2   The acosh functions compute the (nonnegative) arc hyperbolic cosine of x. A domain
+    error occurs for arguments less than 1.
+<b>    Returns</b>
+3   The acosh functions return arcosh x in the interval [0, +(inf)].
+<a name="7.12.5.2" href="#7.12.5.2"><b>    7.12.5.2 The asinh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double asinh(double x);
+           float asinhf(float x);
+           long double asinhl(long double x);
+<b>    Description</b>
+2   The asinh functions compute the arc hyperbolic sine of x.
+<b>    Returns</b>
+3   The asinh functions return arsinh x.
+<a name="7.12.5.3" href="#7.12.5.3"><b>    7.12.5.3 The atanh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double atanh(double x);
+           float atanhf(float x);
+           long double atanhl(long double x);
+<b>    Description</b>
+2   The atanh functions compute the arc hyperbolic tangent of x. A domain error occurs
+    for arguments not in the interval [-1, +1]. A range error may occur if the argument
+    equals -1 or +1.
+
+[<a name="p221" href="#p221">page 221</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The atanh functions return artanh x.
+<a name="7.12.5.4" href="#7.12.5.4"><b>    7.12.5.4 The cosh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double cosh(double x);
+           float coshf(float x);
+           long double coshl(long double x);
+<b>    Description</b>
+2   The cosh functions compute the hyperbolic cosine of x. A range error occurs if the
+    magnitude of x is too large.
+<b>    Returns</b>
+3   The cosh functions return cosh x.
+<a name="7.12.5.5" href="#7.12.5.5"><b>    7.12.5.5 The sinh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double sinh(double x);
+           float sinhf(float x);
+           long double sinhl(long double x);
+<b>    Description</b>
+2   The sinh functions compute the hyperbolic sine of x. A range error occurs if the
+    magnitude of x is too large.
+<b>    Returns</b>
+3   The sinh functions return sinh x.
+<a name="7.12.5.6" href="#7.12.5.6"><b>    7.12.5.6 The tanh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double tanh(double x);
+           float tanhf(float x);
+           long double tanhl(long double x);
+<b>    Description</b>
+2   The tanh functions compute the hyperbolic tangent of x.
+
+[<a name="p222" href="#p222">page 222</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The tanh functions return tanh x.
+<a name="7.12.6" href="#7.12.6"><b>    7.12.6 Exponential and logarithmic functions</b></a>
+<a name="7.12.6.1" href="#7.12.6.1"><b>    7.12.6.1 The exp functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double exp(double x);
+           float expf(float x);
+           long double expl(long double x);
+<b>    Description</b>
+2   The exp functions compute the base-e exponential of x. A range error occurs if the
+    magnitude of x is too large.
+<b>    Returns</b>
+3   The exp functions return ex .
+<a name="7.12.6.2" href="#7.12.6.2"><b>    7.12.6.2 The exp2 functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double exp2(double x);
+           float exp2f(float x);
+           long double exp2l(long double x);
+<b>    Description</b>
+2   The exp2 functions compute the base-2 exponential of x. A range error occurs if the
+    magnitude of x is too large.
+<b>    Returns</b>
+3   The exp2 functions return 2x .
+<a name="7.12.6.3" href="#7.12.6.3"><b>    7.12.6.3 The expm1 functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double expm1(double x);
+           float expm1f(float x);
+           long double expm1l(long double x);
+
+[<a name="p223" href="#p223">page 223</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The expm1 functions compute the base-e exponential of the argument, minus 1. A range
+    error occurs if x is too large.<sup><a href="#note208"><b>208)</b></a></sup>
+<b>    Returns</b>
+3   The expm1 functions return ex - 1.
+<a name="7.12.6.4" href="#7.12.6.4"><b>    7.12.6.4 The frexp functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double frexp(double value, int *exp);
+            float frexpf(float value, int *exp);
+            long double frexpl(long double value, int *exp);
+<b>    Description</b>
+2   The frexp functions break a floating-point number into a normalized fraction and an
+    integral power of 2. They store the integer in the int object pointed to by exp.
+<b>    Returns</b>
+3   If value is not a floating-point number, the results are unspecified. Otherwise, the
+    frexp functions return the value x, such that x has a magnitude in the interval [1/2, 1) or
+    zero, and value equals x x 2*exp . If value is zero, both parts of the result are zero.
+<a name="7.12.6.5" href="#7.12.6.5"><b>    7.12.6.5 The ilogb functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int ilogb(double x);
+            int ilogbf(float x);
+            int ilogbl(long double x);
+<b>    Description</b>
+2   The ilogb functions extract the exponent of x as a signed int value. If x is zero they
+    compute the value FP_ILOGB0; if x is infinite they compute the value INT_MAX; if x is
+    a NaN they compute the value FP_ILOGBNAN; otherwise, they are equivalent to calling
+    the corresponding logb function and casting the returned value to type int. A domain
+    error or range error may occur if x is zero, infinite, or NaN. If the correct value is outside
+    the range of the return type, the numeric result is unspecified.
+
+
+
+
+    <sup><a name="note208" href="#note208"><b>208)</b></a></sup> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
+
+[<a name="p224" href="#p224">page 224</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The ilogb functions return the exponent of x as a signed int value.
+    Forward references: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
+<a name="7.12.6.6" href="#7.12.6.6"><b>    7.12.6.6 The ldexp functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double ldexp(double x, int exp);
+           float ldexpf(float x, int exp);
+           long double ldexpl(long double x, int exp);
+<b>    Description</b>
+2   The ldexp functions multiply a floating-point number by an integral power of 2. A
+    range error may occur.
+<b>    Returns</b>
+3   The ldexp functions return x x 2exp .
+<a name="7.12.6.7" href="#7.12.6.7"><b>    7.12.6.7 The log functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double log(double x);
+           float logf(float x);
+           long double logl(long double x);
+<b>    Description</b>
+2   The log functions compute the base-e (natural) logarithm of x. A domain error occurs if
+    the argument is negative. A range error may occur if the argument is zero.
+<b>    Returns</b>
+3   The log functions return loge x.
+<a name="7.12.6.8" href="#7.12.6.8"><b>    7.12.6.8 The log10 functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double log10(double x);
+           float log10f(float x);
+           long double log10l(long double x);
+
+[<a name="p225" href="#p225">page 225</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The log10 functions compute the base-10 (common) logarithm of x. A domain error
+    occurs if the argument is negative. A range error may occur if the argument is zero.
+<b>    Returns</b>
+3   The log10 functions return log10 x.
+<a name="7.12.6.9" href="#7.12.6.9"><b>    7.12.6.9 The log1p functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double log1p(double x);
+            float log1pf(float x);
+            long double log1pl(long double x);
+<b>    Description</b>
+2   The log1p functions compute the base-e (natural) logarithm of 1 plus the argument.<sup><a href="#note209"><b>209)</b></a></sup>
+    A domain error occurs if the argument is less than -1. A range error may occur if the
+    argument equals -1.
+<b>    Returns</b>
+3   The log1p functions return loge (1 + x).
+<a name="7.12.6.10" href="#7.12.6.10"><b>    7.12.6.10 The log2 functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double log2(double x);
+            float log2f(float x);
+            long double log2l(long double x);
+<b>    Description</b>
+2   The log2 functions compute the base-2 logarithm of x. A domain error occurs if the
+    argument is less than zero. A range error may occur if the argument is zero.
+<b>    Returns</b>
+3   The log2 functions return log2 x.
+
+
+
+
+    <sup><a name="note209" href="#note209"><b>209)</b></a></sup> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
+
+[<a name="p226" href="#p226">page 226</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.6.11" href="#7.12.6.11"><b>    7.12.6.11 The logb functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double logb(double x);
+           float logbf(float x);
+           long double logbl(long double x);
+<b>    Description</b>
+2   The logb functions extract the exponent of x, as a signed integer value in floating-point
+    format. If x is subnormal it is treated as though it were normalized; thus, for positive
+    finite x,
+          1 &lt;= x x FLT_RADIX-logb(x) &lt; FLT_RADIX
+    A domain error or range error may occur if the argument is zero.
+<b>    Returns</b>
+3   The logb functions return the signed exponent of x.
+<a name="7.12.6.12" href="#7.12.6.12"><b>    7.12.6.12 The modf functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double modf(double value, double *iptr);
+           float modff(float value, float *iptr);
+           long double modfl(long double value, long double *iptr);
+<b>    Description</b>
+2   The modf functions break the argument value into integral and fractional parts, each of
+    which has the same type and sign as the argument. They store the integral part (in
+    floating-point format) in the object pointed to by iptr.
+<b>    Returns</b>
+3   The modf functions return the signed fractional part of value.
+
+[<a name="p227" href="#p227">page 227</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.6.13" href="#7.12.6.13"><b>    7.12.6.13 The scalbn and scalbln functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double scalbn(double x, int n);
+           float scalbnf(float x, int n);
+           long double scalbnl(long double x, int n);
+           double scalbln(double x, long int n);
+           float scalblnf(float x, long int n);
+           long double scalblnl(long double x, long int n);
+<b>    Description</b>
+2   The scalbn and scalbln functions compute x x FLT_RADIXn efficiently, not
+    normally by computing FLT_RADIXn explicitly. A range error may occur.
+<b>    Returns</b>
+3   The scalbn and scalbln functions return x x FLT_RADIXn .
+<a name="7.12.7" href="#7.12.7"><b>    7.12.7 Power and absolute-value functions</b></a>
+<a name="7.12.7.1" href="#7.12.7.1"><b>    7.12.7.1 The cbrt functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double cbrt(double x);
+           float cbrtf(float x);
+           long double cbrtl(long double x);
+<b>    Description</b>
+2   The cbrt functions compute the real cube root of x.
+<b>    Returns</b>
+3   The cbrt functions return x1/3 .
+<a name="7.12.7.2" href="#7.12.7.2"><b>    7.12.7.2 The fabs functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double fabs(double x);
+           float fabsf(float x);
+           long double fabsl(long double x);
+<b>    Description</b>
+2   The fabs functions compute the absolute value of a floating-point number x.
+
+[<a name="p228" href="#p228">page 228</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The fabs functions return | x |.
+<a name="7.12.7.3" href="#7.12.7.3"><b>    7.12.7.3 The hypot functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double hypot(double x, double y);
+           float hypotf(float x, float y);
+           long double hypotl(long double x, long double y);
+<b>    Description</b>
+2   The hypot functions compute the square root of the sum of the squares of x and y,
+    without undue overflow or underflow. A range error may occur.
+3   Returns
+4   The hypot functions return (sqrt)x2 + y2 .
+                               ???
+                               ???????????????
+<a name="7.12.7.4" href="#7.12.7.4"><b>    7.12.7.4 The pow functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double pow(double x, double y);
+           float powf(float x, float y);
+           long double powl(long double x, long double y);
+<b>    Description</b>
+2   The pow functions compute x raised to the power y. A domain error occurs if x is finite
+    and negative and y is finite and not an integer value. A range error may occur. A domain
+    error may occur if x is zero and y is zero. A domain error or range error may occur if x
+    is zero and y is less than zero.
+<b>    Returns</b>
+3   The pow functions return xy .
+<a name="7.12.7.5" href="#7.12.7.5"><b>    7.12.7.5 The sqrt functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double sqrt(double x);
+           float sqrtf(float x);
+           long double sqrtl(long double x);
+
+[<a name="p229" href="#p229">page 229</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The sqrt functions compute the nonnegative square root of x. A domain error occurs if
+    the argument is less than zero.
+<b>    Returns</b>
+3   The sqrt functions return (sqrt)x.
+                              ???
+                              ???
+<a name="7.12.8" href="#7.12.8"><b>    7.12.8 Error and gamma functions</b></a>
+<a name="7.12.8.1" href="#7.12.8.1"><b>    7.12.8.1 The erf functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double erf(double x);
+           float erff(float x);
+           long double erfl(long double x);
+<b>    Description</b>
+2   The erf functions compute the error function of x.
+<b>    Returns</b>
+                                       2        x
+                                            (integral)
+3
+    The erf functions return erf x =                e-t dt.
+                                                      2
+
+
+                                       (sqrt)pi
+                                       ???
+                                       ???    0
+
+<a name="7.12.8.2" href="#7.12.8.2"><b>    7.12.8.2 The erfc functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double erfc(double x);
+           float erfcf(float x);
+           long double erfcl(long double x);
+<b>    Description</b>
+2   The erfc functions compute the complementary error function of x. A range error
+    occurs if x is too large.
+<b>    Returns</b>
+                                                              2        (inf)
+                                                                   (integral)
+3
+    The erfc functions return erfc x = 1 - erf x =                         e-t dt.
+                                                                             2
+
+
+                                                              (sqrt)pi
+                                                              ???
+                                                              ???    x
+
+[<a name="p230" href="#p230">page 230</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.8.3" href="#7.12.8.3"><b>    7.12.8.3 The lgamma functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double lgamma(double x);
+           float lgammaf(float x);
+           long double lgammal(long double x);
+<b>    Description</b>
+2   The lgamma functions compute the natural logarithm of the absolute value of gamma of
+    x. A range error occurs if x is too large. A range error may occur if x is a negative
+    integer or zero.
+<b>    Returns</b>
+3   The lgamma functions return loge | (Gamma)(x) |.
+<a name="7.12.8.4" href="#7.12.8.4"><b>    7.12.8.4 The tgamma functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double tgamma(double x);
+           float tgammaf(float x);
+           long double tgammal(long double x);
+<b>    Description</b>
+2   The tgamma functions compute the gamma function of x. A domain error or range error
+    may occur if x is a negative integer or zero. A range error may occur if the magnitude of
+    x is too large or too small.
+<b>    Returns</b>
+3   The tgamma functions return (Gamma)(x).
+<a name="7.12.9" href="#7.12.9"><b>    7.12.9 Nearest integer functions</b></a>
+<a name="7.12.9.1" href="#7.12.9.1"><b>    7.12.9.1 The ceil functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double ceil(double x);
+           float ceilf(float x);
+           long double ceill(long double x);
+<b>    Description</b>
+2   The ceil functions compute the smallest integer value not less than x.
+
+[<a name="p231" href="#p231">page 231</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The ceil functions return ???x???, expressed as a floating-point number.
+<a name="7.12.9.2" href="#7.12.9.2"><b>    7.12.9.2 The floor functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double floor(double x);
+           float floorf(float x);
+           long double floorl(long double x);
+<b>    Description</b>
+2   The floor functions compute the largest integer value not greater than x.
+<b>    Returns</b>
+3   The floor functions return ???x???, expressed as a floating-point number.
+<a name="7.12.9.3" href="#7.12.9.3"><b>    7.12.9.3 The nearbyint functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double nearbyint(double x);
+           float nearbyintf(float x);
+           long double nearbyintl(long double x);
+<b>    Description</b>
+2   The nearbyint functions round their argument to an integer value in floating-point
+    format, using the current rounding direction and without raising the ''inexact'' floating-
+    point exception.
+<b>    Returns</b>
+3   The nearbyint functions return the rounded integer value.
+<a name="7.12.9.4" href="#7.12.9.4"><b>    7.12.9.4 The rint functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double rint(double x);
+           float rintf(float x);
+           long double rintl(long double x);
+<b>    Description</b>
+2   The rint functions differ from the nearbyint functions (<a href="#7.12.9.3">7.12.9.3</a>) only in that the
+    rint functions may raise the ''inexact'' floating-point exception if the result differs in
+    value from the argument.
+
+[<a name="p232" href="#p232">page 232</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The rint functions return the rounded integer value.
+<a name="7.12.9.5" href="#7.12.9.5"><b>    7.12.9.5 The lrint and llrint functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           long int lrint(double x);
+           long int lrintf(float x);
+           long int lrintl(long double x);
+           long long int llrint(double x);
+           long long int llrintf(float x);
+           long long int llrintl(long double x);
+<b>    Description</b>
+2   The lrint and llrint functions round their argument to the nearest integer value,
+    rounding according to the current rounding direction. If the rounded value is outside the
+    range of the return type, the numeric result is unspecified and a domain error or range
+    error may occur.                                                                          *
+<b>    Returns</b>
+3   The lrint and llrint functions return the rounded integer value.
+<a name="7.12.9.6" href="#7.12.9.6"><b>    7.12.9.6 The round functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double round(double x);
+           float roundf(float x);
+           long double roundl(long double x);
+<b>    Description</b>
+2   The round functions round their argument to the nearest integer value in floating-point
+    format, rounding halfway cases away from zero, regardless of the current rounding
+    direction.
+<b>    Returns</b>
+3   The round functions return the rounded integer value.
+
+[<a name="p233" href="#p233">page 233</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.9.7" href="#7.12.9.7"><b>    7.12.9.7 The lround and llround functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           long int lround(double x);
+           long int lroundf(float x);
+           long int lroundl(long double x);
+           long long int llround(double x);
+           long long int llroundf(float x);
+           long long int llroundl(long double x);
+<b>    Description</b>
+2   The lround and llround functions round their argument to the nearest integer value,
+    rounding halfway cases away from zero, regardless of the current rounding direction. If
+    the rounded value is outside the range of the return type, the numeric result is unspecified
+    and a domain error or range error may occur.
+<b>    Returns</b>
+3   The lround and llround functions return the rounded integer value.
+<a name="7.12.9.8" href="#7.12.9.8"><b>    7.12.9.8 The trunc functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double trunc(double x);
+           float truncf(float x);
+           long double truncl(long double x);
+<b>    Description</b>
+2   The trunc functions round their argument to the integer value, in floating format,
+    nearest to but no larger in magnitude than the argument.
+<b>    Returns</b>
+3   The trunc functions return the truncated integer value.
+
+[<a name="p234" href="#p234">page 234</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.10" href="#7.12.10"><b>    7.12.10 Remainder functions</b></a>
+<a name="7.12.10.1" href="#7.12.10.1"><b>    7.12.10.1 The fmod functions</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             double fmod(double x, double y);
+             float fmodf(float x, float y);
+             long double fmodl(long double x, long double y);
+<b>    Description</b>
+2   The fmod functions compute the floating-point remainder of x/y.
+<b>    Returns</b>
+3   The fmod functions return the value x - ny, for some integer n such that, if y is nonzero,
+    the result has the same sign as x and magnitude less than the magnitude of y. If y is zero,
+    whether a domain error occurs or the fmod functions return zero is implementation-
+    defined.
+<a name="7.12.10.2" href="#7.12.10.2"><b>    7.12.10.2 The remainder functions</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             double remainder(double x, double y);
+             float remainderf(float x, float y);
+             long double remainderl(long double x, long double y);
+<b>    Description</b>
+2   The remainder functions compute the remainder x REM y required by IEC 60559.<sup><a href="#note210"><b>210)</b></a></sup>
+<b>    Returns</b>
+3   The remainder functions return x REM y. If y is zero, whether a domain error occurs
+    or the functions return zero is implementation defined.
+
+
+
+
+    <sup><a name="note210" href="#note210"><b>210)</b></a></sup> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
+         mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
+         | n - x/y | = 1/2, then n is even. Thus, the remainder is always exact. If r = 0, its sign shall be that of
+         x.'' This definition is applicable for all implementations.
+
+[<a name="p235" href="#p235">page 235</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.10.3" href="#7.12.10.3"><b>    7.12.10.3 The remquo functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double remquo(double x, double y, int *quo);
+           float remquof(float x, float y, int *quo);
+           long double remquol(long double x, long double y,
+                int *quo);
+<b>    Description</b>
+2   The remquo functions compute the same remainder as the remainder functions. In
+    the object pointed to by quo they store a value whose sign is the sign of x/y and whose
+    magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where
+    n is an implementation-defined integer greater than or equal to 3.
+<b>    Returns</b>
+3   The remquo functions return x REM y. If y is zero, the value stored in the object
+    pointed to by quo is unspecified and whether a domain error occurs or the functions
+    return zero is implementation defined.
+<a name="7.12.11" href="#7.12.11"><b>    7.12.11 Manipulation functions</b></a>
+<a name="7.12.11.1" href="#7.12.11.1"><b>    7.12.11.1 The copysign functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double copysign(double x, double y);
+           float copysignf(float x, float y);
+           long double copysignl(long double x, long double y);
+<b>    Description</b>
+2   The copysign functions produce a value with the magnitude of x and the sign of y.
+    They produce a NaN (with the sign of y) if x is a NaN. On implementations that
+    represent a signed zero but do not treat negative zero consistently in arithmetic
+    operations, the copysign functions regard the sign of zero as positive.
+<b>    Returns</b>
+3   The copysign functions return a value with the magnitude of x and the sign of y.
+
+[<a name="p236" href="#p236">page 236</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.11.2" href="#7.12.11.2"><b>    7.12.11.2 The nan functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double nan(const char *tagp);
+            float nanf(const char *tagp);
+            long double nanl(const char *tagp);
+<b>    Description</b>
+2   The call nan("n-char-sequence") is equivalent to strtod("NAN(n-char-
+    sequence)",     (char**)       NULL); the call nan("") is equivalent to
+    strtod("NAN()", (char**) NULL). If tagp does not point to an n-char
+    sequence or an empty string, the call is equivalent to strtod("NAN", (char**)
+    NULL). Calls to nanf and nanl are equivalent to the corresponding calls to strtof
+    and strtold.
+<b>    Returns</b>
+3   The nan functions return a quiet NaN, if available, with content indicated through tagp.
+    If the implementation does not support quiet NaNs, the functions return zero.
+    Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>).
+<a name="7.12.11.3" href="#7.12.11.3"><b>    7.12.11.3 The nextafter functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double nextafter(double x, double y);
+            float nextafterf(float x, float y);
+            long double nextafterl(long double x, long double y);
+<b>    Description</b>
+2   The nextafter functions determine the next representable value, in the type of the
+    function, after x in the direction of y, where x and y are first converted to the type of the
+    function.<sup><a href="#note211"><b>211)</b></a></sup> The nextafter functions return y if x equals y. A range error may occur
+    if the magnitude of x is the largest finite value representable in the type and the result is
+    infinite or not representable in the type.
+<b>    Returns</b>
+3   The nextafter functions return the next representable value in the specified format
+    after x in the direction of y.
+
+
+    <sup><a name="note211" href="#note211"><b>211)</b></a></sup> The argument values are converted to the type of the function, even by a macro implementation of the
+         function.
+
+[<a name="p237" href="#p237">page 237</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.11.4" href="#7.12.11.4"><b>    7.12.11.4 The nexttoward functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double nexttoward(double x, long double y);
+            float nexttowardf(float x, long double y);
+            long double nexttowardl(long double x, long double y);
+<b>    Description</b>
+2   The nexttoward functions are equivalent to the nextafter functions except that the
+    second parameter has type long double and the functions return y converted to the
+    type of the function if x equals y.<sup><a href="#note212"><b>212)</b></a></sup>
+<a name="7.12.12" href="#7.12.12"><b>    7.12.12 Maximum, minimum, and positive difference functions</b></a>
+<a name="7.12.12.1" href="#7.12.12.1"><b>    7.12.12.1 The fdim functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fdim(double x, double y);
+            float fdimf(float x, float y);
+            long double fdiml(long double x, long double y);
+<b>    Description</b>
+2   The fdim functions determine the positive difference between their arguments:
+          ???x - y if x &gt; y
+          ???
+          ???+0     if x &lt;= y
+    A range error may occur.
+<b>    Returns</b>
+3   The fdim functions return the positive difference value.
+<a name="7.12.12.2" href="#7.12.12.2"><b>    7.12.12.2 The fmax functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fmax(double x, double y);
+            float fmaxf(float x, float y);
+            long double fmaxl(long double x, long double y);
+
+
+
+    <sup><a name="note212" href="#note212"><b>212)</b></a></sup> The result of the nexttoward functions is determined in the type of the function, without loss of
+         range or precision in a floating second argument.
+
+[<a name="p238" href="#p238">page 238</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The fmax functions determine the maximum numeric value of their arguments.<sup><a href="#note213"><b>213)</b></a></sup>
+<b>    Returns</b>
+3   The fmax functions return the maximum numeric value of their arguments.
+<a name="7.12.12.3" href="#7.12.12.3"><b>    7.12.12.3 The fmin functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fmin(double x, double y);
+            float fminf(float x, float y);
+            long double fminl(long double x, long double y);
+<b>    Description</b>
+2   The fmin functions determine the minimum numeric value of their arguments.<sup><a href="#note214"><b>214)</b></a></sup>
+<b>    Returns</b>
+3   The fmin functions return the minimum numeric value of their arguments.
+<a name="7.12.13" href="#7.12.13"><b>    7.12.13 Floating multiply-add</b></a>
+<a name="7.12.13.1" href="#7.12.13.1"><b>    7.12.13.1 The fma functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fma(double x, double y, double z);
+            float fmaf(float x, float y, float z);
+            long double fmal(long double x, long double y,
+                 long double z);
+<b>    Description</b>
+2   The fma functions compute (x x y) + z, rounded as one ternary operation: they compute
+    the value (as if) to infinite precision and round once to the result format, according to the
+    current rounding mode. A range error may occur.
+<b>    Returns</b>
+3   The fma functions return (x x y) + z, rounded as one ternary operation.
+
+
+
+
+    <sup><a name="note213" href="#note213"><b>213)</b></a></sup> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
+         fmax functions choose the numeric value. See <a href="#F.9.9.2">F.9.9.2</a>.
+    <sup><a name="note214" href="#note214"><b>214)</b></a></sup> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
+
+[<a name="p239" href="#p239">page 239</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.14" href="#7.12.14"><b>    7.12.14 Comparison macros</b></a>
+1   The relational and equality operators support the usual mathematical relationships
+    between numeric values. For any ordered pair of numeric values exactly one of the
+    relationships -- less, greater, and equal -- is true. Relational operators may raise the
+    ''invalid'' floating-point exception when argument values are NaNs. For a NaN and a
+    numeric value, or for two NaNs, just the unordered relationship is true.<sup><a href="#note215"><b>215)</b></a></sup> The following
+    subclauses provide macros that are quiet (non floating-point exception raising) versions
+    of the relational operators, and other comparison macros that facilitate writing efficient
+    code that accounts for NaNs without suffering the ''invalid'' floating-point exception. In
+    the synopses in this subclause, real-floating indicates that the argument shall be an
+    expression of real floating type.
+<a name="7.12.14.1" href="#7.12.14.1"><b>    7.12.14.1 The isgreater macro</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             int isgreater(real-floating x, real-floating y);
+<b>    Description</b>
+2   The isgreater macro determines whether its first argument is greater than its second
+    argument. The value of isgreater(x, y) is always equal to (x) &gt; (y); however,
+    unlike (x) &gt; (y), isgreater(x, y) does not raise the ''invalid'' floating-point
+    exception when x and y are unordered.
+<b>    Returns</b>
+3   The isgreater macro returns the value of (x) &gt; (y).
+<a name="7.12.14.2" href="#7.12.14.2"><b>    7.12.14.2 The isgreaterequal macro</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             int isgreaterequal(real-floating x, real-floating y);
+<b>    Description</b>
+2   The isgreaterequal macro determines whether its first argument is greater than or
+    equal to its second argument. The value of isgreaterequal(x, y) is always equal
+    to (x) &gt;= (y); however, unlike (x) &gt;= (y), isgreaterequal(x, y) does
+    not raise the ''invalid'' floating-point exception when x and y are unordered.
+
+
+
+    <sup><a name="note215" href="#note215"><b>215)</b></a></sup> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
+         the operands compare unordered, as an error indicator for programs written without consideration of
+         NaNs; the result in these cases is false.
+
+[<a name="p240" href="#p240">page 240</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The isgreaterequal macro returns the value of (x) &gt;= (y).
+<a name="7.12.14.3" href="#7.12.14.3"><b>    7.12.14.3 The isless macro</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           int isless(real-floating x, real-floating y);
+<b>    Description</b>
+2   The isless macro determines whether its first argument is less than its second
+    argument. The value of isless(x, y) is always equal to (x) &lt; (y); however,
+    unlike (x) &lt; (y), isless(x, y) does not raise the ''invalid'' floating-point
+    exception when x and y are unordered.
+<b>    Returns</b>
+3   The isless macro returns the value of (x) &lt; (y).
+<a name="7.12.14.4" href="#7.12.14.4"><b>    7.12.14.4 The islessequal macro</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           int islessequal(real-floating x, real-floating y);
+<b>    Description</b>
+2   The islessequal macro determines whether its first argument is less than or equal to
+    its second argument. The value of islessequal(x, y) is always equal to
+    (x) &lt;= (y); however, unlike (x) &lt;= (y), islessequal(x, y) does not raise
+    the ''invalid'' floating-point exception when x and y are unordered.
+<b>    Returns</b>
+3   The islessequal macro returns the value of (x) &lt;= (y).
+<a name="7.12.14.5" href="#7.12.14.5"><b>    7.12.14.5 The islessgreater macro</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           int islessgreater(real-floating x, real-floating y);
+<b>    Description</b>
+2   The islessgreater macro determines whether its first argument is less than or
+    greater than its second argument. The islessgreater(x, y) macro is similar to
+    (x) &lt; (y) || (x) &gt; (y); however, islessgreater(x, y) does not raise
+    the ''invalid'' floating-point exception when x and y are unordered (nor does it evaluate x
+    and y twice).
+
+[<a name="p241" href="#p241">page 241</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The islessgreater macro returns the value of (x) &lt; (y) || (x) &gt; (y).
+<a name="7.12.14.6" href="#7.12.14.6"><b>    7.12.14.6 The isunordered macro</b></a>
+<b>    Synopsis</b>
+1         #include <a href="#7.12">&lt;math.h&gt;</a>
+          int isunordered(real-floating x, real-floating y);
+<b>    Description</b>
+2   The isunordered macro determines whether its arguments are unordered.
+<b>    Returns</b>
+3   The isunordered macro returns 1 if its arguments are unordered and 0 otherwise.
+
+[<a name="p242" href="#p242">page 242</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.13" href="#7.13"><b>    7.13 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
+1   The header <a href="#7.13">&lt;setjmp.h&gt;</a> defines the macro setjmp, and declares one function and
+    one type, for bypassing the normal function call and return discipline.<sup><a href="#note216"><b>216)</b></a></sup>
+2   The type declared is
+            jmp_buf
+    which is an array type suitable for holding the information needed to restore a calling
+    environment. The environment of a call to the setjmp macro consists of information
+    sufficient for a call to the longjmp function to return execution to the correct block and
+    invocation of that block, were it called recursively. It does not include the state of the
+    floating-point status flags, of open files, or of any other component of the abstract
+    machine.
+3   It is unspecified whether setjmp is a macro or an identifier declared with external
+    linkage. If a macro definition is suppressed in order to access an actual function, or a
+    program defines an external identifier with the name setjmp, the behavior is undefined.
+<a name="7.13.1" href="#7.13.1"><b>    7.13.1 Save calling environment</b></a>
+<a name="7.13.1.1" href="#7.13.1.1"><b>    7.13.1.1 The setjmp macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.13">&lt;setjmp.h&gt;</a>
+            int setjmp(jmp_buf env);
+<b>    Description</b>
+2   The setjmp macro saves its calling environment in its jmp_buf argument for later use
+    by the longjmp function.
+<b>    Returns</b>
+3   If the return is from a direct invocation, the setjmp macro returns the value zero. If the
+    return is from a call to the longjmp function, the setjmp macro returns a nonzero
+    value.
+    Environmental limits
+4   An invocation of the setjmp macro shall appear only in one of the following contexts:
+    -- the entire controlling expression of a selection or iteration statement;
+    -- one operand of a relational or equality operator with the other operand an integer
+      constant expression, with the resulting expression being the entire controlling
+
+
+    <sup><a name="note216" href="#note216"><b>216)</b></a></sup> These functions are useful for dealing with unusual conditions encountered in a low-level function of
+         a program.
+
+[<a name="p243" href="#p243">page 243</a>] (<a href="#Contents">Contents</a>)
+
+        expression of a selection or iteration statement;
+    -- the operand of a unary ! operator with the resulting expression being the entire
+      controlling expression of a selection or iteration statement; or
+    -- the entire expression of an expression statement (possibly cast to void).
+5   If the invocation appears in any other context, the behavior is undefined.
+<a name="7.13.2" href="#7.13.2"><b>    7.13.2 Restore calling environment</b></a>
+<a name="7.13.2.1" href="#7.13.2.1"><b>    7.13.2.1 The longjmp function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.13">&lt;setjmp.h&gt;</a>
+             void longjmp(jmp_buf env, int val);
+<b>    Description</b>
+2   The longjmp function restores the environment saved by the most recent invocation of
+    the setjmp macro in the same invocation of the program with the corresponding
+    jmp_buf argument. If there has been no such invocation, or if the function containing
+    the invocation of the setjmp macro has terminated execution<sup><a href="#note217"><b>217)</b></a></sup> in the interim, or if the
+    invocation of the setjmp macro was within the scope of an identifier with variably
+    modified type and execution has left that scope in the interim, the behavior is undefined.
+3   All accessible objects have values, and all other components of the abstract machine<sup><a href="#note218"><b>218)</b></a></sup>
+    have state, as of the time the longjmp function was called, except that the values of
+    objects of automatic storage duration that are local to the function containing the
+    invocation of the corresponding setjmp macro that do not have volatile-qualified type
+    and have been changed between the setjmp invocation and longjmp call are
+    indeterminate.
+<b>    Returns</b>
+4   After longjmp is completed, program execution continues as if the corresponding
+    invocation of the setjmp macro had just returned the value specified by val. The
+    longjmp function cannot cause the setjmp macro to return the value 0; if val is 0,
+    the setjmp macro returns the value 1.
+5   EXAMPLE The longjmp function that returns control back to the point of the setjmp invocation
+    might cause memory associated with a variable length array object to be squandered.
+
+
+
+
+    <sup><a name="note217" href="#note217"><b>217)</b></a></sup> For example, by executing a return statement or because another longjmp call has caused a
+         transfer to a setjmp invocation in a function earlier in the set of nested calls.
+    <sup><a name="note218" href="#note218"><b>218)</b></a></sup> This includes, but is not limited to, the floating-point status flags and the state of open files.
+
+[<a name="p244" href="#p244">page 244</a>] (<a href="#Contents">Contents</a>)
+
+       #include <a href="#7.13">&lt;setjmp.h&gt;</a>
+       jmp_buf buf;
+       void g(int n);
+       void h(int n);
+       int n = 6;
+       void f(void)
+       {
+             int x[n];          // valid: f is not terminated
+             setjmp(buf);
+             g(n);
+       }
+       void g(int n)
+       {
+             int a[n];          // a may remain allocated
+             h(n);
+       }
+       void h(int n)
+       {
+             int b[n];          // b may remain allocated
+             longjmp(buf, 2);   // might cause memory loss
+       }
+
+[<a name="p245" href="#p245">page 245</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.14" href="#7.14"><b>    7.14 Signal handling &lt;signal.h&gt;</b></a>
+1   The header <a href="#7.14">&lt;signal.h&gt;</a> declares a type and two functions and defines several macros,
+    for handling various signals (conditions that may be reported during program execution).
+2   The type defined is
+            sig_atomic_t
+    which is the (possibly volatile-qualified) integer type of an object that can be accessed as
+    an atomic entity, even in the presence of asynchronous interrupts.
+3   The macros defined are
+            SIG_DFL
+            SIG_ERR
+            SIG_IGN
+    which expand to constant expressions with distinct values that have type compatible with
+    the second argument to, and the return value of, the signal function, and whose values
+    compare unequal to the address of any declarable function; and the following, which
+    expand to positive integer constant expressions with type int and distinct values that are
+    the signal numbers, each corresponding to the specified condition:
+            SIGABRT abnormal termination, such as is initiated by the abort function
+            SIGFPE         an erroneous arithmetic operation, such as zero divide or an operation
+                           resulting in overflow
+            SIGILL         detection of an invalid function image, such as an invalid instruction
+            SIGINT         receipt of an interactive attention signal
+            SIGSEGV an invalid access to storage
+            SIGTERM a termination request sent to the program
+4   An implementation need not generate any of these signals, except as a result of explicit
+    calls to the raise function. Additional signals and pointers to undeclarable functions,
+    with macro definitions beginning, respectively, with the letters SIG and an uppercase
+    letter or with SIG_ and an uppercase letter,<sup><a href="#note219"><b>219)</b></a></sup> may also be specified by the
+    implementation. The complete set of signals, their semantics, and their default handling
+    is implementation-defined; all signal numbers shall be positive.
+
+
+
+
+    <sup><a name="note219" href="#note219"><b>219)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>). The names of the signal numbers reflect the following terms
+         (respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
+         and termination.
+
+[<a name="p246" href="#p246">page 246</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.14.1" href="#7.14.1"><b>    7.14.1 Specify signal handling</b></a>
+<a name="7.14.1.1" href="#7.14.1.1"><b>    7.14.1.1 The signal function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.14">&lt;signal.h&gt;</a>
+            void (*signal(int sig, void (*func)(int)))(int);
+<b>    Description</b>
+2   The signal function chooses one of three ways in which receipt of the signal number
+    sig is to be subsequently handled. If the value of func is SIG_DFL, default handling
+    for that signal will occur. If the value of func is SIG_IGN, the signal will be ignored.
+    Otherwise, func shall point to a function to be called when that signal occurs. An
+    invocation of such a function because of a signal, or (recursively) of any further functions
+    called by that invocation (other than functions in the standard library), is called a signal
+    handler.
+3   When a signal occurs and func points to a function, it is implementation-defined
+    whether the equivalent of signal(sig, SIG_DFL); is executed or the
+    implementation prevents some implementation-defined set of signals (at least including
+    sig) from occurring until the current signal handling has completed; in the case of
+    SIGILL, the implementation may alternatively define that no action is taken. Then the
+    equivalent of (*func)(sig); is executed. If and when the function returns, if the
+    value of sig is SIGFPE, SIGILL, SIGSEGV, or any other implementation-defined
+    value corresponding to a computational exception, the behavior is undefined; otherwise
+    the program will resume execution at the point it was interrupted.
+4   If the signal occurs as the result of calling the abort or raise function, the signal
+    handler shall not call the raise function.
+5   If the signal occurs other than as the result of calling the abort or raise function, the
+    behavior is undefined if the signal handler refers to any object with static storage duration
+    other than by assigning a value to an object declared as volatile sig_atomic_t, or
+    the signal handler calls any function in the standard library other than the abort
+    function, the _Exit function, or the signal function with the first argument equal to
+    the signal number corresponding to the signal that caused the invocation of the handler.
+    Furthermore, if such a call to the signal function results in a SIG_ERR return, the
+    value of errno is indeterminate.<sup><a href="#note220"><b>220)</b></a></sup>
+6   At program startup, the equivalent of
+            signal(sig, SIG_IGN);
+
+
+    <sup><a name="note220" href="#note220"><b>220)</b></a></sup> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
+
+[<a name="p247" href="#p247">page 247</a>] (<a href="#Contents">Contents</a>)
+
+    may be executed for some signals selected in an implementation-defined manner; the
+    equivalent of
+           signal(sig, SIG_DFL);
+    is executed for all other signals defined by the implementation.
+7   The implementation shall behave as if no library function calls the signal function.
+<b>    Returns</b>
+8   If the request can be honored, the signal function returns the value of func for the
+    most recent successful call to signal for the specified signal sig. Otherwise, a value of
+    SIG_ERR is returned and a positive value is stored in errno.
+    Forward references: the abort function (<a href="#7.20.4.1">7.20.4.1</a>), the exit function (<a href="#7.20.4.3">7.20.4.3</a>), the
+    _Exit function (<a href="#7.20.4.4">7.20.4.4</a>).
+<a name="7.14.2" href="#7.14.2"><b>    7.14.2 Send signal</b></a>
+<a name="7.14.2.1" href="#7.14.2.1"><b>    7.14.2.1 The raise function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.14">&lt;signal.h&gt;</a>
+           int raise(int sig);
+<b>    Description</b>
+2   The raise function carries out the actions described in <a href="#7.14.1.1">7.14.1.1</a> for the signal sig. If a
+    signal handler is called, the raise function shall not return until after the signal handler
+    does.
+<b>    Returns</b>
+3   The raise function returns zero if successful, nonzero if unsuccessful.
+
+[<a name="p248" href="#p248">page 248</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.15" href="#7.15"><b>    7.15 Variable arguments &lt;stdarg.h&gt;</b></a>
+1   The header <a href="#7.15">&lt;stdarg.h&gt;</a> declares a type and defines four macros, for advancing
+    through a list of arguments whose number and types are not known to the called function
+    when it is translated.
+2   A function may be called with a variable number of arguments of varying types. As
+    described in <a href="#6.9.1">6.9.1</a>, its parameter list contains one or more parameters. The rightmost
+    parameter plays a special role in the access mechanism, and will be designated parmN in
+    this description.
+3   The type declared is
+            va_list
+    which is an object type suitable for holding information needed by the macros
+    va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
+    desired, the called function shall declare an object (generally referred to as ap in this
+    subclause) having type va_list. The object ap may be passed as an argument to
+    another function; if that function invokes the va_arg macro with parameter ap, the
+    value of ap in the calling function is indeterminate and shall be passed to the va_end
+    macro prior to any further reference to ap.<sup><a href="#note221"><b>221)</b></a></sup>
+<a name="7.15.1" href="#7.15.1"><b>    7.15.1 Variable argument list access macros</b></a>
+1   The va_start and va_arg macros described in this subclause shall be implemented
+    as macros, not functions. It is unspecified whether va_copy and va_end are macros or
+    identifiers declared with external linkage. If a macro definition is suppressed in order to
+    access an actual function, or a program defines an external identifier with the same name,
+    the behavior is undefined. Each invocation of the va_start and va_copy macros
+    shall be matched by a corresponding invocation of the va_end macro in the same
+    function.
+<a name="7.15.1.1" href="#7.15.1.1"><b>    7.15.1.1 The va_arg macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+            type va_arg(va_list ap, type);
+<b>    Description</b>
+2   The va_arg macro expands to an expression that has the specified type and the value of
+    the next argument in the call. The parameter ap shall have been initialized by the
+    va_start or va_copy macro (without an intervening invocation of the va_end
+
+    <sup><a name="note221" href="#note221"><b>221)</b></a></sup> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
+         case the original function may make further use of the original list after the other function returns.
+
+[<a name="p249" href="#p249">page 249</a>] (<a href="#Contents">Contents</a>)
+
+    macro for the same ap). Each invocation of the va_arg macro modifies ap so that the
+    values of successive arguments are returned in turn. The parameter type shall be a type
+    name specified such that the type of a pointer to an object that has the specified type can
+    be obtained simply by postfixing a * to type. If there is no actual next argument, or if
+    type is not compatible with the type of the actual next argument (as promoted according
+    to the default argument promotions), the behavior is undefined, except for the following
+    cases:
+    -- one type is a signed integer type, the other type is the corresponding unsigned integer
+      type, and the value is representable in both types;
+    -- one type is pointer to void and the other is a pointer to a character type.
+<b>    Returns</b>
+3   The first invocation of the va_arg macro after that of the va_start macro returns the
+    value of the argument after that specified by parmN . Successive invocations return the
+    values of the remaining arguments in succession.
+<a name="7.15.1.2" href="#7.15.1.2"><b>    7.15.1.2 The va_copy macro</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           void va_copy(va_list dest, va_list src);
+<b>    Description</b>
+2   The va_copy macro initializes dest as a copy of src, as if the va_start macro had
+    been applied to dest followed by the same sequence of uses of the va_arg macro as
+    had previously been used to reach the present state of src. Neither the va_copy nor
+    va_start macro shall be invoked to reinitialize dest without an intervening
+    invocation of the va_end macro for the same dest.
+<b>    Returns</b>
+3   The va_copy macro returns no value.
+<a name="7.15.1.3" href="#7.15.1.3"><b>    7.15.1.3 The va_end macro</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           void va_end(va_list ap);
+<b>    Description</b>
+2   The va_end macro facilitates a normal return from the function whose variable
+    argument list was referred to by the expansion of the va_start macro, or the function
+    containing the expansion of the va_copy macro, that initialized the va_list ap. The
+    va_end macro may modify ap so that it is no longer usable (without being reinitialized
+
+[<a name="p250" href="#p250">page 250</a>] (<a href="#Contents">Contents</a>)
+
+    by the va_start or va_copy macro). If there is no corresponding invocation of the
+    va_start or va_copy macro, or if the va_end macro is not invoked before the
+    return, the behavior is undefined.
+<b>    Returns</b>
+3   The va_end macro returns no value.
+<a name="7.15.1.4" href="#7.15.1.4"><b>    7.15.1.4 The va_start macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+            void va_start(va_list ap, parmN);
+<b>    Description</b>
+2   The va_start macro shall be invoked before any access to the unnamed arguments.
+3   The va_start macro initializes ap for subsequent use by the va_arg and va_end
+    macros. Neither the va_start nor va_copy macro shall be invoked to reinitialize ap
+    without an intervening invocation of the va_end macro for the same ap.
+4   The parameter parmN is the identifier of the rightmost parameter in the variable
+    parameter list in the function definition (the one just before the , ...). If the parameter
+    parmN is declared with the register storage class, with a function or array type, or
+    with a type that is not compatible with the type that results after application of the default
+    argument promotions, the behavior is undefined.
+<b>    Returns</b>
+5   The va_start macro returns no value.
+6   EXAMPLE 1 The function f1 gathers into an array a list of arguments that are pointers to strings (but not
+    more than MAXARGS arguments), then passes the array as a single argument to function f2. The number of
+    pointers is specified by the first argument to f1.
+            #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+            #define MAXARGS   31
+            void f1(int n_ptrs, ...)
+            {
+                  va_list ap;
+                  char *array[MAXARGS];
+                  int ptr_no = 0;
+
+[<a name="p251" href="#p251">page 251</a>] (<a href="#Contents">Contents</a>)
+
+                      if (n_ptrs &gt; MAXARGS)
+                            n_ptrs = MAXARGS;
+                      va_start(ap, n_ptrs);
+                      while (ptr_no &lt; n_ptrs)
+                            array[ptr_no++] = va_arg(ap, char *);
+                      va_end(ap);
+                      f2(n_ptrs, array);
+             }
+    Each call to f1 is required to have visible the definition of the function or a declaration such as
+             void f1(int, ...);
+
+7   EXAMPLE 2 The function f3 is similar, but saves the status of the variable argument list after the
+    indicated number of arguments; after f2 has been called once with the whole list, the trailing part of the list
+    is gathered again and passed to function f4.
+             #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+             #define MAXARGS 31
+             void f3(int n_ptrs, int f4_after, ...)
+             {
+                   va_list ap, ap_save;
+                   char *array[MAXARGS];
+                   int ptr_no = 0;
+                   if (n_ptrs &gt; MAXARGS)
+                         n_ptrs = MAXARGS;
+                   va_start(ap, f4_after);
+                   while (ptr_no &lt; n_ptrs) {
+                         array[ptr_no++] = va_arg(ap, char *);
+                         if (ptr_no == f4_after)
+                               va_copy(ap_save, ap);
+                   }
+                   va_end(ap);
+                   f2(n_ptrs, array);
+                      // Now process the saved copy.
+                      n_ptrs -= f4_after;
+                      ptr_no = 0;
+                      while (ptr_no &lt; n_ptrs)
+                            array[ptr_no++] = va_arg(ap_save, char *);
+                      va_end(ap_save);
+                      f4(n_ptrs, array);
+             }
+
+[<a name="p252" href="#p252">page 252</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.16" href="#7.16"><b>    7.16 Boolean type and values &lt;stdbool.h&gt;</b></a>
+1   The header <a href="#7.16">&lt;stdbool.h&gt;</a> defines four macros.
+2   The macro
+             bool
+    expands to _Bool.
+3   The remaining three macros are suitable for use in #if preprocessing directives. They
+    are
+             true
+    which expands to the integer constant 1,
+             false
+    which expands to the integer constant 0, and
+             __bool_true_false_are_defined
+    which expands to the integer constant 1.
+4   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+    redefine the macros bool, true, and false.<sup><a href="#note222"><b>222)</b></a></sup>
+
+
+
+
+    <sup><a name="note222" href="#note222"><b>222)</b></a></sup> See ''future library directions'' (<a href="#7.26.7">7.26.7</a>).
+
+[<a name="p253" href="#p253">page 253</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.17" href="#7.17"><b>    7.17 Common definitions &lt;stddef.h&gt;</b></a>
+1   The following types and macros are defined in the standard header <a href="#7.17">&lt;stddef.h&gt;</a>. Some
+    are also defined in other headers, as noted in their respective subclauses.
+2   The types are
+           ptrdiff_t
+    which is the signed integer type of the result of subtracting two pointers;
+           size_t
+    which is the unsigned integer type of the result of the sizeof operator; and
+           wchar_t
+    which is an integer type whose range of values can represent distinct codes for all
+    members of the largest extended character set specified among the supported locales; the
+    null character shall have the code value zero. Each member of the basic character set
+    shall have a code value equal to its value when used as the lone character in an integer
+    character      constant     if     an      implementation      does      not      define
+    __STDC_MB_MIGHT_NEQ_WC__.
+3   The macros are
+           NULL
+    which expands to an implementation-defined null pointer constant; and
+           offsetof(type, member-designator)
+    which expands to an integer constant expression that has type size_t, the value of
+    which is the offset in bytes, to the structure member (designated by member-designator),
+    from the beginning of its structure (designated by type). The type and member designator
+    shall be such that given
+           static type t;
+    then the expression &amp;(t.member-designator) evaluates to an address constant. (If the
+    specified member is a bit-field, the behavior is undefined.)
+    Recommended practice
+4   The types used for size_t and ptrdiff_t should not have an integer conversion rank
+    greater than that of signed long int unless the implementation supports objects
+    large enough to make this necessary.
+    Forward references: localization (<a href="#7.11">7.11</a>).
+
+[<a name="p254" href="#p254">page 254</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.18" href="#7.18"><b>    7.18 Integer types &lt;stdint.h&gt;</b></a>
+1   The header <a href="#7.18">&lt;stdint.h&gt;</a> declares sets of integer types having specified widths, and
+    defines corresponding sets of macros.<sup><a href="#note223"><b>223)</b></a></sup> It also defines macros that specify limits of
+    integer types corresponding to types defined in other standard headers.
+2   Types are defined in the following categories:
+    -- integer types having certain exact widths;
+    -- integer types having at least certain specified widths;
+    -- fastest integer types having at least certain specified widths;
+    -- integer types wide enough to hold pointers to objects;
+    -- integer types having greatest width.
+    (Some of these types may denote the same type.)
+3   Corresponding macros specify limits of the declared types and construct suitable
+    constants.
+4   For each type described herein that the implementation provides,<sup><a href="#note224"><b>224)</b></a></sup> <a href="#7.18">&lt;stdint.h&gt;</a> shall
+    declare that typedef name and define the associated macros. Conversely, for each type
+    described herein that the implementation does not provide, <a href="#7.18">&lt;stdint.h&gt;</a> shall not
+    declare that typedef name nor shall it define the associated macros. An implementation
+    shall provide those types described as ''required'', but need not provide any of the others
+    (described as ''optional'').
+<a name="7.18.1" href="#7.18.1"><b>    7.18.1 Integer types</b></a>
+1   When typedef names differing only in the absence or presence of the initial u are defined,
+    they shall denote corresponding signed and unsigned types as described in <a href="#6.2.5">6.2.5</a>; an
+    implementation providing one of these corresponding types shall also provide the other.
+2   In the following descriptions, the symbol N represents an unsigned decimal integer with
+    no leading zeros (e.g., 8 or 24, but not 04 or 048).
+
+
+
+
+    <sup><a name="note223" href="#note223"><b>223)</b></a></sup> See ''future library directions'' (<a href="#7.26.8">7.26.8</a>).
+    <sup><a name="note224" href="#note224"><b>224)</b></a></sup> Some of these types may denote implementation-defined extended integer types.
+
+[<a name="p255" href="#p255">page 255</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.18.1.1" href="#7.18.1.1"><b>    7.18.1.1 Exact-width integer types</b></a>
+1   The typedef name intN_t designates a signed integer type with width N , no padding
+    bits, and a two's complement representation. Thus, int8_t denotes a signed integer
+    type with a width of exactly 8 bits.
+2   The typedef name uintN_t designates an unsigned integer type with width N . Thus,
+    uint24_t denotes an unsigned integer type with a width of exactly 24 bits.
+3   These types are optional. However, if an implementation provides integer types with
+    widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a
+    two's complement representation, it shall define the corresponding typedef names.
+<a name="7.18.1.2" href="#7.18.1.2"><b>    7.18.1.2 Minimum-width integer types</b></a>
+1   The typedef name int_leastN_t designates a signed integer type with a width of at
+    least N , such that no signed integer type with lesser size has at least the specified width.
+    Thus, int_least32_t denotes a signed integer type with a width of at least 32 bits.
+2   The typedef name uint_leastN_t designates an unsigned integer type with a width
+    of at least N , such that no unsigned integer type with lesser size has at least the specified
+    width. Thus, uint_least16_t denotes an unsigned integer type with a width of at
+    least 16 bits.
+3   The following types are required:
+             int_least8_t                                      uint_least8_t
+             int_least16_t                                     uint_least16_t
+             int_least32_t                                     uint_least32_t
+             int_least64_t                                     uint_least64_t
+    All other types of this form are optional.
+<a name="7.18.1.3" href="#7.18.1.3"><b>    7.18.1.3 Fastest minimum-width integer types</b></a>
+1   Each of the following types designates an integer type that is usually fastest<sup><a href="#note225"><b>225)</b></a></sup> to operate
+    with among all integer types that have at least the specified width.
+2   The typedef name int_fastN_t designates the fastest signed integer type with a width
+    of at least N . The typedef name uint_fastN_t designates the fastest unsigned integer
+    type with a width of at least N .
+
+
+
+
+    <sup><a name="note225" href="#note225"><b>225)</b></a></sup> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
+         grounds for choosing one type over another, it will simply pick some integer type satisfying the
+         signedness and width requirements.
+
+[<a name="p256" href="#p256">page 256</a>] (<a href="#Contents">Contents</a>)
+
+3   The following types are required:
+           int_fast8_t                                 uint_fast8_t
+           int_fast16_t                                uint_fast16_t
+           int_fast32_t                                uint_fast32_t
+           int_fast64_t                                uint_fast64_t
+    All other types of this form are optional.
+<a name="7.18.1.4" href="#7.18.1.4"><b>    7.18.1.4 Integer types capable of holding object pointers</b></a>
+1   The following type designates a signed integer type with the property that any valid
+    pointer to void can be converted to this type, then converted back to pointer to void,
+    and the result will compare equal to the original pointer:
+           intptr_t
+    The following type designates an unsigned integer type with the property that any valid
+    pointer to void can be converted to this type, then converted back to pointer to void,
+    and the result will compare equal to the original pointer:
+           uintptr_t
+    These types are optional.
+<a name="7.18.1.5" href="#7.18.1.5"><b>    7.18.1.5 Greatest-width integer types</b></a>
+1   The following type designates a signed integer type capable of representing any value of
+    any signed integer type:
+           intmax_t
+    The following type designates an unsigned integer type capable of representing any value
+    of any unsigned integer type:
+           uintmax_t
+    These types are required.
+<a name="7.18.2" href="#7.18.2"><b>    7.18.2 Limits of specified-width integer types</b></a>
+1   The following object-like macros<sup><a href="#note226"><b>226)</b></a></sup> specify the minimum and maximum limits of the
+    types declared in <a href="#7.18">&lt;stdint.h&gt;</a>. Each macro name corresponds to a similar type name in
+    <a href="#7.18.1">7.18.1</a>.
+2   Each instance of any defined macro shall be replaced by a constant expression suitable
+    for use in #if preprocessing directives, and this expression shall have the same type as
+    would an expression that is an object of the corresponding type converted according to
+
+    <sup><a name="note226" href="#note226"><b>226)</b></a></sup> C++ implementations should define these macros only when __STDC_LIMIT_MACROS is defined
+         before <a href="#7.18">&lt;stdint.h&gt;</a> is included.
+
+[<a name="p257" href="#p257">page 257</a>] (<a href="#Contents">Contents</a>)
+
+    the integer promotions. Its implementation-defined value shall be equal to or greater in
+    magnitude (absolute value) than the corresponding value given below, with the same sign,
+    except where stated to be exactly the given value.
+<a name="7.18.2.1" href="#7.18.2.1"><b>    7.18.2.1 Limits of exact-width integer types</b></a>
+1   -- minimum values of exact-width signed integer types
+       INTN_MIN                                    exactly -(2 N -1 )
+    -- maximum values of exact-width signed integer types
+       INTN_MAX                                    exactly 2 N -1 - 1
+    -- maximum values of exact-width unsigned integer types
+       UINTN_MAX                                   exactly 2 N - 1
+<a name="7.18.2.2" href="#7.18.2.2"><b>    7.18.2.2 Limits of minimum-width integer types</b></a>
+1   -- minimum values of minimum-width signed integer types
+       INT_LEASTN_MIN                                      -(2 N -1 - 1)
+    -- maximum values of minimum-width signed integer types
+       INT_LEASTN_MAX                                      2 N -1 - 1
+    -- maximum values of minimum-width unsigned integer types
+       UINT_LEASTN_MAX                                     2N - 1
+<a name="7.18.2.3" href="#7.18.2.3"><b>    7.18.2.3 Limits of fastest minimum-width integer types</b></a>
+1   -- minimum values of fastest minimum-width signed integer types
+       INT_FASTN_MIN                                       -(2 N -1 - 1)
+    -- maximum values of fastest minimum-width signed integer types
+       INT_FASTN_MAX                                       2 N -1 - 1
+    -- maximum values of fastest minimum-width unsigned integer types
+       UINT_FASTN_MAX                                      2N - 1
+<a name="7.18.2.4" href="#7.18.2.4"><b>    7.18.2.4 Limits of integer types capable of holding object pointers</b></a>
+1   -- minimum value of pointer-holding signed integer type
+          INTPTR_MIN                                       -(215 - 1)
+    -- maximum value of pointer-holding signed integer type
+          INTPTR_MAX                                       215 - 1
+
+[<a name="p258" href="#p258">page 258</a>] (<a href="#Contents">Contents</a>)
+
+    -- maximum value of pointer-holding unsigned integer type
+        UINTPTR_MAX                                                   216 - 1
+<a name="7.18.2.5" href="#7.18.2.5"><b>    7.18.2.5 Limits of greatest-width integer types</b></a>
+1   -- minimum value of greatest-width signed integer type
+        INTMAX_MIN                                                    -(263 - 1)
+    -- maximum value of greatest-width signed integer type
+        INTMAX_MAX                                                    263 - 1
+    -- maximum value of greatest-width unsigned integer type
+        UINTMAX_MAX                                                   264 - 1
+<a name="7.18.3" href="#7.18.3"><b>    7.18.3 Limits of other integer types</b></a>
+1   The following object-like macros<sup><a href="#note227"><b>227)</b></a></sup> specify the minimum and maximum limits of
+    integer types corresponding to types defined in other standard headers.
+2   Each instance of these macros shall be replaced by a constant expression suitable for use
+    in #if preprocessing directives, and this expression shall have the same type as would an
+    expression that is an object of the corresponding type converted according to the integer
+    promotions. Its implementation-defined value shall be equal to or greater in magnitude
+    (absolute value) than the corresponding value given below, with the same sign. An
+    implementation shall define only the macros corresponding to those typedef names it
+    actually provides.<sup><a href="#note228"><b>228)</b></a></sup>
+    -- limits of ptrdiff_t
+        PTRDIFF_MIN                                                 -65535
+        PTRDIFF_MAX                                                 +65535
+    -- limits of sig_atomic_t
+        SIG_ATOMIC_MIN                                              see below
+        SIG_ATOMIC_MAX                                              see below
+    -- limit of size_t
+        SIZE_MAX                                                      65535
+    -- limits of wchar_t
+
+
+
+    <sup><a name="note227" href="#note227"><b>227)</b></a></sup> C++ implementations should define these macros only when __STDC_LIMIT_MACROS is defined
+         before <a href="#7.18">&lt;stdint.h&gt;</a> is included.
+    <sup><a name="note228" href="#note228"><b>228)</b></a></sup> A freestanding implementation need not provide all of these types.
+
+[<a name="p259" href="#p259">page 259</a>] (<a href="#Contents">Contents</a>)
+
+       WCHAR_MIN                                              see below
+       WCHAR_MAX                                              see below
+    -- limits of wint_t
+       WINT_MIN                                               see below
+       WINT_MAX                                               see below
+3   If sig_atomic_t (see <a href="#7.14">7.14</a>) is defined as a signed integer type, the value of
+    SIG_ATOMIC_MIN shall be no greater than -127 and the value of SIG_ATOMIC_MAX
+    shall be no less than 127; otherwise, sig_atomic_t is defined as an unsigned integer
+    type, and the value of SIG_ATOMIC_MIN shall be 0 and the value of
+    SIG_ATOMIC_MAX shall be no less than 255.
+4   If wchar_t (see <a href="#7.17">7.17</a>) is defined as a signed integer type, the value of WCHAR_MIN
+    shall be no greater than -127 and the value of WCHAR_MAX shall be no less than 127;
+    otherwise, wchar_t is defined as an unsigned integer type, and the value of
+    WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.<sup><a href="#note229"><b>229)</b></a></sup>
+5   If wint_t (see <a href="#7.24">7.24</a>) is defined as a signed integer type, the value of WINT_MIN shall
+    be no greater than -32767 and the value of WINT_MAX shall be no less than 32767;
+    otherwise, wint_t is defined as an unsigned integer type, and the value of WINT_MIN
+    shall be 0 and the value of WINT_MAX shall be no less than 65535.
+<a name="7.18.4" href="#7.18.4"><b>    7.18.4 Macros for integer constants</b></a>
+1   The following function-like macros<sup><a href="#note230"><b>230)</b></a></sup> expand to integer constants suitable for
+    initializing objects that have integer types corresponding to types defined in
+    <a href="#7.18">&lt;stdint.h&gt;</a>. Each macro name corresponds to a similar type name in <a href="#7.18.1.2">7.18.1.2</a> or
+    <a href="#7.18.1.5">7.18.1.5</a>.
+2   The argument in any instance of these macros shall be an unsuffixed integer constant (as
+    defined in <a href="#6.4.4.1">6.4.4.1</a>) with a value that does not exceed the limits for the corresponding type.
+3   Each invocation of one of these macros shall expand to an integer constant expression
+    suitable for use in #if preprocessing directives. The type of the expression shall have
+    the same type as would an expression of the corresponding type converted according to
+    the integer promotions. The value of the expression shall be that of the argument.
+
+
+
+
+    <sup><a name="note229" href="#note229"><b>229)</b></a></sup> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
+         character set.
+    <sup><a name="note230" href="#note230"><b>230)</b></a></sup> C++ implementations should define these macros only when __STDC_CONSTANT_MACROS is
+         defined before <a href="#7.18">&lt;stdint.h&gt;</a> is included.
+
+[<a name="p260" href="#p260">page 260</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.18.4.1" href="#7.18.4.1"><b>    7.18.4.1 Macros for minimum-width integer constants</b></a>
+1   The macro INTN_C(value) shall expand to an integer constant expression
+    corresponding to the type int_leastN_t. The macro UINTN_C(value) shall expand
+    to an integer constant expression corresponding to the type uint_leastN_t. For
+    example, if uint_least64_t is a name for the type unsigned long long int,
+    then UINT64_C(0x123) might expand to the integer constant 0x123ULL.
+<a name="7.18.4.2" href="#7.18.4.2"><b>    7.18.4.2 Macros for greatest-width integer constants</b></a>
+1   The following macro expands to an integer constant expression having the value specified
+    by its argument and the type intmax_t:
+           INTMAX_C(value)
+    The following macro expands to an integer constant expression having the value specified
+    by its argument and the type uintmax_t:
+           UINTMAX_C(value)
+
+[<a name="p261" href="#p261">page 261</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19" href="#7.19"><b>    7.19 Input/output &lt;stdio.h&gt;</b></a>
+<a name="7.19.1" href="#7.19.1"><b>    7.19.1 Introduction</b></a>
+1   The header <a href="#7.19">&lt;stdio.h&gt;</a> declares three types, several macros, and many functions for
+    performing input and output.
+2   The types declared are size_t (described in <a href="#7.17">7.17</a>);
+           FILE
+    which is an object type capable of recording all the information needed to control a
+    stream, including its file position indicator, a pointer to its associated buffer (if any), an
+    error indicator that records whether a read/write error has occurred, and an end-of-file
+    indicator that records whether the end of the file has been reached; and
+           fpos_t
+    which is an object type other than an array type capable of recording all the information
+    needed to specify uniquely every position within a file.
+3   The macros are NULL (described in <a href="#7.17">7.17</a>);
+           _IOFBF
+           _IOLBF
+           _IONBF
+    which expand to integer constant expressions with distinct values, suitable for use as the
+    third argument to the setvbuf function;
+           BUFSIZ
+    which expands to an integer constant expression that is the size of the buffer used by the
+    setbuf function;
+           EOF
+    which expands to an integer constant expression, with type int and a negative value, that
+    is returned by several functions to indicate end-of-file, that is, no more input from a
+    stream;
+           FOPEN_MAX
+    which expands to an integer constant expression that is the minimum number of files that
+    the implementation guarantees can be open simultaneously;
+           FILENAME_MAX
+    which expands to an integer constant expression that is the size needed for an array of
+    char large enough to hold the longest file name string that the implementation
+
+[<a name="p262" href="#p262">page 262</a>] (<a href="#Contents">Contents</a>)
+
+    guarantees can be opened;<sup><a href="#note231"><b>231)</b></a></sup>
+            L_tmpnam
+    which expands to an integer constant expression that is the size needed for an array of
+    char large enough to hold a temporary file name string generated by the tmpnam
+    function;
+            SEEK_CUR
+            SEEK_END
+            SEEK_SET
+    which expand to integer constant expressions with distinct values, suitable for use as the
+    third argument to the fseek function;
+            TMP_MAX
+    which expands to an integer constant expression that is the maximum number of unique
+    file names that can be generated by the tmpnam function;
+            stderr
+            stdin
+            stdout
+    which are expressions of type ''pointer to FILE'' that point to the FILE objects
+    associated, respectively, with the standard error, input, and output streams.
+4   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares a number of functions useful for wide character input
+    and output. The wide character input/output functions described in that subclause
+    provide operations analogous to most of those described here, except that the
+    fundamental units internal to the program are wide characters. The external
+    representation (in the file) is a sequence of ''generalized'' multibyte characters, as
+    described further in <a href="#7.19.3">7.19.3</a>.
+5   The input/output functions are given the following collective terms:
+    -- The wide character input functions -- those functions described in <a href="#7.24">7.24</a> that perform
+      input into wide characters and wide strings: fgetwc, fgetws, getwc, getwchar,
+      fwscanf, wscanf, vfwscanf, and vwscanf.
+    -- The wide character output functions -- those functions described in <a href="#7.24">7.24</a> that perform
+      output from wide characters and wide strings: fputwc, fputws, putwc,
+      putwchar, fwprintf, wprintf, vfwprintf, and vwprintf.
+
+
+    <sup><a name="note231" href="#note231"><b>231)</b></a></sup> If the implementation imposes no practical limit on the length of file name strings, the value of
+         FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
+         string. Of course, file name string contents are subject to other system-specific constraints; therefore
+         all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
+
+[<a name="p263" href="#p263">page 263</a>] (<a href="#Contents">Contents</a>)
+
+    -- The wide character input/output functions -- the union of the ungetwc function, the
+      wide character input functions, and the wide character output functions.
+    -- The byte input/output functions -- those functions described in this subclause that
+      perform input/output: fgetc, fgets, fprintf, fputc, fputs, fread,
+      fscanf, fwrite, getc, getchar, gets, printf, putc, putchar, puts,
+      scanf, ungetc, vfprintf, vfscanf, vprintf, and vscanf.
+    Forward references: files (<a href="#7.19.3">7.19.3</a>), the fseek function (<a href="#7.19.9.2">7.19.9.2</a>), streams (<a href="#7.19.2">7.19.2</a>), the
+    tmpnam function (<a href="#7.19.4.4">7.19.4.4</a>), <a href="#7.24">&lt;wchar.h&gt;</a> (<a href="#7.24">7.24</a>).
+<a name="7.19.2" href="#7.19.2"><b>    7.19.2 Streams</b></a>
+1   Input and output, whether to or from physical devices such as terminals and tape drives,
+    or whether to or from files supported on structured storage devices, are mapped into
+    logical data streams, whose properties are more uniform than their various inputs and
+    outputs. Two forms of mapping are supported, for text streams and for binary
+    streams.<sup><a href="#note232"><b>232)</b></a></sup>
+2   A text stream is an ordered sequence of characters composed into lines, each line
+    consisting of zero or more characters plus a terminating new-line character. Whether the
+    last line requires a terminating new-line character is implementation-defined. Characters
+    may have to be added, altered, or deleted on input and output to conform to differing
+    conventions for representing text in the host environment. Thus, there need not be a one-
+    to-one correspondence between the characters in a stream and those in the external
+    representation. Data read in from a text stream will necessarily compare equal to the data
+    that were earlier written out to that stream only if: the data consist only of printing
+    characters and the control characters horizontal tab and new-line; no new-line character is
+    immediately preceded by space characters; and the last character is a new-line character.
+    Whether space characters that are written out immediately before a new-line character
+    appear when read in is implementation-defined.
+3   A binary stream is an ordered sequence of characters that can transparently record
+    internal data. Data read in from a binary stream shall compare equal to the data that were
+    earlier written out to that stream, under the same implementation. Such a stream may,
+    however, have an implementation-defined number of null characters appended to the end
+    of the stream.
+4   Each stream has an orientation. After a stream is associated with an external file, but
+    before any operations are performed on it, the stream is without orientation. Once a wide
+    character input/output function has been applied to a stream without orientation, the
+
+
+    <sup><a name="note232" href="#note232"><b>232)</b></a></sup> An implementation need not distinguish between text streams and binary streams. In such an
+         implementation, there need be no new-line characters in a text stream nor any limit to the length of a
+         line.
+
+[<a name="p264" href="#p264">page 264</a>] (<a href="#Contents">Contents</a>)
+
+    stream becomes a wide-oriented stream. Similarly, once a byte input/output function has
+    been applied to a stream without orientation, the stream becomes a byte-oriented stream.
+    Only a call to the freopen function or the fwide function can otherwise alter the
+    orientation of a stream. (A successful call to freopen removes any orientation.)<sup><a href="#note233"><b>233)</b></a></sup>
+5   Byte input/output functions shall not be applied to a wide-oriented stream and wide
+    character input/output functions shall not be applied to a byte-oriented stream. The
+    remaining stream operations do not affect, and are not affected by, a stream's orientation,
+    except for the following additional restrictions:
+    -- Binary wide-oriented streams have the file-positioning restrictions ascribed to both
+      text and binary streams.
+    -- For wide-oriented streams, after a successful call to a file-positioning function that
+      leaves the file position indicator prior to the end-of-file, a wide character output
+      function can overwrite a partial multibyte character; any file contents beyond the
+      byte(s) written are henceforth indeterminate.
+6   Each wide-oriented stream has an associated mbstate_t object that stores the current
+    parse state of the stream. A successful call to fgetpos stores a representation of the
+    value of this mbstate_t object as part of the value of the fpos_t object. A later
+    successful call to fsetpos using the same stored fpos_t value restores the value of
+    the associated mbstate_t object as well as the position within the controlled stream.
+    Environmental limits
+7   An implementation shall support text files with lines containing at least 254 characters,
+    including the terminating new-line character. The value of the macro BUFSIZ shall be at
+    least 256.
+    Forward references: the freopen function (<a href="#7.19.5.4">7.19.5.4</a>), the fwide function (<a href="#7.24.3.5">7.24.3.5</a>),
+    mbstate_t (<a href="#7.25.1">7.25.1</a>), the fgetpos function (<a href="#7.19.9.1">7.19.9.1</a>), the fsetpos function
+    (<a href="#7.19.9.3">7.19.9.3</a>).
+
+
+
+
+    <sup><a name="note233" href="#note233"><b>233)</b></a></sup> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
+
+[<a name="p265" href="#p265">page 265</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.3" href="#7.19.3"><b>    7.19.3 Files</b></a>
+1   A stream is associated with an external file (which may be a physical device) by opening
+    a file, which may involve creating a new file. Creating an existing file causes its former
+    contents to be discarded, if necessary. If a file can support positioning requests (such as a
+    disk file, as opposed to a terminal), then a file position indicator associated with the
+    stream is positioned at the start (character number zero) of the file, unless the file is
+    opened with append mode in which case it is implementation-defined whether the file
+    position indicator is initially positioned at the beginning or the end of the file. The file
+    position indicator is maintained by subsequent reads, writes, and positioning requests, to
+    facilitate an orderly progression through the file.
+2   Binary files are not truncated, except as defined in <a href="#7.19.5.3">7.19.5.3</a>. Whether a write on a text
+    stream causes the associated file to be truncated beyond that point is implementation-
+    defined.
+3   When a stream is unbuffered, characters are intended to appear from the source or at the
+    destination as soon as possible. Otherwise characters may be accumulated and
+    transmitted to or from the host environment as a block. When a stream is fully buffered,
+    characters are intended to be transmitted to or from the host environment as a block when
+    a buffer is filled. When a stream is line buffered, characters are intended to be
+    transmitted to or from the host environment as a block when a new-line character is
+    encountered. Furthermore, characters are intended to be transmitted as a block to the host
+    environment when a buffer is filled, when input is requested on an unbuffered stream, or
+    when input is requested on a line buffered stream that requires the transmission of
+    characters from the host environment. Support for these characteristics is
+    implementation-defined, and may be affected via the setbuf and setvbuf functions.
+4   A file may be disassociated from a controlling stream by closing the file. Output streams
+    are flushed (any unwritten buffer contents are transmitted to the host environment) before
+    the stream is disassociated from the file. The value of a pointer to a FILE object is
+    indeterminate after the associated file is closed (including the standard text streams).
+    Whether a file of zero length (on which no characters have been written by an output
+    stream) actually exists is implementation-defined.
+5   The file may be subsequently reopened, by the same or another program execution, and
+    its contents reclaimed or modified (if it can be repositioned at its start). If the main
+    function returns to its original caller, or if the exit function is called, all open files are
+    closed (hence all output streams are flushed) before program termination. Other paths to
+    program termination, such as calling the abort function, need not close all files
+    properly.
+6   The address of the FILE object used to control a stream may be significant; a copy of a
+    FILE object need not serve in place of the original.
+
+[<a name="p266" href="#p266">page 266</a>] (<a href="#Contents">Contents</a>)
+
+7    At program startup, three text streams are predefined and need not be opened explicitly
+     -- standard input (for reading conventional input), standard output (for writing
+     conventional output), and standard error (for writing diagnostic output). As initially
+     opened, the standard error stream is not fully buffered; the standard input and standard
+     output streams are fully buffered if and only if the stream can be determined not to refer
+     to an interactive device.
+8    Functions that open additional (nontemporary) files require a file name, which is a string.
+     The rules for composing valid file names are implementation-defined. Whether the same
+     file can be simultaneously open multiple times is also implementation-defined.
+9    Although both text and binary wide-oriented streams are conceptually sequences of wide
+     characters, the external file associated with a wide-oriented stream is a sequence of
+     multibyte characters, generalized as follows:
+     -- Multibyte encodings within files may contain embedded null bytes (unlike multibyte
+       encodings valid for use internal to the program).
+     -- A file need not begin nor end in the initial shift state.<sup><a href="#note234"><b>234)</b></a></sup>
+10   Moreover, the encodings used for multibyte characters may differ among files. Both the
+     nature and choice of such encodings are implementation-defined.
+11   The wide character input functions read multibyte characters from the stream and convert
+     them to wide characters as if they were read by successive calls to the fgetwc function.
+     Each conversion occurs as if by a call to the mbrtowc function, with the conversion state
+     described by the stream's own mbstate_t object. The byte input functions read
+     characters from the stream as if by successive calls to the fgetc function.
+12   The wide character output functions convert wide characters to multibyte characters and
+     write them to the stream as if they were written by successive calls to the fputwc
+     function. Each conversion occurs as if by a call to the wcrtomb function, with the
+     conversion state described by the stream's own mbstate_t object. The byte output
+     functions write characters to the stream as if by successive calls to the fputc function.
+13   In some cases, some of the byte input/output functions also perform conversions between
+     multibyte characters and wide characters. These conversions also occur as if by calls to
+     the mbrtowc and wcrtomb functions.
+14   An encoding error occurs if the character sequence presented to the underlying
+     mbrtowc function does not form a valid (generalized) multibyte character, or if the code
+     value passed to the underlying wcrtomb does not correspond to a valid (generalized)
+
+
+     <sup><a name="note234" href="#note234"><b>234)</b></a></sup> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
+          undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
+          with state-dependent encoding that does not assuredly end in the initial shift state.
+
+[<a name="p267" href="#p267">page 267</a>] (<a href="#Contents">Contents</a>)
+
+     multibyte character. The wide character input/output functions and the byte input/output
+     functions store the value of the macro EILSEQ in errno if and only if an encoding error
+     occurs.
+     Environmental limits
+15   The value of FOPEN_MAX shall be at least eight, including the three standard text
+     streams.
+     Forward references: the exit function (<a href="#7.20.4.3">7.20.4.3</a>), the fgetc function (<a href="#7.19.7.1">7.19.7.1</a>), the
+     fopen function (<a href="#7.19.5.3">7.19.5.3</a>), the fputc function (<a href="#7.19.7.3">7.19.7.3</a>), the setbuf function
+     (<a href="#7.19.5.5">7.19.5.5</a>), the setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>), the fgetwc function (<a href="#7.24.3.1">7.24.3.1</a>), the
+     fputwc function (<a href="#7.24.3.3">7.24.3.3</a>), conversion state (<a href="#7.24.6">7.24.6</a>), the mbrtowc function
+     (<a href="#7.24.6.3.2">7.24.6.3.2</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+<a name="7.19.4" href="#7.19.4"><b>     7.19.4 Operations on files</b></a>
+<a name="7.19.4.1" href="#7.19.4.1"><b>     7.19.4.1 The remove function</b></a>
+<b>     Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            int remove(const char *filename);
+<b>     Description</b>
+2    The remove function causes the file whose name is the string pointed to by filename
+     to be no longer accessible by that name. A subsequent attempt to open that file using that
+     name will fail, unless it is created anew. If the file is open, the behavior of the remove
+     function is implementation-defined.
+<b>     Returns</b>
+3    The remove function returns zero if the operation succeeds, nonzero if it fails.
+<a name="7.19.4.2" href="#7.19.4.2"><b>     7.19.4.2 The rename function</b></a>
+<b>     Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            int rename(const char *old, const char *new);
+<b>     Description</b>
+2    The rename function causes the file whose name is the string pointed to by old to be
+     henceforth known by the name given by the string pointed to by new. The file named
+     old is no longer accessible by that name. If a file named by the string pointed to by new
+     exists prior to the call to the rename function, the behavior is implementation-defined.
+
+[<a name="p268" href="#p268">page 268</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The rename function returns zero if the operation succeeds, nonzero if it fails,<sup><a href="#note235"><b>235)</b></a></sup> in
+    which case if the file existed previously it is still known by its original name.
+<a name="7.19.4.3" href="#7.19.4.3"><b>    7.19.4.3 The tmpfile function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            FILE *tmpfile(void);
+<b>    Description</b>
+2   The tmpfile function creates a temporary binary file that is different from any other
+    existing file and that will automatically be removed when it is closed or at program
+    termination. If the program terminates abnormally, whether an open temporary file is
+    removed is implementation-defined. The file is opened for update with "wb+" mode.
+    Recommended practice
+3   It should be possible to open at least TMP_MAX temporary files during the lifetime of the
+    program (this limit may be shared with tmpnam) and there should be no limit on the
+    number simultaneously open other than this limit and any limit on the number of open
+    files (FOPEN_MAX).
+<b>    Returns</b>
+4   The tmpfile function returns a pointer to the stream of the file that it created. If the file
+    cannot be created, the tmpfile function returns a null pointer.
+    Forward references: the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
+<a name="7.19.4.4" href="#7.19.4.4"><b>    7.19.4.4 The tmpnam function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            char *tmpnam(char *s);
+<b>    Description</b>
+2   The tmpnam function generates a string that is a valid file name and that is not the same
+    as the name of an existing file.<sup><a href="#note236"><b>236)</b></a></sup> The function is potentially capable of generating
+
+
+    <sup><a name="note235" href="#note235"><b>235)</b></a></sup> Among the reasons the implementation may cause the rename function to fail are that the file is open
+         or that it is necessary to copy its contents to effectuate its renaming.
+    <sup><a name="note236" href="#note236"><b>236)</b></a></sup> Files created using strings generated by the tmpnam function are temporary only in the sense that
+         their names should not collide with those generated by conventional naming rules for the
+         implementation. It is still necessary to use the remove function to remove such files when their use
+         is ended, and before program termination.
+
+[<a name="p269" href="#p269">page 269</a>] (<a href="#Contents">Contents</a>)
+
+    TMP_MAX different strings, but any or all of them may already be in use by existing files
+    and thus not be suitable return values.
+3   The tmpnam function generates a different string each time it is called.
+4   The implementation shall behave as if no library function calls the tmpnam function.
+<b>    Returns</b>
+5   If no suitable string can be generated, the tmpnam function returns a null pointer.
+    Otherwise, if the argument is a null pointer, the tmpnam function leaves its result in an
+    internal static object and returns a pointer to that object (subsequent calls to the tmpnam
+    function may modify the same object). If the argument is not a null pointer, it is assumed
+    to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
+    in that array and returns the argument as its value.
+    Environmental limits
+6   The value of the macro TMP_MAX shall be at least 25.
+<a name="7.19.5" href="#7.19.5"><b>    7.19.5 File access functions</b></a>
+<a name="7.19.5.1" href="#7.19.5.1"><b>    7.19.5.1 The fclose function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int fclose(FILE *stream);
+<b>    Description</b>
+2   A successful call to the fclose function causes the stream pointed to by stream to be
+    flushed and the associated file to be closed. Any unwritten buffered data for the stream
+    are delivered to the host environment to be written to the file; any unread buffered data
+    are discarded. Whether or not the call succeeds, the stream is disassociated from the file
+    and any buffer set by the setbuf or setvbuf function is disassociated from the stream
+    (and deallocated if it was automatically allocated).
+<b>    Returns</b>
+3   The fclose function returns zero if the stream was successfully closed, or EOF if any
+    errors were detected.
+<a name="7.19.5.2" href="#7.19.5.2"><b>    7.19.5.2 The fflush function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int fflush(FILE *stream);
+
+[<a name="p270" href="#p270">page 270</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   If stream points to an output stream or an update stream in which the most recent
+    operation was not input, the fflush function causes any unwritten data for that stream
+    to be delivered to the host environment to be written to the file; otherwise, the behavior is
+    undefined.
+3   If stream is a null pointer, the fflush function performs this flushing action on all
+    streams for which the behavior is defined above.
+<b>    Returns</b>
+4   The fflush function sets the error indicator for the stream and returns EOF if a write
+    error occurs, otherwise it returns zero.
+    Forward references: the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
+<a name="7.19.5.3" href="#7.19.5.3"><b>    7.19.5.3 The fopen function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            FILE *fopen(const char * restrict filename,
+                 const char * restrict mode);
+<b>    Description</b>
+2   The fopen function opens the file whose name is the string pointed to by filename,
+    and associates a stream with it.
+3   The argument mode points to a string. If the string is one of the following, the file is
+    open in the indicated mode. Otherwise, the behavior is undefined.<sup><a href="#note237"><b>237)</b></a></sup>
+    r                open text file for reading
+    w                truncate to zero length or create text file for writing
+    a                append; open or create text file for writing at end-of-file
+    rb               open binary file for reading
+    wb               truncate to zero length or create binary file for writing
+    ab               append; open or create binary file for writing at end-of-file
+    r+               open text file for update (reading and writing)
+    w+               truncate to zero length or create text file for update
+    a+               append; open or create text file for update, writing at end-of-file
+
+
+
+
+    <sup><a name="note237" href="#note237"><b>237)</b></a></sup> If the string begins with one of the above sequences, the implementation might choose to ignore the
+         remaining characters, or it might use them to select different kinds of a file (some of which might not
+         conform to the properties in <a href="#7.19.2">7.19.2</a>).
+
+[<a name="p271" href="#p271">page 271</a>] (<a href="#Contents">Contents</a>)
+
+    r+b or rb+ open binary file for update (reading and writing)
+    w+b or wb+ truncate to zero length or create binary file for update
+    a+b or ab+ append; open or create binary file for update, writing at end-of-file
+4   Opening a file with read mode ('r' as the first character in the mode argument) fails if
+    the file does not exist or cannot be read.
+5   Opening a file with append mode ('a' as the first character in the mode argument)
+    causes all subsequent writes to the file to be forced to the then current end-of-file,
+    regardless of intervening calls to the fseek function. In some implementations, opening
+    a binary file with append mode ('b' as the second or third character in the above list of
+    mode argument values) may initially position the file position indicator for the stream
+    beyond the last data written, because of null character padding.
+6   When a file is opened with update mode ('+' as the second or third character in the
+    above list of mode argument values), both input and output may be performed on the
+    associated stream. However, output shall not be directly followed by input without an
+    intervening call to the fflush function or to a file positioning function (fseek,
+    fsetpos, or rewind), and input shall not be directly followed by output without an
+    intervening call to a file positioning function, unless the input operation encounters end-
+    of-file. Opening (or creating) a text file with update mode may instead open (or create) a
+    binary stream in some implementations.
+7   When opened, a stream is fully buffered if and only if it can be determined not to refer to
+    an interactive device. The error and end-of-file indicators for the stream are cleared.
+<b>    Returns</b>
+8   The fopen function returns a pointer to the object controlling the stream. If the open
+    operation fails, fopen returns a null pointer.
+    Forward references: file positioning functions (<a href="#7.19.9">7.19.9</a>).
+<a name="7.19.5.4" href="#7.19.5.4"><b>    7.19.5.4 The freopen function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           FILE *freopen(const char * restrict filename,
+                const char * restrict mode,
+                FILE * restrict stream);
+<b>    Description</b>
+2   The freopen function opens the file whose name is the string pointed to by filename
+    and associates the stream pointed to by stream with it. The mode argument is used just
+
+[<a name="p272" href="#p272">page 272</a>] (<a href="#Contents">Contents</a>)
+
+    as in the fopen function.<sup><a href="#note238"><b>238)</b></a></sup>
+3   If filename is a null pointer, the freopen function attempts to change the mode of
+    the stream to that specified by mode, as if the name of the file currently associated with
+    the stream had been used. It is implementation-defined which changes of mode are
+    permitted (if any), and under what circumstances.
+4   The freopen function first attempts to close any file that is associated with the specified
+    stream. Failure to close the file is ignored. The error and end-of-file indicators for the
+    stream are cleared.
+<b>    Returns</b>
+5   The freopen function returns a null pointer if the open operation fails. Otherwise,
+    freopen returns the value of stream.
+<a name="7.19.5.5" href="#7.19.5.5"><b>    7.19.5.5 The setbuf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            void setbuf(FILE * restrict stream,
+                 char * restrict buf);
+<b>    Description</b>
+2   Except that it returns no value, the setbuf function is equivalent to the setvbuf
+    function invoked with the values _IOFBF for mode and BUFSIZ for size, or (if buf
+    is a null pointer), with the value _IONBF for mode.
+<b>    Returns</b>
+3   The setbuf function returns no value.
+    Forward references: the setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>).
+<a name="7.19.5.6" href="#7.19.5.6"><b>    7.19.5.6 The setvbuf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            int setvbuf(FILE * restrict stream,
+                 char * restrict buf,
+                 int mode, size_t size);
+
+
+
+
+    <sup><a name="note238" href="#note238"><b>238)</b></a></sup> The primary use of the freopen function is to change the file associated with a standard text stream
+         (stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
+         returned by the fopen function may be assigned.
+
+[<a name="p273" href="#p273">page 273</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The setvbuf function may be used only after the stream pointed to by stream has
+    been associated with an open file and before any other operation (other than an
+    unsuccessful call to setvbuf) is performed on the stream. The argument mode
+    determines how stream will be buffered, as follows: _IOFBF causes input/output to be
+    fully buffered; _IOLBF causes input/output to be line buffered; _IONBF causes
+    input/output to be unbuffered. If buf is not a null pointer, the array it points to may be
+    used instead of a buffer allocated by the setvbuf function<sup><a href="#note239"><b>239)</b></a></sup> and the argument size
+    specifies the size of the array; otherwise, size may determine the size of a buffer
+    allocated by the setvbuf function. The contents of the array at any time are
+    indeterminate.
+<b>    Returns</b>
+3   The setvbuf function returns zero on success, or nonzero if an invalid value is given
+    for mode or if the request cannot be honored.
+<a name="7.19.6" href="#7.19.6"><b>    7.19.6 Formatted input/output functions</b></a>
+1   The formatted input/output functions shall behave as if there is a sequence point after the
+    actions associated with each specifier.<sup><a href="#note240"><b>240)</b></a></sup>
+<a name="7.19.6.1" href="#7.19.6.1"><b>    7.19.6.1 The fprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            int fprintf(FILE * restrict stream,
+                 const char * restrict format, ...);
+<b>    Description</b>
+2   The fprintf function writes output to the stream pointed to by stream, under control
+    of the string pointed to by format that specifies how subsequent arguments are
+    converted for output. If there are insufficient arguments for the format, the behavior is
+    undefined. If the format is exhausted while arguments remain, the excess arguments are
+    evaluated (as always) but are otherwise ignored. The fprintf function returns when
+    the end of the format string is encountered.
+3   The format shall be a multibyte character sequence, beginning and ending in its initial
+    shift state. The format is composed of zero or more directives: ordinary multibyte
+    characters (not %), which are copied unchanged to the output stream; and conversion
+
+
+    <sup><a name="note239" href="#note239"><b>239)</b></a></sup> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
+         before a buffer that has automatic storage duration is deallocated upon block exit.
+    <sup><a name="note240" href="#note240"><b>240)</b></a></sup> The fprintf functions perform writes to memory for the %n specifier.
+
+[<a name="p274" href="#p274">page 274</a>] (<a href="#Contents">Contents</a>)
+
+    specifications, each of which results in fetching zero or more subsequent arguments,
+    converting them, if applicable, according to the corresponding conversion specifier, and
+    then writing the result to the output stream.
+4   Each conversion specification is introduced by the character %. After the %, the following
+    appear in sequence:
+    -- Zero or more flags (in any order) that modify the meaning of the conversion
+      specification.
+    -- An optional minimum field width. If the converted value has fewer characters than the
+      field width, it is padded with spaces (by default) on the left (or right, if the left
+      adjustment flag, described later, has been given) to the field width. The field width
+      takes the form of an asterisk * (described later) or a nonnegative decimal integer.<sup><a href="#note241"><b>241)</b></a></sup>
+    -- An optional precision that gives the minimum number of digits to appear for the d, i,
+      o, u, x, and X conversions, the number of digits to appear after the decimal-point
+      character for a, A, e, E, f, and F conversions, the maximum number of significant
+      digits for the g and G conversions, or the maximum number of bytes to be written for
+      s conversions. The precision takes the form of a period (.) followed either by an
+      asterisk * (described later) or by an optional decimal integer; if only the period is
+      specified, the precision is taken as zero. If a precision appears with any other
+      conversion specifier, the behavior is undefined.
+    -- An optional length modifier that specifies the size of the argument.
+    -- A conversion specifier character that specifies the type of conversion to be applied.
+5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+    this case, an int argument supplies the field width or precision. The arguments
+    specifying field width, or precision, or both, shall appear (in that order) before the
+    argument (if any) to be converted. A negative field width argument is taken as a - flag
+    followed by a positive field width. A negative precision argument is taken as if the
+    precision were omitted.
+6   The flag characters and their meanings are:
+    -        The result of the conversion is left-justified within the field. (It is right-justified if
+             this flag is not specified.)
+    +        The result of a signed conversion always begins with a plus or minus sign. (It
+             begins with a sign only when a negative value is converted if this flag is not
+
+
+
+
+    <sup><a name="note241" href="#note241"><b>241)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
+
+[<a name="p275" href="#p275">page 275</a>] (<a href="#Contents">Contents</a>)
+
+              specified.)<sup><a href="#note242"><b>242)</b></a></sup>
+    space If the first character of a signed conversion is not a sign, or if a signed conversion
+          results in no characters, a space is prefixed to the result. If the space and + flags
+          both appear, the space flag is ignored.
+    #         The result is converted to an ''alternative form''. For o conversion, it increases
+              the precision, if and only if necessary, to force the first digit of the result to be a
+              zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+              conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
+              and G conversions, the result of converting a floating-point number always
+              contains a decimal-point character, even if no digits follow it. (Normally, a
+              decimal-point character appears in the result of these conversions only if a digit
+              follows it.) For g and G conversions, trailing zeros are not removed from the
+              result. For other conversions, the behavior is undefined.
+    0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+              (following any indication of sign or base) are used to pad to the field width rather
+              than performing space padding, except when converting an infinity or NaN. If the
+              0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
+              conversions, if a precision is specified, the 0 flag is ignored. For other
+              conversions, the behavior is undefined.
+7   The length modifiers and their meanings are:
+    hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   signed char or unsigned char argument (the argument will have
+                   been promoted according to the integer promotions, but its value shall be
+                   converted to signed char or unsigned char before printing); or that
+                   a following n conversion specifier applies to a pointer to a signed char
+                   argument.
+    h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   short int or unsigned short int argument (the argument will
+                   have been promoted according to the integer promotions, but its value shall
+                   be converted to short int or unsigned short int before printing);
+                   or that a following n conversion specifier applies to a pointer to a short
+                   int argument.
+    l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   long int or unsigned long int argument; that a following n
+                   conversion specifier applies to a pointer to a long int argument; that a
+
+    <sup><a name="note242" href="#note242"><b>242)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+         include a minus sign.
+
+[<a name="p276" href="#p276">page 276</a>] (<a href="#Contents">Contents</a>)
+
+                 following c conversion specifier applies to a wint_t argument; that a
+                 following s conversion specifier applies to a pointer to a wchar_t
+                 argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+                 specifier.
+    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 long long int or unsigned long long int argument; or that a
+                 following n conversion specifier applies to a pointer to a long long int
+                 argument.
+    j            Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+                 an intmax_t or uintmax_t argument; or that a following n conversion
+                 specifier applies to a pointer to an intmax_t argument.
+    z            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 size_t or the corresponding signed integer type argument; or that a
+                 following n conversion specifier applies to a pointer to a signed integer type
+                 corresponding to size_t argument.
+    t            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 ptrdiff_t or the corresponding unsigned integer type argument; or that a
+                 following n conversion specifier applies to a pointer to a ptrdiff_t
+                 argument.
+    L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                 applies to a long double argument.
+    If a length modifier appears with any conversion specifier other than as specified above,
+    the behavior is undefined.
+8   The conversion specifiers and their meanings are:
+    d,i         The int argument is converted to signed decimal in the style [-]dddd. The
+                precision specifies the minimum number of digits to appear; if the value
+                being converted can be represented in fewer digits, it is expanded with
+                leading zeros. The default precision is 1. The result of converting a zero
+                value with a precision of zero is no characters.
+    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+            letters abcdef are used for x conversion and the letters ABCDEF for X
+            conversion. The precision specifies the minimum number of digits to appear;
+            if the value being converted can be represented in fewer digits, it is expanded
+            with leading zeros. The default precision is 1. The result of converting a
+            zero value with a precision of zero is no characters.
+
+[<a name="p277" href="#p277">page 277</a>] (<a href="#Contents">Contents</a>)
+
+f,F          A double argument representing a floating-point number is converted to
+             decimal notation in the style [-]ddd.ddd, where the number of digits after
+             the decimal-point character is equal to the precision specification. If the
+             precision is missing, it is taken as 6; if the precision is zero and the # flag is
+             not specified, no decimal-point character appears. If a decimal-point
+             character appears, at least one digit appears before it. The value is rounded to
+             the appropriate number of digits.
+             A double argument representing an infinity is converted in one of the styles
+             [-]inf or [-]infinity -- which style is implementation-defined. A
+             double argument representing a NaN is converted in one of the styles
+             [-]nan or [-]nan(n-char-sequence) -- which style, and the meaning of
+             any n-char-sequence, is implementation-defined. The F conversion specifier
+             produces INF, INFINITY, or NAN instead of inf, infinity, or nan,
+             respectively.<sup><a href="#note243"><b>243)</b></a></sup>
+e,E          A double argument representing a floating-point number is converted in the
+             style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+             argument is nonzero) before the decimal-point character and the number of
+             digits after it is equal to the precision; if the precision is missing, it is taken as
+             6; if the precision is zero and the # flag is not specified, no decimal-point
+             character appears. The value is rounded to the appropriate number of digits.
+             The E conversion specifier produces a number with E instead of e
+             introducing the exponent. The exponent always contains at least two digits,
+             and only as many more digits as necessary to represent the exponent. If the
+             value is zero, the exponent is zero.
+             A double argument representing an infinity or NaN is converted in the style
+             of an f or F conversion specifier.
+g,G          A double argument representing a floating-point number is converted in
+             style f or e (or in style F or E in the case of a G conversion specifier),
+             depending on the value converted and the precision. Let P equal the
+             precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+             Then, if a conversion with style E would have an exponent of X :
+             -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+               P - (X + 1).
+             -- otherwise, the conversion is with style e (or E) and precision P - 1.
+             Finally, unless the # flag is used, any trailing zeros are removed from the
+
+<sup><a name="note243" href="#note243"><b>243)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
+     the # and 0 flag characters have no effect.
+
+[<a name="p278" href="#p278">page 278</a>] (<a href="#Contents">Contents</a>)
+
+              fractional portion of the result and the decimal-point character is removed if
+              there is no fractional portion remaining.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.
+a,A           A double argument representing a floating-point number is converted in the
+              style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+              nonzero if the argument is a normalized floating-point number and is
+              otherwise unspecified) before the decimal-point character<sup><a href="#note244"><b>244)</b></a></sup> and the number
+              of hexadecimal digits after it is equal to the precision; if the precision is
+              missing and FLT_RADIX is a power of 2, then the precision is sufficient for
+              an exact representation of the value; if the precision is missing and
+              FLT_RADIX is not a power of 2, then the precision is sufficient to
+              distinguish<sup><a href="#note245"><b>245)</b></a></sup> values of type double, except that trailing zeros may be
+              omitted; if the precision is zero and the # flag is not specified, no decimal-
+              point character appears. The letters abcdef are used for a conversion and
+              the letters ABCDEF for A conversion. The A conversion specifier produces a
+              number with X and P instead of x and p. The exponent always contains at
+              least one digit, and only as many more digits as necessary to represent the
+              decimal exponent of 2. If the value is zero, the exponent is zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.
+c             If no l length modifier is present, the int argument is converted to an
+              unsigned char, and the resulting character is written.
+              If an l length modifier is present, the wint_t argument is converted as if by
+              an ls conversion specification with no precision and an argument that points
+              to the initial element of a two-element array of wchar_t, the first element
+              containing the wint_t argument to the lc conversion specification and the
+              second a null wide character.
+s             If no l length modifier is present, the argument shall be a pointer to the initial
+              element of an array of character type.<sup><a href="#note246"><b>246)</b></a></sup> Characters from the array are
+
+
+<sup><a name="note244" href="#note244"><b>244)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
+     that subsequent digits align to nibble (4-bit) boundaries.
+<sup><a name="note245" href="#note245"><b>245)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+     might suffice depending on the implementation's scheme for determining the digit to the left of the
+     decimal-point character.
+<sup><a name="note246" href="#note246"><b>246)</b></a></sup> No special provisions are made for multibyte characters.
+
+[<a name="p279" href="#p279">page 279</a>] (<a href="#Contents">Contents</a>)
+
+                    written up to (but not including) the terminating null character. If the
+                    precision is specified, no more than that many bytes are written. If the
+                    precision is not specified or is greater than the size of the array, the array shall
+                    contain a null character.
+                    If an l length modifier is present, the argument shall be a pointer to the initial
+                    element of an array of wchar_t type. Wide characters from the array are
+                    converted to multibyte characters (each as if by a call to the wcrtomb
+                    function, with the conversion state described by an mbstate_t object
+                    initialized to zero before the first wide character is converted) up to and
+                    including a terminating null wide character. The resulting multibyte
+                    characters are written up to (but not including) the terminating null character
+                    (byte). If no precision is specified, the array shall contain a null wide
+                    character. If a precision is specified, no more than that many bytes are
+                    written (including shift sequences, if any), and the array shall contain a null
+                    wide character if, to equal the multibyte character sequence length given by
+                    the precision, the function would need to access a wide character one past the
+                    end of the array. In no case is a partial multibyte character written.<sup><a href="#note247"><b>247)</b></a></sup>
+     p              The argument shall be a pointer to void. The value of the pointer is
+                    converted to a sequence of printing characters, in an implementation-defined
+                    manner.
+     n              The argument shall be a pointer to signed integer into which is written the
+                    number of characters written to the output stream so far by this call to
+                    fprintf. No argument is converted, but one is consumed. If the conversion
+                    specification includes any flags, a field width, or a precision, the behavior is
+                    undefined.
+     %              A % character is written. No argument is converted. The complete
+                    conversion specification shall be %%.
+9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note248"><b>248)</b></a></sup> If any argument is
+     not the correct type for the corresponding conversion specification, the behavior is
+     undefined.
+10   In no case does a nonexistent or small field width cause truncation of a field; if the result
+     of a conversion is wider than the field width, the field is expanded to contain the
+     conversion result.
+
+
+
+
+     <sup><a name="note247" href="#note247"><b>247)</b></a></sup> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
+     <sup><a name="note248" href="#note248"><b>248)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
+
+[<a name="p280" href="#p280">page 280</a>] (<a href="#Contents">Contents</a>)
+
+11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+     to a hexadecimal floating number with the given precision.
+     Recommended practice
+12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+     representable in the given precision, the result should be one of the two adjacent numbers
+     in hexadecimal floating style with the given precision, with the extra stipulation that the
+     error should have a correct sign for the current rounding direction.
+13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note249"><b>249)</b></a></sup> If the number of
+     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+     representable with DECIMAL_DIG digits, then the result should be an exact
+     representation with trailing zeros. Otherwise, the source value is bounded by two
+     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+     the error should have a correct sign for the current rounding direction.
+<b>     Returns</b>
+14   The fprintf function returns the number of characters transmitted, or a negative value
+     if an output or encoding error occurred.
+     Environmental limits
+15   The number of characters that can be produced by any single conversion shall be at least
+     4095.
+16   EXAMPLE 1 To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+     places:
+             #include <a href="#7.12">&lt;math.h&gt;</a>
+             #include <a href="#7.19">&lt;stdio.h&gt;</a>
+             /* ... */
+             char *weekday, *month;      // pointers to strings
+             int day, hour, min;
+             fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
+                     weekday, month, day, hour, min);
+             fprintf(stdout, "pi = %.5f\n", 4 * atan(1.0));
+
+17   EXAMPLE 2 In this example, multibyte characters do not have a state-dependent encoding, and the
+     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+     the first of which is denoted here by a and the second by an uppercase letter.
+
+
+
+
+     <sup><a name="note249" href="#note249"><b>249)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+          given format specifier. The number of significant digits is determined by the format specifier, and in
+          the case of fixed-point conversion by the source value as well.
+
+[<a name="p281" href="#p281">page 281</a>] (<a href="#Contents">Contents</a>)
+
+18   Given the following wide string with length seven,
+              static wchar_t wstr[] = L" X Yabc Z W";
+     the seven calls
+              fprintf(stdout,          "|1234567890123|\n");
+              fprintf(stdout,          "|%13ls|\n", wstr);
+              fprintf(stdout,          "|%-13.9ls|\n", wstr);
+              fprintf(stdout,          "|%13.10ls|\n", wstr);
+              fprintf(stdout,          "|%13.11ls|\n", wstr);
+              fprintf(stdout,          "|%13.15ls|\n", &amp;wstr[2]);
+              fprintf(stdout,          "|%13lc|\n", (wint_t) wstr[5]);
+     will print the following seven lines:
+              |1234567890123|
+              |   X Yabc Z W|
+              | X Yabc Z    |
+              |     X Yabc Z|
+              |   X Yabc Z W|
+              |      abc Z W|
+              |            Z|
+
+     Forward references: conversion state (<a href="#7.24.6">7.24.6</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+<a name="7.19.6.2" href="#7.19.6.2"><b>     7.19.6.2 The fscanf function</b></a>
+<b>     Synopsis</b>
+1             #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              int fscanf(FILE * restrict stream,
+                   const char * restrict format, ...);
+<b>     Description</b>
+2    The fscanf function reads input from the stream pointed to by stream, under control
+     of the string pointed to by format that specifies the admissible input sequences and how
+     they are to be converted for assignment, using subsequent arguments as pointers to the
+     objects to receive the converted input. If there are insufficient arguments for the format,
+     the behavior is undefined. If the format is exhausted while arguments remain, the excess
+     arguments are evaluated (as always) but are otherwise ignored.
+3    The format shall be a multibyte character sequence, beginning and ending in its initial
+     shift state. The format is composed of zero or more directives: one or more white-space
+     characters, an ordinary multibyte character (neither % nor a white-space character), or a
+     conversion specification. Each conversion specification is introduced by the character %.
+     After the %, the following appear in sequence:
+     -- An optional assignment-suppressing character *.
+     -- An optional decimal integer greater than zero that specifies the maximum field width
+       (in characters).
+
+[<a name="p282" href="#p282">page 282</a>] (<a href="#Contents">Contents</a>)
+
+     -- An optional length modifier that specifies the size of the receiving object.
+     -- A conversion specifier character that specifies the type of conversion to be applied.
+4    The fscanf function executes each directive of the format in turn. If a directive fails, as
+     detailed below, the function returns. Failures are described as input failures (due to the
+     occurrence of an encoding error or the unavailability of input characters), or matching
+     failures (due to inappropriate input).
+5    A directive composed of white-space character(s) is executed by reading input up to the
+     first non-white-space character (which remains unread), or until no more characters can
+     be read.
+6    A directive that is an ordinary multibyte character is executed by reading the next
+     characters of the stream. If any of those characters differ from the ones composing the
+     directive, the directive fails and the differing and subsequent characters remain unread.
+     Similarly, if end-of-file, an encoding error, or a read error prevents a character from being
+     read, the directive fails.
+7    A directive that is a conversion specification defines a set of matching input sequences, as
+     described below for each specifier. A conversion specification is executed in the
+     following steps:
+8    Input white-space characters (as specified by the isspace function) are skipped, unless
+     the specification includes a [, c, or n specifier.<sup><a href="#note250"><b>250)</b></a></sup>
+9    An input item is read from the stream, unless the specification includes an n specifier. An
+     input item is defined as the longest sequence of input characters which does not exceed
+     any specified field width and which is, or is a prefix of, a matching input sequence.<sup><a href="#note251"><b>251)</b></a></sup>
+     The first character, if any, after the input item remains unread. If the length of the input
+     item is zero, the execution of the directive fails; this condition is a matching failure unless
+     end-of-file, an encoding error, or a read error prevented input from the stream, in which
+     case it is an input failure.
+10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+     count of input characters) is converted to a type appropriate to the conversion specifier. If
+     the input item is not a matching sequence, the execution of the directive fails: this
+     condition is a matching failure. Unless assignment suppression was indicated by a *, the
+     result of the conversion is placed in the object pointed to by the first argument following
+     the format argument that has not already received a conversion result. If this object
+     does not have an appropriate type, or if the result of the conversion cannot be represented
+
+
+     <sup><a name="note250" href="#note250"><b>250)</b></a></sup> These white-space characters are not counted against a specified field width.
+     <sup><a name="note251" href="#note251"><b>251)</b></a></sup> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
+          that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
+
+[<a name="p283" href="#p283">page 283</a>] (<a href="#Contents">Contents</a>)
+
+     in the object, the behavior is undefined.
+11   The length modifiers and their meanings are:
+     hh           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to signed char or unsigned char.
+     h            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to short int or unsigned short
+                  int.
+     l (ell)      Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to long int or unsigned long
+                  int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+                  an argument with type pointer to double; or that a following c, s, or [
+                  conversion specifier applies to an argument with type pointer to wchar_t.
+     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to long long int or unsigned
+                  long long int.
+     j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to intmax_t or uintmax_t.
+     z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to size_t or the corresponding signed
+                  integer type.
+     t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to ptrdiff_t or the corresponding
+                  unsigned integer type.
+     L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                  applies to an argument with type pointer to long double.
+     If a length modifier appears with any conversion specifier other than as specified above,
+     the behavior is undefined.
+12   The conversion specifiers and their meanings are:
+     d           Matches an optionally signed decimal integer, whose format is the same as
+                 expected for the subject sequence of the strtol function with the value 10
+                 for the base argument. The corresponding argument shall be a pointer to
+                 signed integer.
+     i           Matches an optionally signed integer, whose format is the same as expected
+                 for the subject sequence of the strtol function with the value 0 for the
+                 base argument. The corresponding argument shall be a pointer to signed
+                 integer.
+
+[<a name="p284" href="#p284">page 284</a>] (<a href="#Contents">Contents</a>)
+
+o             Matches an optionally signed octal integer, whose format is the same as
+              expected for the subject sequence of the strtoul function with the value 8
+              for the base argument. The corresponding argument shall be a pointer to
+              unsigned integer.
+u             Matches an optionally signed decimal integer, whose format is the same as
+              expected for the subject sequence of the strtoul function with the value 10
+              for the base argument. The corresponding argument shall be a pointer to
+              unsigned integer.
+x             Matches an optionally signed hexadecimal integer, whose format is the same
+              as expected for the subject sequence of the strtoul function with the value
+              16 for the base argument. The corresponding argument shall be a pointer to
+              unsigned integer.
+a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+        format is the same as expected for the subject sequence of the strtod
+        function. The corresponding argument shall be a pointer to floating.
+c             Matches a sequence of characters of exactly the number specified by the field
+              width (1 if no field width is present in the directive).<sup><a href="#note252"><b>252)</b></a></sup>
+              If no l length modifier is present, the corresponding argument shall be a
+              pointer to the initial element of a character array large enough to accept the
+              sequence. No null character is added.
+              If an l length modifier is present, the input shall be a sequence of multibyte
+              characters that begins in the initial shift state. Each multibyte character in the
+              sequence is converted to a wide character as if by a call to the mbrtowc
+              function, with the conversion state described by an mbstate_t object
+              initialized to zero before the first multibyte character is converted. The
+              corresponding argument shall be a pointer to the initial element of an array of
+              wchar_t large enough to accept the resulting sequence of wide characters.
+              No null wide character is added.
+s             Matches a sequence of non-white-space characters.252)
+              If no l length modifier is present, the corresponding argument shall be a
+              pointer to the initial element of a character array large enough to accept the
+              sequence and a terminating null character, which will be added automatically.
+              If an l length modifier is present, the input shall be a sequence of multibyte
+
+
+<sup><a name="note252" href="#note252"><b>252)</b></a></sup> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
+     conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
+     resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
+
+[<a name="p285" href="#p285">page 285</a>] (<a href="#Contents">Contents</a>)
+
+         characters that begins in the initial shift state. Each multibyte character is
+         converted to a wide character as if by a call to the mbrtowc function, with
+         the conversion state described by an mbstate_t object initialized to zero
+         before the first multibyte character is converted. The corresponding argument
+         shall be a pointer to the initial element of an array of wchar_t large enough
+         to accept the sequence and the terminating null wide character, which will be
+         added automatically.
+[        Matches a nonempty sequence of characters from a set of expected characters
+         (the scanset).252)
+         If no l length modifier is present, the corresponding argument shall be a
+         pointer to the initial element of a character array large enough to accept the
+         sequence and a terminating null character, which will be added automatically.
+         If an l length modifier is present, the input shall be a sequence of multibyte
+         characters that begins in the initial shift state. Each multibyte character is
+         converted to a wide character as if by a call to the mbrtowc function, with
+         the conversion state described by an mbstate_t object initialized to zero
+         before the first multibyte character is converted. The corresponding argument
+         shall be a pointer to the initial element of an array of wchar_t large enough
+         to accept the sequence and the terminating null wide character, which will be
+         added automatically.
+         The conversion specifier includes all subsequent characters in the format
+         string, up to and including the matching right bracket (]). The characters
+         between the brackets (the scanlist) compose the scanset, unless the character
+         after the left bracket is a circumflex (^), in which case the scanset contains all
+         characters that do not appear in the scanlist between the circumflex and the
+         right bracket. If the conversion specifier begins with [] or [^], the right
+         bracket character is in the scanlist and the next following right bracket
+         character is the matching right bracket that ends the specification; otherwise
+         the first following right bracket character is the one that ends the
+         specification. If a - character is in the scanlist and is not the first, nor the
+         second where the first character is a ^, nor the last character, the behavior is
+         implementation-defined.
+p        Matches an implementation-defined set of sequences, which should be the
+         same as the set of sequences that may be produced by the %p conversion of
+         the fprintf function. The corresponding argument shall be a pointer to a
+         pointer to void. The input item is converted to a pointer value in an
+         implementation-defined manner. If the input item is a value converted earlier
+         during the same program execution, the pointer that results shall compare
+         equal to that value; otherwise the behavior of the %p conversion is undefined.
+
+[<a name="p286" href="#p286">page 286</a>] (<a href="#Contents">Contents</a>)
+
+     n              No input is consumed. The corresponding argument shall be a pointer to
+                    signed integer into which is to be written the number of characters read from
+                    the input stream so far by this call to the fscanf function. Execution of a
+                    %n directive does not increment the assignment count returned at the
+                    completion of execution of the fscanf function. No argument is converted,
+                    but one is consumed. If the conversion specification includes an assignment-
+                    suppressing character or a field width, the behavior is undefined.
+     %              Matches a single % character; no conversion or assignment occurs. The
+                    complete conversion specification shall be %%.
+13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note253"><b>253)</b></a></sup>
+14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+     respectively, a, e, f, g, and x.
+15   Trailing white space (including new-line characters) is left unread unless matched by a
+     directive. The success of literal matches and suppressed assignments is not directly
+     determinable other than via the %n directive.
+<b>     Returns</b>
+16   The fscanf function returns the value of the macro EOF if an input failure occurs
+     before any conversion. Otherwise, the function returns the number of input items
+     assigned, which can be fewer than provided for, or even zero, in the event of an early
+     matching failure.
+17   EXAMPLE 1        The call:
+              #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              /* ... */
+              int n, i; float x; char name[50];
+              n = fscanf(stdin, "%d%f%s", &amp;i, &amp;x, name);
+     with the input line:
+              25 54.32E-1 thompson
+     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+     thompson\0.
+
+18   EXAMPLE 2        The call:
+              #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              /* ... */
+              int i; float x; char name[50];
+              fscanf(stdin, "%2d%f%*d %[0123456789]", &amp;i, &amp;x, name);
+     with input:
+
+
+
+     <sup><a name="note253" href="#note253"><b>253)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
+
+[<a name="p287" href="#p287">page 287</a>] (<a href="#Contents">Contents</a>)
+
+              56789 0123 56a72
+     will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
+     sequence 56\0. The next character read from the input stream will be a.
+
+19   EXAMPLE 3         To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
+              #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              /* ... */
+              int count; float quant; char units[21], item[21];
+              do {
+                      count = fscanf(stdin, "%f%20s of %20s", &amp;quant, units, item);
+                      fscanf(stdin,"%*[^\n]");
+              } while (!feof(stdin) &amp;&amp; !ferror(stdin));
+20   If the stdin stream contains the following lines:
+              2 quarts of oil
+              -12.8degrees Celsius
+              lots of luck
+              10.0LBS      of
+              dirt
+              100ergs of energy
+     the execution of the above example will be analogous to the following assignments:
+              quant     =    2; strcpy(units, "quarts"); strcpy(item, "oil");
+              count     =    3;
+              quant     =    -12.8; strcpy(units, "degrees");
+              count     =    2; // "C" fails to match "o"
+              count     =    0; // "l" fails to match "%f"
+              quant     =    10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
+              count     =    3;
+              count     =    0; // "100e" fails to match "%f"
+              count     =    EOF;
+
+21   EXAMPLE 4         In:
+              #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              /* ... */
+              int d1, d2, n1, n2, i;
+              i = sscanf("123", "%d%n%n%d", &amp;d1, &amp;n1, &amp;n2, &amp;d2);
+     the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
+     of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
+
+22   EXAMPLE 5 In these examples, multibyte characters do have a state-dependent encoding, and the
+     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+     the first of which is denoted here by a and the second by an uppercase letter, but are only recognized as
+     such when in the alternate shift state. The shift sequences are denoted by (uparrow) and (downarrow), in which the first causes
+     entry into the alternate shift state.
+23   After the call:
+
+[<a name="p288" href="#p288">page 288</a>] (<a href="#Contents">Contents</a>)
+
+               #include <a href="#7.19">&lt;stdio.h&gt;</a>
+               /* ... */
+               char str[50];
+               fscanf(stdin, "a%s", str);
+     with the input line:
+               a(uparrow) X Y(downarrow) bc
+     str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
+     characters, in the more general case) appears to be a single-byte white-space character.
+24   In contrast, after the call:
+               #include <a href="#7.19">&lt;stdio.h&gt;</a>
+               #include <a href="#7.17">&lt;stddef.h&gt;</a>
+               /* ... */
+               wchar_t wstr[50];
+               fscanf(stdin, "a%ls", wstr);
+     with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
+     terminating null wide character.
+25   However, the call:
+               #include <a href="#7.19">&lt;stdio.h&gt;</a>
+               #include <a href="#7.17">&lt;stddef.h&gt;</a>
+               /* ... */
+               wchar_t wstr[50];
+               fscanf(stdin, "a(uparrow) X(downarrow)%ls", wstr);
+     with the same input line will return zero due to a matching failure against the (downarrow) sequence in the format
+     string.
+26   Assuming that the first byte of the multibyte character X is the same as the first byte of the multibyte
+     character Y, after the call:
+               #include <a href="#7.19">&lt;stdio.h&gt;</a>
+               #include <a href="#7.17">&lt;stddef.h&gt;</a>
+               /* ... */
+               wchar_t wstr[50];
+               fscanf(stdin, "a(uparrow) Y(downarrow)%ls", wstr);
+     with the same input line, zero will again be returned, but stdin will be left with a partially consumed
+     multibyte character.
+
+     Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>), the
+     strtol, strtoll, strtoul, and strtoull functions (<a href="#7.20.1.4">7.20.1.4</a>), conversion state
+     (<a href="#7.24.6">7.24.6</a>), the wcrtomb function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+
+[<a name="p289" href="#p289">page 289</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.6.3" href="#7.19.6.3"><b>    7.19.6.3 The printf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int printf(const char * restrict format, ...);
+<b>    Description</b>
+2   The printf function is equivalent to fprintf with the argument stdout interposed
+    before the arguments to printf.
+<b>    Returns</b>
+3   The printf function returns the number of characters transmitted, or a negative value if
+    an output or encoding error occurred.
+<a name="7.19.6.4" href="#7.19.6.4"><b>    7.19.6.4 The scanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int scanf(const char * restrict format, ...);
+<b>    Description</b>
+2   The scanf function is equivalent to fscanf with the argument stdin interposed
+    before the arguments to scanf.
+<b>    Returns</b>
+3   The scanf function returns the value of the macro EOF if an input failure occurs before
+    any conversion. Otherwise, the scanf function returns the number of input items
+    assigned, which can be fewer than provided for, or even zero, in the event of an early
+    matching failure.
+<a name="7.19.6.5" href="#7.19.6.5"><b>    7.19.6.5 The snprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int snprintf(char * restrict s, size_t n,
+                const char * restrict format, ...);
+<b>    Description</b>
+2   The snprintf function is equivalent to fprintf, except that the output is written into
+    an array (specified by argument s) rather than to a stream. If n is zero, nothing is written,
+    and s may be a null pointer. Otherwise, output characters beyond the n-1st are
+    discarded rather than being written to the array, and a null character is written at the end
+    of the characters actually written into the array. If copying takes place between objects
+    that overlap, the behavior is undefined.
+
+[<a name="p290" href="#p290">page 290</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The snprintf function returns the number of characters that would have been written
+    had n been sufficiently large, not counting the terminating null character, or a negative
+    value if an encoding error occurred. Thus, the null-terminated output has been
+    completely written if and only if the returned value is nonnegative and less than n.
+<a name="7.19.6.6" href="#7.19.6.6"><b>    7.19.6.6 The sprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int sprintf(char * restrict s,
+                const char * restrict format, ...);
+<b>    Description</b>
+2   The sprintf function is equivalent to fprintf, except that the output is written into
+    an array (specified by the argument s) rather than to a stream. A null character is written
+    at the end of the characters written; it is not counted as part of the returned value. If
+    copying takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The sprintf function returns the number of characters written in the array, not
+    counting the terminating null character, or a negative value if an encoding error occurred.
+<a name="7.19.6.7" href="#7.19.6.7"><b>    7.19.6.7 The sscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int sscanf(const char * restrict s,
+                const char * restrict format, ...);
+<b>    Description</b>
+2   The sscanf function is equivalent to fscanf, except that input is obtained from a
+    string (specified by the argument s) rather than from a stream. Reaching the end of the
+    string is equivalent to encountering end-of-file for the fscanf function. If copying
+    takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The sscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the sscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+
+[<a name="p291" href="#p291">page 291</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.6.8" href="#7.19.6.8"><b>    7.19.6.8 The vfprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int vfprintf(FILE * restrict stream,
+                const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vfprintf function is equivalent to fprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfprintf function does not invoke the
+    va_end macro.<sup><a href="#note254"><b>254)</b></a></sup>
+<b>    Returns</b>
+3   The vfprintf function returns the number of characters transmitted, or a negative
+    value if an output or encoding error occurred.
+4   EXAMPLE       The following shows the use of the vfprintf function in a general error-reporting routine.
+           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           void error(char *function_name, char *format, ...)
+           {
+                 va_list args;
+                    va_start(args, format);
+                    // print out name of function causing error
+                    fprintf(stderr, "ERROR in %s: ", function_name);
+                    // print out remainder of message
+                    vfprintf(stderr, format, args);
+                    va_end(args);
+           }
+
+
+
+
+    <sup><a name="note254" href="#note254"><b>254)</b></a></sup> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
+         vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+[<a name="p292" href="#p292">page 292</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.6.9" href="#7.19.6.9"><b>    7.19.6.9 The vfscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int vfscanf(FILE * restrict stream,
+                const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vfscanf function is equivalent to fscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfscanf function does not invoke the
+    va_end macro.254)
+<b>    Returns</b>
+3   The vfscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the vfscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+<a name="7.19.6.10" href="#7.19.6.10"><b>    7.19.6.10 The vprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int vprintf(const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vprintf function is equivalent to printf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vprintf function does not invoke the
+    va_end macro.254)
+<b>    Returns</b>
+3   The vprintf function returns the number of characters transmitted, or a negative value
+    if an output or encoding error occurred.
+
+[<a name="p293" href="#p293">page 293</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.6.11" href="#7.19.6.11"><b>    7.19.6.11 The vscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int vscanf(const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vscanf function is equivalent to scanf, with the variable argument list replaced
+    by arg, which shall have been initialized by the va_start macro (and possibly
+    subsequent va_arg calls). The vscanf function does not invoke the va_end
+    macro.254)
+<b>    Returns</b>
+3   The vscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the vscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+<a name="7.19.6.12" href="#7.19.6.12"><b>    7.19.6.12 The vsnprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int vsnprintf(char * restrict s, size_t n,
+                const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vsnprintf function is equivalent to snprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vsnprintf function does not invoke the
+    va_end macro.254) If copying takes place between objects that overlap, the behavior is
+    undefined.
+<b>    Returns</b>
+3   The vsnprintf function returns the number of characters that would have been written
+    had n been sufficiently large, not counting the terminating null character, or a negative
+    value if an encoding error occurred. Thus, the null-terminated output has been
+    completely written if and only if the returned value is nonnegative and less than n.
+
+[<a name="p294" href="#p294">page 294</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.6.13" href="#7.19.6.13"><b>    7.19.6.13 The vsprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int vsprintf(char * restrict s,
+                const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vsprintf function is equivalent to sprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vsprintf function does not invoke the
+    va_end macro.254) If copying takes place between objects that overlap, the behavior is
+    undefined.
+<b>    Returns</b>
+3   The vsprintf function returns the number of characters written in the array, not
+    counting the terminating null character, or a negative value if an encoding error occurred.
+<a name="7.19.6.14" href="#7.19.6.14"><b>    7.19.6.14 The vsscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int vsscanf(const char * restrict s,
+                const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vsscanf function is equivalent to sscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vsscanf function does not invoke the
+    va_end macro.254)
+<b>    Returns</b>
+3   The vsscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the vsscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+
+[<a name="p295" href="#p295">page 295</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.7" href="#7.19.7"><b>    7.19.7 Character input/output functions</b></a>
+<a name="7.19.7.1" href="#7.19.7.1"><b>    7.19.7.1 The fgetc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            int fgetc(FILE *stream);
+<b>    Description</b>
+2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
+    next character is present, the fgetc function obtains that character as an unsigned
+    char converted to an int and advances the associated file position indicator for the
+    stream (if defined).
+<b>    Returns</b>
+3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+    of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the
+    fgetc function returns the next character from the input stream pointed to by stream.
+    If a read error occurs, the error indicator for the stream is set and the fgetc function
+    returns EOF.<sup><a href="#note255"><b>255)</b></a></sup>
+<a name="7.19.7.2" href="#7.19.7.2"><b>    7.19.7.2 The fgets function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            char *fgets(char * restrict s, int n,
+                 FILE * restrict stream);
+<b>    Description</b>
+2   The fgets function reads at most one less than the number of characters specified by n
+    from the stream pointed to by stream into the array pointed to by s. No additional
+    characters are read after a new-line character (which is retained) or after end-of-file. A
+    null character is written immediately after the last character read into the array.
+<b>    Returns</b>
+3   The fgets function returns s if successful. If end-of-file is encountered and no
+    characters have been read into the array, the contents of the array remain unchanged and a
+    null pointer is returned. If a read error occurs during the operation, the array contents are
+    indeterminate and a null pointer is returned.
+
+
+
+
+    <sup><a name="note255" href="#note255"><b>255)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+
+[<a name="p296" href="#p296">page 296</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.7.3" href="#7.19.7.3"><b>    7.19.7.3 The fputc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int fputc(int c, FILE *stream);
+<b>    Description</b>
+2   The fputc function writes the character specified by c (converted to an unsigned
+    char) to the output stream pointed to by stream, at the position indicated by the
+    associated file position indicator for the stream (if defined), and advances the indicator
+    appropriately. If the file cannot support positioning requests, or if the stream was opened
+    with append mode, the character is appended to the output stream.
+<b>    Returns</b>
+3   The fputc function returns the character written. If a write error occurs, the error
+    indicator for the stream is set and fputc returns EOF.
+<a name="7.19.7.4" href="#7.19.7.4"><b>    7.19.7.4 The fputs function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int fputs(const char * restrict s,
+                FILE * restrict stream);
+<b>    Description</b>
+2   The fputs function writes the string pointed to by s to the stream pointed to by
+    stream. The terminating null character is not written.
+<b>    Returns</b>
+3   The fputs function returns EOF if a write error occurs; otherwise it returns a
+    nonnegative value.
+<a name="7.19.7.5" href="#7.19.7.5"><b>    7.19.7.5 The getc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int getc(FILE *stream);
+<b>    Description</b>
+2   The getc function is equivalent to fgetc, except that if it is implemented as a macro, it
+    may evaluate stream more than once, so the argument should never be an expression
+    with side effects.
+
+[<a name="p297" href="#p297">page 297</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The getc function returns the next character from the input stream pointed to by
+    stream. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+    getc returns EOF. If a read error occurs, the error indicator for the stream is set and
+    getc returns EOF.
+<a name="7.19.7.6" href="#7.19.7.6"><b>    7.19.7.6 The getchar function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int getchar(void);
+<b>    Description</b>
+2   The getchar function is equivalent to getc with the argument stdin.
+<b>    Returns</b>
+3   The getchar function returns the next character from the input stream pointed to by
+    stdin. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+    getchar returns EOF. If a read error occurs, the error indicator for the stream is set and
+    getchar returns EOF.
+<a name="7.19.7.7" href="#7.19.7.7"><b>    7.19.7.7 The gets function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           char *gets(char *s);
+<b>    Description</b>
+2   The gets function reads characters from the input stream pointed to by stdin, into the
+    array pointed to by s, until end-of-file is encountered or a new-line character is read.
+    Any new-line character is discarded, and a null character is written immediately after the
+    last character read into the array.
+<b>    Returns</b>
+3   The gets function returns s if successful. If end-of-file is encountered and no
+    characters have been read into the array, the contents of the array remain unchanged and a
+    null pointer is returned. If a read error occurs during the operation, the array contents are
+    indeterminate and a null pointer is returned.
+    Forward references: future library directions (<a href="#7.26.9">7.26.9</a>).
+
+[<a name="p298" href="#p298">page 298</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.7.8" href="#7.19.7.8"><b>    7.19.7.8 The putc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int putc(int c, FILE *stream);
+<b>    Description</b>
+2   The putc function is equivalent to fputc, except that if it is implemented as a macro, it
+    may evaluate stream more than once, so that argument should never be an expression
+    with side effects.
+<b>    Returns</b>
+3   The putc function returns the character written. If a write error occurs, the error
+    indicator for the stream is set and putc returns EOF.
+<a name="7.19.7.9" href="#7.19.7.9"><b>    7.19.7.9 The putchar function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int putchar(int c);
+<b>    Description</b>
+2   The putchar function is equivalent to putc with the second argument stdout.
+<b>    Returns</b>
+3   The putchar function returns the character written. If a write error occurs, the error
+    indicator for the stream is set and putchar returns EOF.
+<a name="7.19.7.10" href="#7.19.7.10"><b>    7.19.7.10 The puts function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int puts(const char *s);
+<b>    Description</b>
+2   The puts function writes the string pointed to by s to the stream pointed to by stdout,
+    and appends a new-line character to the output. The terminating null character is not
+    written.
+<b>    Returns</b>
+3   The puts function returns EOF if a write error occurs; otherwise it returns a nonnegative
+    value.
+
+[<a name="p299" href="#p299">page 299</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.7.11" href="#7.19.7.11"><b>    7.19.7.11 The ungetc function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.19">&lt;stdio.h&gt;</a>
+             int ungetc(int c, FILE *stream);
+<b>    Description</b>
+2   The ungetc function pushes the character specified by c (converted to an unsigned
+    char) back onto the input stream pointed to by stream. Pushed-back characters will be
+    returned by subsequent reads on that stream in the reverse order of their pushing. A
+    successful intervening call (with the stream pointed to by stream) to a file positioning
+    function (fseek, fsetpos, or rewind) discards any pushed-back characters for the
+    stream. The external storage corresponding to the stream is unchanged.
+3   One character of pushback is guaranteed. If the ungetc function is called too many
+    times on the same stream without an intervening read or file positioning operation on that
+    stream, the operation may fail.
+4   If the value of c equals that of the macro EOF, the operation fails and the input stream is
+    unchanged.
+5   A successful call to the ungetc function clears the end-of-file indicator for the stream.
+    The value of the file position indicator for the stream after reading or discarding all
+    pushed-back characters shall be the same as it was before the characters were pushed
+    back. For a text stream, the value of its file position indicator after a successful call to the
+    ungetc function is unspecified until all pushed-back characters are read or discarded.
+    For a binary stream, its file position indicator is decremented by each successful call to
+    the ungetc function; if its value was zero before a call, it is indeterminate after the
+    call.<sup><a href="#note256"><b>256)</b></a></sup>
+<b>    Returns</b>
+6   The ungetc function returns the character pushed back after conversion, or EOF if the
+    operation fails.
+    Forward references: file positioning functions (<a href="#7.19.9">7.19.9</a>).
+
+
+
+
+    <sup><a name="note256" href="#note256"><b>256)</b></a></sup> See ''future library directions'' (<a href="#7.26.9">7.26.9</a>).
+
+[<a name="p300" href="#p300">page 300</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.8" href="#7.19.8"><b>    7.19.8 Direct input/output functions</b></a>
+<a name="7.19.8.1" href="#7.19.8.1"><b>    7.19.8.1 The fread function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           size_t fread(void * restrict ptr,
+                size_t size, size_t nmemb,
+                FILE * restrict stream);
+<b>    Description</b>
+2   The fread function reads, into the array pointed to by ptr, up to nmemb elements
+    whose size is specified by size, from the stream pointed to by stream. For each
+    object, size calls are made to the fgetc function and the results stored, in the order
+    read, in an array of unsigned char exactly overlaying the object. The file position
+    indicator for the stream (if defined) is advanced by the number of characters successfully
+    read. If an error occurs, the resulting value of the file position indicator for the stream is
+    indeterminate. If a partial element is read, its value is indeterminate.
+<b>    Returns</b>
+3   The fread function returns the number of elements successfully read, which may be
+    less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero,
+    fread returns zero and the contents of the array and the state of the stream remain
+    unchanged.
+<a name="7.19.8.2" href="#7.19.8.2"><b>    7.19.8.2 The fwrite function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           size_t fwrite(const void * restrict ptr,
+                size_t size, size_t nmemb,
+                FILE * restrict stream);
+<b>    Description</b>
+2   The fwrite function writes, from the array pointed to by ptr, up to nmemb elements
+    whose size is specified by size, to the stream pointed to by stream. For each object,
+    size calls are made to the fputc function, taking the values (in order) from an array of
+    unsigned char exactly overlaying the object. The file position indicator for the
+    stream (if defined) is advanced by the number of characters successfully written. If an
+    error occurs, the resulting value of the file position indicator for the stream is
+    indeterminate.
+
+[<a name="p301" href="#p301">page 301</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The fwrite function returns the number of elements successfully written, which will be
+    less than nmemb only if a write error is encountered. If size or nmemb is zero,
+    fwrite returns zero and the state of the stream remains unchanged.
+<a name="7.19.9" href="#7.19.9"><b>    7.19.9 File positioning functions</b></a>
+<a name="7.19.9.1" href="#7.19.9.1"><b>    7.19.9.1 The fgetpos function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int fgetpos(FILE * restrict stream,
+                fpos_t * restrict pos);
+<b>    Description</b>
+2   The fgetpos function stores the current values of the parse state (if any) and file
+    position indicator for the stream pointed to by stream in the object pointed to by pos.
+    The values stored contain unspecified information usable by the fsetpos function for
+    repositioning the stream to its position at the time of the call to the fgetpos function.
+<b>    Returns</b>
+3   If successful, the fgetpos function returns zero; on failure, the fgetpos function
+    returns nonzero and stores an implementation-defined positive value in errno.
+    Forward references: the fsetpos function (<a href="#7.19.9.3">7.19.9.3</a>).
+<a name="7.19.9.2" href="#7.19.9.2"><b>    7.19.9.2 The fseek function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int fseek(FILE *stream, long int offset, int whence);
+<b>    Description</b>
+2   The fseek function sets the file position indicator for the stream pointed to by stream.
+    If a read or write error occurs, the error indicator for the stream is set and fseek fails.
+3   For a binary stream, the new position, measured in characters from the beginning of the
+    file, is obtained by adding offset to the position specified by whence. The specified
+    position is the beginning of the file if whence is SEEK_SET, the current value of the file
+    position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
+    meaningfully support fseek calls with a whence value of SEEK_END.
+4   For a text stream, either offset shall be zero, or offset shall be a value returned by
+    an earlier successful call to the ftell function on a stream associated with the same file
+    and whence shall be SEEK_SET.
+
+[<a name="p302" href="#p302">page 302</a>] (<a href="#Contents">Contents</a>)
+
+5   After determining the new position, a successful call to the fseek function undoes any
+    effects of the ungetc function on the stream, clears the end-of-file indicator for the
+    stream, and then establishes the new position. After a successful fseek call, the next
+    operation on an update stream may be either input or output.
+<b>    Returns</b>
+6   The fseek function returns nonzero only for a request that cannot be satisfied.
+    Forward references: the ftell function (<a href="#7.19.9.4">7.19.9.4</a>).
+<a name="7.19.9.3" href="#7.19.9.3"><b>    7.19.9.3 The fsetpos function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int fsetpos(FILE *stream, const fpos_t *pos);
+<b>    Description</b>
+2   The fsetpos function sets the mbstate_t object (if any) and file position indicator
+    for the stream pointed to by stream according to the value of the object pointed to by
+    pos, which shall be a value obtained from an earlier successful call to the fgetpos
+    function on a stream associated with the same file. If a read or write error occurs, the
+    error indicator for the stream is set and fsetpos fails.
+3   A successful call to the fsetpos function undoes any effects of the ungetc function
+    on the stream, clears the end-of-file indicator for the stream, and then establishes the new
+    parse state and position. After a successful fsetpos call, the next operation on an
+    update stream may be either input or output.
+<b>    Returns</b>
+4   If successful, the fsetpos function returns zero; on failure, the fsetpos function
+    returns nonzero and stores an implementation-defined positive value in errno.
+<a name="7.19.9.4" href="#7.19.9.4"><b>    7.19.9.4 The ftell function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           long int ftell(FILE *stream);
+<b>    Description</b>
+2   The ftell function obtains the current value of the file position indicator for the stream
+    pointed to by stream. For a binary stream, the value is the number of characters from
+    the beginning of the file. For a text stream, its file position indicator contains unspecified
+    information, usable by the fseek function for returning the file position indicator for the
+    stream to its position at the time of the ftell call; the difference between two such
+    return values is not necessarily a meaningful measure of the number of characters written
+
+[<a name="p303" href="#p303">page 303</a>] (<a href="#Contents">Contents</a>)
+
+    or read.
+<b>    Returns</b>
+3   If successful, the ftell function returns the current value of the file position indicator
+    for the stream. On failure, the ftell function returns -1L and stores an
+    implementation-defined positive value in errno.
+<a name="7.19.9.5" href="#7.19.9.5"><b>    7.19.9.5 The rewind function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           void rewind(FILE *stream);
+<b>    Description</b>
+2   The rewind function sets the file position indicator for the stream pointed to by
+    stream to the beginning of the file. It is equivalent to
+           (void)fseek(stream, 0L, SEEK_SET)
+    except that the error indicator for the stream is also cleared.
+<b>    Returns</b>
+3   The rewind function returns no value.
+<a name="7.19.10" href="#7.19.10"><b>    7.19.10 Error-handling functions</b></a>
+<a name="7.19.10.1" href="#7.19.10.1"><b>    7.19.10.1 The clearerr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           void clearerr(FILE *stream);
+<b>    Description</b>
+2   The clearerr function clears the end-of-file and error indicators for the stream pointed
+    to by stream.
+<b>    Returns</b>
+3   The clearerr function returns no value.
+
+[<a name="p304" href="#p304">page 304</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19.10.2" href="#7.19.10.2"><b>    7.19.10.2 The feof function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int feof(FILE *stream);
+<b>    Description</b>
+2   The feof function tests the end-of-file indicator for the stream pointed to by stream.
+<b>    Returns</b>
+3   The feof function returns nonzero if and only if the end-of-file indicator is set for
+    stream.
+<a name="7.19.10.3" href="#7.19.10.3"><b>    7.19.10.3 The ferror function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           int ferror(FILE *stream);
+<b>    Description</b>
+2   The ferror function tests the error indicator for the stream pointed to by stream.
+<b>    Returns</b>
+3   The ferror function returns nonzero if and only if the error indicator is set for
+    stream.
+<a name="7.19.10.4" href="#7.19.10.4"><b>    7.19.10.4 The perror function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           void perror(const char *s);
+<b>    Description</b>
+2   The perror function maps the error number in the integer expression errno to an
+    error message. It writes a sequence of characters to the standard error stream thus: first
+    (if s is not a null pointer and the character pointed to by s is not the null character), the
+    string pointed to by s followed by a colon (:) and a space; then an appropriate error
+    message string followed by a new-line character. The contents of the error message
+    strings are the same as those returned by the strerror function with argument errno.
+<b>    Returns</b>
+3   The perror function returns no value.
+    Forward references: the strerror function (<a href="#7.21.6.2">7.21.6.2</a>).
+
+[<a name="p305" href="#p305">page 305</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20" href="#7.20"><b>    7.20 General utilities &lt;stdlib.h&gt;</b></a>
+1   The header <a href="#7.20">&lt;stdlib.h&gt;</a> declares five types and several functions of general utility, and
+    defines several macros.<sup><a href="#note257"><b>257)</b></a></sup>
+2   The types declared are size_t and wchar_t (both described in <a href="#7.17">7.17</a>),
+             div_t
+    which is a structure type that is the type of the value returned by the div function,
+             ldiv_t
+    which is a structure type that is the type of the value returned by the ldiv function, and
+             lldiv_t
+    which is a structure type that is the type of the value returned by the lldiv function.
+3   The macros defined are NULL (described in <a href="#7.17">7.17</a>);
+             EXIT_FAILURE
+    and
+             EXIT_SUCCESS
+    which expand to integer constant expressions that can be used as the argument to the
+    exit function to return unsuccessful or successful termination status, respectively, to the
+    host environment;
+             RAND_MAX
+    which expands to an integer constant expression that is the maximum value returned by
+    the rand function; and
+             MB_CUR_MAX
+    which expands to a positive integer expression with type size_t that is the maximum
+    number of bytes in a multibyte character for the extended character set specified by the
+    current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
+
+
+
+
+    <sup><a name="note257" href="#note257"><b>257)</b></a></sup> See ''future library directions'' (<a href="#7.26.10">7.26.10</a>).
+
+[<a name="p306" href="#p306">page 306</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.1" href="#7.20.1"><b>    7.20.1 Numeric conversion functions</b></a>
+1   The functions atof, atoi, atol, and atoll need not affect the value of the integer
+    expression errno on an error. If the value of the result cannot be represented, the
+    behavior is undefined.
+<a name="7.20.1.1" href="#7.20.1.1"><b>    7.20.1.1 The atof function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           double atof(const char *nptr);
+<b>    Description</b>
+2   The atof function converts the initial portion of the string pointed to by nptr to
+    double representation. Except for the behavior on error, it is equivalent to
+           strtod(nptr, (char **)NULL)
+<b>    Returns</b>
+3   The atof function returns the converted value.
+    Forward references: the strtod, strtof, and strtold functions (<a href="#7.20.1.3">7.20.1.3</a>).
+<a name="7.20.1.2" href="#7.20.1.2"><b>    7.20.1.2 The atoi, atol, and atoll functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           int atoi(const char *nptr);
+           long int atol(const char *nptr);
+           long long int atoll(const char *nptr);
+<b>    Description</b>
+2   The atoi, atol, and atoll functions convert the initial portion of the string pointed
+    to by nptr to int, long int, and long long int representation, respectively.
+    Except for the behavior on error, they are equivalent to
+           atoi: (int)strtol(nptr, (char **)NULL, 10)
+           atol: strtol(nptr, (char **)NULL, 10)
+           atoll: strtoll(nptr, (char **)NULL, 10)
+<b>    Returns</b>
+3   The atoi, atol, and atoll functions return the converted value.
+    Forward references: the strtol, strtoll, strtoul, and strtoull functions
+    (<a href="#7.20.1.4">7.20.1.4</a>).
+
+[<a name="p307" href="#p307">page 307</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.1.3" href="#7.20.1.3"><b>    7.20.1.3 The strtod, strtof, and strtold functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           double strtod(const char * restrict nptr,
+                char ** restrict endptr);
+           float strtof(const char * restrict nptr,
+                char ** restrict endptr);
+           long double strtold(const char * restrict nptr,
+                char ** restrict endptr);
+<b>    Description</b>
+2   The strtod, strtof, and strtold functions convert the initial portion of the string
+    pointed to by nptr to double, float, and long double representation,
+    respectively. First, they decompose the input string into three parts: an initial, possibly
+    empty, sequence of white-space characters (as specified by the isspace function), a
+    subject sequence resembling a floating-point constant or representing an infinity or NaN;
+    and a final string of one or more unrecognized characters, including the terminating null
+    character of the input string. Then, they attempt to convert the subject sequence to a
+    floating-point number, and return the result.
+3   The expected form of the subject sequence is an optional plus or minus sign, then one of
+    the following:
+    -- a nonempty sequence of decimal digits optionally containing a decimal-point
+      character, then an optional exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+      decimal-point character, then an optional binary exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+    -- INF or INFINITY, ignoring case
+    -- NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part, where:
+               n-char-sequence:
+                      digit
+                      nondigit
+                      n-char-sequence digit
+                      n-char-sequence nondigit
+    The subject sequence is defined as the longest initial subsequence of the input string,
+    starting with the first non-white-space character, that is of the expected form. The subject
+    sequence contains no characters if the input string is not of the expected form.
+4   If the subject sequence has the expected form for a floating-point number, the sequence of
+    characters starting with the first digit or the decimal-point character (whichever occurs
+    first) is interpreted as a floating constant according to the rules of <a href="#6.4.4.2">6.4.4.2</a>, except that the
+
+[<a name="p308" href="#p308">page 308</a>] (<a href="#Contents">Contents</a>)
+
+    decimal-point character is used in place of a period, and that if neither an exponent part
+    nor a decimal-point character appears in a decimal floating point number, or if a binary
+    exponent part does not appear in a hexadecimal floating point number, an exponent part
+    of the appropriate type with value zero is assumed to follow the last digit in the string. If
+    the subject sequence begins with a minus sign, the sequence is interpreted as negated.<sup><a href="#note258"><b>258)</b></a></sup>
+    A character sequence INF or INFINITY is interpreted as an infinity, if representable in
+    the return type, else like a floating constant that is too large for the range of the return
+    type. A character sequence NAN or NAN(n-char-sequenceopt), is interpreted as a quiet
+    NaN, if supported in the return type, else like a subject sequence part that does not have
+    the expected form; the meaning of the n-char sequences is implementation-defined.<sup><a href="#note259"><b>259)</b></a></sup> A
+    pointer to the final string is stored in the object pointed to by endptr, provided that
+    endptr is not a null pointer.
+5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+    value resulting from the conversion is correctly rounded.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+    Recommended practice
+8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+    the result is not exactly representable, the result should be one of the two numbers in the
+    appropriate internal format that are adjacent to the hexadecimal floating source value,
+    with the extra stipulation that the error should have a correct sign for the current rounding
+    direction.
+9   If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+    <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
+    sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+    consider the two bounding, adjacent decimal strings L and U, both having
+    DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+    The result should be one of the (equal or adjacent) values that would be obtained by
+    correctly rounding L and U according to the current rounding direction, with the extra
+
+    <sup><a name="note258" href="#note258"><b>258)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+         methods may yield different results if rounding is toward positive or negative infinity. In either case,
+         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+    <sup><a name="note259" href="#note259"><b>259)</b></a></sup> An implementation may use the n-char sequence to determine extra information to be represented in
+         the NaN's significand.
+
+[<a name="p309" href="#p309">page 309</a>] (<a href="#Contents">Contents</a>)
+
+     stipulation that the error with respect to D should have a correct sign for the current
+     rounding direction.<sup><a href="#note260"><b>260)</b></a></sup>
+<b>     Returns</b>
+10   The functions return the converted value, if any. If no conversion could be performed,
+     zero is returned. If the correct value is outside the range of representable values, plus or
+     minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the return
+     type and sign of the value), and the value of the macro ERANGE is stored in errno. If
+     the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is no greater
+     than the smallest normalized positive number in the return type; whether errno acquires
+     the value ERANGE is implementation-defined.
+<a name="7.20.1.4" href="#7.20.1.4"><b>     7.20.1.4 The strtol, strtoll, strtoul, and strtoull functions</b></a>
+<b>     Synopsis</b>
+1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+             long int strtol(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+             long long int strtoll(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+             unsigned long int strtoul(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+             unsigned long long int strtoull(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+<b>     Description</b>
+2    The strtol, strtoll, strtoul, and strtoull functions convert the initial
+     portion of the string pointed to by nptr to long int, long long int, unsigned
+     long int, and unsigned long long int representation, respectively. First,
+     they decompose the input string into three parts: an initial, possibly empty, sequence of
+     white-space characters (as specified by the isspace function), a subject sequence
+
+
+     <sup><a name="note260" href="#note260"><b>260)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
+          to the same internal floating value, but if not will round to adjacent values.
+
+[<a name="p310" href="#p310">page 310</a>] (<a href="#Contents">Contents</a>)
+
+    resembling an integer represented in some radix determined by the value of base, and a
+    final string of one or more unrecognized characters, including the terminating null
+    character of the input string. Then, they attempt to convert the subject sequence to an
+    integer, and return the result.
+3   If the value of base is zero, the expected form of the subject sequence is that of an
+    integer constant as described in <a href="#6.4.4.1">6.4.4.1</a>, optionally preceded by a plus or minus sign, but
+    not including an integer suffix. If the value of base is between 2 and 36 (inclusive), the
+    expected form of the subject sequence is a sequence of letters and digits representing an
+    integer with the radix specified by base, optionally preceded by a plus or minus sign,
+    but not including an integer suffix. The letters from a (or A) through z (or Z) are
+    ascribed the values 10 through 35; only letters and digits whose ascribed values are less
+    than that of base are permitted. If the value of base is 16, the characters 0x or 0X may
+    optionally precede the sequence of letters and digits, following the sign if present.
+4   The subject sequence is defined as the longest initial subsequence of the input string,
+    starting with the first non-white-space character, that is of the expected form. The subject
+    sequence contains no characters if the input string is empty or consists entirely of white
+    space, or if the first non-white-space character is other than a sign or a permissible letter
+    or digit.
+5   If the subject sequence has the expected form and the value of base is zero, the sequence
+    of characters starting with the first digit is interpreted as an integer constant according to
+    the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the value of base
+    is between 2 and 36, it is used as the base for conversion, ascribing to each letter its value
+    as given above. If the subject sequence begins with a minus sign, the value resulting from
+    the conversion is negated (in the return type). A pointer to the final string is stored in the
+    object pointed to by endptr, provided that endptr is not a null pointer.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+<b>    Returns</b>
+8   The strtol, strtoll, strtoul, and strtoull functions return the converted
+    value, if any. If no conversion could be performed, zero is returned. If the correct value
+    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+    and sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+
+[<a name="p311" href="#p311">page 311</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.2" href="#7.20.2"><b>    7.20.2 Pseudo-random sequence generation functions</b></a>
+<a name="7.20.2.1" href="#7.20.2.1"><b>    7.20.2.1 The rand function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           int rand(void);
+<b>    Description</b>
+2   The rand function computes a sequence of pseudo-random integers in the range 0 to
+    RAND_MAX.
+3   The implementation shall behave as if no library function calls the rand function.
+<b>    Returns</b>
+4   The rand function returns a pseudo-random integer.
+    Environmental limits
+5   The value of the RAND_MAX macro shall be at least 32767.
+<a name="7.20.2.2" href="#7.20.2.2"><b>    7.20.2.2 The srand function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           void srand(unsigned int seed);
+<b>    Description</b>
+2   The srand function uses the argument as a seed for a new sequence of pseudo-random
+    numbers to be returned by subsequent calls to rand. If srand is then called with the
+    same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is
+    called before any calls to srand have been made, the same sequence shall be generated
+    as when srand is first called with a seed value of 1.
+3   The implementation shall behave as if no library function calls the srand function.
+<b>    Returns</b>
+4   The srand function returns no value.
+5   EXAMPLE       The following functions define a portable implementation of rand and srand.
+           static unsigned long int next = 1;
+           int rand(void)   // RAND_MAX assumed to be 32767
+           {
+                 next = next * 1103515245 + 12345;
+                 return (unsigned int)(next/65536) % 32768;
+           }
+
+[<a name="p312" href="#p312">page 312</a>] (<a href="#Contents">Contents</a>)
+
+            void srand(unsigned int seed)
+            {
+                  next = seed;
+            }
+
+<a name="7.20.3" href="#7.20.3"><b>    7.20.3 Memory management functions</b></a>
+1   The order and contiguity of storage allocated by successive calls to the calloc,
+    malloc, and realloc functions is unspecified. The pointer returned if the allocation
+    succeeds is suitably aligned so that it may be assigned to a pointer to any type of object
+    and then used to access such an object or an array of such objects in the space allocated
+    (until the space is explicitly deallocated). The lifetime of an allocated object extends
+    from the allocation until the deallocation. Each such allocation shall yield a pointer to an
+    object disjoint from any other object. The pointer returned points to the start (lowest byte
+    address) of the allocated space. If the space cannot be allocated, a null pointer is
+    returned. If the size of the space requested is zero, the behavior is implementation-
+    defined: either a null pointer is returned, or the behavior is as if the size were some
+    nonzero value, except that the returned pointer shall not be used to access an object.
+<a name="7.20.3.1" href="#7.20.3.1"><b>    7.20.3.1 The calloc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+            void *calloc(size_t nmemb, size_t size);
+<b>    Description</b>
+2   The calloc function allocates space for an array of nmemb objects, each of whose size
+    is size. The space is initialized to all bits zero.<sup><a href="#note261"><b>261)</b></a></sup>
+<b>    Returns</b>
+3   The calloc function returns either a null pointer or a pointer to the allocated space.
+<a name="7.20.3.2" href="#7.20.3.2"><b>    7.20.3.2 The free function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+            void free(void *ptr);
+<b>    Description</b>
+2   The free function causes the space pointed to by ptr to be deallocated, that is, made
+    available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if
+    the argument does not match a pointer earlier returned by the calloc, malloc, or
+
+
+    <sup><a name="note261" href="#note261"><b>261)</b></a></sup> Note that this need not be the same as the representation of floating-point zero or a null pointer
+         constant.
+
+[<a name="p313" href="#p313">page 313</a>] (<a href="#Contents">Contents</a>)
+
+    realloc function, or if the space has been deallocated by a call to free or realloc,
+    the behavior is undefined.
+<b>    Returns</b>
+3   The free function returns no value.
+<a name="7.20.3.3" href="#7.20.3.3"><b>    7.20.3.3 The malloc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           void *malloc(size_t size);
+<b>    Description</b>
+2   The malloc function allocates space for an object whose size is specified by size and
+    whose value is indeterminate.
+<b>    Returns</b>
+3   The malloc function returns either a null pointer or a pointer to the allocated space.
+<a name="7.20.3.4" href="#7.20.3.4"><b>    7.20.3.4 The realloc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           void *realloc(void *ptr, size_t size);
+<b>    Description</b>
+2   The realloc function deallocates the old object pointed to by ptr and returns a
+    pointer to a new object that has the size specified by size. The contents of the new
+    object shall be the same as that of the old object prior to deallocation, up to the lesser of
+    the new and old sizes. Any bytes in the new object beyond the size of the old object have
+    indeterminate values.
+3   If ptr is a null pointer, the realloc function behaves like the malloc function for the
+    specified size. Otherwise, if ptr does not match a pointer earlier returned by the
+    calloc, malloc, or realloc function, or if the space has been deallocated by a call
+    to the free or realloc function, the behavior is undefined. If memory for the new
+    object cannot be allocated, the old object is not deallocated and its value is unchanged.
+<b>    Returns</b>
+4   The realloc function returns a pointer to the new object (which may have the same
+    value as a pointer to the old object), or a null pointer if the new object could not be
+    allocated.
+
+[<a name="p314" href="#p314">page 314</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.4" href="#7.20.4"><b>    7.20.4 Communication with the environment</b></a>
+<a name="7.20.4.1" href="#7.20.4.1"><b>    7.20.4.1 The abort function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           void abort(void);
+<b>    Description</b>
+2   The abort function causes abnormal program termination to occur, unless the signal
+    SIGABRT is being caught and the signal handler does not return. Whether open streams
+    with unwritten buffered data are flushed, open streams are closed, or temporary files are
+    removed is implementation-defined. An implementation-defined form of the status
+    unsuccessful termination is returned to the host environment by means of the function
+    call raise(SIGABRT).
+<b>    Returns</b>
+3   The abort function does not return to its caller.
+<a name="7.20.4.2" href="#7.20.4.2"><b>    7.20.4.2 The atexit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           int atexit(void (*func)(void));
+<b>    Description</b>
+2   The atexit function registers the function pointed to by func, to be called without
+    arguments at normal program termination.
+    Environmental limits
+3   The implementation shall support the registration of at least 32 functions.
+<b>    Returns</b>
+4   The atexit function returns zero if the registration succeeds, nonzero if it fails.
+    Forward references: the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+<a name="7.20.4.3" href="#7.20.4.3"><b>    7.20.4.3 The exit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           void exit(int status);
+<b>    Description</b>
+2   The exit function causes normal program termination to occur. If more than one call to
+    the exit function is executed by a program, the behavior is undefined.
+
+[<a name="p315" href="#p315">page 315</a>] (<a href="#Contents">Contents</a>)
+
+3   First, all functions registered by the atexit function are called, in the reverse order of
+    their registration,<sup><a href="#note262"><b>262)</b></a></sup> except that a function is called after any previously registered
+    functions that had already been called at the time it was registered. If, during the call to
+    any such function, a call to the longjmp function is made that would terminate the call
+    to the registered function, the behavior is undefined.
+4   Next, all open streams with unwritten buffered data are flushed, all open streams are
+    closed, and all files created by the tmpfile function are removed.
+5   Finally, control is returned to the host environment. If the value of status is zero or
+    EXIT_SUCCESS, an implementation-defined form of the status successful termination is
+    returned. If the value of status is EXIT_FAILURE, an implementation-defined form
+    of the status unsuccessful termination is returned. Otherwise the status returned is
+    implementation-defined.
+<b>    Returns</b>
+6   The exit function cannot return to its caller.
+<a name="7.20.4.4" href="#7.20.4.4"><b>    7.20.4.4 The _Exit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+            void _Exit(int status);
+<b>    Description</b>
+2   The _Exit function causes normal program termination to occur and control to be
+    returned to the host environment. No functions registered by the atexit function or
+    signal handlers registered by the signal function are called. The status returned to the
+    host environment is determined in the same way as for the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+    Whether open streams with unwritten buffered data are flushed, open streams are closed,
+    or temporary files are removed is implementation-defined.
+<b>    Returns</b>
+3   The _Exit function cannot return to its caller.
+
+
+
+
+    <sup><a name="note262" href="#note262"><b>262)</b></a></sup> Each function is called as many times as it was registered, and in the correct order with respect to
+         other registered functions.
+
+[<a name="p316" href="#p316">page 316</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.4.5" href="#7.20.4.5"><b>    7.20.4.5 The getenv function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           char *getenv(const char *name);
+<b>    Description</b>
+2   The getenv function searches an environment list, provided by the host environment,
+    for a string that matches the string pointed to by name. The set of environment names
+    and the method for altering the environment list are implementation-defined.
+3   The implementation shall behave as if no library function calls the getenv function.
+<b>    Returns</b>
+4   The getenv function returns a pointer to a string associated with the matched list
+    member. The string pointed to shall not be modified by the program, but may be
+    overwritten by a subsequent call to the getenv function. If the specified name cannot
+    be found, a null pointer is returned.
+<a name="7.20.4.6" href="#7.20.4.6"><b>    7.20.4.6 The system function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           int system(const char *string);
+<b>    Description</b>
+2   If string is a null pointer, the system function determines whether the host
+    environment has a command processor. If string is not a null pointer, the system
+    function passes the string pointed to by string to that command processor to be
+    executed in a manner which the implementation shall document; this might then cause the
+    program calling system to behave in a non-conforming manner or to terminate.
+<b>    Returns</b>
+3   If the argument is a null pointer, the system function returns nonzero only if a
+    command processor is available. If the argument is not a null pointer, and the system
+    function does return, it returns an implementation-defined value.
+
+[<a name="p317" href="#p317">page 317</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.5" href="#7.20.5"><b>    7.20.5 Searching and sorting utilities</b></a>
+1   These utilities make use of a comparison function to search or sort arrays of unspecified
+    type. Where an argument declared as size_t nmemb specifies the length of the array
+    for a function, nmemb can have the value zero on a call to that function; the comparison
+    function is not called, a search finds no matching element, and sorting performs no
+    rearrangement. Pointer arguments on such a call shall still have valid values, as described
+    in <a href="#7.1.4">7.1.4</a>.
+2   The implementation shall ensure that the second argument of the comparison function
+    (when called from bsearch), or both arguments (when called from qsort), are
+    pointers to elements of the array.<sup><a href="#note263"><b>263)</b></a></sup> The first argument when called from bsearch
+    shall equal key.
+3   The comparison function shall not alter the contents of the array. The implementation
+    may reorder elements of the array between calls to the comparison function, but shall not
+    alter the contents of any individual element.
+4   When the same objects (consisting of size bytes, irrespective of their current positions
+    in the array) are passed more than once to the comparison function, the results shall be
+    consistent with one another. That is, for qsort they shall define a total ordering on the
+    array, and for bsearch the same object shall always compare the same way with the
+    key.
+5   A sequence point occurs immediately before and immediately after each call to the
+    comparison function, and also between any call to the comparison function and any
+    movement of the objects passed as arguments to that call.
+<a name="7.20.5.1" href="#7.20.5.1"><b>    7.20.5.1 The bsearch function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+             void *bsearch(const void *key, const void *base,
+                  size_t nmemb, size_t size,
+                  int (*compar)(const void *, const void *));
+<b>    Description</b>
+2   The bsearch function searches an array of nmemb objects, the initial element of which
+    is pointed to by base, for an element that matches the object pointed to by key. The
+
+
+    <sup><a name="note263" href="#note263"><b>263)</b></a></sup> That is, if the value passed is p, then the following expressions are always nonzero:
+                  ((char *)p - (char *)base) % size == 0
+                  (char *)p &gt;= (char *)base
+                  (char *)p &lt; (char *)base + nmemb * size
+
+[<a name="p318" href="#p318">page 318</a>] (<a href="#Contents">Contents</a>)
+
+    size of each element of the array is specified by size.
+3   The comparison function pointed to by compar is called with two arguments that point
+    to the key object and to an array element, in that order. The function shall return an
+    integer less than, equal to, or greater than zero if the key object is considered,
+    respectively, to be less than, to match, or to be greater than the array element. The array
+    shall consist of: all the elements that compare less than, all the elements that compare
+    equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note264"><b>264)</b></a></sup>
+<b>    Returns</b>
+4   The bsearch function returns a pointer to a matching element of the array, or a null
+    pointer if no match is found. If two elements compare as equal, which element is
+    matched is unspecified.
+<a name="7.20.5.2" href="#7.20.5.2"><b>    7.20.5.2 The qsort function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+             void qsort(void *base, size_t nmemb, size_t size,
+                  int (*compar)(const void *, const void *));
+<b>    Description</b>
+2   The qsort function sorts an array of nmemb objects, the initial element of which is
+    pointed to by base. The size of each object is specified by size.
+3   The contents of the array are sorted into ascending order according to a comparison
+    function pointed to by compar, which is called with two arguments that point to the
+    objects being compared. The function shall return an integer less than, equal to, or
+    greater than zero if the first argument is considered to be respectively less than, equal to,
+    or greater than the second.
+4   If two elements compare as equal, their order in the resulting sorted array is unspecified.
+<b>    Returns</b>
+5   The qsort function returns no value.
+
+
+
+
+    <sup><a name="note264" href="#note264"><b>264)</b></a></sup> In practice, the entire array is sorted according to the comparison function.
+
+[<a name="p319" href="#p319">page 319</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.6" href="#7.20.6"><b>    7.20.6 Integer arithmetic functions</b></a>
+<a name="7.20.6.1" href="#7.20.6.1"><b>    7.20.6.1 The abs, labs and llabs functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+            int abs(int j);
+            long int labs(long int j);
+            long long int llabs(long long int j);
+<b>    Description</b>
+2   The abs, labs, and llabs functions compute the absolute value of an integer j. If the
+    result cannot be represented, the behavior is undefined.<sup><a href="#note265"><b>265)</b></a></sup>
+<b>    Returns</b>
+3   The abs, labs, and llabs, functions return the absolute value.
+<a name="7.20.6.2" href="#7.20.6.2"><b>    7.20.6.2 The div, ldiv, and lldiv functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+            div_t div(int numer, int denom);
+            ldiv_t ldiv(long int numer, long int denom);
+            lldiv_t lldiv(long long int numer, long long int denom);
+<b>    Description</b>
+2   The div, ldiv, and lldiv, functions compute numer / denom and numer %
+    denom in a single operation.
+<b>    Returns</b>
+3   The div, ldiv, and lldiv functions return a structure of type div_t, ldiv_t, and
+    lldiv_t, respectively, comprising both the quotient and the remainder. The structures
+    shall contain (in either order) the members quot (the quotient) and rem (the remainder),
+    each of which has the same type as the arguments numer and denom. If either part of
+    the result cannot be represented, the behavior is undefined.
+
+
+
+
+    <sup><a name="note265" href="#note265"><b>265)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
+
+[<a name="p320" href="#p320">page 320</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.7" href="#7.20.7"><b>    7.20.7 Multibyte/wide character conversion functions</b></a>
+1   The behavior of the multibyte character functions is affected by the LC_CTYPE category
+    of the current locale. For a state-dependent encoding, each function is placed into its
+    initial conversion state by a call for which its character pointer argument, s, is a null
+    pointer. Subsequent calls with s as other than a null pointer cause the internal conversion
+    state of the function to be altered as necessary. A call with s as a null pointer causes
+    these functions to return a nonzero value if encodings have state dependency, and zero
+    otherwise.<sup><a href="#note266"><b>266)</b></a></sup> Changing the LC_CTYPE category causes the conversion state of these
+    functions to be indeterminate.
+<a name="7.20.7.1" href="#7.20.7.1"><b>    7.20.7.1 The mblen function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+            int mblen(const char *s, size_t n);
+<b>    Description</b>
+2   If s is not a null pointer, the mblen function determines the number of bytes contained
+    in the multibyte character pointed to by s. Except that the conversion state of the
+    mbtowc function is not affected, it is equivalent to
+            mbtowc((wchar_t *)0, s, n);
+3   The implementation shall behave as if no library function calls the mblen function.
+<b>    Returns</b>
+4   If s is a null pointer, the mblen function returns a nonzero or zero value, if multibyte
+    character encodings, respectively, do or do not have state-dependent encodings. If s is
+    not a null pointer, the mblen function either returns 0 (if s points to the null character),
+    or returns the number of bytes that are contained in the multibyte character (if the next n
+    or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
+    multibyte character).
+    Forward references: the mbtowc function (<a href="#7.20.7.2">7.20.7.2</a>).
+
+
+
+
+    <sup><a name="note266" href="#note266"><b>266)</b></a></sup> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+         character codes, but are grouped with an adjacent multibyte character.
+
+[<a name="p321" href="#p321">page 321</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.7.2" href="#7.20.7.2"><b>    7.20.7.2 The mbtowc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           int mbtowc(wchar_t * restrict pwc,
+                const char * restrict s,
+                size_t n);
+<b>    Description</b>
+2   If s is not a null pointer, the mbtowc function inspects at most n bytes beginning with
+    the byte pointed to by s to determine the number of bytes needed to complete the next
+    multibyte character (including any shift sequences). If the function determines that the
+    next multibyte character is complete and valid, it determines the value of the
+    corresponding wide character and then, if pwc is not a null pointer, stores that value in
+    the object pointed to by pwc. If the corresponding wide character is the null wide
+    character, the function is left in the initial conversion state.
+3   The implementation shall behave as if no library function calls the mbtowc function.
+<b>    Returns</b>
+4   If s is a null pointer, the mbtowc function returns a nonzero or zero value, if multibyte
+    character encodings, respectively, do or do not have state-dependent encodings. If s is
+    not a null pointer, the mbtowc function either returns 0 (if s points to the null character),
+    or returns the number of bytes that are contained in the converted multibyte character (if
+    the next n or fewer bytes form a valid multibyte character), or returns -1 (if they do not
+    form a valid multibyte character).
+5   In no case will the value returned be greater than n or the value of the MB_CUR_MAX
+    macro.
+<a name="7.20.7.3" href="#7.20.7.3"><b>    7.20.7.3 The wctomb function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           int wctomb(char *s, wchar_t wc);
+<b>    Description</b>
+2   The wctomb function determines the number of bytes needed to represent the multibyte
+    character corresponding to the wide character given by wc (including any shift
+    sequences), and stores the multibyte character representation in the array whose first
+    element is pointed to by s (if s is not a null pointer). At most MB_CUR_MAX characters
+    are stored. If wc is a null wide character, a null byte is stored, preceded by any shift
+    sequence needed to restore the initial shift state, and the function is left in the initial
+    conversion state.
+
+[<a name="p322" href="#p322">page 322</a>] (<a href="#Contents">Contents</a>)
+
+3   The implementation shall behave as if no library function calls the wctomb function.
+<b>    Returns</b>
+4   If s is a null pointer, the wctomb function returns a nonzero or zero value, if multibyte
+    character encodings, respectively, do or do not have state-dependent encodings. If s is
+    not a null pointer, the wctomb function returns -1 if the value of wc does not correspond
+    to a valid multibyte character, or returns the number of bytes that are contained in the
+    multibyte character corresponding to the value of wc.
+5   In no case will the value returned be greater than the value of the MB_CUR_MAX macro.
+<a name="7.20.8" href="#7.20.8"><b>    7.20.8 Multibyte/wide string conversion functions</b></a>
+1   The behavior of the multibyte string functions is affected by the LC_CTYPE category of
+    the current locale.
+<a name="7.20.8.1" href="#7.20.8.1"><b>    7.20.8.1 The mbstowcs function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+             size_t mbstowcs(wchar_t * restrict pwcs,
+                  const char * restrict s,
+                  size_t n);
+<b>    Description</b>
+2   The mbstowcs function converts a sequence of multibyte characters that begins in the
+    initial shift state from the array pointed to by s into a sequence of corresponding wide
+    characters and stores not more than n wide characters into the array pointed to by pwcs.
+    No multibyte characters that follow a null character (which is converted into a null wide
+    character) will be examined or converted. Each multibyte character is converted as if by
+    a call to the mbtowc function, except that the conversion state of the mbtowc function is
+    not affected.
+3   No more than n elements will be modified in the array pointed to by pwcs. If copying
+    takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+4   If an invalid multibyte character is encountered, the mbstowcs function returns
+    (size_t)(-1). Otherwise, the mbstowcs function returns the number of array
+    elements modified, not including a terminating null wide character, if any.<sup><a href="#note267"><b>267)</b></a></sup>
+
+
+
+
+    <sup><a name="note267" href="#note267"><b>267)</b></a></sup> The array will not be null-terminated if the value returned is n.
+
+[<a name="p323" href="#p323">page 323</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.8.2" href="#7.20.8.2"><b>    7.20.8.2 The wcstombs function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.20">&lt;stdlib.h&gt;</a>
+           size_t wcstombs(char * restrict s,
+                const wchar_t * restrict pwcs,
+                size_t n);
+<b>    Description</b>
+2   The wcstombs function converts a sequence of wide characters from the array pointed
+    to by pwcs into a sequence of corresponding multibyte characters that begins in the
+    initial shift state, and stores these multibyte characters into the array pointed to by s,
+    stopping if a multibyte character would exceed the limit of n total bytes or if a null
+    character is stored. Each wide character is converted as if by a call to the wctomb
+    function, except that the conversion state of the wctomb function is not affected.
+3   No more than n bytes will be modified in the array pointed to by s. If copying takes place
+    between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+4   If a wide character is encountered that does not correspond to a valid multibyte character,
+    the wcstombs function returns (size_t)(-1). Otherwise, the wcstombs function
+    returns the number of bytes modified, not including a terminating null character, if
+    any.267)
+
+[<a name="p324" href="#p324">page 324</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21" href="#7.21"><b>    7.21 String handling &lt;string.h&gt;</b></a>
+<a name="7.21.1" href="#7.21.1"><b>    7.21.1 String function conventions</b></a>
+1   The header <a href="#7.21">&lt;string.h&gt;</a> declares one type and several functions, and defines one
+    macro useful for manipulating arrays of character type and other objects treated as arrays
+    of character type.<sup><a href="#note268"><b>268)</b></a></sup> The type is size_t and the macro is NULL (both described in
+<a name="7.17)" href="#7.17)"><b>    7.17). Various methods are used for determining the lengths of the arrays, but in all cases</b></a>
+    a char * or void * argument points to the initial (lowest addressed) character of the
+    array. If an array is accessed beyond the end of an object, the behavior is undefined.
+2   Where an argument declared as size_t n specifies the length of the array for a
+    function, n can have the value zero on a call to that function. Unless explicitly stated
+    otherwise in the description of a particular function in this subclause, pointer arguments
+    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+    function that locates a character finds no occurrence, a function that compares two
+    character sequences returns zero, and a function that copies characters copies zero
+    characters.
+3   For all functions in this subclause, each character shall be interpreted as if it had the type
+    unsigned char (and therefore every possible object representation is valid and has a
+    different value).
+<a name="7.21.2" href="#7.21.2"><b>    7.21.2 Copying functions</b></a>
+<a name="7.21.2.1" href="#7.21.2.1"><b>    7.21.2.1 The memcpy function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.21">&lt;string.h&gt;</a>
+             void *memcpy(void * restrict s1,
+                  const void * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The memcpy function copies n characters from the object pointed to by s2 into the
+    object pointed to by s1. If copying takes place between objects that overlap, the behavior
+    is undefined.
+<b>    Returns</b>
+3   The memcpy function returns the value of s1.
+
+
+
+
+    <sup><a name="note268" href="#note268"><b>268)</b></a></sup> See ''future library directions'' (<a href="#7.26.11">7.26.11</a>).
+
+[<a name="p325" href="#p325">page 325</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.2.2" href="#7.21.2.2"><b>    7.21.2.2 The memmove function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           void *memmove(void *s1, const void *s2, size_t n);
+<b>    Description</b>
+2   The memmove function copies n characters from the object pointed to by s2 into the
+    object pointed to by s1. Copying takes place as if the n characters from the object
+    pointed to by s2 are first copied into a temporary array of n characters that does not
+    overlap the objects pointed to by s1 and s2, and then the n characters from the
+    temporary array are copied into the object pointed to by s1.
+<b>    Returns</b>
+3   The memmove function returns the value of s1.
+<a name="7.21.2.3" href="#7.21.2.3"><b>    7.21.2.3 The strcpy function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strcpy(char * restrict s1,
+                const char * restrict s2);
+<b>    Description</b>
+2   The strcpy function copies the string pointed to by s2 (including the terminating null
+    character) into the array pointed to by s1. If copying takes place between objects that
+    overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The strcpy function returns the value of s1.
+<a name="7.21.2.4" href="#7.21.2.4"><b>    7.21.2.4 The strncpy function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strncpy(char * restrict s1,
+                const char * restrict s2,
+                size_t n);
+<b>    Description</b>
+2   The strncpy function copies not more than n characters (characters that follow a null
+    character are not copied) from the array pointed to by s2 to the array pointed to by
+
+[<a name="p326" href="#p326">page 326</a>] (<a href="#Contents">Contents</a>)
+
+    s1.<sup><a href="#note269"><b>269)</b></a></sup> If copying takes place between objects that overlap, the behavior is undefined.
+3   If the array pointed to by s2 is a string that is shorter than n characters, null characters
+    are appended to the copy in the array pointed to by s1, until n characters in all have been
+    written.
+<b>    Returns</b>
+4   The strncpy function returns the value of s1.
+<a name="7.21.3" href="#7.21.3"><b>    7.21.3 Concatenation functions</b></a>
+<a name="7.21.3.1" href="#7.21.3.1"><b>    7.21.3.1 The strcat function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.21">&lt;string.h&gt;</a>
+             char *strcat(char * restrict s1,
+                  const char * restrict s2);
+<b>    Description</b>
+2   The strcat function appends a copy of the string pointed to by s2 (including the
+    terminating null character) to the end of the string pointed to by s1. The initial character
+    of s2 overwrites the null character at the end of s1. If copying takes place between
+    objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The strcat function returns the value of s1.
+<a name="7.21.3.2" href="#7.21.3.2"><b>    7.21.3.2 The strncat function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.21">&lt;string.h&gt;</a>
+             char *strncat(char * restrict s1,
+                  const char * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The strncat function appends not more than n characters (a null character and
+    characters that follow it are not appended) from the array pointed to by s2 to the end of
+    the string pointed to by s1. The initial character of s2 overwrites the null character at the
+    end of s1. A terminating null character is always appended to the result.<sup><a href="#note270"><b>270)</b></a></sup> If copying
+
+    <sup><a name="note269" href="#note269"><b>269)</b></a></sup> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
+         not be null-terminated.
+    <sup><a name="note270" href="#note270"><b>270)</b></a></sup> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
+         strlen(s1)+n+1.
+
+[<a name="p327" href="#p327">page 327</a>] (<a href="#Contents">Contents</a>)
+
+    takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The strncat function returns the value of s1.
+    Forward references: the strlen function (<a href="#7.21.6.3">7.21.6.3</a>).
+<a name="7.21.4" href="#7.21.4"><b>    7.21.4 Comparison functions</b></a>
+1   The sign of a nonzero value returned by the comparison functions memcmp, strcmp,
+    and strncmp is determined by the sign of the difference between the values of the first
+    pair of characters (both interpreted as unsigned char) that differ in the objects being
+    compared.
+<a name="7.21.4.1" href="#7.21.4.1"><b>    7.21.4.1 The memcmp function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;string.h&gt;</a>
+            int memcmp(const void *s1, const void *s2, size_t n);
+<b>    Description</b>
+2   The memcmp function compares the first n characters of the object pointed to by s1 to
+    the first n characters of the object pointed to by s2.<sup><a href="#note271"><b>271)</b></a></sup>
+<b>    Returns</b>
+3   The memcmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+    pointed to by s2.
+<a name="7.21.4.2" href="#7.21.4.2"><b>    7.21.4.2 The strcmp function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;string.h&gt;</a>
+            int strcmp(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strcmp function compares the string pointed to by s1 to the string pointed to by
+    s2.
+<b>    Returns</b>
+3   The strcmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+
+    <sup><a name="note271" href="#note271"><b>271)</b></a></sup> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
+         indeterminate. Strings shorter than their allocated space and unions may also cause problems in
+         comparison.
+
+[<a name="p328" href="#p328">page 328</a>] (<a href="#Contents">Contents</a>)
+
+    pointed to by s2.
+<a name="7.21.4.3" href="#7.21.4.3"><b>    7.21.4.3 The strcoll function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           int strcoll(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strcoll function compares the string pointed to by s1 to the string pointed to by
+    s2, both interpreted as appropriate to the LC_COLLATE category of the current locale.
+<b>    Returns</b>
+3   The strcoll function returns an integer greater than, equal to, or less than zero,
+    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+    pointed to by s2 when both are interpreted as appropriate to the current locale.
+<a name="7.21.4.4" href="#7.21.4.4"><b>    7.21.4.4 The strncmp function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           int strncmp(const char *s1, const char *s2, size_t n);
+<b>    Description</b>
+2   The strncmp function compares not more than n characters (characters that follow a
+    null character are not compared) from the array pointed to by s1 to the array pointed to
+    by s2.
+<b>    Returns</b>
+3   The strncmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+    to, or less than the possibly null-terminated array pointed to by s2.
+<a name="7.21.4.5" href="#7.21.4.5"><b>    7.21.4.5 The strxfrm function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           size_t strxfrm(char * restrict s1,
+                const char * restrict s2,
+                size_t n);
+<b>    Description</b>
+2   The strxfrm function transforms the string pointed to by s2 and places the resulting
+    string into the array pointed to by s1. The transformation is such that if the strcmp
+    function is applied to two transformed strings, it returns a value greater than, equal to, or
+
+[<a name="p329" href="#p329">page 329</a>] (<a href="#Contents">Contents</a>)
+
+    less than zero, corresponding to the result of the strcoll function applied to the same
+    two original strings. No more than n characters are placed into the resulting array
+    pointed to by s1, including the terminating null character. If n is zero, s1 is permitted to
+    be a null pointer. If copying takes place between objects that overlap, the behavior is
+    undefined.
+<b>    Returns</b>
+3   The strxfrm function returns the length of the transformed string (not including the
+    terminating null character). If the value returned is n or more, the contents of the array
+    pointed to by s1 are indeterminate.
+4   EXAMPLE The value of the following expression is the size of the array needed to hold the
+    transformation of the string pointed to by s.
+           1 + strxfrm(NULL, s, 0)
+
+<a name="7.21.5" href="#7.21.5"><b>    7.21.5 Search functions</b></a>
+<a name="7.21.5.1" href="#7.21.5.1"><b>    7.21.5.1 The memchr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           void *memchr(const void *s, int c, size_t n);
+<b>    Description</b>
+2   The memchr function locates the first occurrence of c (converted to an unsigned
+    char) in the initial n characters (each interpreted as unsigned char) of the object
+    pointed to by s.
+<b>    Returns</b>
+3   The memchr function returns a pointer to the located character, or a null pointer if the
+    character does not occur in the object.
+<a name="7.21.5.2" href="#7.21.5.2"><b>    7.21.5.2 The strchr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strchr(const char *s, int c);
+<b>    Description</b>
+2   The strchr function locates the first occurrence of c (converted to a char) in the
+    string pointed to by s. The terminating null character is considered to be part of the
+    string.
+<b>    Returns</b>
+3   The strchr function returns a pointer to the located character, or a null pointer if the
+    character does not occur in the string.
+
+[<a name="p330" href="#p330">page 330</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.5.3" href="#7.21.5.3"><b>    7.21.5.3 The strcspn function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           size_t strcspn(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strcspn function computes the length of the maximum initial segment of the string
+    pointed to by s1 which consists entirely of characters not from the string pointed to by
+    s2.
+<b>    Returns</b>
+3   The strcspn function returns the length of the segment.
+<a name="7.21.5.4" href="#7.21.5.4"><b>    7.21.5.4 The strpbrk function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strpbrk(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strpbrk function locates the first occurrence in the string pointed to by s1 of any
+    character from the string pointed to by s2.
+<b>    Returns</b>
+3   The strpbrk function returns a pointer to the character, or a null pointer if no character
+    from s2 occurs in s1.
+<a name="7.21.5.5" href="#7.21.5.5"><b>    7.21.5.5 The strrchr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strrchr(const char *s, int c);
+<b>    Description</b>
+2   The strrchr function locates the last occurrence of c (converted to a char) in the
+    string pointed to by s. The terminating null character is considered to be part of the
+    string.
+<b>    Returns</b>
+3   The strrchr function returns a pointer to the character, or a null pointer if c does not
+    occur in the string.
+
+[<a name="p331" href="#p331">page 331</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.5.6" href="#7.21.5.6"><b>    7.21.5.6 The strspn function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           size_t strspn(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strspn function computes the length of the maximum initial segment of the string
+    pointed to by s1 which consists entirely of characters from the string pointed to by s2.
+<b>    Returns</b>
+3   The strspn function returns the length of the segment.
+<a name="7.21.5.7" href="#7.21.5.7"><b>    7.21.5.7 The strstr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strstr(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strstr function locates the first occurrence in the string pointed to by s1 of the
+    sequence of characters (excluding the terminating null character) in the string pointed to
+    by s2.
+<b>    Returns</b>
+3   The strstr function returns a pointer to the located string, or a null pointer if the string
+    is not found. If s2 points to a string with zero length, the function returns s1.
+<a name="7.21.5.8" href="#7.21.5.8"><b>    7.21.5.8 The strtok function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strtok(char * restrict s1,
+                const char * restrict s2);
+<b>    Description</b>
+2   A sequence of calls to the strtok function breaks the string pointed to by s1 into a
+    sequence of tokens, each of which is delimited by a character from the string pointed to
+    by s2. The first call in the sequence has a non-null first argument; subsequent calls in the
+    sequence have a null first argument. The separator string pointed to by s2 may be
+    different from call to call.
+3   The first call in the sequence searches the string pointed to by s1 for the first character
+    that is not contained in the current separator string pointed to by s2. If no such character
+    is found, then there are no tokens in the string pointed to by s1 and the strtok function
+
+[<a name="p332" href="#p332">page 332</a>] (<a href="#Contents">Contents</a>)
+
+    returns a null pointer. If such a character is found, it is the start of the first token.
+4   The strtok function then searches from there for a character that is contained in the
+    current separator string. If no such character is found, the current token extends to the
+    end of the string pointed to by s1, and subsequent searches for a token will return a null
+    pointer. If such a character is found, it is overwritten by a null character, which
+    terminates the current token. The strtok function saves a pointer to the following
+    character, from which the next search for a token will start.
+5   Each subsequent call, with a null pointer as the value of the first argument, starts
+    searching from the saved pointer and behaves as described above.
+6   The implementation shall behave as if no library function calls the strtok function.
+<b>    Returns</b>
+7   The strtok function returns a pointer to the first character of a token, or a null pointer
+    if there is no token.
+8   EXAMPLE
+            #include <a href="#7.21">&lt;string.h&gt;</a>
+            static char str[] = "?a???b,,,#c";
+            char *t;
+            t   =   strtok(str, "?");       //   t   points to the token "a"
+            t   =   strtok(NULL, ",");      //   t   points to the token "??b"
+            t   =   strtok(NULL, "#,");     //   t   points to the token "c"
+            t   =   strtok(NULL, "?");      //   t   is a null pointer
+
+<a name="7.21.6" href="#7.21.6"><b>    7.21.6 Miscellaneous functions</b></a>
+<a name="7.21.6.1" href="#7.21.6.1"><b>    7.21.6.1 The memset function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;string.h&gt;</a>
+            void *memset(void *s, int c, size_t n);
+<b>    Description</b>
+2   The memset function copies the value of c (converted to an unsigned char) into
+    each of the first n characters of the object pointed to by s.
+<b>    Returns</b>
+3   The memset function returns the value of s.
+
+[<a name="p333" href="#p333">page 333</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.6.2" href="#7.21.6.2"><b>    7.21.6.2 The strerror function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           char *strerror(int errnum);
+<b>    Description</b>
+2   The strerror function maps the number in errnum to a message string. Typically,
+    the values for errnum come from errno, but strerror shall map any value of type
+    int to a message.
+3   The implementation shall behave as if no library function calls the strerror function.
+<b>    Returns</b>
+4   The strerror function returns a pointer to the string, the contents of which are locale-
+    specific. The array pointed to shall not be modified by the program, but may be
+    overwritten by a subsequent call to the strerror function.
+<a name="7.21.6.3" href="#7.21.6.3"><b>    7.21.6.3 The strlen function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;string.h&gt;</a>
+           size_t strlen(const char *s);
+<b>    Description</b>
+2   The strlen function computes the length of the string pointed to by s.
+<b>    Returns</b>
+3   The strlen function returns the number of characters that precede the terminating null
+    character.
+
+[<a name="p334" href="#p334">page 334</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22" href="#7.22"><b>    7.22 Type-generic math &lt;tgmath.h&gt;</b></a>
+1   The header <a href="#7.22">&lt;tgmath.h&gt;</a> includes the headers <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> and
+    defines several type-generic macros.
+2   Of the <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> functions without an f (float) or l (long
+    double) suffix, several have one or more parameters whose corresponding real type is
+    double. For each such function, except modf, there is a corresponding type-generic
+    macro.<sup><a href="#note272"><b>272)</b></a></sup> The parameters whose corresponding real type is double in the function
+    synopsis are generic parameters. Use of the macro invokes a function whose
+    corresponding real type and type domain are determined by the arguments for the generic
+    parameters.<sup><a href="#note273"><b>273)</b></a></sup>
+3   Use of the macro invokes a function whose generic parameters have the corresponding
+    real type determined as follows:
+    -- First, if any argument for generic parameters has type long double, the type
+      determined is long double.
+    -- Otherwise, if any argument for generic parameters has type double or is of integer
+      type, the type determined is double.
+    -- Otherwise, the type determined is float.
+4   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> for which there is a function in
+    <a href="#7.3">&lt;complex.h&gt;</a> with the same name except for a c prefix, the corresponding type-
+    generic macro (for both functions) has the same name as the function in <a href="#7.12">&lt;math.h&gt;</a>. The
+    corresponding type-generic macro for fabs and cabs is fabs.
+
+
+
+
+    <sup><a name="note272" href="#note272"><b>272)</b></a></sup> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
+         make available the corresponding ordinary function.
+    <sup><a name="note273" href="#note273"><b>273)</b></a></sup> If the type of the argument is not compatible with the type of the parameter for the selected function,
+         the behavior is undefined.
+
+[<a name="p335" href="#p335">page 335</a>] (<a href="#Contents">Contents</a>)
+
+            <a href="#7.12">&lt;math.h&gt;</a>          <a href="#7.3">&lt;complex.h&gt;</a>           type-generic
+             function            function              macro
+              acos               cacos                acos
+              asin               casin                asin
+              atan               catan                atan
+              acosh              cacosh               acosh
+              asinh              casinh               asinh
+              atanh              catanh               atanh
+              cos                ccos                 cos
+              sin                csin                 sin
+              tan                ctan                 tan
+              cosh               ccosh                cosh
+              sinh               csinh                sinh
+              tanh               ctanh                tanh
+              exp                cexp                 exp
+              log                clog                 log
+              pow                cpow                 pow
+              sqrt               csqrt                sqrt
+              fabs               cabs                 fabs
+    If at least one argument for a generic parameter is complex, then use of the macro invokes
+    a complex function; otherwise, use of the macro invokes a real function.
+5   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> without a c-prefixed counterpart in
+    <a href="#7.3">&lt;complex.h&gt;</a> (except modf), the corresponding type-generic macro has the same
+    name as the function. These type-generic macros are:
+          atan2                fma                  llround              remainder
+          cbrt                 fmax                 log10                remquo
+          ceil                 fmin                 log1p                rint
+          copysign             fmod                 log2                 round
+          erf                  frexp                logb                 scalbn
+          erfc                 hypot                lrint                scalbln
+          exp2                 ilogb                lround               tgamma
+          expm1                ldexp                nearbyint            trunc
+          fdim                 lgamma               nextafter
+          floor                llrint               nexttoward
+    If all arguments for generic parameters are real, then use of the macro invokes a real
+    function; otherwise, use of the macro results in undefined behavior.
+6   For each unsuffixed function in <a href="#7.3">&lt;complex.h&gt;</a> that is not a c-prefixed counterpart to a
+    function in <a href="#7.12">&lt;math.h&gt;</a>, the corresponding type-generic macro has the same name as the
+    function. These type-generic macros are:
+
+[<a name="p336" href="#p336">page 336</a>] (<a href="#Contents">Contents</a>)
+
+            carg                    conj                     creal
+            cimag                   cproj
+    Use of the macro with any real or complex argument invokes a complex function.
+7   EXAMPLE       With the declarations
+            #include <a href="#7.22">&lt;tgmath.h&gt;</a>
+            int n;
+            float f;
+            double d;
+            long double ld;
+            float complex fc;
+            double complex dc;
+            long double complex ldc;
+    functions invoked by use of type-generic macros are shown in the following table:
+                     macro use                                  invokes
+                exp(n)                              exp(n), the function
+                acosh(f)                            acoshf(f)
+                sin(d)                              sin(d), the function
+                atan(ld)                            atanl(ld)
+                log(fc)                             clogf(fc)
+                sqrt(dc)                            csqrt(dc)
+                pow(ldc, f)                         cpowl(ldc, f)
+                remainder(n, n)                     remainder(n, n), the function
+                nextafter(d, f)                     nextafter(d, f), the function
+                nexttoward(f, ld)                   nexttowardf(f, ld)
+                copysign(n, ld)                     copysignl(n, ld)
+                ceil(fc)                            undefined behavior
+                rint(dc)                            undefined behavior
+                fmax(ldc, ld)                       undefined behavior
+                carg(n)                             carg(n), the function
+                cproj(f)                            cprojf(f)
+                creal(d)                            creal(d), the function
+                cimag(ld)                           cimagl(ld)
+                fabs(fc)                            cabsf(fc)
+                carg(dc)                            carg(dc), the function
+                cproj(ldc)                          cprojl(ldc)
+
+[<a name="p337" href="#p337">page 337</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.23" href="#7.23"><b>    7.23 Date and time &lt;time.h&gt;</b></a>
+<a name="7.23.1" href="#7.23.1"><b>    7.23.1 Components of time</b></a>
+1   The header <a href="#7.23">&lt;time.h&gt;</a> defines two macros, and declares several types and functions for
+    manipulating time. Many functions deal with a calendar time that represents the current
+    date (according to the Gregorian calendar) and time. Some functions deal with local
+    time, which is the calendar time expressed for some specific time zone, and with Daylight
+    Saving Time, which is a temporary change in the algorithm for determining local time.
+    The local time zone and Daylight Saving Time are implementation-defined.
+2   The macros defined are NULL (described in <a href="#7.17">7.17</a>); and
+            CLOCKS_PER_SEC
+    which expands to an expression with type clock_t (described below) that is the
+    number per second of the value returned by the clock function.
+3   The types declared are size_t (described in <a href="#7.17">7.17</a>);
+            clock_t
+    and
+            time_t
+    which are arithmetic types capable of representing times; and
+            struct tm
+    which holds the components of a calendar time, called the broken-down time.
+4   The range and precision of times representable in clock_t and time_t are
+    implementation-defined. The tm structure shall contain at least the following members,
+    in any order. The semantics of the members and their normal ranges are expressed in the
+    comments.<sup><a href="#note274"><b>274)</b></a></sup>
+            int    tm_sec;           //   seconds after the minute -- [0, 60]
+            int    tm_min;           //   minutes after the hour -- [0, 59]
+            int    tm_hour;          //   hours since midnight -- [0, 23]
+            int    tm_mday;          //   day of the month -- [1, 31]
+            int    tm_mon;           //   months since January -- [0, 11]
+            int    tm_year;          //   years since 1900
+            int    tm_wday;          //   days since Sunday -- [0, 6]
+            int    tm_yday;          //   days since January 1 -- [0, 365]
+            int    tm_isdst;         //   Daylight Saving Time flag
+
+
+
+    <sup><a name="note274" href="#note274"><b>274)</b></a></sup> The range [0, 60] for tm_sec allows for a positive leap second.
+
+[<a name="p338" href="#p338">page 338</a>] (<a href="#Contents">Contents</a>)
+
+    The value of tm_isdst is positive if Daylight Saving Time is in effect, zero if Daylight
+    Saving Time is not in effect, and negative if the information is not available.
+<a name="7.23.2" href="#7.23.2"><b>    7.23.2 Time manipulation functions</b></a>
+<a name="7.23.2.1" href="#7.23.2.1"><b>    7.23.2.1 The clock function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;time.h&gt;</a>
+            clock_t clock(void);
+<b>    Description</b>
+2   The clock function determines the processor time used.
+<b>    Returns</b>
+3   The clock function returns the implementation's best approximation to the processor
+    time used by the program since the beginning of an implementation-defined era related
+    only to the program invocation. To determine the time in seconds, the value returned by
+    the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
+    the processor time used is not available or its value cannot be represented, the function
+    returns the value (clock_t)(-1).<sup><a href="#note275"><b>275)</b></a></sup>
+<a name="7.23.2.2" href="#7.23.2.2"><b>    7.23.2.2 The difftime function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;time.h&gt;</a>
+            double difftime(time_t time1, time_t time0);
+<b>    Description</b>
+2   The difftime function computes the difference between two calendar times: time1 -
+    time0.
+<b>    Returns</b>
+3   The difftime function returns the difference expressed in seconds as a double.
+
+
+
+
+    <sup><a name="note275" href="#note275"><b>275)</b></a></sup> In order to measure the time spent in a program, the clock function should be called at the start of
+         the program and its return value subtracted from the value returned by subsequent calls.
+
+[<a name="p339" href="#p339">page 339</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.23.2.3" href="#7.23.2.3"><b>    7.23.2.3 The mktime function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;time.h&gt;</a>
+            time_t mktime(struct tm *timeptr);
+<b>    Description</b>
+2   The mktime function converts the broken-down time, expressed as local time, in the
+    structure pointed to by timeptr into a calendar time value with the same encoding as
+    that of the values returned by the time function. The original values of the tm_wday
+    and tm_yday components of the structure are ignored, and the original values of the
+    other components are not restricted to the ranges indicated above.<sup><a href="#note276"><b>276)</b></a></sup> On successful
+    completion, the values of the tm_wday and tm_yday components of the structure are
+    set appropriately, and the other components are set to represent the specified calendar
+    time, but with their values forced to the ranges indicated above; the final value of
+    tm_mday is not set until tm_mon and tm_year are determined.
+<b>    Returns</b>
+3   The mktime function returns the specified calendar time encoded as a value of type
+    time_t. If the calendar time cannot be represented, the function returns the value
+    (time_t)(-1).
+4   EXAMPLE       What day of the week is July 4, 2001?
+            #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.23">&lt;time.h&gt;</a>
+            static const char *const wday[] = {
+                    "Sunday", "Monday", "Tuesday", "Wednesday",
+                    "Thursday", "Friday", "Saturday", "-unknown-"
+            };
+            struct tm time_str;
+            /* ... */
+
+
+
+
+    <sup><a name="note276" href="#note276"><b>276)</b></a></sup> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
+         Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
+         causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
+
+[<a name="p340" href="#p340">page 340</a>] (<a href="#Contents">Contents</a>)
+
+           time_str.tm_year   = 2001 - 1900;
+           time_str.tm_mon    = 7 - 1;
+           time_str.tm_mday   = 4;
+           time_str.tm_hour   = 0;
+           time_str.tm_min    = 0;
+           time_str.tm_sec    = 1;
+           time_str.tm_isdst = -1;
+           if (mktime(&amp;time_str) == (time_t)(-1))
+                 time_str.tm_wday = 7;
+           printf("%s\n", wday[time_str.tm_wday]);
+
+<a name="7.23.2.4" href="#7.23.2.4"><b>    7.23.2.4 The time function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;time.h&gt;</a>
+           time_t time(time_t *timer);
+<b>    Description</b>
+2   The time function determines the current calendar time. The encoding of the value is
+    unspecified.
+<b>    Returns</b>
+3   The time function returns the implementation's best approximation to the current
+    calendar time. The value (time_t)(-1) is returned if the calendar time is not
+    available. If timer is not a null pointer, the return value is also assigned to the object it
+    points to.
+<a name="7.23.3" href="#7.23.3"><b>    7.23.3 Time conversion functions</b></a>
+1   Except for the strftime function, these functions each return a pointer to one of two
+    types of static objects: a broken-down time structure or an array of char. Execution of
+    any of the functions that return a pointer to one of these object types may overwrite the
+    information in any object of the same type pointed to by the value returned from any
+    previous call to any of them. The implementation shall behave as if no other library
+    functions call these functions.
+<a name="7.23.3.1" href="#7.23.3.1"><b>    7.23.3.1 The asctime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;time.h&gt;</a>
+           char *asctime(const struct tm *timeptr);
+<b>    Description</b>
+2   The asctime function converts the broken-down time in the structure pointed to by
+    timeptr into a string in the form
+           Sun Sep 16 01:03:52 1973\n\0
+
+[<a name="p341" href="#p341">page 341</a>] (<a href="#Contents">Contents</a>)
+
+    using the equivalent of the following algorithm.
+    char *asctime(const struct tm *timeptr)
+    {
+         static const char wday_name[7][3] = {
+              "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+         };
+         static const char mon_name[12][3] = {
+              "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+         };
+         static char result[26];
+           sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
+                wday_name[timeptr-&gt;tm_wday],
+                mon_name[timeptr-&gt;tm_mon],
+                timeptr-&gt;tm_mday, timeptr-&gt;tm_hour,
+                timeptr-&gt;tm_min, timeptr-&gt;tm_sec,
+                1900 + timeptr-&gt;tm_year);
+           return result;
+    }
+<b>    Returns</b>
+3   The asctime function returns a pointer to the string.
+<a name="7.23.3.2" href="#7.23.3.2"><b>    7.23.3.2 The ctime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;time.h&gt;</a>
+           char *ctime(const time_t *timer);
+<b>    Description</b>
+2   The ctime function converts the calendar time pointed to by timer to local time in the
+    form of a string. It is equivalent to
+           asctime(localtime(timer))
+<b>    Returns</b>
+3   The ctime function returns the pointer returned by the asctime function with that
+    broken-down time as argument.
+    Forward references: the localtime function (<a href="#7.23.3.4">7.23.3.4</a>).
+
+[<a name="p342" href="#p342">page 342</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.23.3.3" href="#7.23.3.3"><b>    7.23.3.3 The gmtime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;time.h&gt;</a>
+           struct tm *gmtime(const time_t *timer);
+<b>    Description</b>
+2   The gmtime function converts the calendar time pointed to by timer into a broken-
+    down time, expressed as UTC.
+<b>    Returns</b>
+3   The gmtime function returns a pointer to the broken-down time, or a null pointer if the
+    specified time cannot be converted to UTC.
+<a name="7.23.3.4" href="#7.23.3.4"><b>    7.23.3.4 The localtime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;time.h&gt;</a>
+           struct tm *localtime(const time_t *timer);
+<b>    Description</b>
+2   The localtime function converts the calendar time pointed to by timer into a
+    broken-down time, expressed as local time.
+<b>    Returns</b>
+3   The localtime function returns a pointer to the broken-down time, or a null pointer if
+    the specified time cannot be converted to local time.
+<a name="7.23.3.5" href="#7.23.3.5"><b>    7.23.3.5 The strftime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;time.h&gt;</a>
+           size_t strftime(char * restrict s,
+                size_t maxsize,
+                const char * restrict format,
+                const struct tm * restrict timeptr);
+<b>    Description</b>
+2   The strftime function places characters into the array pointed to by s as controlled by
+    the string pointed to by format. The format shall be a multibyte character sequence,
+    beginning and ending in its initial shift state. The format string consists of zero or
+    more conversion specifiers and ordinary multibyte characters. A conversion specifier
+    consists of a % character, possibly followed by an E or O modifier character (described
+    below), followed by a character that determines the behavior of the conversion specifier.
+    All ordinary multibyte characters (including the terminating null character) are copied
+
+[<a name="p343" href="#p343">page 343</a>] (<a href="#Contents">Contents</a>)
+
+    unchanged into the array. If copying takes place between objects that overlap, the
+    behavior is undefined. No more than maxsize characters are placed into the array.
+3   Each conversion specifier is replaced by appropriate characters as described in the
+    following list. The appropriate characters are determined using the LC_TIME category
+    of the current locale and by the values of zero or more members of the broken-down time
+    structure pointed to by timeptr, as specified in brackets in the description. If any of
+    the specified values is outside the normal range, the characters stored are unspecified.
+    %a    is replaced by the locale's abbreviated weekday name. [tm_wday]
+    %A    is replaced by the locale's full weekday name. [tm_wday]
+    %b    is replaced by the locale's abbreviated month name. [tm_mon]
+    %B    is replaced by the locale's full month name. [tm_mon]
+    %c    is replaced by the locale's appropriate date and time representation. [all specified
+          in <a href="#7.23.1">7.23.1</a>]
+    %C    is replaced by the year divided by 100 and truncated to an integer, as a decimal
+          number (00-99). [tm_year]
+    %d    is replaced by the day of the month as a decimal number (01-31). [tm_mday]
+    %D    is equivalent to ''%m/%d/%y''. [tm_mon, tm_mday, tm_year]
+    %e    is replaced by the day of the month as a decimal number (1-31); a single digit is
+          preceded by a space. [tm_mday]
+    %F    is equivalent to ''%Y-%m-%d'' (the ISO 8601 date format). [tm_year, tm_mon,
+          tm_mday]
+    %g    is replaced by the last 2 digits of the week-based year (see below) as a decimal
+          number (00-99). [tm_year, tm_wday, tm_yday]
+    %G    is replaced by the week-based year (see below) as a decimal number (e.g., 1997).
+          [tm_year, tm_wday, tm_yday]
+    %h    is equivalent to ''%b''. [tm_mon]
+    %H    is replaced by the hour (24-hour clock) as a decimal number (00-23). [tm_hour]
+    %I    is replaced by the hour (12-hour clock) as a decimal number (01-12). [tm_hour]
+    %j    is replaced by the day of the year as a decimal number (001-366). [tm_yday]
+    %m    is replaced by the month as a decimal number (01-12). [tm_mon]
+    %M    is replaced by the minute as a decimal number (00-59). [tm_min]
+    %n    is replaced by a new-line character.
+    %p    is replaced by the locale's equivalent of the AM/PM designations associated with a
+          12-hour clock. [tm_hour]
+    %r    is replaced by the locale's 12-hour clock time. [tm_hour, tm_min, tm_sec]
+    %R    is equivalent to ''%H:%M''. [tm_hour, tm_min]
+    %S    is replaced by the second as a decimal number (00-60). [tm_sec]
+    %t    is replaced by a horizontal-tab character.
+    %T    is equivalent to ''%H:%M:%S'' (the ISO 8601 time format). [tm_hour, tm_min,
+          tm_sec]
+
+[<a name="p344" href="#p344">page 344</a>] (<a href="#Contents">Contents</a>)
+
+    %u   is replaced by the ISO 8601 weekday as a decimal number (1-7), where Monday
+         is 1. [tm_wday]
+    %U   is replaced by the week number of the year (the first Sunday as the first day of week
+         <sup><a name="note1" href="#note1"><b>1)</b></a></sup> as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
+    %V   is replaced by the ISO 8601 week number (see below) as a decimal number
+         (01-53). [tm_year, tm_wday, tm_yday]
+    %w   is replaced by the weekday as a decimal number (0-6), where Sunday is 0.
+         [tm_wday]
+    %W   is replaced by the week number of the year (the first Monday as the first day of
+         week 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
+    %x   is replaced by the locale's appropriate date representation. [all specified in <a href="#7.23.1">7.23.1</a>]
+    %X   is replaced by the locale's appropriate time representation. [all specified in <a href="#7.23.1">7.23.1</a>]
+    %y   is replaced by the last 2 digits of the year as a decimal number (00-99).
+         [tm_year]
+    %Y   is replaced by the year as a decimal number (e.g., 1997). [tm_year]
+    %z   is replaced by the offset from UTC in the ISO 8601 format ''-0430'' (meaning 4
+         hours 30 minutes behind UTC, west of Greenwich), or by no characters if no time
+         zone is determinable. [tm_isdst]
+    %Z   is replaced by the locale's time zone name or abbreviation, or by no characters if no
+         time zone is determinable. [tm_isdst]
+    %%   is replaced by %.
+4   Some conversion specifiers can be modified by the inclusion of an E or O modifier
+    character to indicate an alternative format or specification. If the alternative format or
+    specification does not exist for the current locale, the modifier is ignored.
+    %Ec is replaced by the locale's alternative date and time representation.
+    %EC is replaced by the name of the base year (period) in the locale's alternative
+        representation.
+    %Ex is replaced by the locale's alternative date representation.
+    %EX is replaced by the locale's alternative time representation.
+    %Ey is replaced by the offset from %EC (year only) in the locale's alternative
+        representation.
+    %EY is replaced by the locale's full alternative year representation.
+    %Od is replaced by the day of the month, using the locale's alternative numeric symbols
+        (filled as needed with leading zeros, or with leading spaces if there is no alternative
+        symbol for zero).
+    %Oe is replaced by the day of the month, using the locale's alternative numeric symbols
+        (filled as needed with leading spaces).
+    %OH is replaced by the hour (24-hour clock), using the locale's alternative numeric
+        symbols.
+
+[<a name="p345" href="#p345">page 345</a>] (<a href="#Contents">Contents</a>)
+
+    %OI is replaced by the hour (12-hour clock), using the locale's alternative numeric
+        symbols.
+    %Om is replaced by the month, using the locale's alternative numeric symbols.
+    %OM is replaced by the minutes, using the locale's alternative numeric symbols.
+    %OS is replaced by the seconds, using the locale's alternative numeric symbols.
+    %Ou is replaced by the ISO 8601 weekday as a number in the locale's alternative
+        representation, where Monday is 1.
+    %OU is replaced by the week number, using the locale's alternative numeric symbols.
+    %OV is replaced by the ISO 8601 week number, using the locale's alternative numeric
+        symbols.
+    %Ow is replaced by the weekday as a number, using the locale's alternative numeric
+        symbols.
+    %OW is replaced by the week number of the year, using the locale's alternative numeric
+        symbols.
+    %Oy is replaced by the last 2 digits of the year, using the locale's alternative numeric
+        symbols.
+5   %g, %G, and %V give values according to the ISO 8601 week-based year. In this system,
+    weeks begin on a Monday and week 1 of the year is the week that includes January 4th,
+    which is also the week that includes the first Thursday of the year, and is also the first
+    week that contains at least four days in the year. If the first Monday of January is the
+    2nd, 3rd, or 4th, the preceding days are part of the last week of the preceding year; thus,
+    for Saturday 2nd January 1999, %G is replaced by 1998 and %V is replaced by 53. If
+    December 29th, 30th, or 31st is a Monday, it and any following days are part of week 1 of
+    the following year. Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and
+    %V is replaced by 01.
+6   If a conversion specifier is not one of the above, the behavior is undefined.
+7   In the "C" locale, the E and O modifiers are ignored and the replacement strings for the
+    following specifiers are:
+    %a    the first three characters of %A.
+    %A    one of ''Sunday'', ''Monday'', ... , ''Saturday''.
+    %b    the first three characters of %B.
+    %B    one of ''January'', ''February'', ... , ''December''.
+    %c    equivalent to ''%a %b %e %T %Y''.
+    %p    one of ''AM'' or ''PM''.
+    %r    equivalent to ''%I:%M:%S %p''.
+    %x    equivalent to ''%m/%d/%y''.
+    %X    equivalent to %T.
+    %Z    implementation-defined.
+
+[<a name="p346" href="#p346">page 346</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+8   If the total number of resulting characters including the terminating null character is not
+    more than maxsize, the strftime function returns the number of characters placed
+    into the array pointed to by s not including the terminating null character. Otherwise,
+    zero is returned and the contents of the array are indeterminate.
+
+[<a name="p347" href="#p347">page 347</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24" href="#7.24"><b>    7.24 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
+<a name="7.24.1" href="#7.24.1"><b>    7.24.1 Introduction</b></a>
+1   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares four data types, one tag, four macros, and many
+    functions.<sup><a href="#note277"><b>277)</b></a></sup>
+2   The types declared are wchar_t and size_t (both described in <a href="#7.17">7.17</a>);
+             mbstate_t
+    which is an object type other than an array type that can hold the conversion state
+    information necessary to convert between sequences of multibyte characters and wide
+    characters;
+             wint_t
+    which is an integer type unchanged by default argument promotions that can hold any
+    value corresponding to members of the extended character set, as well as at least one
+    value that does not correspond to any member of the extended character set (see WEOF
+    below);<sup><a href="#note278"><b>278)</b></a></sup> and
+             struct tm
+    which is declared as an incomplete structure type (the contents are described in <a href="#7.23.1">7.23.1</a>).
+3   The macros defined are NULL (described in <a href="#7.17">7.17</a>); WCHAR_MIN and WCHAR_MAX
+    (described in <a href="#7.18.3">7.18.3</a>); and
+             WEOF
+    which expands to a constant expression of type wint_t whose value does not
+    correspond to any member of the extended character set.<sup><a href="#note279"><b>279)</b></a></sup> It is accepted (and returned)
+    by several functions in this subclause to indicate end-of-file, that is, no more input from a
+    stream. It is also used as a wide character value that does not correspond to any member
+    of the extended character set.
+4   The functions declared are grouped as follows:
+    -- Functions that perform input and output of wide characters, or multibyte characters,
+      or both;
+    -- Functions that provide wide string numeric conversion;
+    -- Functions that perform general wide string manipulation;
+
+
+    <sup><a name="note277" href="#note277"><b>277)</b></a></sup> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
+    <sup><a name="note278" href="#note278"><b>278)</b></a></sup> wchar_t and wint_t can be the same integer type.
+    <sup><a name="note279" href="#note279"><b>279)</b></a></sup> The value of the macro WEOF may differ from that of EOF and need not be negative.
+
+[<a name="p348" href="#p348">page 348</a>] (<a href="#Contents">Contents</a>)
+
+    -- Functions for wide string date and time conversion; and
+    -- Functions that provide extended capabilities for conversion between multibyte and
+      wide character sequences.
+5   Unless explicitly stated otherwise, if the execution of a function described in this
+    subclause causes copying to take place between objects that overlap, the behavior is
+    undefined.
+<a name="7.24.2" href="#7.24.2"><b>    7.24.2 Formatted wide character input/output functions</b></a>
+1   The formatted wide character input/output functions shall behave as if there is a sequence
+    point after the actions associated with each specifier.<sup><a href="#note280"><b>280)</b></a></sup>
+<a name="7.24.2.1" href="#7.24.2.1"><b>    7.24.2.1 The fwprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            int fwprintf(FILE * restrict stream,
+                 const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The fwprintf function writes output to the stream pointed to by stream, under
+    control of the wide string pointed to by format that specifies how subsequent arguments
+    are converted for output. If there are insufficient arguments for the format, the behavior
+    is undefined. If the format is exhausted while arguments remain, the excess arguments
+    are evaluated (as always) but are otherwise ignored. The fwprintf function returns
+    when the end of the format string is encountered.
+3   The format is composed of zero or more directives: ordinary wide characters (not %),
+    which are copied unchanged to the output stream; and conversion specifications, each of
+    which results in fetching zero or more subsequent arguments, converting them, if
+    applicable, according to the corresponding conversion specifier, and then writing the
+    result to the output stream.
+4   Each conversion specification is introduced by the wide character %. After the %, the
+    following appear in sequence:
+    -- Zero or more flags (in any order) that modify the meaning of the conversion
+      specification.
+    -- An optional minimum field width. If the converted value has fewer wide characters
+      than the field width, it is padded with spaces (by default) on the left (or right, if the
+
+
+    <sup><a name="note280" href="#note280"><b>280)</b></a></sup> The fwprintf functions perform writes to memory for the %n specifier.
+
+[<a name="p349" href="#p349">page 349</a>] (<a href="#Contents">Contents</a>)
+
+        left adjustment flag, described later, has been given) to the field width. The field
+        width takes the form of an asterisk * (described later) or a nonnegative decimal
+        integer.<sup><a href="#note281"><b>281)</b></a></sup>
+    -- An optional precision that gives the minimum number of digits to appear for the d, i,
+      o, u, x, and X conversions, the number of digits to appear after the decimal-point
+      wide character for a, A, e, E, f, and F conversions, the maximum number of
+      significant digits for the g and G conversions, or the maximum number of wide
+      characters to be written for s conversions. The precision takes the form of a period
+      (.) followed either by an asterisk * (described later) or by an optional decimal
+      integer; if only the period is specified, the precision is taken as zero. If a precision
+      appears with any other conversion specifier, the behavior is undefined.
+    -- An optional length modifier that specifies the size of the argument.
+    -- A conversion specifier wide character that specifies the type of conversion to be
+      applied.
+5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+    this case, an int argument supplies the field width or precision. The arguments
+    specifying field width, or precision, or both, shall appear (in that order) before the
+    argument (if any) to be converted. A negative field width argument is taken as a - flag
+    followed by a positive field width. A negative precision argument is taken as if the
+    precision were omitted.
+6   The flag wide characters and their meanings are:
+    -        The result of the conversion is left-justified within the field. (It is right-justified if
+             this flag is not specified.)
+    +        The result of a signed conversion always begins with a plus or minus sign. (It
+             begins with a sign only when a negative value is converted if this flag is not
+             specified.)<sup><a href="#note282"><b>282)</b></a></sup>
+    space If the first wide character of a signed conversion is not a sign, or if a signed
+          conversion results in no wide characters, a space is prefixed to the result. If the
+          space and + flags both appear, the space flag is ignored.
+    #        The result is converted to an ''alternative form''. For o conversion, it increases
+             the precision, if and only if necessary, to force the first digit of the result to be a
+             zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+             conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
+
+    <sup><a name="note281" href="#note281"><b>281)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
+    <sup><a name="note282" href="#note282"><b>282)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+         include a minus sign.
+
+[<a name="p350" href="#p350">page 350</a>] (<a href="#Contents">Contents</a>)
+
+              and G conversions, the result of converting a floating-point number always
+              contains a decimal-point wide character, even if no digits follow it. (Normally, a
+              decimal-point wide character appears in the result of these conversions only if a
+              digit follows it.) For g and G conversions, trailing zeros are not removed from the
+              result. For other conversions, the behavior is undefined.
+    0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+              (following any indication of sign or base) are used to pad to the field width rather
+              than performing space padding, except when converting an infinity or NaN. If the
+              0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
+              conversions, if a precision is specified, the 0 flag is ignored. For other
+              conversions, the behavior is undefined.
+7   The length modifiers and their meanings are:
+    hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   signed char or unsigned char argument (the argument will have
+                   been promoted according to the integer promotions, but its value shall be
+                   converted to signed char or unsigned char before printing); or that
+                   a following n conversion specifier applies to a pointer to a signed char
+                   argument.
+    h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   short int or unsigned short int argument (the argument will
+                   have been promoted according to the integer promotions, but its value shall
+                   be converted to short int or unsigned short int before printing);
+                   or that a following n conversion specifier applies to a pointer to a short
+                   int argument.
+    l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   long int or unsigned long int argument; that a following n
+                   conversion specifier applies to a pointer to a long int argument; that a
+                   following c conversion specifier applies to a wint_t argument; that a
+                   following s conversion specifier applies to a pointer to a wchar_t
+                   argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+                   specifier.
+    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 long long int or unsigned long long int argument; or that a
+                 following n conversion specifier applies to a pointer to a long long int
+                 argument.
+    j              Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+                   an intmax_t or uintmax_t argument; or that a following n conversion
+                   specifier applies to a pointer to an intmax_t argument.
+
+[<a name="p351" href="#p351">page 351</a>] (<a href="#Contents">Contents</a>)
+
+    z           Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                size_t or the corresponding signed integer type argument; or that a
+                following n conversion specifier applies to a pointer to a signed integer type
+                corresponding to size_t argument.
+    t           Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                ptrdiff_t or the corresponding unsigned integer type argument; or that a
+                following n conversion specifier applies to a pointer to a ptrdiff_t
+                argument.
+    L           Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                applies to a long double argument.
+    If a length modifier appears with any conversion specifier other than as specified above,
+    the behavior is undefined.
+8   The conversion specifiers and their meanings are:
+    d,i        The int argument is converted to signed decimal in the style [-]dddd. The
+               precision specifies the minimum number of digits to appear; if the value
+               being converted can be represented in fewer digits, it is expanded with
+               leading zeros. The default precision is 1. The result of converting a zero
+               value with a precision of zero is no wide characters.
+    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+            letters abcdef are used for x conversion and the letters ABCDEF for X
+            conversion. The precision specifies the minimum number of digits to appear;
+            if the value being converted can be represented in fewer digits, it is expanded
+            with leading zeros. The default precision is 1. The result of converting a
+            zero value with a precision of zero is no wide characters.
+    f,F        A double argument representing a floating-point number is converted to
+               decimal notation in the style [-]ddd.ddd, where the number of digits after
+               the decimal-point wide character is equal to the precision specification. If the
+               precision is missing, it is taken as 6; if the precision is zero and the # flag is
+               not specified, no decimal-point wide character appears. If a decimal-point
+               wide character appears, at least one digit appears before it. The value is
+               rounded to the appropriate number of digits.
+               A double argument representing an infinity is converted in one of the styles
+               [-]inf or [-]infinity -- which style is implementation-defined. A
+               double argument representing a NaN is converted in one of the styles
+               [-]nan or [-]nan(n-wchar-sequence) -- which style, and the meaning of
+               any n-wchar-sequence, is implementation-defined. The F conversion
+               specifier produces INF, INFINITY, or NAN instead of inf, infinity, or
+
+[<a name="p352" href="#p352">page 352</a>] (<a href="#Contents">Contents</a>)
+
+             nan, respectively.<sup><a href="#note283"><b>283)</b></a></sup>
+e,E          A double argument representing a floating-point number is converted in the
+             style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+             argument is nonzero) before the decimal-point wide character and the number
+             of digits after it is equal to the precision; if the precision is missing, it is taken
+             as 6; if the precision is zero and the # flag is not specified, no decimal-point
+             wide character appears. The value is rounded to the appropriate number of
+             digits. The E conversion specifier produces a number with E instead of e
+             introducing the exponent. The exponent always contains at least two digits,
+             and only as many more digits as necessary to represent the exponent. If the
+             value is zero, the exponent is zero.
+             A double argument representing an infinity or NaN is converted in the style
+             of an f or F conversion specifier.
+g,G          A double argument representing a floating-point number is converted in
+             style f or e (or in style F or E in the case of a G conversion specifier),
+             depending on the value converted and the precision. Let P equal the
+             precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+             Then, if a conversion with style E would have an exponent of X :
+             -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+               P - (X + 1).
+             -- otherwise, the conversion is with style e (or E) and precision P - 1.
+             Finally, unless the # flag is used, any trailing zeros are removed from the
+             fractional portion of the result and the decimal-point wide character is
+             removed if there is no fractional portion remaining.
+             A double argument representing an infinity or NaN is converted in the style
+             of an f or F conversion specifier.
+a,A          A double argument representing a floating-point number is converted in the
+             style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+             nonzero if the argument is a normalized floating-point number and is
+             otherwise unspecified) before the decimal-point wide character<sup><a href="#note284"><b>284)</b></a></sup> and the
+             number of hexadecimal digits after it is equal to the precision; if the precision
+             is missing and FLT_RADIX is a power of 2, then the precision is sufficient
+
+
+<sup><a name="note283" href="#note283"><b>283)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
+     meaning; the # and 0 flag wide characters have no effect.
+<sup><a name="note284" href="#note284"><b>284)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
+     character so that subsequent digits align to nibble (4-bit) boundaries.
+
+[<a name="p353" href="#p353">page 353</a>] (<a href="#Contents">Contents</a>)
+
+             for an exact representation of the value; if the precision is missing and
+             FLT_RADIX is not a power of 2, then the precision is sufficient to
+             distinguish<sup><a href="#note285"><b>285)</b></a></sup> values of type double, except that trailing zeros may be
+             omitted; if the precision is zero and the # flag is not specified, no decimal-
+             point wide character appears. The letters abcdef are used for a conversion
+             and the letters ABCDEF for A conversion. The A conversion specifier
+             produces a number with X and P instead of x and p. The exponent always
+             contains at least one digit, and only as many more digits as necessary to
+             represent the decimal exponent of 2. If the value is zero, the exponent is
+             zero.
+             A double argument representing an infinity or NaN is converted in the style
+             of an f or F conversion specifier.
+c            If no l length modifier is present, the int argument is converted to a wide
+             character as if by calling btowc and the resulting wide character is written.
+             If an l length modifier is present, the wint_t argument is converted to
+             wchar_t and written.
+s            If no l length modifier is present, the argument shall be a pointer to the initial
+             element of a character array containing a multibyte character sequence
+             beginning in the initial shift state. Characters from the array are converted as
+             if by repeated calls to the mbrtowc function, with the conversion state
+             described by an mbstate_t object initialized to zero before the first
+             multibyte character is converted, and written up to (but not including) the
+             terminating null wide character. If the precision is specified, no more than
+             that many wide characters are written. If the precision is not specified or is
+             greater than the size of the converted array, the converted array shall contain a
+             null wide character.
+             If an l length modifier is present, the argument shall be a pointer to the initial
+             element of an array of wchar_t type. Wide characters from the array are
+             written up to (but not including) a terminating null wide character. If the
+             precision is specified, no more than that many wide characters are written. If
+             the precision is not specified or is greater than the size of the array, the array
+             shall contain a null wide character.
+p            The argument shall be a pointer to void. The value of the pointer is
+             converted to a sequence of printing wide characters, in an implementation-
+
+<sup><a name="note285" href="#note285"><b>285)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+     might suffice depending on the implementation's scheme for determining the digit to the left of the
+     decimal-point wide character.
+
+[<a name="p354" href="#p354">page 354</a>] (<a href="#Contents">Contents</a>)
+
+                    defined manner.
+     n              The argument shall be a pointer to signed integer into which is written the
+                    number of wide characters written to the output stream so far by this call to
+                    fwprintf. No argument is converted, but one is consumed. If the
+                    conversion specification includes any flags, a field width, or a precision, the
+                    behavior is undefined.
+     %              A % wide character is written. No argument is converted. The complete
+                    conversion specification shall be %%.
+9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note286"><b>286)</b></a></sup> If any argument is
+     not the correct type for the corresponding conversion specification, the behavior is
+     undefined.
+10   In no case does a nonexistent or small field width cause truncation of a field; if the result
+     of a conversion is wider than the field width, the field is expanded to contain the
+     conversion result.
+11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+     to a hexadecimal floating number with the given precision.
+     Recommended practice
+12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+     representable in the given precision, the result should be one of the two adjacent numbers
+     in hexadecimal floating style with the given precision, with the extra stipulation that the
+     error should have a correct sign for the current rounding direction.
+13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note287"><b>287)</b></a></sup> If the number of
+     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+     representable with DECIMAL_DIG digits, then the result should be an exact
+     representation with trailing zeros. Otherwise, the source value is bounded by two
+     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+     the error should have a correct sign for the current rounding direction.
+<b>     Returns</b>
+14   The fwprintf function returns the number of wide characters transmitted, or a negative
+     value if an output or encoding error occurred.
+
+     <sup><a name="note286" href="#note286"><b>286)</b></a></sup> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
+     <sup><a name="note287" href="#note287"><b>287)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+          given format specifier. The number of significant digits is determined by the format specifier, and in
+          the case of fixed-point conversion by the source value as well.
+
+[<a name="p355" href="#p355">page 355</a>] (<a href="#Contents">Contents</a>)
+
+     Environmental limits
+15   The number of wide characters that can be produced by any single conversion shall be at
+     least 4095.
+16   EXAMPLE       To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+     places:
+            #include <a href="#7.12">&lt;math.h&gt;</a>
+            #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            /* ... */
+            wchar_t *weekday, *month; // pointers to wide strings
+            int day, hour, min;
+            fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
+                    weekday, month, day, hour, min);
+            fwprintf(stdout, L"pi = %.5f\n", 4 * atan(1.0));
+
+     Forward references:          the btowc function (<a href="#7.24.6.1.1">7.24.6.1.1</a>), the mbrtowc function
+     (<a href="#7.24.6.3.2">7.24.6.3.2</a>).
+<a name="7.24.2.2" href="#7.24.2.2"><b>     7.24.2.2 The fwscanf function</b></a>
+<b>     Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            int fwscanf(FILE * restrict stream,
+                 const wchar_t * restrict format, ...);
+<b>     Description</b>
+2    The fwscanf function reads input from the stream pointed to by stream, under
+     control of the wide string pointed to by format that specifies the admissible input
+     sequences and how they are to be converted for assignment, using subsequent arguments
+     as pointers to the objects to receive the converted input. If there are insufficient
+     arguments for the format, the behavior is undefined. If the format is exhausted while
+     arguments remain, the excess arguments are evaluated (as always) but are otherwise
+     ignored.
+3    The format is composed of zero or more directives: one or more white-space wide
+     characters, an ordinary wide character (neither % nor a white-space wide character), or a
+     conversion specification. Each conversion specification is introduced by the wide
+     character %. After the %, the following appear in sequence:
+     -- An optional assignment-suppressing wide character *.
+     -- An optional decimal integer greater than zero that specifies the maximum field width
+       (in wide characters).
+
+[<a name="p356" href="#p356">page 356</a>] (<a href="#Contents">Contents</a>)
+
+     -- An optional length modifier that specifies the size of the receiving object.
+     -- A conversion specifier wide character that specifies the type of conversion to be
+       applied.
+4    The fwscanf function executes each directive of the format in turn. If a directive fails,
+     as detailed below, the function returns. Failures are described as input failures (due to the
+     occurrence of an encoding error or the unavailability of input characters), or matching
+     failures (due to inappropriate input).
+5    A directive composed of white-space wide character(s) is executed by reading input up to
+     the first non-white-space wide character (which remains unread), or until no more wide
+     characters can be read.
+6    A directive that is an ordinary wide character is executed by reading the next wide
+     character of the stream. If that wide character differs from the directive, the directive
+     fails and the differing and subsequent wide characters remain unread. Similarly, if end-
+     of-file, an encoding error, or a read error prevents a wide character from being read, the
+     directive fails.
+7    A directive that is a conversion specification defines a set of matching input sequences, as
+     described below for each specifier. A conversion specification is executed in the
+     following steps:
+8    Input white-space wide characters (as specified by the iswspace function) are skipped,
+     unless the specification includes a [, c, or n specifier.<sup><a href="#note288"><b>288)</b></a></sup>
+9    An input item is read from the stream, unless the specification includes an n specifier. An
+     input item is defined as the longest sequence of input wide characters which does not
+     exceed any specified field width and which is, or is a prefix of, a matching input
+     sequence.<sup><a href="#note289"><b>289)</b></a></sup> The first wide character, if any, after the input item remains unread. If the
+     length of the input item is zero, the execution of the directive fails; this condition is a
+     matching failure unless end-of-file, an encoding error, or a read error prevented input
+     from the stream, in which case it is an input failure.
+10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+     count of input wide characters) is converted to a type appropriate to the conversion
+     specifier. If the input item is not a matching sequence, the execution of the directive fails:
+     this condition is a matching failure. Unless assignment suppression was indicated by a *,
+     the result of the conversion is placed in the object pointed to by the first argument
+     following the format argument that has not already received a conversion result. If this
+
+
+     <sup><a name="note288" href="#note288"><b>288)</b></a></sup> These white-space wide characters are not counted against a specified field width.
+     <sup><a name="note289" href="#note289"><b>289)</b></a></sup> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
+          sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
+
+[<a name="p357" href="#p357">page 357</a>] (<a href="#Contents">Contents</a>)
+
+     object does not have an appropriate type, or if the result of the conversion cannot be
+     represented in the object, the behavior is undefined.
+11   The length modifiers and their meanings are:
+     hh          Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                 to an argument with type pointer to signed char or unsigned char.
+     h           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                 to an argument with type pointer to short int or unsigned short
+                 int.
+     l (ell)     Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                 to an argument with type pointer to long int or unsigned long
+                 int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+                 an argument with type pointer to double; or that a following c, s, or [
+                 conversion specifier applies to an argument with type pointer to wchar_t.
+     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to long long int or unsigned
+                  long long int.
+     j           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                 to an argument with type pointer to intmax_t or uintmax_t.
+     z           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                 to an argument with type pointer to size_t or the corresponding signed
+                 integer type.
+     t           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                 to an argument with type pointer to ptrdiff_t or the corresponding
+                 unsigned integer type.
+     L           Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                 applies to an argument with type pointer to long double.
+     If a length modifier appears with any conversion specifier other than as specified above,
+     the behavior is undefined.
+12   The conversion specifiers and their meanings are:
+     d          Matches an optionally signed decimal integer, whose format is the same as
+                expected for the subject sequence of the wcstol function with the value 10
+                for the base argument. The corresponding argument shall be a pointer to
+                signed integer.
+     i          Matches an optionally signed integer, whose format is the same as expected
+                for the subject sequence of the wcstol function with the value 0 for the
+                base argument. The corresponding argument shall be a pointer to signed
+
+[<a name="p358" href="#p358">page 358</a>] (<a href="#Contents">Contents</a>)
+
+            integer.
+o           Matches an optionally signed octal integer, whose format is the same as
+            expected for the subject sequence of the wcstoul function with the value 8
+            for the base argument. The corresponding argument shall be a pointer to
+            unsigned integer.
+u           Matches an optionally signed decimal integer, whose format is the same as
+            expected for the subject sequence of the wcstoul function with the value 10
+            for the base argument. The corresponding argument shall be a pointer to
+            unsigned integer.
+x           Matches an optionally signed hexadecimal integer, whose format is the same
+            as expected for the subject sequence of the wcstoul function with the value
+            16 for the base argument. The corresponding argument shall be a pointer to
+            unsigned integer.
+a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+        format is the same as expected for the subject sequence of the wcstod
+        function. The corresponding argument shall be a pointer to floating.
+c           Matches a sequence of wide characters of exactly the number specified by the
+            field width (1 if no field width is present in the directive).
+            If no l length modifier is present, characters from the input field are
+            converted as if by repeated calls to the wcrtomb function, with the
+            conversion state described by an mbstate_t object initialized to zero
+            before the first wide character is converted. The corresponding argument
+            shall be a pointer to the initial element of a character array large enough to
+            accept the sequence. No null character is added.
+            If an l length modifier is present, the corresponding argument shall be a
+            pointer to the initial element of an array of wchar_t large enough to accept
+            the sequence. No null wide character is added.
+s           Matches a sequence of non-white-space wide characters.
+            If no l length modifier is present, characters from the input field are
+            converted as if by repeated calls to the wcrtomb function, with the
+            conversion state described by an mbstate_t object initialized to zero
+            before the first wide character is converted. The corresponding argument
+            shall be a pointer to the initial element of a character array large enough to
+            accept the sequence and a terminating null character, which will be added
+            automatically.
+            If an l length modifier is present, the corresponding argument shall be a
+            pointer to the initial element of an array of wchar_t large enough to accept
+
+[<a name="p359" href="#p359">page 359</a>] (<a href="#Contents">Contents</a>)
+
+         the sequence and the terminating null wide character, which will be added
+         automatically.
+[        Matches a nonempty sequence of wide characters from a set of expected
+         characters (the scanset).
+         If no l length modifier is present, characters from the input field are
+         converted as if by repeated calls to the wcrtomb function, with the
+         conversion state described by an mbstate_t object initialized to zero
+         before the first wide character is converted. The corresponding argument
+         shall be a pointer to the initial element of a character array large enough to
+         accept the sequence and a terminating null character, which will be added
+         automatically.
+         If an l length modifier is present, the corresponding argument shall be a
+         pointer to the initial element of an array of wchar_t large enough to accept
+         the sequence and the terminating null wide character, which will be added
+         automatically.
+         The conversion specifier includes all subsequent wide characters in the
+         format string, up to and including the matching right bracket (]). The wide
+         characters between the brackets (the scanlist) compose the scanset, unless the
+         wide character after the left bracket is a circumflex (^), in which case the
+         scanset contains all wide characters that do not appear in the scanlist between
+         the circumflex and the right bracket. If the conversion specifier begins with
+         [] or [^], the right bracket wide character is in the scanlist and the next
+         following right bracket wide character is the matching right bracket that ends
+         the specification; otherwise the first following right bracket wide character is
+         the one that ends the specification. If a - wide character is in the scanlist and
+         is not the first, nor the second where the first wide character is a ^, nor the
+         last character, the behavior is implementation-defined.
+p        Matches an implementation-defined set of sequences, which should be the
+         same as the set of sequences that may be produced by the %p conversion of
+         the fwprintf function. The corresponding argument shall be a pointer to a
+         pointer to void. The input item is converted to a pointer value in an
+         implementation-defined manner. If the input item is a value converted earlier
+         during the same program execution, the pointer that results shall compare
+         equal to that value; otherwise the behavior of the %p conversion is undefined.
+n        No input is consumed. The corresponding argument shall be a pointer to
+         signed integer into which is to be written the number of wide characters read
+         from the input stream so far by this call to the fwscanf function. Execution
+         of a %n directive does not increment the assignment count returned at the
+         completion of execution of the fwscanf function. No argument is
+
+[<a name="p360" href="#p360">page 360</a>] (<a href="#Contents">Contents</a>)
+
+                    converted, but one is consumed. If the conversion specification includes an
+                    assignment-suppressing wide character or a field width, the behavior is
+                    undefined.
+     %              Matches a single % wide character; no conversion or assignment occurs. The
+                    complete conversion specification shall be %%.
+13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note290"><b>290)</b></a></sup>
+14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+     respectively, a, e, f, g, and x.
+15   Trailing white space (including new-line wide characters) is left unread unless matched
+     by a directive. The success of literal matches and suppressed assignments is not directly
+     determinable other than via the %n directive.
+<b>     Returns</b>
+16   The fwscanf function returns the value of the macro EOF if an input failure occurs
+     before any conversion. Otherwise, the function returns the number of input items
+     assigned, which can be fewer than provided for, or even zero, in the event of an early
+     matching failure.
+17   EXAMPLE 1        The call:
+              #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              #include <a href="#7.24">&lt;wchar.h&gt;</a>
+              /* ... */
+              int n, i; float x; wchar_t name[50];
+              n = fwscanf(stdin, L"%d%f%ls", &amp;i, &amp;x, name);
+     with the input line:
+              25 54.32E-1 thompson
+     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+     thompson\0.
+
+18   EXAMPLE 2        The call:
+              #include <a href="#7.19">&lt;stdio.h&gt;</a>
+              #include <a href="#7.24">&lt;wchar.h&gt;</a>
+              /* ... */
+              int i; float x; double y;
+              fwscanf(stdin, L"%2d%f%*d %lf", &amp;i, &amp;x, &amp;y);
+     with input:
+              56789 0123 56a72
+     will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
+     56.0. The next wide character read from the input stream will be a.
+
+
+     <sup><a name="note290" href="#note290"><b>290)</b></a></sup> See ''future library directions'' (<a href="#7.26.12">7.26.12</a>).
+
+[<a name="p361" href="#p361">page 361</a>] (<a href="#Contents">Contents</a>)
+
+    Forward references: the wcstod, wcstof, and wcstold functions (<a href="#7.24.4.1.1">7.24.4.1.1</a>), the
+    wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.24.4.1.2">7.24.4.1.2</a>), the wcrtomb
+    function (<a href="#7.24.6.3.3">7.24.6.3.3</a>).
+<a name="7.24.2.3" href="#7.24.2.3"><b>    7.24.2.3 The swprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int swprintf(wchar_t * restrict s,
+                size_t n,
+                const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The swprintf function is equivalent to fwprintf, except that the argument s
+    specifies an array of wide characters into which the generated output is to be written,
+    rather than written to a stream. No more than n wide characters are written, including a
+    terminating null wide character, which is always added (unless n is zero).
+<b>    Returns</b>
+3   The swprintf function returns the number of wide characters written in the array, not
+    counting the terminating null wide character, or a negative value if an encoding error
+    occurred or if n or more wide characters were requested to be written.
+<a name="7.24.2.4" href="#7.24.2.4"><b>    7.24.2.4 The swscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int swscanf(const wchar_t * restrict s,
+                const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The swscanf function is equivalent to fwscanf, except that the argument s specifies a
+    wide string from which the input is to be obtained, rather than from a stream. Reaching
+    the end of the wide string is equivalent to encountering end-of-file for the fwscanf
+    function.
+<b>    Returns</b>
+3   The swscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the swscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+
+[<a name="p362" href="#p362">page 362</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.2.5" href="#7.24.2.5"><b>    7.24.2.5 The vfwprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int vfwprintf(FILE * restrict stream,
+                const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vfwprintf function is equivalent to fwprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfwprintf function does not invoke the
+    va_end macro.<sup><a href="#note291"><b>291)</b></a></sup>
+<b>    Returns</b>
+3   The vfwprintf function returns the number of wide characters transmitted, or a
+    negative value if an output or encoding error occurred.
+4   EXAMPLE       The following shows the use of the vfwprintf function in a general error-reporting
+    routine.
+           #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           void error(char *function_name, wchar_t *format, ...)
+           {
+                 va_list args;
+                    va_start(args, format);
+                    // print out name of function causing error
+                    fwprintf(stderr, L"ERROR in %s: ", function_name);
+                    // print out remainder of message
+                    vfwprintf(stderr, format, args);
+                    va_end(args);
+           }
+
+
+
+
+    <sup><a name="note291" href="#note291"><b>291)</b></a></sup> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
+         invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+[<a name="p363" href="#p363">page 363</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.2.6" href="#7.24.2.6"><b>    7.24.2.6 The vfwscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int vfwscanf(FILE * restrict stream,
+                const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vfwscanf function is equivalent to fwscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfwscanf function does not invoke the
+    va_end macro.291)
+<b>    Returns</b>
+3   The vfwscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the vfwscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+<a name="7.24.2.7" href="#7.24.2.7"><b>    7.24.2.7 The vswprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int vswprintf(wchar_t * restrict s,
+                size_t n,
+                const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vswprintf function is equivalent to swprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vswprintf function does not invoke the
+    va_end macro.291)
+<b>    Returns</b>
+3   The vswprintf function returns the number of wide characters written in the array, not
+    counting the terminating null wide character, or a negative value if an encoding error
+    occurred or if n or more wide characters were requested to be generated.
+
+[<a name="p364" href="#p364">page 364</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.2.8" href="#7.24.2.8"><b>    7.24.2.8 The vswscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int vswscanf(const wchar_t * restrict s,
+                const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vswscanf function is equivalent to swscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vswscanf function does not invoke the
+    va_end macro.291)
+<b>    Returns</b>
+3   The vswscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the vswscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+<a name="7.24.2.9" href="#7.24.2.9"><b>    7.24.2.9 The vwprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int vwprintf(const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vwprintf function is equivalent to wprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vwprintf function does not invoke the
+    va_end macro.291)
+<b>    Returns</b>
+3   The vwprintf function returns the number of wide characters transmitted, or a negative
+    value if an output or encoding error occurred.
+
+[<a name="p365" href="#p365">page 365</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.2.10" href="#7.24.2.10"><b>    7.24.2.10 The vwscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.15">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int vwscanf(const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vwscanf function is equivalent to wscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vwscanf function does not invoke the
+    va_end macro.291)
+<b>    Returns</b>
+3   The vwscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the vwscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+<a name="7.24.2.11" href="#7.24.2.11"><b>    7.24.2.11 The wprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int wprintf(const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The wprintf function is equivalent to fwprintf with the argument stdout
+    interposed before the arguments to wprintf.
+<b>    Returns</b>
+3   The wprintf function returns the number of wide characters transmitted, or a negative
+    value if an output or encoding error occurred.
+<a name="7.24.2.12" href="#7.24.2.12"><b>    7.24.2.12 The wscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int wscanf(const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The wscanf function is equivalent to fwscanf with the argument stdin interposed
+    before the arguments to wscanf.
+
+[<a name="p366" href="#p366">page 366</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The wscanf function returns the value of the macro EOF if an input failure occurs
+    before any conversion. Otherwise, the wscanf function returns the number of input
+    items assigned, which can be fewer than provided for, or even zero, in the event of an
+    early matching failure.
+<a name="7.24.3" href="#7.24.3"><b>    7.24.3 Wide character input/output functions</b></a>
+<a name="7.24.3.1" href="#7.24.3.1"><b>    7.24.3.1 The fgetwc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            wint_t fgetwc(FILE *stream);
+<b>    Description</b>
+2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
+    next wide character is present, the fgetwc function obtains that wide character as a
+    wchar_t converted to a wint_t and advances the associated file position indicator for
+    the stream (if defined).
+<b>    Returns</b>
+3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+    of-file indicator for the stream is set and the fgetwc function returns WEOF. Otherwise,
+    the fgetwc function returns the next wide character from the input stream pointed to by
+    stream. If a read error occurs, the error indicator for the stream is set and the fgetwc
+    function returns WEOF. If an encoding error occurs (including too few bytes), the value of
+    the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note292"><b>292)</b></a></sup>
+<a name="7.24.3.2" href="#7.24.3.2"><b>    7.24.3.2 The fgetws function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            wchar_t *fgetws(wchar_t * restrict s,
+                 int n, FILE * restrict stream);
+<b>    Description</b>
+2   The fgetws function reads at most one less than the number of wide characters
+    specified by n from the stream pointed to by stream into the array pointed to by s. No
+
+
+    <sup><a name="note292" href="#note292"><b>292)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+         Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
+
+[<a name="p367" href="#p367">page 367</a>] (<a href="#Contents">Contents</a>)
+
+    additional wide characters are read after a new-line wide character (which is retained) or
+    after end-of-file. A null wide character is written immediately after the last wide
+    character read into the array.
+<b>    Returns</b>
+3   The fgetws function returns s if successful. If end-of-file is encountered and no
+    characters have been read into the array, the contents of the array remain unchanged and a
+    null pointer is returned. If a read or encoding error occurs during the operation, the array
+    contents are indeterminate and a null pointer is returned.
+<a name="7.24.3.3" href="#7.24.3.3"><b>    7.24.3.3 The fputwc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wint_t fputwc(wchar_t c, FILE *stream);
+<b>    Description</b>
+2   The fputwc function writes the wide character specified by c to the output stream
+    pointed to by stream, at the position indicated by the associated file position indicator
+    for the stream (if defined), and advances the indicator appropriately. If the file cannot
+    support positioning requests, or if the stream was opened with append mode, the
+    character is appended to the output stream.
+<b>    Returns</b>
+3   The fputwc function returns the wide character written. If a write error occurs, the
+    error indicator for the stream is set and fputwc returns WEOF. If an encoding error
+    occurs, the value of the macro EILSEQ is stored in errno and fputwc returns WEOF.
+<a name="7.24.3.4" href="#7.24.3.4"><b>    7.24.3.4 The fputws function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int fputws(const wchar_t * restrict s,
+                FILE * restrict stream);
+<b>    Description</b>
+2   The fputws function writes the wide string pointed to by s to the stream pointed to by
+    stream. The terminating null wide character is not written.
+<b>    Returns</b>
+3   The fputws function returns EOF if a write or encoding error occurs; otherwise, it
+    returns a nonnegative value.
+
+[<a name="p368" href="#p368">page 368</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.3.5" href="#7.24.3.5"><b>    7.24.3.5 The fwide function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            int fwide(FILE *stream, int mode);
+<b>    Description</b>
+2   The fwide function determines the orientation of the stream pointed to by stream. If
+    mode is greater than zero, the function first attempts to make the stream wide oriented. If
+    mode is less than zero, the function first attempts to make the stream byte oriented.<sup><a href="#note293"><b>293)</b></a></sup>
+    Otherwise, mode is zero and the function does not alter the orientation of the stream.
+<b>    Returns</b>
+3   The fwide function returns a value greater than zero if, after the call, the stream has
+    wide orientation, a value less than zero if the stream has byte orientation, or zero if the
+    stream has no orientation.
+<a name="7.24.3.6" href="#7.24.3.6"><b>    7.24.3.6 The getwc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stdio.h&gt;</a>
+            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            wint_t getwc(FILE *stream);
+<b>    Description</b>
+2   The getwc function is equivalent to fgetwc, except that if it is implemented as a
+    macro, it may evaluate stream more than once, so the argument should never be an
+    expression with side effects.
+<b>    Returns</b>
+3   The getwc function returns the next wide character from the input stream pointed to by
+    stream, or WEOF.
+<a name="7.24.3.7" href="#7.24.3.7"><b>    7.24.3.7 The getwchar function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            wint_t getwchar(void);
+
+
+
+
+    <sup><a name="note293" href="#note293"><b>293)</b></a></sup> If the orientation of the stream has already been determined, fwide does not change it.
+
+[<a name="p369" href="#p369">page 369</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The getwchar function is equivalent to getwc with the argument stdin.
+<b>    Returns</b>
+3   The getwchar function returns the next wide character from the input stream pointed to
+    by stdin, or WEOF.
+<a name="7.24.3.8" href="#7.24.3.8"><b>    7.24.3.8 The putwc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wint_t putwc(wchar_t c, FILE *stream);
+<b>    Description</b>
+2   The putwc function is equivalent to fputwc, except that if it is implemented as a
+    macro, it may evaluate stream more than once, so that argument should never be an
+    expression with side effects.
+<b>    Returns</b>
+3   The putwc function returns the wide character written, or WEOF.
+<a name="7.24.3.9" href="#7.24.3.9"><b>    7.24.3.9 The putwchar function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wint_t putwchar(wchar_t c);
+<b>    Description</b>
+2   The putwchar function is equivalent to putwc with the second argument stdout.
+<b>    Returns</b>
+3   The putwchar function returns the character written, or WEOF.
+<a name="7.24.3.10" href="#7.24.3.10"><b>    7.24.3.10 The ungetwc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wint_t ungetwc(wint_t c, FILE *stream);
+<b>    Description</b>
+2   The ungetwc function pushes the wide character specified by c back onto the input
+    stream pointed to by stream. Pushed-back wide characters will be returned by
+    subsequent reads on that stream in the reverse order of their pushing. A successful
+
+[<a name="p370" href="#p370">page 370</a>] (<a href="#Contents">Contents</a>)
+
+    intervening call (with the stream pointed to by stream) to a file positioning function
+    (fseek, fsetpos, or rewind) discards any pushed-back wide characters for the
+    stream. The external storage corresponding to the stream is unchanged.
+3   One wide character of pushback is guaranteed, even if the call to the ungetwc function
+    follows just after a call to a formatted wide character input function fwscanf,
+    vfwscanf, vwscanf, or wscanf. If the ungetwc function is called too many times
+    on the same stream without an intervening read or file positioning operation on that
+    stream, the operation may fail.
+4   If the value of c equals that of the macro WEOF, the operation fails and the input stream is
+    unchanged.
+5   A successful call to the ungetwc function clears the end-of-file indicator for the stream.
+    The value of the file position indicator for the stream after reading or discarding all
+    pushed-back wide characters is the same as it was before the wide characters were pushed
+    back. For a text or binary stream, the value of its file position indicator after a successful
+    call to the ungetwc function is unspecified until all pushed-back wide characters are
+    read or discarded.
+<b>    Returns</b>
+6   The ungetwc function returns the wide character pushed back, or WEOF if the operation
+    fails.
+<a name="7.24.4" href="#7.24.4"><b>    7.24.4 General wide string utilities</b></a>
+1   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares a number of functions useful for wide string
+    manipulation. Various methods are used for determining the lengths of the arrays, but in
+    all cases a wchar_t * argument points to the initial (lowest addressed) element of the
+    array. If an array is accessed beyond the end of an object, the behavior is undefined.
+2   Where an argument declared as size_t n determines the length of the array for a
+    function, n can have the value zero on a call to that function. Unless explicitly stated
+    otherwise in the description of a particular function in this subclause, pointer arguments
+    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+    function that locates a wide character finds no occurrence, a function that compares two
+    wide character sequences returns zero, and a function that copies wide characters copies
+    zero wide characters.
+
+[<a name="p371" href="#p371">page 371</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.4.1" href="#7.24.4.1"><b>    7.24.4.1 Wide string numeric conversion functions</b></a>
+<a name="7.24.4.1.1" href="#7.24.4.1.1"><b>    7.24.4.1.1 The wcstod, wcstof, and wcstold functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           double wcstod(const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr);
+           float wcstof(const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr);
+           long double wcstold(const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr);
+<b>    Description</b>
+2   The wcstod, wcstof, and wcstold functions convert the initial portion of the wide
+    string pointed to by nptr to double, float, and long double representation,
+    respectively. First, they decompose the input string into three parts: an initial, possibly
+    empty, sequence of white-space wide characters (as specified by the iswspace
+    function), a subject sequence resembling a floating-point constant or representing an
+    infinity or NaN; and a final wide string of one or more unrecognized wide characters,
+    including the terminating null wide character of the input wide string. Then, they attempt
+    to convert the subject sequence to a floating-point number, and return the result.
+3   The expected form of the subject sequence is an optional plus or minus sign, then one of
+    the following:
+    -- a nonempty sequence of decimal digits optionally containing a decimal-point wide
+      character, then an optional exponent part as defined for the corresponding single-byte
+      characters in <a href="#6.4.4.2">6.4.4.2</a>;
+    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+      decimal-point wide character, then an optional binary exponent part as defined in
+      <a href="#6.4.4.2">6.4.4.2</a>;
+    -- INF or INFINITY, or any other wide string equivalent except for case
+    -- NAN or NAN(n-wchar-sequenceopt), or any other wide string equivalent except for
+      case in the NAN part, where:
+               n-wchar-sequence:
+                     digit
+                     nondigit
+                     n-wchar-sequence digit
+                     n-wchar-sequence nondigit
+    The subject sequence is defined as the longest initial subsequence of the input wide
+    string, starting with the first non-white-space wide character, that is of the expected form.
+
+[<a name="p372" href="#p372">page 372</a>] (<a href="#Contents">Contents</a>)
+
+    The subject sequence contains no wide characters if the input wide string is not of the
+    expected form.
+4   If the subject sequence has the expected form for a floating-point number, the sequence of
+    wide characters starting with the first digit or the decimal-point wide character
+    (whichever occurs first) is interpreted as a floating constant according to the rules of
+    <a href="#6.4.4.2">6.4.4.2</a>, except that the decimal-point wide character is used in place of a period, and that
+    if neither an exponent part nor a decimal-point wide character appears in a decimal
+    floating point number, or if a binary exponent part does not appear in a hexadecimal
+    floating point number, an exponent part of the appropriate type with value zero is
+    assumed to follow the last digit in the string. If the subject sequence begins with a minus
+    sign, the sequence is interpreted as negated.<sup><a href="#note294"><b>294)</b></a></sup> A wide character sequence INF or
+    INFINITY is interpreted as an infinity, if representable in the return type, else like a
+    floating constant that is too large for the range of the return type. A wide character
+    sequence NAN or NAN(n-wchar-sequenceopt) is interpreted as a quiet NaN, if supported
+    in the return type, else like a subject sequence part that does not have the expected form;
+    the meaning of the n-wchar sequences is implementation-defined.<sup><a href="#note295"><b>295)</b></a></sup> A pointer to the
+    final wide string is stored in the object pointed to by endptr, provided that endptr is
+    not a null pointer.
+5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+    value resulting from the conversion is correctly rounded.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+    Recommended practice
+8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+    the result is not exactly representable, the result should be one of the two numbers in the
+    appropriate internal format that are adjacent to the hexadecimal floating source value,
+    with the extra stipulation that the error should have a correct sign for the current rounding
+    direction.
+
+
+
+    <sup><a name="note294" href="#note294"><b>294)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+         methods may yield different results if rounding is toward positive or negative infinity. In either case,
+         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+    <sup><a name="note295" href="#note295"><b>295)</b></a></sup> An implementation may use the n-wchar sequence to determine extra information to be represented in
+         the NaN's significand.
+
+[<a name="p373" href="#p373">page 373</a>] (<a href="#Contents">Contents</a>)
+
+9    If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+     <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
+     sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+     consider the two bounding, adjacent decimal strings L and U, both having
+     DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+     The result should be one of the (equal or adjacent) values that would be obtained by
+     correctly rounding L and U according to the current rounding direction, with the extra
+     stipulation that the error with respect to D should have a correct sign for the current
+     rounding direction.<sup><a href="#note296"><b>296)</b></a></sup>
+<b>     Returns</b>
+10   The functions return the converted value, if any. If no conversion could be performed,
+     zero is returned. If the correct value is outside the range of representable values, plus or
+     minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the return
+     type and sign of the value), and the value of the macro ERANGE is stored in errno. If
+     the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is no greater
+     than the smallest normalized positive number in the return type; whether errno acquires
+     the value ERANGE is implementation-defined.
+
+
+
+
+     <sup><a name="note296" href="#note296"><b>296)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
+          to the same internal floating value, but if not will round to adjacent values.
+
+[<a name="p374" href="#p374">page 374</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.4.1.2" href="#7.24.4.1.2"><b>    7.24.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           long int wcstol(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+           long long int wcstoll(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+           unsigned long int wcstoul(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+           unsigned long long int wcstoull(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+<b>    Description</b>
+2   The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
+    portion of the wide string pointed to by nptr to long int, long long int,
+    unsigned long int, and unsigned long long int representation,
+    respectively. First, they decompose the input string into three parts: an initial, possibly
+    empty, sequence of white-space wide characters (as specified by the iswspace
+    function), a subject sequence resembling an integer represented in some radix determined
+    by the value of base, and a final wide string of one or more unrecognized wide
+    characters, including the terminating null wide character of the input wide string. Then,
+    they attempt to convert the subject sequence to an integer, and return the result.
+3   If the value of base is zero, the expected form of the subject sequence is that of an
+    integer constant as described for the corresponding single-byte characters in <a href="#6.4.4.1">6.4.4.1</a>,
+    optionally preceded by a plus or minus sign, but not including an integer suffix. If the
+    value of base is between 2 and 36 (inclusive), the expected form of the subject sequence
+    is a sequence of letters and digits representing an integer with the radix specified by
+    base, optionally preceded by a plus or minus sign, but not including an integer suffix.
+    The letters from a (or A) through z (or Z) are ascribed the values 10 through 35; only
+    letters and digits whose ascribed values are less than that of base are permitted. If the
+    value of base is 16, the wide characters 0x or 0X may optionally precede the sequence
+    of letters and digits, following the sign if present.
+
+[<a name="p375" href="#p375">page 375</a>] (<a href="#Contents">Contents</a>)
+
+4   The subject sequence is defined as the longest initial subsequence of the input wide
+    string, starting with the first non-white-space wide character, that is of the expected form.
+    The subject sequence contains no wide characters if the input wide string is empty or
+    consists entirely of white space, or if the first non-white-space wide character is other
+    than a sign or a permissible letter or digit.
+5   If the subject sequence has the expected form and the value of base is zero, the sequence
+    of wide characters starting with the first digit is interpreted as an integer constant
+    according to the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the
+    value of base is between 2 and 36, it is used as the base for conversion, ascribing to each
+    letter its value as given above. If the subject sequence begins with a minus sign, the value
+    resulting from the conversion is negated (in the return type). A pointer to the final wide
+    string is stored in the object pointed to by endptr, provided that endptr is not a null
+    pointer.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+<b>    Returns</b>
+8   The wcstol, wcstoll, wcstoul, and wcstoull functions return the converted
+    value, if any. If no conversion could be performed, zero is returned. If the correct value
+    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+    sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+<a name="7.24.4.2" href="#7.24.4.2"><b>    7.24.4.2 Wide string copying functions</b></a>
+<a name="7.24.4.2.1" href="#7.24.4.2.1"><b>    7.24.4.2.1 The wcscpy function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcscpy(wchar_t * restrict s1,
+                const wchar_t * restrict s2);
+<b>    Description</b>
+2   The wcscpy function copies the wide string pointed to by s2 (including the terminating
+    null wide character) into the array pointed to by s1.
+<b>    Returns</b>
+3   The wcscpy function returns the value of s1.
+
+[<a name="p376" href="#p376">page 376</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.4.2.2" href="#7.24.4.2.2"><b>    7.24.4.2.2 The wcsncpy function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+             wchar_t *wcsncpy(wchar_t * restrict s1,
+                  const wchar_t * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The wcsncpy function copies not more than n wide characters (those that follow a null
+    wide character are not copied) from the array pointed to by s2 to the array pointed to by
+    s1.<sup><a href="#note297"><b>297)</b></a></sup>
+3   If the array pointed to by s2 is a wide string that is shorter than n wide characters, null
+    wide characters are appended to the copy in the array pointed to by s1, until n wide
+    characters in all have been written.
+<b>    Returns</b>
+4   The wcsncpy function returns the value of s1.
+<a name="7.24.4.2.3" href="#7.24.4.2.3"><b>    7.24.4.2.3 The wmemcpy function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+             wchar_t *wmemcpy(wchar_t * restrict s1,
+                  const wchar_t * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The wmemcpy function copies n wide characters from the object pointed to by s2 to the
+    object pointed to by s1.
+<b>    Returns</b>
+3   The wmemcpy function returns the value of s1.
+
+
+
+
+    <sup><a name="note297" href="#note297"><b>297)</b></a></sup> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
+         result will not be null-terminated.
+
+[<a name="p377" href="#p377">page 377</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.4.2.4" href="#7.24.4.2.4"><b>    7.24.4.2.4 The wmemmove function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+                size_t n);
+<b>    Description</b>
+2   The wmemmove function copies n wide characters from the object pointed to by s2 to
+    the object pointed to by s1. Copying takes place as if the n wide characters from the
+    object pointed to by s2 are first copied into a temporary array of n wide characters that
+    does not overlap the objects pointed to by s1 or s2, and then the n wide characters from
+    the temporary array are copied into the object pointed to by s1.
+<b>    Returns</b>
+3   The wmemmove function returns the value of s1.
+<a name="7.24.4.3" href="#7.24.4.3"><b>    7.24.4.3 Wide string concatenation functions</b></a>
+<a name="7.24.4.3.1" href="#7.24.4.3.1"><b>    7.24.4.3.1 The wcscat function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcscat(wchar_t * restrict s1,
+                const wchar_t * restrict s2);
+<b>    Description</b>
+2   The wcscat function appends a copy of the wide string pointed to by s2 (including the
+    terminating null wide character) to the end of the wide string pointed to by s1. The initial
+    wide character of s2 overwrites the null wide character at the end of s1.
+<b>    Returns</b>
+3   The wcscat function returns the value of s1.
+<a name="7.24.4.3.2" href="#7.24.4.3.2"><b>    7.24.4.3.2 The wcsncat function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcsncat(wchar_t * restrict s1,
+                const wchar_t * restrict s2,
+                size_t n);
+<b>    Description</b>
+2   The wcsncat function appends not more than n wide characters (a null wide character
+    and those that follow it are not appended) from the array pointed to by s2 to the end of
+
+[<a name="p378" href="#p378">page 378</a>] (<a href="#Contents">Contents</a>)
+
+    the wide string pointed to by s1. The initial wide character of s2 overwrites the null
+    wide character at the end of s1. A terminating null wide character is always appended to
+    the result.<sup><a href="#note298"><b>298)</b></a></sup>
+<b>    Returns</b>
+3   The wcsncat function returns the value of s1.
+<a name="7.24.4.4" href="#7.24.4.4"><b>    7.24.4.4 Wide string comparison functions</b></a>
+1   Unless explicitly stated otherwise, the functions described in this subclause order two
+    wide characters the same way as two integers of the underlying integer type designated
+    by wchar_t.
+<a name="7.24.4.4.1" href="#7.24.4.4.1"><b>    7.24.4.4.1 The wcscmp function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            int wcscmp(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcscmp function compares the wide string pointed to by s1 to the wide string
+    pointed to by s2.
+<b>    Returns</b>
+3   The wcscmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+    wide string pointed to by s2.
+<a name="7.24.4.4.2" href="#7.24.4.4.2"><b>    7.24.4.4.2 The wcscoll function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            int wcscoll(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcscoll function compares the wide string pointed to by s1 to the wide string
+    pointed to by s2, both interpreted as appropriate to the LC_COLLATE category of the
+    current locale.
+<b>    Returns</b>
+3   The wcscoll function returns an integer greater than, equal to, or less than zero,
+    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+
+
+    <sup><a name="note298" href="#note298"><b>298)</b></a></sup> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
+         wcslen(s1)+n+1.
+
+[<a name="p379" href="#p379">page 379</a>] (<a href="#Contents">Contents</a>)
+
+    wide string pointed to by s2 when both are interpreted as appropriate to the current
+    locale.
+<a name="7.24.4.4.3" href="#7.24.4.4.3"><b>    7.24.4.4.3 The wcsncmp function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+                size_t n);
+<b>    Description</b>
+2   The wcsncmp function compares not more than n wide characters (those that follow a
+    null wide character are not compared) from the array pointed to by s1 to the array
+    pointed to by s2.
+<b>    Returns</b>
+3   The wcsncmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+    to, or less than the possibly null-terminated array pointed to by s2.
+<a name="7.24.4.4.4" href="#7.24.4.4.4"><b>    7.24.4.4.4 The wcsxfrm function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           size_t wcsxfrm(wchar_t * restrict s1,
+                const wchar_t * restrict s2,
+                size_t n);
+<b>    Description</b>
+2   The wcsxfrm function transforms the wide string pointed to by s2 and places the
+    resulting wide string into the array pointed to by s1. The transformation is such that if
+    the wcscmp function is applied to two transformed wide strings, it returns a value greater
+    than, equal to, or less than zero, corresponding to the result of the wcscoll function
+    applied to the same two original wide strings. No more than n wide characters are placed
+    into the resulting array pointed to by s1, including the terminating null wide character. If
+    n is zero, s1 is permitted to be a null pointer.
+<b>    Returns</b>
+3   The wcsxfrm function returns the length of the transformed wide string (not including
+    the terminating null wide character). If the value returned is n or greater, the contents of
+    the array pointed to by s1 are indeterminate.
+4   EXAMPLE The value of the following expression is the length of the array needed to hold the
+    transformation of the wide string pointed to by s:
+
+[<a name="p380" href="#p380">page 380</a>] (<a href="#Contents">Contents</a>)
+
+           1 + wcsxfrm(NULL, s, 0)
+
+<a name="7.24.4.4.5" href="#7.24.4.4.5"><b>    7.24.4.4.5 The wmemcmp function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int wmemcmp(const wchar_t *s1, const wchar_t *s2,
+                size_t n);
+<b>    Description</b>
+2   The wmemcmp function compares the first n wide characters of the object pointed to by
+    s1 to the first n wide characters of the object pointed to by s2.
+<b>    Returns</b>
+3   The wmemcmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+    pointed to by s2.
+<a name="7.24.4.5" href="#7.24.4.5"><b>    7.24.4.5 Wide string search functions</b></a>
+<a name="7.24.4.5.1" href="#7.24.4.5.1"><b>    7.24.4.5.1 The wcschr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcschr(const wchar_t *s, wchar_t c);
+<b>    Description</b>
+2   The wcschr function locates the first occurrence of c in the wide string pointed to by s.
+    The terminating null wide character is considered to be part of the wide string.
+<b>    Returns</b>
+3   The wcschr function returns a pointer to the located wide character, or a null pointer if
+    the wide character does not occur in the wide string.
+<a name="7.24.4.5.2" href="#7.24.4.5.2"><b>    7.24.4.5.2 The wcscspn function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcscspn function computes the length of the maximum initial segment of the wide
+    string pointed to by s1 which consists entirely of wide characters not from the wide
+    string pointed to by s2.
+
+[<a name="p381" href="#p381">page 381</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The wcscspn function returns the length of the segment.
+<a name="7.24.4.5.3" href="#7.24.4.5.3"><b>    7.24.4.5.3 The wcspbrk function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcspbrk function locates the first occurrence in the wide string pointed to by s1 of
+    any wide character from the wide string pointed to by s2.
+<b>    Returns</b>
+3   The wcspbrk function returns a pointer to the wide character in s1, or a null pointer if
+    no wide character from s2 occurs in s1.
+<a name="7.24.4.5.4" href="#7.24.4.5.4"><b>    7.24.4.5.4 The wcsrchr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
+<b>    Description</b>
+2   The wcsrchr function locates the last occurrence of c in the wide string pointed to by
+    s. The terminating null wide character is considered to be part of the wide string.
+<b>    Returns</b>
+3   The wcsrchr function returns a pointer to the wide character, or a null pointer if c does
+    not occur in the wide string.
+<a name="7.24.4.5.5" href="#7.24.4.5.5"><b>    7.24.4.5.5 The wcsspn function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcsspn function computes the length of the maximum initial segment of the wide
+    string pointed to by s1 which consists entirely of wide characters from the wide string
+    pointed to by s2.
+<b>    Returns</b>
+3   The wcsspn function returns the length of the segment.
+
+[<a name="p382" href="#p382">page 382</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.4.5.6" href="#7.24.4.5.6"><b>    7.24.4.5.6 The wcsstr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcsstr function locates the first occurrence in the wide string pointed to by s1 of
+    the sequence of wide characters (excluding the terminating null wide character) in the
+    wide string pointed to by s2.
+<b>    Returns</b>
+3   The wcsstr function returns a pointer to the located wide string, or a null pointer if the
+    wide string is not found. If s2 points to a wide string with zero length, the function
+    returns s1.
+<a name="7.24.4.5.7" href="#7.24.4.5.7"><b>    7.24.4.5.7 The wcstok function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wcstok(wchar_t * restrict s1,
+                const wchar_t * restrict s2,
+                wchar_t ** restrict ptr);
+<b>    Description</b>
+2   A sequence of calls to the wcstok function breaks the wide string pointed to by s1 into
+    a sequence of tokens, each of which is delimited by a wide character from the wide string
+    pointed to by s2. The third argument points to a caller-provided wchar_t pointer into
+    which the wcstok function stores information necessary for it to continue scanning the
+    same wide string.
+3   The first call in a sequence has a non-null first argument and stores an initial value in the
+    object pointed to by ptr. Subsequent calls in the sequence have a null first argument and
+    the object pointed to by ptr is required to have the value stored by the previous call in
+    the sequence, which is then updated. The separator wide string pointed to by s2 may be
+    different from call to call.
+4   The first call in the sequence searches the wide string pointed to by s1 for the first wide
+    character that is not contained in the current separator wide string pointed to by s2. If no
+    such wide character is found, then there are no tokens in the wide string pointed to by s1
+    and the wcstok function returns a null pointer. If such a wide character is found, it is
+    the start of the first token.
+5   The wcstok function then searches from there for a wide character that is contained in
+    the current separator wide string. If no such wide character is found, the current token
+
+[<a name="p383" href="#p383">page 383</a>] (<a href="#Contents">Contents</a>)
+
+    extends to the end of the wide string pointed to by s1, and subsequent searches in the
+    same wide string for a token return a null pointer. If such a wide character is found, it is
+    overwritten by a null wide character, which terminates the current token.
+6   In all cases, the wcstok function stores sufficient information in the pointer pointed to
+    by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+    value for ptr, shall start searching just past the element overwritten by a null wide
+    character (if any).
+<b>    Returns</b>
+7   The wcstok function returns a pointer to the first wide character of a token, or a null
+    pointer if there is no token.
+8   EXAMPLE
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           static wchar_t str1[] = L"?a???b,,,#c";
+           static wchar_t str2[] = L"\t \t";
+           wchar_t *t, *ptr1, *ptr2;
+           t   =   wcstok(str1,   L"?", &amp;ptr1);          //   t   points to the token L"a"
+           t   =   wcstok(NULL,   L",", &amp;ptr1);          //   t   points to the token L"??b"
+           t   =   wcstok(str2,   L" \t", &amp;ptr2);        //   t   is a null pointer
+           t   =   wcstok(NULL,   L"#,", &amp;ptr1);         //   t   points to the token L"c"
+           t   =   wcstok(NULL,   L"?", &amp;ptr1);          //   t   is a null pointer
+
+<a name="7.24.4.5.8" href="#7.24.4.5.8"><b>    7.24.4.5.8 The wmemchr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wmemchr(const wchar_t *s, wchar_t c,
+                size_t n);
+<b>    Description</b>
+2   The wmemchr function locates the first occurrence of c in the initial n wide characters of
+    the object pointed to by s.
+<b>    Returns</b>
+3   The wmemchr function returns a pointer to the located wide character, or a null pointer if
+    the wide character does not occur in the object.
+
+[<a name="p384" href="#p384">page 384</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.4.6" href="#7.24.4.6"><b>    7.24.4.6 Miscellaneous functions</b></a>
+<a name="7.24.4.6.1" href="#7.24.4.6.1"><b>    7.24.4.6.1 The wcslen function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           size_t wcslen(const wchar_t *s);
+<b>    Description</b>
+2   The wcslen function computes the length of the wide string pointed to by s.
+<b>    Returns</b>
+3   The wcslen function returns the number of wide characters that precede the terminating
+    null wide character.
+<a name="7.24.4.6.2" href="#7.24.4.6.2"><b>    7.24.4.6.2 The wmemset function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
+<b>    Description</b>
+2   The wmemset function copies the value of c into each of the first n wide characters of
+    the object pointed to by s.
+<b>    Returns</b>
+3   The wmemset function returns the value of s.
+<a name="7.24.5" href="#7.24.5"><b>    7.24.5 Wide character time conversion functions</b></a>
+<a name="7.24.5.1" href="#7.24.5.1"><b>    7.24.5.1 The wcsftime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;time.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           size_t wcsftime(wchar_t * restrict s,
+                size_t maxsize,
+                const wchar_t * restrict format,
+                const struct tm * restrict timeptr);
+<b>    Description</b>
+2   The wcsftime function is equivalent to the strftime function, except that:
+    -- The argument s points to the initial element of an array of wide characters into which
+      the generated output is to be placed.
+
+[<a name="p385" href="#p385">page 385</a>] (<a href="#Contents">Contents</a>)
+
+    -- The argument maxsize indicates the limiting number of wide characters.
+    -- The argument format is a wide string and the conversion specifiers are replaced by
+      corresponding sequences of wide characters.
+    -- The return value indicates the number of wide characters.
+<b>    Returns</b>
+3   If the total number of resulting wide characters including the terminating null wide
+    character is not more than maxsize, the wcsftime function returns the number of
+    wide characters placed into the array pointed to by s not including the terminating null
+    wide character. Otherwise, zero is returned and the contents of the array are
+    indeterminate.
+<a name="7.24.6" href="#7.24.6"><b>    7.24.6 Extended multibyte/wide character conversion utilities</b></a>
+1   The header <a href="#7.24">&lt;wchar.h&gt;</a> declares an extended set of functions useful for conversion
+    between multibyte characters and wide characters.
+2   Most of the following functions -- those that are listed as ''restartable'', <a href="#7.24.6.3">7.24.6.3</a> and
+    <a href="#7.24.6.4">7.24.6.4</a> -- take as a last argument a pointer to an object of type mbstate_t that is used
+    to describe the current conversion state from a particular multibyte character sequence to
+    a wide character sequence (or the reverse) under the rules of a particular setting for the
+    LC_CTYPE category of the current locale.
+3   The initial conversion state corresponds, for a conversion in either direction, to the
+    beginning of a new multibyte character in the initial shift state. A zero-valued
+    mbstate_t object is (at least) one way to describe an initial conversion state. A zero-
+    valued mbstate_t object can be used to initiate conversion involving any multibyte
+    character sequence, in any LC_CTYPE category setting. If an mbstate_t object has
+    been altered by any of the functions described in this subclause, and is then used with a
+    different multibyte character sequence, or in the other conversion direction, or with a
+    different LC_CTYPE category setting than on earlier function calls, the behavior is
+    undefined.<sup><a href="#note299"><b>299)</b></a></sup>
+4   On entry, each function takes the described conversion state (either internal or pointed to
+    by an argument) as current. The conversion state described by the pointed-to object is
+    altered as needed to track the shift state, and the position within a multibyte character, for
+    the associated multibyte character sequence.
+
+
+
+
+    <sup><a name="note299" href="#note299"><b>299)</b></a></sup> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
+         mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
+         character string.
+
+[<a name="p386" href="#p386">page 386</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.6.1" href="#7.24.6.1"><b>    7.24.6.1 Single-byte/wide character conversion functions</b></a>
+<a name="7.24.6.1.1" href="#7.24.6.1.1"><b>    7.24.6.1.1 The btowc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           wint_t btowc(int c);
+<b>    Description</b>
+2   The btowc function determines whether c constitutes a valid single-byte character in the
+    initial shift state.
+<b>    Returns</b>
+3   The btowc function returns WEOF if c has the value EOF or if (unsigned char)c
+    does not constitute a valid single-byte character in the initial shift state. Otherwise, it
+    returns the wide character representation of that character.
+<a name="7.24.6.1.2" href="#7.24.6.1.2"><b>    7.24.6.1.2 The wctob function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.19">&lt;stdio.h&gt;</a>
+           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int wctob(wint_t c);
+<b>    Description</b>
+2   The wctob function determines whether c corresponds to a member of the extended
+    character set whose multibyte character representation is a single byte when in the initial
+    shift state.
+<b>    Returns</b>
+3   The wctob function returns EOF if c does not correspond to a multibyte character with
+    length one in the initial shift state. Otherwise, it returns the single-byte representation of
+    that character as an unsigned char converted to an int.
+<a name="7.24.6.2" href="#7.24.6.2"><b>    7.24.6.2 Conversion state functions</b></a>
+<a name="7.24.6.2.1" href="#7.24.6.2.1"><b>    7.24.6.2.1 The mbsinit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           int mbsinit(const mbstate_t *ps);
+<b>    Description</b>
+2   If ps is not a null pointer, the mbsinit function determines whether the pointed-to
+    mbstate_t object describes an initial conversion state.
+
+[<a name="p387" href="#p387">page 387</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The mbsinit function returns nonzero if ps is a null pointer or if the pointed-to object
+    describes an initial conversion state; otherwise, it returns zero.
+<a name="7.24.6.3" href="#7.24.6.3"><b>    7.24.6.3 Restartable multibyte/wide character conversion functions</b></a>
+1   These functions differ from the corresponding multibyte character functions of <a href="#7.20.7">7.20.7</a>
+    (mblen, mbtowc, and wctomb) in that they have an extra parameter, ps, of type
+    pointer to mbstate_t that points to an object that can completely describe the current
+    conversion state of the associated multibyte character sequence. If ps is a null pointer,
+    each function uses its own internal mbstate_t object instead, which is initialized at
+    program startup to the initial conversion state. The implementation behaves as if no
+    library function calls these functions with a null pointer for ps.
+2   Also unlike their corresponding functions, the return value does not represent whether the
+    encoding is state-dependent.
+<a name="7.24.6.3.1" href="#7.24.6.3.1"><b>    7.24.6.3.1 The mbrlen function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.24">&lt;wchar.h&gt;</a>
+           size_t mbrlen(const char * restrict s,
+                size_t n,
+                mbstate_t * restrict ps);
+<b>    Description</b>
+2   The mbrlen function is equivalent to the call:
+           mbrtowc(NULL, s, n, ps != NULL ? ps : &amp;internal)
+    where internal is the mbstate_t object for the mbrlen function, except that the
+    expression designated by ps is evaluated only once.
+<b>    Returns</b>
+3   The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
+    or (size_t)(-1).
+    Forward references: the mbrtowc function (<a href="#7.24.6.3.2">7.24.6.3.2</a>).
+
+[<a name="p388" href="#p388">page 388</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.6.3.2" href="#7.24.6.3.2"><b>    7.24.6.3.2 The mbrtowc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            size_t mbrtowc(wchar_t * restrict pwc,
+                 const char * restrict s,
+                 size_t n,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the mbrtowc function is equivalent to the call:
+                    mbrtowc(NULL, "", 1, ps)
+    In this case, the values of the parameters pwc and n are ignored.
+3   If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
+    the byte pointed to by s to determine the number of bytes needed to complete the next
+    multibyte character (including any shift sequences). If the function determines that the
+    next multibyte character is complete and valid, it determines the value of the
+    corresponding wide character and then, if pwc is not a null pointer, stores that value in
+    the object pointed to by pwc. If the corresponding wide character is the null wide
+    character, the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The mbrtowc function returns the first of the following that applies (given the current
+    conversion state):
+    0                     if the next n or fewer bytes complete the multibyte character that
+                          corresponds to the null wide character (which is the value stored).
+    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+                       character (which is the value stored); the value returned is the number
+                       of bytes that complete the multibyte character.
+    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+                 multibyte character, and all n bytes have been processed (no value is
+                 stored).<sup><a href="#note300"><b>300)</b></a></sup>
+    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+                 do not contribute to a complete and valid multibyte character (no
+                 value is stored); the value of the macro EILSEQ is stored in errno,
+                 and the conversion state is unspecified.
+
+    <sup><a name="note300" href="#note300"><b>300)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+         sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+[<a name="p389" href="#p389">page 389</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.6.3.3" href="#7.24.6.3.3"><b>    7.24.6.3.3 The wcrtomb function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            size_t wcrtomb(char * restrict s,
+                 wchar_t wc,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the wcrtomb function is equivalent to the call
+                    wcrtomb(buf, L'\0', ps)
+    where buf is an internal buffer.
+3   If s is not a null pointer, the wcrtomb function determines the number of bytes needed
+    to represent the multibyte character that corresponds to the wide character given by wc
+    (including any shift sequences), and stores the multibyte character representation in the
+    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+    wc is a null wide character, a null byte is stored, preceded by any shift sequence needed
+    to restore the initial shift state; the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The wcrtomb function returns the number of bytes stored in the array object (including
+    any shift sequences). When wc is not a valid wide character, an encoding error occurs:
+    the function stores the value of the macro EILSEQ in errno and returns
+    (size_t)(-1); the conversion state is unspecified.
+<a name="7.24.6.4" href="#7.24.6.4"><b>    7.24.6.4 Restartable multibyte/wide string conversion functions</b></a>
+1   These functions differ from the corresponding multibyte string functions of <a href="#7.20.8">7.20.8</a>
+    (mbstowcs and wcstombs) in that they have an extra parameter, ps, of type pointer to
+    mbstate_t that points to an object that can completely describe the current conversion
+    state of the associated multibyte character sequence. If ps is a null pointer, each function
+    uses its own internal mbstate_t object instead, which is initialized at program startup
+    to the initial conversion state. The implementation behaves as if no library function calls
+    these functions with a null pointer for ps.
+2   Also unlike their corresponding functions, the conversion source parameter, src, has a
+    pointer-to-pointer type. When the function is storing the results of conversions (that is,
+    when dst is not a null pointer), the pointer object pointed to by this parameter is updated
+    to reflect the amount of the source processed by that invocation.
+
+[<a name="p390" href="#p390">page 390</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.6.4.1" href="#7.24.6.4.1"><b>    7.24.6.4.1 The mbsrtowcs function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.24">&lt;wchar.h&gt;</a>
+             size_t mbsrtowcs(wchar_t * restrict dst,
+                  const char ** restrict src,
+                  size_t len,
+                  mbstate_t * restrict ps);
+<b>    Description</b>
+2   The mbsrtowcs function converts a sequence of multibyte characters that begins in the
+    conversion state described by the object pointed to by ps, from the array indirectly
+    pointed to by src into a sequence of corresponding wide characters. If dst is not a null
+    pointer, the converted characters are stored into the array pointed to by dst. Conversion
+    continues up to and including a terminating null character, which is also stored.
+    Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
+    not form a valid multibyte character, or (if dst is not a null pointer) when len wide
+    characters have been stored into the array pointed to by dst.<sup><a href="#note301"><b>301)</b></a></sup> Each conversion takes
+    place as if by a call to the mbrtowc function.
+3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+    pointer (if conversion stopped due to reaching a terminating null character) or the address
+    just past the last multibyte character converted (if any). If conversion stopped due to
+    reaching a terminating null character and if dst is not a null pointer, the resulting state
+    described is the initial conversion state.
+<b>    Returns</b>
+4   If the input conversion encounters a sequence of bytes that do not form a valid multibyte
+    character, an encoding error occurs: the mbsrtowcs function stores the value of the
+    macro EILSEQ in errno and returns (size_t)(-1); the conversion state is
+    unspecified. Otherwise, it returns the number of multibyte characters successfully
+    converted, not including the terminating null character (if any).
+
+
+
+
+    <sup><a name="note301" href="#note301"><b>301)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
+
+[<a name="p391" href="#p391">page 391</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24.6.4.2" href="#7.24.6.4.2"><b>    7.24.6.4.2 The wcsrtombs function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.24">&lt;wchar.h&gt;</a>
+            size_t wcsrtombs(char * restrict dst,
+                 const wchar_t ** restrict src,
+                 size_t len,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   The wcsrtombs function converts a sequence of wide characters from the array
+    indirectly pointed to by src into a sequence of corresponding multibyte characters that
+    begins in the conversion state described by the object pointed to by ps. If dst is not a
+    null pointer, the converted characters are then stored into the array pointed to by dst.
+    Conversion continues up to and including a terminating null wide character, which is also
+    stored. Conversion stops earlier in two cases: when a wide character is reached that does
+    not correspond to a valid multibyte character, or (if dst is not a null pointer) when the
+    next multibyte character would exceed the limit of len total bytes to be stored into the
+    array pointed to by dst. Each conversion takes place as if by a call to the wcrtomb
+    function.<sup><a href="#note302"><b>302)</b></a></sup>
+3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+    pointer (if conversion stopped due to reaching a terminating null wide character) or the
+    address just past the last wide character converted (if any). If conversion stopped due to
+    reaching a terminating null wide character, the resulting state described is the initial
+    conversion state.
+<b>    Returns</b>
+4   If conversion stops because a wide character is reached that does not correspond to a
+    valid multibyte character, an encoding error occurs: the wcsrtombs function stores the
+    value of the macro EILSEQ in errno and returns (size_t)(-1); the conversion
+    state is unspecified. Otherwise, it returns the number of bytes in the resulting multibyte
+    character sequence, not including the terminating null character (if any).
+
+
+
+
+    <sup><a name="note302" href="#note302"><b>302)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
+         include those necessary to reach the initial shift state immediately before the null byte.
+
+[<a name="p392" href="#p392">page 392</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.25" href="#7.25"><b>    7.25 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
+<a name="7.25.1" href="#7.25.1"><b>    7.25.1 Introduction</b></a>
+1   The header <a href="#7.25">&lt;wctype.h&gt;</a> declares three data types, one macro, and many functions.<sup><a href="#note303"><b>303)</b></a></sup>
+2   The types declared are
+             wint_t
+    described in <a href="#7.24.1">7.24.1</a>;
+             wctrans_t
+    which is a scalar type that can hold values which represent locale-specific character
+    mappings; and
+             wctype_t
+    which is a scalar type that can hold values which represent locale-specific character
+    classifications.
+3   The macro defined is WEOF (described in <a href="#7.24.1">7.24.1</a>).
+4   The functions declared are grouped as follows:
+    -- Functions that provide wide character classification;
+    -- Extensible functions that provide wide character classification;
+    -- Functions that provide wide character case mapping;
+    -- Extensible functions that provide wide character mapping.
+5   For all functions described in this subclause that accept an argument of type wint_t, the
+    value shall be representable as a wchar_t or shall equal the value of the macro WEOF. If
+    this argument has any other value, the behavior is undefined.
+6   The behavior of these functions is affected by the LC_CTYPE category of the current
+    locale.
+
+
+
+
+    <sup><a name="note303" href="#note303"><b>303)</b></a></sup> See ''future library directions'' (<a href="#7.26.13">7.26.13</a>).
+
+[<a name="p393" href="#p393">page 393</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.25.2" href="#7.25.2"><b>    7.25.2 Wide character classification utilities</b></a>
+1   The header <a href="#7.25">&lt;wctype.h&gt;</a> declares several functions useful for classifying wide
+    characters.
+2   The term printing wide character refers to a member of a locale-specific set of wide
+    characters, each of which occupies at least one printing position on a display device. The
+    term control wide character refers to a member of a locale-specific set of wide characters
+    that are not printing wide characters.
+<a name="7.25.2.1" href="#7.25.2.1"><b>    7.25.2.1 Wide character classification functions</b></a>
+1   The functions in this subclause return nonzero (true) if and only if the value of the
+    argument wc conforms to that in the description of the function.
+2   Each of the following functions returns true for each wide character that corresponds (as
+    if by a call to the wctob function) to a single-byte character for which the corresponding
+    character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
+    iswpunct functions may differ with respect to wide characters other than L' ' that are
+    both printing and white-space wide characters.<sup><a href="#note304"><b>304)</b></a></sup>
+    Forward references: the wctob function (<a href="#7.24.6.1.2">7.24.6.1.2</a>).
+<a name="7.25.2.1.1" href="#7.25.2.1.1"><b>    7.25.2.1.1 The iswalnum function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           int iswalnum(wint_t wc);
+<b>    Description</b>
+2   The iswalnum function tests for any wide character for which iswalpha or
+    iswdigit is true.
+<a name="7.25.2.1.2" href="#7.25.2.1.2"><b>    7.25.2.1.2 The iswalpha function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           int iswalpha(wint_t wc);
+<b>    Description</b>
+2   The iswalpha function tests for any wide character for which iswupper or
+    iswlower is true, or any wide character that is one of a locale-specific set of alphabetic
+
+    <sup><a name="note304" href="#note304"><b>304)</b></a></sup> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
+         iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
+         (which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
+         &amp;&amp; iswspace(wc) is true, but not both.
+
+[<a name="p394" href="#p394">page 394</a>] (<a href="#Contents">Contents</a>)
+
+    wide characters for which none of iswcntrl, iswdigit, iswpunct, or iswspace
+    is true.<sup><a href="#note305"><b>305)</b></a></sup>
+<a name="7.25.2.1.3" href="#7.25.2.1.3"><b>    7.25.2.1.3 The iswblank function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswblank(wint_t wc);
+<b>    Description</b>
+2   The iswblank function tests for any wide character that is a standard blank wide
+    character or is one of a locale-specific set of wide characters for which iswspace is true
+    and that is used to separate words within a line of text. The standard blank wide
+    characters are the following: space (L' '), and horizontal tab (L'\t'). In the "C"
+    locale, iswblank returns true only for the standard blank characters.
+<a name="7.25.2.1.4" href="#7.25.2.1.4"><b>    7.25.2.1.4 The iswcntrl function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswcntrl(wint_t wc);
+<b>    Description</b>
+2   The iswcntrl function tests for any control wide character.
+<a name="7.25.2.1.5" href="#7.25.2.1.5"><b>    7.25.2.1.5 The iswdigit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswdigit(wint_t wc);
+<b>    Description</b>
+2   The iswdigit function tests for any wide character that corresponds to a decimal-digit
+    character (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.25.2.1.6" href="#7.25.2.1.6"><b>    7.25.2.1.6 The iswgraph function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswgraph(wint_t wc);
+
+
+
+
+    <sup><a name="note305" href="#note305"><b>305)</b></a></sup> The functions iswlower and iswupper test true or false separately for each of these additional
+         wide characters; all four combinations are possible.
+
+[<a name="p395" href="#p395">page 395</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The iswgraph function tests for any wide character for which iswprint is true and
+    iswspace is false.<sup><a href="#note306"><b>306)</b></a></sup>
+<a name="7.25.2.1.7" href="#7.25.2.1.7"><b>    7.25.2.1.7 The iswlower function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswlower(wint_t wc);
+<b>    Description</b>
+2   The iswlower function tests for any wide character that corresponds to a lowercase
+    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+    iswdigit, iswpunct, or iswspace is true.
+<a name="7.25.2.1.8" href="#7.25.2.1.8"><b>    7.25.2.1.8 The iswprint function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswprint(wint_t wc);
+<b>    Description</b>
+2   The iswprint function tests for any printing wide character.
+<a name="7.25.2.1.9" href="#7.25.2.1.9"><b>    7.25.2.1.9 The iswpunct function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswpunct(wint_t wc);
+<b>    Description</b>
+2   The iswpunct function tests for any printing wide character that is one of a locale-
+    specific set of punctuation wide characters for which neither iswspace nor iswalnum
+    is true.306)
+<a name="7.25.2.1.10" href="#7.25.2.1.10"><b>    7.25.2.1.10 The iswspace function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;wctype.h&gt;</a>
+            int iswspace(wint_t wc);
+
+
+
+    <sup><a name="note306" href="#note306"><b>306)</b></a></sup> Note that the behavior of the iswgraph and iswpunct functions may differ from their
+         corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
+         characters other than ' '.
+
+[<a name="p396" href="#p396">page 396</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The iswspace function tests for any wide character that corresponds to a locale-specific
+    set of white-space wide characters for which none of iswalnum, iswgraph, or
+    iswpunct is true.
+<a name="7.25.2.1.11" href="#7.25.2.1.11"><b>    7.25.2.1.11 The iswupper function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           int iswupper(wint_t wc);
+<b>    Description</b>
+2   The iswupper function tests for any wide character that corresponds to an uppercase
+    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+    iswdigit, iswpunct, or iswspace is true.
+<a name="7.25.2.1.12" href="#7.25.2.1.12"><b>    7.25.2.1.12 The iswxdigit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           int iswxdigit(wint_t wc);
+<b>    Description</b>
+2   The iswxdigit function tests for any wide character that corresponds to a
+    hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+<a name="7.25.2.2" href="#7.25.2.2"><b>    7.25.2.2 Extensible wide character classification functions</b></a>
+1   The functions wctype and iswctype provide extensible wide character classification
+    as well as testing equivalent to that performed by the functions described in the previous
+    subclause (<a href="#7.25.2.1">7.25.2.1</a>).
+<a name="7.25.2.2.1" href="#7.25.2.2.1"><b>    7.25.2.2.1 The iswctype function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           int iswctype(wint_t wc, wctype_t desc);
+<b>    Description</b>
+2   The iswctype function determines whether the wide character wc has the property
+    described by desc. The current setting of the LC_CTYPE category shall be the same as
+    during the call to wctype that returned the value desc.
+3   Each of the following expressions has a truth-value equivalent to the call to the wide
+    character classification function (<a href="#7.25.2.1">7.25.2.1</a>) in the comment that follows the expression:
+
+[<a name="p397" href="#p397">page 397</a>] (<a href="#Contents">Contents</a>)
+
+           iswctype(wc,       wctype("alnum"))             //   iswalnum(wc)
+           iswctype(wc,       wctype("alpha"))             //   iswalpha(wc)
+           iswctype(wc,       wctype("blank"))             //   iswblank(wc)
+           iswctype(wc,       wctype("cntrl"))             //   iswcntrl(wc)
+           iswctype(wc,       wctype("digit"))             //   iswdigit(wc)
+           iswctype(wc,       wctype("graph"))             //   iswgraph(wc)
+           iswctype(wc,       wctype("lower"))             //   iswlower(wc)
+           iswctype(wc,       wctype("print"))             //   iswprint(wc)
+           iswctype(wc,       wctype("punct"))             //   iswpunct(wc)
+           iswctype(wc,       wctype("space"))             //   iswspace(wc)
+           iswctype(wc,       wctype("upper"))             //   iswupper(wc)
+           iswctype(wc,       wctype("xdigit"))            //   iswxdigit(wc)
+<b>    Returns</b>
+4   The iswctype function returns nonzero (true) if and only if the value of the wide
+    character wc has the property described by desc.
+    Forward references: the wctype function (<a href="#7.25.2.2.2">7.25.2.2.2</a>).
+<a name="7.25.2.2.2" href="#7.25.2.2.2"><b>    7.25.2.2.2 The wctype function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           wctype_t wctype(const char *property);
+<b>    Description</b>
+2   The wctype function constructs a value with type wctype_t that describes a class of
+    wide characters identified by the string argument property.
+3   The strings listed in the description of the iswctype function shall be valid in all
+    locales as property arguments to the wctype function.
+<b>    Returns</b>
+4   If property identifies a valid class of wide characters according to the LC_CTYPE
+    category of the current locale, the wctype function returns a nonzero value that is valid
+    as the second argument to the iswctype function; otherwise, it returns zero.              *
+
+[<a name="p398" href="#p398">page 398</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.25.3" href="#7.25.3"><b>    7.25.3 Wide character case mapping utilities</b></a>
+1   The header <a href="#7.25">&lt;wctype.h&gt;</a> declares several functions useful for mapping wide characters.
+<a name="7.25.3.1" href="#7.25.3.1"><b>    7.25.3.1 Wide character case mapping functions</b></a>
+<a name="7.25.3.1.1" href="#7.25.3.1.1"><b>    7.25.3.1.1 The towlower function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           wint_t towlower(wint_t wc);
+<b>    Description</b>
+2   The towlower function converts an uppercase letter to a corresponding lowercase letter.
+<b>    Returns</b>
+3   If the argument is a wide character for which iswupper is true and there are one or
+    more corresponding wide characters, as specified by the current locale, for which
+    iswlower is true, the towlower function returns one of the corresponding wide
+    characters (always the same one for any given locale); otherwise, the argument is
+    returned unchanged.
+<a name="7.25.3.1.2" href="#7.25.3.1.2"><b>    7.25.3.1.2 The towupper function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           wint_t towupper(wint_t wc);
+<b>    Description</b>
+2   The towupper function converts a lowercase letter to a corresponding uppercase letter.
+<b>    Returns</b>
+3   If the argument is a wide character for which iswlower is true and there are one or
+    more corresponding wide characters, as specified by the current locale, for which
+    iswupper is true, the towupper function returns one of the corresponding wide
+    characters (always the same one for any given locale); otherwise, the argument is
+    returned unchanged.
+<a name="7.25.3.2" href="#7.25.3.2"><b>    7.25.3.2 Extensible wide character case mapping functions</b></a>
+1   The functions wctrans and towctrans provide extensible wide character mapping as
+    well as case mapping equivalent to that performed by the functions described in the
+    previous subclause (<a href="#7.25.3.1">7.25.3.1</a>).
+
+[<a name="p399" href="#p399">page 399</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.25.3.2.1" href="#7.25.3.2.1"><b>    7.25.3.2.1 The towctrans function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           wint_t towctrans(wint_t wc, wctrans_t desc);
+<b>    Description</b>
+2   The towctrans function maps the wide character wc using the mapping described by
+    desc. The current setting of the LC_CTYPE category shall be the same as during the call
+    to wctrans that returned the value desc.
+3   Each of the following expressions behaves the same as the call to the wide character case
+    mapping function (<a href="#7.25.3.1">7.25.3.1</a>) in the comment that follows the expression:
+           towctrans(wc, wctrans("tolower"))                      // towlower(wc)
+           towctrans(wc, wctrans("toupper"))                      // towupper(wc)
+<b>    Returns</b>
+4   The towctrans function returns the mapped value of wc using the mapping described
+    by desc.
+<a name="7.25.3.2.2" href="#7.25.3.2.2"><b>    7.25.3.2.2 The wctrans function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;wctype.h&gt;</a>
+           wctrans_t wctrans(const char *property);
+<b>    Description</b>
+2   The wctrans function constructs a value with type wctrans_t that describes a
+    mapping between wide characters identified by the string argument property.
+3   The strings listed in the description of the towctrans function shall be valid in all
+    locales as property arguments to the wctrans function.
+<b>    Returns</b>
+4   If property identifies a valid mapping of wide characters according to the LC_CTYPE
+    category of the current locale, the wctrans function returns a nonzero value that is valid
+    as the second argument to the towctrans function; otherwise, it returns zero.
+
+[<a name="p400" href="#p400">page 400</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.26" href="#7.26"><b>    7.26 Future library directions</b></a>
+1   The following names are grouped under individual headers for convenience. All external
+    names described below are reserved no matter what headers are included by the program.
+<a name="7.26.1" href="#7.26.1"><b>    7.26.1 Complex arithmetic &lt;complex.h&gt;</b></a>
+1   The function names
+         cerf                cexpm1              clog2
+         cerfc               clog10              clgamma
+         cexp2               clog1p              ctgamma
+    and the same names suffixed with f or l may be added to the declarations in the
+    <a href="#7.3">&lt;complex.h&gt;</a> header.
+<a name="7.26.2" href="#7.26.2"><b>    7.26.2 Character handling &lt;ctype.h&gt;</b></a>
+1   Function names that begin with either is or to, and a lowercase letter may be added to
+    the declarations in the <a href="#7.4">&lt;ctype.h&gt;</a> header.
+<a name="7.26.3" href="#7.26.3"><b>    7.26.3 Errors &lt;errno.h&gt;</b></a>
+1   Macros that begin with E and a digit or E and an uppercase letter may be added to the
+    declarations in the <a href="#7.5">&lt;errno.h&gt;</a> header.
+<a name="7.26.4" href="#7.26.4"><b>    7.26.4 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
+1   Macro names beginning with PRI or SCN followed by any lowercase letter or X may be
+    added to the macros defined in the <a href="#7.8">&lt;inttypes.h&gt;</a> header.
+<a name="7.26.5" href="#7.26.5"><b>    7.26.5 Localization &lt;locale.h&gt;</b></a>
+1   Macros that begin with LC_ and an uppercase letter may be added to the definitions in
+    the <a href="#7.11">&lt;locale.h&gt;</a> header.
+<a name="7.26.6" href="#7.26.6"><b>    7.26.6 Signal handling &lt;signal.h&gt;</b></a>
+1   Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
+    letter may be added to the definitions in the <a href="#7.14">&lt;signal.h&gt;</a> header.
+<a name="7.26.7" href="#7.26.7"><b>    7.26.7 Boolean type and values &lt;stdbool.h&gt;</b></a>
+1   The ability to undefine and perhaps then redefine the macros bool, true, and false is
+    an obsolescent feature.
+<a name="7.26.8" href="#7.26.8"><b>    7.26.8 Integer types &lt;stdint.h&gt;</b></a>
+1   Typedef names beginning with int or uint and ending with _t may be added to the
+    types defined in the <a href="#7.18">&lt;stdint.h&gt;</a> header. Macro names beginning with INT or UINT
+    and ending with _MAX, _MIN, or _C may be added to the macros defined in the
+    <a href="#7.18">&lt;stdint.h&gt;</a> header.
+
+[<a name="p401" href="#p401">page 401</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.26.9" href="#7.26.9"><b>    7.26.9 Input/output &lt;stdio.h&gt;</b></a>
+1   Lowercase letters may be added to the conversion specifiers and length modifiers in
+    fprintf and fscanf. Other characters may be used in extensions.
+2   The gets function is obsolescent, and is deprecated.
+3   The use of ungetc on a binary stream where the file position indicator is zero prior to
+    the call is an obsolescent feature.
+<a name="7.26.10" href="#7.26.10"><b>    7.26.10 General utilities &lt;stdlib.h&gt;</b></a>
+1   Function names that begin with str and a lowercase letter may be added to the
+    declarations in the <a href="#7.20">&lt;stdlib.h&gt;</a> header.
+<a name="7.26.11" href="#7.26.11"><b>    7.26.11 String handling &lt;string.h&gt;</b></a>
+1   Function names that begin with str, mem, or wcs and a lowercase letter may be added
+    to the declarations in the <a href="#7.21">&lt;string.h&gt;</a> header.
+<a name="7.26.12" href="#7.26.12"><b>    7.26.12 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
+1   Function names that begin with wcs and a lowercase letter may be added to the
+    declarations in the <a href="#7.24">&lt;wchar.h&gt;</a> header.
+2   Lowercase letters may be added to the conversion specifiers and length modifiers in
+    fwprintf and fwscanf. Other characters may be used in extensions.
+<a name="7.26.13" href="#7.26.13"><b>    7.26.13 Wide character classification and mapping utilities</b></a>
+    <a href="#7.25">&lt;wctype.h&gt;</a>
+1   Function names that begin with is or to and a lowercase letter may be added to the
+    declarations in the <a href="#7.25">&lt;wctype.h&gt;</a> header.
+
+[<a name="p402" href="#p402">page 402</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A" href="#A"><b>                                                   Annex A</b></a>
+                                                 (informative)
+                                  Language syntax summary
+1   NOTE     The notation is described in <a href="#6.1">6.1</a>.
+
+<a name="A.1" href="#A.1"><b>    A.1 Lexical grammar</b></a>
+<a name="A.1.1" href="#A.1.1"><b>    A.1.1 Lexical elements</b></a>
+    (<a href="#6.4">6.4</a>) token:
+                     keyword
+                     identifier
+                     constant
+                     string-literal
+                     punctuator
+    (<a href="#6.4">6.4</a>) preprocessing-token:
+                  header-name
+                  identifier
+                  pp-number
+                  character-constant
+                  string-literal
+                  punctuator
+                  each non-white-space character that cannot be one of the above
+<a name="A.1.2" href="#A.1.2"><b>    A.1.2 Keywords</b></a>
+    (<a href="#6.4.1">6.4.1</a>) keyword: one of
+                  auto                      enum             restrict    unsigned
+                  break                     extern           return      void
+                  case                      float            short       volatile
+                  char                      for              signed      while
+                  const                     goto             sizeof      _Bool
+                  continue                  if               static      _Complex
+                  default                   inline           struct      _Imaginary
+                  do                        int              switch
+                  double                    long             typedef
+                  else                      register         union
+
+[<a name="p403" href="#p403">page 403</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.1.3" href="#A.1.3"><b>A.1.3 Identifiers</b></a>
+(<a href="#6.4.2.1">6.4.2.1</a>) identifier:
+               identifier-nondigit
+               identifier identifier-nondigit
+               identifier digit
+(<a href="#6.4.2.1">6.4.2.1</a>) identifier-nondigit:
+               nondigit
+               universal-character-name
+               other implementation-defined characters
+(<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
+              _ a b          c    d   e   f   g   h     i   j   k   l   m
+                   n o       p    q   r   s   t   u     v   w   x   y   z
+                   A B       C    D   E   F   G   H     I   J   K   L   M
+                   N O       P    Q   R   S   T   U     V   W   X   Y   Z
+(<a href="#6.4.2.1">6.4.2.1</a>) digit: one of
+               0 1 2         3    4   5   6   7   8     9
+<a name="A.1.4" href="#A.1.4"><b>A.1.4 Universal character names</b></a>
+(<a href="#6.4.3">6.4.3</a>) universal-character-name:
+              \u hex-quad
+              \U hex-quad hex-quad
+(<a href="#6.4.3">6.4.3</a>) hex-quad:
+              hexadecimal-digit hexadecimal-digit
+                           hexadecimal-digit hexadecimal-digit
+<a name="A.1.5" href="#A.1.5"><b>A.1.5 Constants</b></a>
+(<a href="#6.4.4">6.4.4</a>) constant:
+              integer-constant
+              floating-constant
+              enumeration-constant
+              character-constant
+(<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
+               decimal-constant integer-suffixopt
+               octal-constant integer-suffixopt
+               hexadecimal-constant integer-suffixopt
+(<a href="#6.4.4.1">6.4.4.1</a>) decimal-constant:
+              nonzero-digit
+              decimal-constant digit
+
+[<a name="p404" href="#p404">page 404</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.4.4.1">6.4.4.1</a>) octal-constant:
+               0
+               octal-constant octal-digit
+(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-constant:
+              hexadecimal-prefix hexadecimal-digit
+              hexadecimal-constant hexadecimal-digit
+(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-prefix: one of
+              0x 0X
+(<a href="#6.4.4.1">6.4.4.1</a>) nonzero-digit: one of
+              1 2 3 4 5              6      7   8   9
+(<a href="#6.4.4.1">6.4.4.1</a>) octal-digit: one of
+               0 1 2 3           4   5      6   7
+(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-digit: one of
+              0 1 2 3 4 5                   6   7   8   9
+              a b c d e f
+              A B C D E F
+(<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
+               unsigned-suffix long-suffixopt
+               unsigned-suffix long-long-suffix
+               long-suffix unsigned-suffixopt
+               long-long-suffix unsigned-suffixopt
+(<a href="#6.4.4.1">6.4.4.1</a>) unsigned-suffix: one of
+               u U
+(<a href="#6.4.4.1">6.4.4.1</a>) long-suffix: one of
+               l L
+(<a href="#6.4.4.1">6.4.4.1</a>) long-long-suffix: one of
+               ll LL
+(<a href="#6.4.4.2">6.4.4.2</a>) floating-constant:
+               decimal-floating-constant
+               hexadecimal-floating-constant
+(<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
+              fractional-constant exponent-partopt floating-suffixopt
+              digit-sequence exponent-part floating-suffixopt
+
+[<a name="p405" href="#p405">page 405</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
+              hexadecimal-prefix hexadecimal-fractional-constant
+                            binary-exponent-part floating-suffixopt
+              hexadecimal-prefix hexadecimal-digit-sequence
+                            binary-exponent-part floating-suffixopt
+(<a href="#6.4.4.2">6.4.4.2</a>) fractional-constant:
+               digit-sequenceopt . digit-sequence
+               digit-sequence .
+(<a href="#6.4.4.2">6.4.4.2</a>) exponent-part:
+              e signopt digit-sequence
+              E signopt digit-sequence
+(<a href="#6.4.4.2">6.4.4.2</a>) sign: one of
+               + -
+(<a href="#6.4.4.2">6.4.4.2</a>) digit-sequence:
+               digit
+               digit-sequence digit
+(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
+              hexadecimal-digit-sequenceopt .
+                             hexadecimal-digit-sequence
+              hexadecimal-digit-sequence .
+(<a href="#6.4.4.2">6.4.4.2</a>) binary-exponent-part:
+               p signopt digit-sequence
+               P signopt digit-sequence
+(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-digit-sequence:
+              hexadecimal-digit
+              hexadecimal-digit-sequence hexadecimal-digit
+(<a href="#6.4.4.2">6.4.4.2</a>) floating-suffix: one of
+               f l F L
+(<a href="#6.4.4.3">6.4.4.3</a>) enumeration-constant:
+              identifier
+(<a href="#6.4.4.4">6.4.4.4</a>) character-constant:
+              ' c-char-sequence '
+              L' c-char-sequence '
+
+[<a name="p406" href="#p406">page 406</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.4.4.4">6.4.4.4</a>) c-char-sequence:
+               c-char
+               c-char-sequence c-char
+(<a href="#6.4.4.4">6.4.4.4</a>) c-char:
+               any member of the source character set except
+                            the single-quote ', backslash \, or new-line character
+               escape-sequence
+(<a href="#6.4.4.4">6.4.4.4</a>) escape-sequence:
+              simple-escape-sequence
+              octal-escape-sequence
+              hexadecimal-escape-sequence
+              universal-character-name
+(<a href="#6.4.4.4">6.4.4.4</a>) simple-escape-sequence: one of
+              \' \" \? \\
+              \a \b \f \n \r \t                   \v
+(<a href="#6.4.4.4">6.4.4.4</a>) octal-escape-sequence:
+               \ octal-digit
+               \ octal-digit octal-digit
+               \ octal-digit octal-digit octal-digit
+(<a href="#6.4.4.4">6.4.4.4</a>) hexadecimal-escape-sequence:
+              \x hexadecimal-digit
+              hexadecimal-escape-sequence hexadecimal-digit
+<a name="A.1.6" href="#A.1.6"><b>A.1.6 String literals</b></a>
+(<a href="#6.4.5">6.4.5</a>) string-literal:
+               " s-char-sequenceopt "
+               L" s-char-sequenceopt "
+(<a href="#6.4.5">6.4.5</a>) s-char-sequence:
+               s-char
+               s-char-sequence s-char
+(<a href="#6.4.5">6.4.5</a>) s-char:
+               any member of the source character set except
+                            the double-quote ", backslash \, or new-line character
+               escape-sequence
+
+[<a name="p407" href="#p407">page 407</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.1.7" href="#A.1.7"><b>A.1.7 Punctuators</b></a>
+(<a href="#6.4.6">6.4.6</a>) punctuator: one of
+              [ ] ( ) { } . -&gt;
+              ++ -- &amp; * + - ~ !
+              / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                     ==      !=    ^    |    &amp;&amp;   ||
+              ? : ; ...
+              = *= /= %= += -= &lt;&lt;=                    &gt;&gt;=      &amp;=       ^=   |=
+              , # ##
+              &lt;: :&gt; &lt;% %&gt; %: %:%:
+<a name="A.1.8" href="#A.1.8"><b>A.1.8 Header names</b></a>
+(<a href="#6.4.7">6.4.7</a>) header-name:
+              &lt; h-char-sequence &gt;
+              " q-char-sequence "
+(<a href="#6.4.7">6.4.7</a>) h-char-sequence:
+              h-char
+              h-char-sequence h-char
+(<a href="#6.4.7">6.4.7</a>) h-char:
+              any member of the source character set except
+                           the new-line character and &gt;
+(<a href="#6.4.7">6.4.7</a>) q-char-sequence:
+              q-char
+              q-char-sequence q-char
+(<a href="#6.4.7">6.4.7</a>) q-char:
+              any member of the source character set except
+                           the new-line character and "
+<a name="A.1.9" href="#A.1.9"><b>A.1.9 Preprocessing numbers</b></a>
+(<a href="#6.4.8">6.4.8</a>) pp-number:
+              digit
+              . digit
+              pp-number   digit
+              pp-number   identifier-nondigit
+              pp-number   e sign
+              pp-number   E sign
+              pp-number   p sign
+              pp-number   P sign
+              pp-number   .
+
+[<a name="p408" href="#p408">page 408</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.2" href="#A.2"><b>A.2 Phrase structure grammar</b></a>
+<a name="A.2.1" href="#A.2.1"><b>A.2.1 Expressions</b></a>
+(<a href="#6.5.1">6.5.1</a>) primary-expression:
+              identifier
+              constant
+              string-literal
+              ( expression )
+(<a href="#6.5.2">6.5.2</a>) postfix-expression:
+              primary-expression
+              postfix-expression [ expression ]
+              postfix-expression ( argument-expression-listopt )
+              postfix-expression . identifier
+              postfix-expression -&gt; identifier
+              postfix-expression ++
+              postfix-expression --
+              ( type-name ) { initializer-list }
+              ( type-name ) { initializer-list , }
+(<a href="#6.5.2">6.5.2</a>) argument-expression-list:
+             assignment-expression
+             argument-expression-list , assignment-expression
+(<a href="#6.5.3">6.5.3</a>) unary-expression:
+              postfix-expression
+              ++ unary-expression
+              -- unary-expression
+              unary-operator cast-expression
+              sizeof unary-expression
+              sizeof ( type-name )
+(<a href="#6.5.3">6.5.3</a>) unary-operator: one of
+              &amp; * + - ~             !
+(<a href="#6.5.4">6.5.4</a>) cast-expression:
+               unary-expression
+               ( type-name ) cast-expression
+(<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
+               cast-expression
+               multiplicative-expression * cast-expression
+               multiplicative-expression / cast-expression
+               multiplicative-expression % cast-expression
+
+[<a name="p409" href="#p409">page 409</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.5.6">6.5.6</a>) additive-expression:
+               multiplicative-expression
+               additive-expression + multiplicative-expression
+               additive-expression - multiplicative-expression
+(<a href="#6.5.7">6.5.7</a>) shift-expression:
+                additive-expression
+                shift-expression &lt;&lt; additive-expression
+                shift-expression &gt;&gt; additive-expression
+(<a href="#6.5.8">6.5.8</a>) relational-expression:
+               shift-expression
+               relational-expression   &lt;    shift-expression
+               relational-expression   &gt;    shift-expression
+               relational-expression   &lt;=   shift-expression
+               relational-expression   &gt;=   shift-expression
+(<a href="#6.5.9">6.5.9</a>) equality-expression:
+               relational-expression
+               equality-expression == relational-expression
+               equality-expression != relational-expression
+(<a href="#6.5.10">6.5.10</a>) AND-expression:
+             equality-expression
+             AND-expression &amp; equality-expression
+(<a href="#6.5.11">6.5.11</a>) exclusive-OR-expression:
+              AND-expression
+              exclusive-OR-expression ^ AND-expression
+(<a href="#6.5.12">6.5.12</a>) inclusive-OR-expression:
+               exclusive-OR-expression
+               inclusive-OR-expression | exclusive-OR-expression
+(<a href="#6.5.13">6.5.13</a>) logical-AND-expression:
+              inclusive-OR-expression
+              logical-AND-expression &amp;&amp; inclusive-OR-expression
+(<a href="#6.5.14">6.5.14</a>) logical-OR-expression:
+              logical-AND-expression
+              logical-OR-expression || logical-AND-expression
+(<a href="#6.5.15">6.5.15</a>) conditional-expression:
+              logical-OR-expression
+              logical-OR-expression ? expression : conditional-expression
+
+[<a name="p410" href="#p410">page 410</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.5.16">6.5.16</a>) assignment-expression:
+              conditional-expression
+              unary-expression assignment-operator assignment-expression
+(<a href="#6.5.16">6.5.16</a>) assignment-operator: one of
+              = *= /= %= +=                -=    &lt;&lt;=    &gt;&gt;=      &amp;=   ^=   |=
+(<a href="#6.5.17">6.5.17</a>) expression:
+              assignment-expression
+              expression , assignment-expression
+(<a href="#6.6">6.6</a>) constant-expression:
+              conditional-expression
+<a name="A.2.2" href="#A.2.2"><b>A.2.2 Declarations</b></a>
+(<a href="#6.7">6.7</a>) declaration:
+               declaration-specifiers init-declarator-listopt ;
+(<a href="#6.7">6.7</a>) declaration-specifiers:
+               storage-class-specifier declaration-specifiersopt
+               type-specifier declaration-specifiersopt
+               type-qualifier declaration-specifiersopt
+               function-specifier declaration-specifiersopt
+(<a href="#6.7">6.7</a>) init-declarator-list:
+               init-declarator
+               init-declarator-list , init-declarator
+(<a href="#6.7">6.7</a>) init-declarator:
+               declarator
+               declarator = initializer
+(<a href="#6.7.1">6.7.1</a>) storage-class-specifier:
+              typedef
+              extern
+              static
+              auto
+              register
+
+[<a name="p411" href="#p411">page 411</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7.2">6.7.2</a>) type-specifier:
+               void
+               char
+               short
+               int
+               long
+               float
+               double
+               signed
+               unsigned
+               _Bool
+               _Complex
+               struct-or-union-specifier                                                 *
+               enum-specifier
+               typedef-name
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
+               struct-or-union identifieropt { struct-declaration-list }
+               struct-or-union identifier
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union:
+               struct
+               union
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration-list:
+               struct-declaration
+               struct-declaration-list struct-declaration
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration:
+               specifier-qualifier-list struct-declarator-list ;
+(<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
+               type-specifier specifier-qualifier-listopt
+               type-qualifier specifier-qualifier-listopt
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator-list:
+               struct-declarator
+               struct-declarator-list , struct-declarator
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator:
+               declarator
+               declaratoropt : constant-expression
+
+[<a name="p412" href="#p412">page 412</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
+              enum identifieropt { enumerator-list }
+              enum identifieropt { enumerator-list , }
+              enum identifier
+(<a href="#6.7.2.2">6.7.2.2</a>) enumerator-list:
+              enumerator
+              enumerator-list , enumerator
+(<a href="#6.7.2.2">6.7.2.2</a>) enumerator:
+              enumeration-constant
+              enumeration-constant = constant-expression
+(<a href="#6.7.3">6.7.3</a>) type-qualifier:
+              const
+              restrict
+              volatile
+(<a href="#6.7.4">6.7.4</a>) function-specifier:
+               inline
+(<a href="#6.7.5">6.7.5</a>) declarator:
+              pointeropt direct-declarator
+(<a href="#6.7.5">6.7.5</a>) direct-declarator:
+               identifier
+               ( declarator )
+               direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+               direct-declarator [ static type-qualifier-listopt assignment-expression ]
+               direct-declarator [ type-qualifier-list static assignment-expression ]
+               direct-declarator [ type-qualifier-listopt * ]
+               direct-declarator ( parameter-type-list )
+               direct-declarator ( identifier-listopt )
+(<a href="#6.7.5">6.7.5</a>) pointer:
+               * type-qualifier-listopt
+               * type-qualifier-listopt pointer
+(<a href="#6.7.5">6.7.5</a>) type-qualifier-list:
+              type-qualifier
+              type-qualifier-list type-qualifier
+(<a href="#6.7.5">6.7.5</a>) parameter-type-list:
+             parameter-list
+             parameter-list , ...
+
+[<a name="p413" href="#p413">page 413</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7.5">6.7.5</a>) parameter-list:
+             parameter-declaration
+             parameter-list , parameter-declaration
+(<a href="#6.7.5">6.7.5</a>) parameter-declaration:
+             declaration-specifiers declarator
+             declaration-specifiers abstract-declaratoropt
+(<a href="#6.7.5">6.7.5</a>) identifier-list:
+               identifier
+               identifier-list , identifier
+(<a href="#6.7.6">6.7.6</a>) type-name:
+              specifier-qualifier-list abstract-declaratoropt
+(<a href="#6.7.6">6.7.6</a>) abstract-declarator:
+              pointer
+              pointeropt direct-abstract-declarator
+(<a href="#6.7.6">6.7.6</a>) direct-abstract-declarator:
+               ( abstract-declarator )
+               direct-abstract-declaratoropt [ type-qualifier-listopt
+                              assignment-expressionopt ]
+               direct-abstract-declaratoropt [ static type-qualifier-listopt
+                              assignment-expression ]
+               direct-abstract-declaratoropt [ type-qualifier-list static
+                              assignment-expression ]
+               direct-abstract-declaratoropt [ * ]
+               direct-abstract-declaratoropt ( parameter-type-listopt )
+(<a href="#6.7.7">6.7.7</a>) typedef-name:
+              identifier
+(<a href="#6.7.8">6.7.8</a>) initializer:
+                assignment-expression
+                { initializer-list }
+                { initializer-list , }
+(<a href="#6.7.8">6.7.8</a>) initializer-list:
+                designationopt initializer
+                initializer-list , designationopt initializer
+(<a href="#6.7.8">6.7.8</a>) designation:
+              designator-list =
+
+[<a name="p414" href="#p414">page 414</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7.8">6.7.8</a>) designator-list:
+              designator
+              designator-list designator
+(<a href="#6.7.8">6.7.8</a>) designator:
+              [ constant-expression ]
+              . identifier
+<a name="A.2.3" href="#A.2.3"><b>A.2.3 Statements</b></a>
+(<a href="#6.8">6.8</a>) statement:
+              labeled-statement
+              compound-statement
+              expression-statement
+              selection-statement
+              iteration-statement
+              jump-statement
+(<a href="#6.8.1">6.8.1</a>) labeled-statement:
+               identifier : statement
+               case constant-expression : statement
+               default : statement
+(<a href="#6.8.2">6.8.2</a>) compound-statement:
+             { block-item-listopt }
+(<a href="#6.8.2">6.8.2</a>) block-item-list:
+               block-item
+               block-item-list block-item
+(<a href="#6.8.2">6.8.2</a>) block-item:
+               declaration
+               statement
+(<a href="#6.8.3">6.8.3</a>) expression-statement:
+              expressionopt ;
+(<a href="#6.8.4">6.8.4</a>) selection-statement:
+               if ( expression ) statement
+               if ( expression ) statement else statement
+               switch ( expression ) statement
+
+[<a name="p415" href="#p415">page 415</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.8.5">6.8.5</a>) iteration-statement:
+                while ( expression ) statement
+                do statement while ( expression ) ;
+                for ( expressionopt ; expressionopt ; expressionopt ) statement
+                for ( declaration expressionopt ; expressionopt ) statement
+(<a href="#6.8.6">6.8.6</a>) jump-statement:
+              goto identifier ;
+              continue ;
+              break ;
+              return expressionopt ;
+<a name="A.2.4" href="#A.2.4"><b>A.2.4 External definitions</b></a>
+(<a href="#6.9">6.9</a>) translation-unit:
+               external-declaration
+               translation-unit external-declaration
+(<a href="#6.9">6.9</a>) external-declaration:
+               function-definition
+               declaration
+(<a href="#6.9.1">6.9.1</a>) function-definition:
+               declaration-specifiers declarator declaration-listopt compound-statement
+(<a href="#6.9.1">6.9.1</a>) declaration-list:
+              declaration
+              declaration-list declaration
+<a name="A.3" href="#A.3"><b>A.3 Preprocessing directives</b></a>
+(<a href="#6.10">6.10</a>) preprocessing-file:
+              groupopt
+(<a href="#6.10">6.10</a>) group:
+                group-part
+                group group-part
+(<a href="#6.10">6.10</a>) group-part:
+              if-section
+              control-line
+              text-line
+              # non-directive
+(<a href="#6.10">6.10</a>) if-section:
+                if-group elif-groupsopt else-groupopt endif-line
+
+[<a name="p416" href="#p416">page 416</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.10">6.10</a>) if-group:
+               # if     constant-expression new-line groupopt
+               # ifdef identifier new-line groupopt
+               # ifndef identifier new-line groupopt
+(<a href="#6.10">6.10</a>) elif-groups:
+               elif-group
+               elif-groups elif-group
+(<a href="#6.10">6.10</a>) elif-group:
+               # elif        constant-expression new-line groupopt
+(<a href="#6.10">6.10</a>) else-group:
+               # else        new-line groupopt
+(<a href="#6.10">6.10</a>) endif-line:
+               # endif       new-line
+(<a href="#6.10">6.10</a>) control-line:
+              # include pp-tokens new-line
+              # define identifier replacement-list new-line
+              # define identifier lparen identifier-listopt )
+                                              replacement-list new-line
+              # define identifier lparen ... ) replacement-list new-line
+              # define identifier lparen identifier-list , ... )
+                                              replacement-list new-line
+              # undef   identifier new-line
+              # line    pp-tokens new-line
+              # error   pp-tokensopt new-line
+              # pragma pp-tokensopt new-line
+              #         new-line
+(<a href="#6.10">6.10</a>) text-line:
+               pp-tokensopt new-line
+(<a href="#6.10">6.10</a>) non-directive:
+              pp-tokens new-line
+(<a href="#6.10">6.10</a>) lparen:
+                 a ( character not immediately preceded by white-space
+(<a href="#6.10">6.10</a>) replacement-list:
+              pp-tokensopt
+
+[<a name="p417" href="#p417">page 417</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.10">6.10</a>) pp-tokens:
+              preprocessing-token
+              pp-tokens preprocessing-token
+(<a href="#6.10">6.10</a>) new-line:
+              the new-line character
+
+[<a name="p418" href="#p418">page 418</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B" href="#B"><b>                                Annex B</b></a>
+                              (informative)
+                          Library summary
+<a name="B.1" href="#B.1"><b>B.1 Diagnostics &lt;assert.h&gt;</b></a>
+       NDEBUG
+       void assert(scalar expression);
+<a name="B.2" href="#B.2"><b>B.2 Complex &lt;complex.h&gt;</b></a>
+       complex               imaginary               I
+       _Complex_I            _Imaginary_I
+       #pragma STDC CX_LIMITED_RANGE on-off-switch
+       double complex cacos(double complex z);
+       float complex cacosf(float complex z);
+       long double complex cacosl(long double complex z);
+       double complex casin(double complex z);
+       float complex casinf(float complex z);
+       long double complex casinl(long double complex z);
+       double complex catan(double complex z);
+       float complex catanf(float complex z);
+       long double complex catanl(long double complex z);
+       double complex ccos(double complex z);
+       float complex ccosf(float complex z);
+       long double complex ccosl(long double complex z);
+       double complex csin(double complex z);
+       float complex csinf(float complex z);
+       long double complex csinl(long double complex z);
+       double complex ctan(double complex z);
+       float complex ctanf(float complex z);
+       long double complex ctanl(long double complex z);
+       double complex cacosh(double complex z);
+       float complex cacoshf(float complex z);
+       long double complex cacoshl(long double complex z);
+       double complex casinh(double complex z);
+       float complex casinhf(float complex z);
+       long double complex casinhl(long double complex z);
+       double complex catanh(double complex z);
+       float complex catanhf(float complex z);
+       long double complex catanhl(long double complex z);
+
+[<a name="p419" href="#p419">page 419</a>] (<a href="#Contents">Contents</a>)
+
+      double complex ccosh(double complex z);
+      float complex ccoshf(float complex z);
+      long double complex ccoshl(long double complex z);
+      double complex csinh(double complex z);
+      float complex csinhf(float complex z);
+      long double complex csinhl(long double complex z);
+      double complex ctanh(double complex z);
+      float complex ctanhf(float complex z);
+      long double complex ctanhl(long double complex z);
+      double complex cexp(double complex z);
+      float complex cexpf(float complex z);
+      long double complex cexpl(long double complex z);
+      double complex clog(double complex z);
+      float complex clogf(float complex z);
+      long double complex clogl(long double complex z);
+      double cabs(double complex z);
+      float cabsf(float complex z);
+      long double cabsl(long double complex z);
+      double complex cpow(double complex x, double complex y);
+      float complex cpowf(float complex x, float complex y);
+      long double complex cpowl(long double complex x,
+           long double complex y);
+      double complex csqrt(double complex z);
+      float complex csqrtf(float complex z);
+      long double complex csqrtl(long double complex z);
+      double carg(double complex z);
+      float cargf(float complex z);
+      long double cargl(long double complex z);
+      double cimag(double complex z);
+      float cimagf(float complex z);
+      long double cimagl(long double complex z);
+      double complex conj(double complex z);
+      float complex conjf(float complex z);
+      long double complex conjl(long double complex z);
+      double complex cproj(double complex z);
+      float complex cprojf(float complex z);
+      long double complex cprojl(long double complex z);
+      double creal(double complex z);
+      float crealf(float complex z);
+      long double creall(long double complex z);
+
+[<a name="p420" href="#p420">page 420</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.3" href="#B.3"><b>B.3 Character handling &lt;ctype.h&gt;</b></a>
+       int    isalnum(int c);
+       int    isalpha(int c);
+       int    isblank(int c);
+       int    iscntrl(int c);
+       int    isdigit(int c);
+       int    isgraph(int c);
+       int    islower(int c);
+       int    isprint(int c);
+       int    ispunct(int c);
+       int    isspace(int c);
+       int    isupper(int c);
+       int    isxdigit(int c);
+       int    tolower(int c);
+       int    toupper(int c);
+<a name="B.4" href="#B.4"><b>B.4 Errors &lt;errno.h&gt;</b></a>
+       EDOM            EILSEQ             ERANGE            errno
+<a name="B.5" href="#B.5"><b>B.5 Floating-point environment &lt;fenv.h&gt;</b></a>
+       fenv_t                 FE_OVERFLOW             FE_TOWARDZERO
+       fexcept_t              FE_UNDERFLOW            FE_UPWARD
+       FE_DIVBYZERO           FE_ALL_EXCEPT           FE_DFL_ENV
+       FE_INEXACT             FE_DOWNWARD
+       FE_INVALID             FE_TONEAREST
+       #pragma STDC FENV_ACCESS on-off-switch
+       int feclearexcept(int excepts);
+       int fegetexceptflag(fexcept_t *flagp, int excepts);
+       int feraiseexcept(int excepts);
+       int fesetexceptflag(const fexcept_t *flagp,
+            int excepts);
+       int fetestexcept(int excepts);
+       int fegetround(void);
+       int fesetround(int round);
+       int fegetenv(fenv_t *envp);
+       int feholdexcept(fenv_t *envp);
+       int fesetenv(const fenv_t *envp);
+       int feupdateenv(const fenv_t *envp);
+
+[<a name="p421" href="#p421">page 421</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.6" href="#B.6"><b>B.6 Characteristics of floating types &lt;float.h&gt;</b></a>
+      FLT_ROUNDS              DBL_MIN_EXP             FLT_MAX
+      FLT_EVAL_METHOD         LDBL_MIN_EXP            DBL_MAX
+      FLT_RADIX               FLT_MIN_10_EXP          LDBL_MAX
+      FLT_MANT_DIG            DBL_MIN_10_EXP          FLT_EPSILON
+      DBL_MANT_DIG            LDBL_MIN_10_EXP         DBL_EPSILON
+      LDBL_MANT_DIG           FLT_MAX_EXP             LDBL_EPSILON
+      DECIMAL_DIG             DBL_MAX_EXP             FLT_MIN
+      FLT_DIG                 LDBL_MAX_EXP            DBL_MIN
+      DBL_DIG                 FLT_MAX_10_EXP          LDBL_MIN
+      LDBL_DIG                DBL_MAX_10_EXP
+      FLT_MIN_EXP             LDBL_MAX_10_EXP
+<a name="B.7" href="#B.7"><b>B.7 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
+      imaxdiv_t
+      PRIdN        PRIdLEASTN        PRIdFASTN        PRIdMAX     PRIdPTR
+      PRIiN        PRIiLEASTN        PRIiFASTN        PRIiMAX     PRIiPTR
+      PRIoN        PRIoLEASTN        PRIoFASTN        PRIoMAX     PRIoPTR
+      PRIuN        PRIuLEASTN        PRIuFASTN        PRIuMAX     PRIuPTR
+      PRIxN        PRIxLEASTN        PRIxFASTN        PRIxMAX     PRIxPTR
+      PRIXN        PRIXLEASTN        PRIXFASTN        PRIXMAX     PRIXPTR
+      SCNdN        SCNdLEASTN        SCNdFASTN        SCNdMAX     SCNdPTR
+      SCNiN        SCNiLEASTN        SCNiFASTN        SCNiMAX     SCNiPTR
+      SCNoN        SCNoLEASTN        SCNoFASTN        SCNoMAX     SCNoPTR
+      SCNuN        SCNuLEASTN        SCNuFASTN        SCNuMAX     SCNuPTR
+      SCNxN        SCNxLEASTN        SCNxFASTN        SCNxMAX     SCNxPTR
+      intmax_t imaxabs(intmax_t j);
+      imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+      intmax_t strtoimax(const char * restrict nptr,
+              char ** restrict endptr, int base);
+      uintmax_t strtoumax(const char * restrict nptr,
+              char ** restrict endptr, int base);
+      intmax_t wcstoimax(const wchar_t * restrict nptr,
+              wchar_t ** restrict endptr, int base);
+      uintmax_t wcstoumax(const wchar_t * restrict nptr,
+              wchar_t ** restrict endptr, int base);
+
+[<a name="p422" href="#p422">page 422</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.8" href="#B.8"><b>B.8 Alternative spellings &lt;iso646.h&gt;</b></a>
+     and             bitor             not_eq            xor
+     and_eq          compl             or                xor_eq
+     bitand          not               or_eq
+<a name="B.9" href="#B.9"><b>B.9 Sizes of integer types &lt;limits.h&gt;</b></a>
+     CHAR_BIT        CHAR_MAX          INT_MIN           ULONG_MAX
+     SCHAR_MIN       MB_LEN_MAX        INT_MAX           LLONG_MIN
+     SCHAR_MAX       SHRT_MIN          UINT_MAX          LLONG_MAX
+     UCHAR_MAX       SHRT_MAX          LONG_MIN          ULLONG_MAX
+     CHAR_MIN        USHRT_MAX         LONG_MAX
+<a name="B.10" href="#B.10"><b>B.10 Localization &lt;locale.h&gt;</b></a>
+     struct lconv    LC_ALL            LC_CTYPE          LC_NUMERIC
+     NULL            LC_COLLATE        LC_MONETARY       LC_TIME
+     char *setlocale(int category, const char *locale);
+     struct lconv *localeconv(void);
+<a name="B.11" href="#B.11"><b>B.11 Mathematics &lt;math.h&gt;</b></a>
+     float_t               FP_INFINITE             FP_FAST_FMAL
+     double_t              FP_NAN                  FP_ILOGB0
+     HUGE_VAL              FP_NORMAL               FP_ILOGBNAN
+     HUGE_VALF             FP_SUBNORMAL            MATH_ERRNO
+     HUGE_VALL             FP_ZERO                 MATH_ERREXCEPT
+     INFINITY              FP_FAST_FMA             math_errhandling
+     NAN                   FP_FAST_FMAF
+      #pragma STDC FP_CONTRACT on-off-switch
+      int fpclassify(real-floating x);
+      int isfinite(real-floating x);
+      int isinf(real-floating x);
+      int isnan(real-floating x);
+      int isnormal(real-floating x);
+      int signbit(real-floating x);
+      double acos(double x);
+      float acosf(float x);
+      long double acosl(long double x);
+      double asin(double x);
+      float asinf(float x);
+      long double asinl(long double x);
+      double atan(double x);
+
+[<a name="p423" href="#p423">page 423</a>] (<a href="#Contents">Contents</a>)
+
+      float atanf(float x);
+      long double atanl(long double x);
+      double atan2(double y, double x);
+      float atan2f(float y, float x);
+      long double atan2l(long double y, long double x);
+      double cos(double x);
+      float cosf(float x);
+      long double cosl(long double x);
+      double sin(double x);
+      float sinf(float x);
+      long double sinl(long double x);
+      double tan(double x);
+      float tanf(float x);
+      long double tanl(long double x);
+      double acosh(double x);
+      float acoshf(float x);
+      long double acoshl(long double x);
+      double asinh(double x);
+      float asinhf(float x);
+      long double asinhl(long double x);
+      double atanh(double x);
+      float atanhf(float x);
+      long double atanhl(long double x);
+      double cosh(double x);
+      float coshf(float x);
+      long double coshl(long double x);
+      double sinh(double x);
+      float sinhf(float x);
+      long double sinhl(long double x);
+      double tanh(double x);
+      float tanhf(float x);
+      long double tanhl(long double x);
+      double exp(double x);
+      float expf(float x);
+      long double expl(long double x);
+      double exp2(double x);
+      float exp2f(float x);
+      long double exp2l(long double x);
+      double expm1(double x);
+      float expm1f(float x);
+      long double expm1l(long double x);
+
+[<a name="p424" href="#p424">page 424</a>] (<a href="#Contents">Contents</a>)
+
+        double frexp(double value, int *exp);
+        float frexpf(float value, int *exp);
+        long double frexpl(long double value, int *exp);
+        int ilogb(double x);
+        int ilogbf(float x);
+        int ilogbl(long double x);
+        double ldexp(double x, int exp);
+        float ldexpf(float x, int exp);
+        long double ldexpl(long double x, int exp);
+        double log(double x);
+        float logf(float x);
+        long double logl(long double x);
+        double log10(double x);
+        float log10f(float x);
+        long double log10l(long double x);
+        double log1p(double x);
+        float log1pf(float x);
+        long double log1pl(long double x);
+        double log2(double x);
+        float log2f(float x);
+        long double log2l(long double x);
+        double logb(double x);
+        float logbf(float x);
+        long double logbl(long double x);
+        double modf(double value, double *iptr);
+        float modff(float value, float *iptr);
+        long double modfl(long double value, long double *iptr);
+        double scalbn(double x, int n);
+        float scalbnf(float x, int n);
+        long double scalbnl(long double x, int n);
+        double scalbln(double x, long int n);
+        float scalblnf(float x, long int n);
+        long double scalblnl(long double x, long int n);
+        double cbrt(double x);
+        float cbrtf(float x);
+        long double cbrtl(long double x);
+        double fabs(double x);
+        float fabsf(float x);
+        long double fabsl(long double x);
+        double hypot(double x, double y);
+        float hypotf(float x, float y);
+
+[<a name="p425" href="#p425">page 425</a>] (<a href="#Contents">Contents</a>)
+
+      long double hypotl(long double x, long double y);
+      double pow(double x, double y);
+      float powf(float x, float y);
+      long double powl(long double x, long double y);
+      double sqrt(double x);
+      float sqrtf(float x);
+      long double sqrtl(long double x);
+      double erf(double x);
+      float erff(float x);
+      long double erfl(long double x);
+      double erfc(double x);
+      float erfcf(float x);
+      long double erfcl(long double x);
+      double lgamma(double x);
+      float lgammaf(float x);
+      long double lgammal(long double x);
+      double tgamma(double x);
+      float tgammaf(float x);
+      long double tgammal(long double x);
+      double ceil(double x);
+      float ceilf(float x);
+      long double ceill(long double x);
+      double floor(double x);
+      float floorf(float x);
+      long double floorl(long double x);
+      double nearbyint(double x);
+      float nearbyintf(float x);
+      long double nearbyintl(long double x);
+      double rint(double x);
+      float rintf(float x);
+      long double rintl(long double x);
+      long int lrint(double x);
+      long int lrintf(float x);
+      long int lrintl(long double x);
+      long long int llrint(double x);
+      long long int llrintf(float x);
+      long long int llrintl(long double x);
+      double round(double x);
+      float roundf(float x);
+      long double roundl(long double x);
+      long int lround(double x);
+
+[<a name="p426" href="#p426">page 426</a>] (<a href="#Contents">Contents</a>)
+
+        long int lroundf(float x);
+        long int lroundl(long double x);
+        long long int llround(double x);
+        long long int llroundf(float x);
+        long long int llroundl(long double x);
+        double trunc(double x);
+        float truncf(float x);
+        long double truncl(long double x);
+        double fmod(double x, double y);
+        float fmodf(float x, float y);
+        long double fmodl(long double x, long double y);
+        double remainder(double x, double y);
+        float remainderf(float x, float y);
+        long double remainderl(long double x, long double y);
+        double remquo(double x, double y, int *quo);
+        float remquof(float x, float y, int *quo);
+        long double remquol(long double x, long double y,
+             int *quo);
+        double copysign(double x, double y);
+        float copysignf(float x, float y);
+        long double copysignl(long double x, long double y);
+        double nan(const char *tagp);
+        float nanf(const char *tagp);
+        long double nanl(const char *tagp);
+        double nextafter(double x, double y);
+        float nextafterf(float x, float y);
+        long double nextafterl(long double x, long double y);
+        double nexttoward(double x, long double y);
+        float nexttowardf(float x, long double y);
+        long double nexttowardl(long double x, long double y);
+        double fdim(double x, double y);
+        float fdimf(float x, float y);
+        long double fdiml(long double x, long double y);
+        double fmax(double x, double y);
+        float fmaxf(float x, float y);
+        long double fmaxl(long double x, long double y);
+        double fmin(double x, double y);
+        float fminf(float x, float y);
+        long double fminl(long double x, long double y);
+        double fma(double x, double y, double z);
+        float fmaf(float x, float y, float z);
+
+[<a name="p427" href="#p427">page 427</a>] (<a href="#Contents">Contents</a>)
+
+      long double fmal(long double x, long double y,
+           long double z);
+      int isgreater(real-floating x, real-floating y);
+      int isgreaterequal(real-floating x, real-floating y);
+      int isless(real-floating x, real-floating y);
+      int islessequal(real-floating x, real-floating y);
+      int islessgreater(real-floating x, real-floating y);
+      int isunordered(real-floating x, real-floating y);
+<a name="B.12" href="#B.12"><b>B.12 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
+      jmp_buf
+      int setjmp(jmp_buf env);
+      void longjmp(jmp_buf env, int val);
+<a name="B.13" href="#B.13"><b>B.13 Signal handling &lt;signal.h&gt;</b></a>
+      sig_atomic_t   SIG_IGN            SIGILL            SIGTERM
+      SIG_DFL        SIGABRT            SIGINT
+      SIG_ERR        SIGFPE             SIGSEGV
+      void (*signal(int sig, void (*func)(int)))(int);
+      int raise(int sig);
+<a name="B.14" href="#B.14"><b>B.14 Variable arguments &lt;stdarg.h&gt;</b></a>
+      va_list
+      type va_arg(va_list ap, type);
+      void va_copy(va_list dest, va_list src);
+      void va_end(va_list ap);
+      void va_start(va_list ap, parmN);
+<a name="B.15" href="#B.15"><b>B.15 Boolean type and values &lt;stdbool.h&gt;</b></a>
+      bool
+      true
+      false
+      __bool_true_false_are_defined
+
+[<a name="p428" href="#p428">page 428</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.16" href="#B.16"><b>B.16 Common definitions &lt;stddef.h&gt;</b></a>
+        ptrdiff_t       size_t            wchar_t           NULL
+        offsetof(type, member-designator)
+<a name="B.17" href="#B.17"><b>B.17 Integer types &lt;stdint.h&gt;</b></a>
+        intN_t                INT_LEASTN_MIN          PTRDIFF_MAX
+        uintN_t               INT_LEASTN_MAX          SIG_ATOMIC_MIN
+        int_leastN_t          UINT_LEASTN_MAX         SIG_ATOMIC_MAX
+        uint_leastN_t         INT_FASTN_MIN           SIZE_MAX
+        int_fastN_t           INT_FASTN_MAX           WCHAR_MIN
+        uint_fastN_t          UINT_FASTN_MAX          WCHAR_MAX
+        intptr_t              INTPTR_MIN              WINT_MIN
+        uintptr_t             INTPTR_MAX              WINT_MAX
+        intmax_t              UINTPTR_MAX             INTN_C(value)
+        uintmax_t             INTMAX_MIN              UINTN_C(value)
+        INTN_MIN              INTMAX_MAX              INTMAX_C(value)
+        INTN_MAX              UINTMAX_MAX             UINTMAX_C(value)
+        UINTN_MAX             PTRDIFF_MIN
+<a name="B.18" href="#B.18"><b>B.18 Input/output &lt;stdio.h&gt;</b></a>
+        size_t          _IOLBF            FILENAME_MAX      TMP_MAX
+        FILE            _IONBF            L_tmpnam          stderr
+        fpos_t          BUFSIZ            SEEK_CUR          stdin
+        NULL            EOF               SEEK_END          stdout
+        _IOFBF          FOPEN_MAX         SEEK_SET
+        int remove(const char *filename);
+        int rename(const char *old, const char *new);
+        FILE *tmpfile(void);
+        char *tmpnam(char *s);
+        int fclose(FILE *stream);
+        int fflush(FILE *stream);
+        FILE *fopen(const char * restrict filename,
+             const char * restrict mode);
+        FILE *freopen(const char * restrict filename,
+             const char * restrict mode,
+             FILE * restrict stream);
+        void setbuf(FILE * restrict stream,
+             char * restrict buf);
+
+[<a name="p429" href="#p429">page 429</a>] (<a href="#Contents">Contents</a>)
+
+      int setvbuf(FILE * restrict stream,
+           char * restrict buf,
+           int mode, size_t size);
+      int fprintf(FILE * restrict stream,
+           const char * restrict format, ...);
+      int fscanf(FILE * restrict stream,
+           const char * restrict format, ...);
+      int printf(const char * restrict format, ...);
+      int scanf(const char * restrict format, ...);
+      int snprintf(char * restrict s, size_t n,
+           const char * restrict format, ...);
+      int sprintf(char * restrict s,
+           const char * restrict format, ...);
+      int sscanf(const char * restrict s,
+           const char * restrict format, ...);
+      int vfprintf(FILE * restrict stream,
+           const char * restrict format, va_list arg);
+      int vfscanf(FILE * restrict stream,
+           const char * restrict format, va_list arg);
+      int vprintf(const char * restrict format, va_list arg);
+      int vscanf(const char * restrict format, va_list arg);
+      int vsnprintf(char * restrict s, size_t n,
+           const char * restrict format, va_list arg);
+      int vsprintf(char * restrict s,
+           const char * restrict format, va_list arg);
+      int vsscanf(const char * restrict s,
+           const char * restrict format, va_list arg);
+      int fgetc(FILE *stream);
+      char *fgets(char * restrict s, int n,
+           FILE * restrict stream);
+      int fputc(int c, FILE *stream);
+      int fputs(const char * restrict s,
+           FILE * restrict stream);
+      int getc(FILE *stream);
+      int getchar(void);
+      char *gets(char *s);
+      int putc(int c, FILE *stream);
+      int putchar(int c);
+      int puts(const char *s);
+      int ungetc(int c, FILE *stream);
+
+[<a name="p430" href="#p430">page 430</a>] (<a href="#Contents">Contents</a>)
+
+        size_t fread(void * restrict ptr,
+             size_t size, size_t nmemb,
+             FILE * restrict stream);
+        size_t fwrite(const void * restrict ptr,
+             size_t size, size_t nmemb,
+             FILE * restrict stream);
+        int fgetpos(FILE * restrict stream,
+             fpos_t * restrict pos);
+        int fseek(FILE *stream, long int offset, int whence);
+        int fsetpos(FILE *stream, const fpos_t *pos);
+        long int ftell(FILE *stream);
+        void rewind(FILE *stream);
+        void clearerr(FILE *stream);
+        int feof(FILE *stream);
+        int ferror(FILE *stream);
+        void perror(const char *s);
+<a name="B.19" href="#B.19"><b>B.19 General utilities &lt;stdlib.h&gt;</b></a>
+        size_t       ldiv_t             EXIT_FAILURE      MB_CUR_MAX
+        wchar_t      lldiv_t            EXIT_SUCCESS
+        div_t        NULL               RAND_MAX
+        double atof(const char *nptr);
+        int atoi(const char *nptr);
+        long int atol(const char *nptr);
+        long long int atoll(const char *nptr);
+        double strtod(const char * restrict nptr,
+             char ** restrict endptr);
+        float strtof(const char * restrict nptr,
+             char ** restrict endptr);
+        long double strtold(const char * restrict nptr,
+             char ** restrict endptr);
+        long int strtol(const char * restrict nptr,
+             char ** restrict endptr, int base);
+        long long int strtoll(const char * restrict nptr,
+             char ** restrict endptr, int base);
+        unsigned long int strtoul(
+             const char * restrict nptr,
+             char ** restrict endptr, int base);
+
+[<a name="p431" href="#p431">page 431</a>] (<a href="#Contents">Contents</a>)
+
+      unsigned long long int strtoull(
+           const char * restrict nptr,
+           char ** restrict endptr, int base);
+      int rand(void);
+      void srand(unsigned int seed);
+      void *calloc(size_t nmemb, size_t size);
+      void free(void *ptr);
+      void *malloc(size_t size);
+      void *realloc(void *ptr, size_t size);
+      void abort(void);
+      int atexit(void (*func)(void));
+      void exit(int status);
+      void _Exit(int status);
+      char *getenv(const char *name);
+      int system(const char *string);
+      void *bsearch(const void *key, const void *base,
+           size_t nmemb, size_t size,
+           int (*compar)(const void *, const void *));
+      void qsort(void *base, size_t nmemb, size_t size,
+           int (*compar)(const void *, const void *));
+      int abs(int j);
+      long int labs(long int j);
+      long long int llabs(long long int j);
+      div_t div(int numer, int denom);
+      ldiv_t ldiv(long int numer, long int denom);
+      lldiv_t lldiv(long long int numer,
+           long long int denom);
+      int mblen(const char *s, size_t n);
+      int mbtowc(wchar_t * restrict pwc,
+           const char * restrict s, size_t n);
+      int wctomb(char *s, wchar_t wchar);
+      size_t mbstowcs(wchar_t * restrict pwcs,
+           const char * restrict s, size_t n);
+      size_t wcstombs(char * restrict s,
+           const wchar_t * restrict pwcs, size_t n);
+
+[<a name="p432" href="#p432">page 432</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.20" href="#B.20"><b>B.20 String handling &lt;string.h&gt;</b></a>
+        size_t
+        NULL
+        void *memcpy(void * restrict s1,
+             const void * restrict s2, size_t n);
+        void *memmove(void *s1, const void *s2, size_t n);
+        char *strcpy(char * restrict s1,
+             const char * restrict s2);
+        char *strncpy(char * restrict s1,
+             const char * restrict s2, size_t n);
+        char *strcat(char * restrict s1,
+             const char * restrict s2);
+        char *strncat(char * restrict s1,
+             const char * restrict s2, size_t n);
+        int memcmp(const void *s1, const void *s2, size_t n);
+        int strcmp(const char *s1, const char *s2);
+        int strcoll(const char *s1, const char *s2);
+        int strncmp(const char *s1, const char *s2, size_t n);
+        size_t strxfrm(char * restrict s1,
+             const char * restrict s2, size_t n);
+        void *memchr(const void *s, int c, size_t n);
+        char *strchr(const char *s, int c);
+        size_t strcspn(const char *s1, const char *s2);
+        char *strpbrk(const char *s1, const char *s2);
+        char *strrchr(const char *s, int c);
+        size_t strspn(const char *s1, const char *s2);
+        char *strstr(const char *s1, const char *s2);
+        char *strtok(char * restrict s1,
+             const char * restrict s2);
+        void *memset(void *s, int c, size_t n);
+        char *strerror(int errnum);
+        size_t strlen(const char *s);
+
+[<a name="p433" href="#p433">page 433</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.21" href="#B.21"><b>B.21 Type-generic math &lt;tgmath.h&gt;</b></a>
+      acos           sqrt               fmod              nextafter
+      asin           fabs               frexp             nexttoward
+      atan           atan2              hypot             remainder
+      acosh          cbrt               ilogb             remquo
+      asinh          ceil               ldexp             rint
+      atanh          copysign           lgamma            round
+      cos            erf                llrint            scalbn
+      sin            erfc               llround           scalbln
+      tan            exp2               log10             tgamma
+      cosh           expm1              log1p             trunc
+      sinh           fdim               log2              carg
+      tanh           floor              logb              cimag
+      exp            fma                lrint             conj
+      log            fmax               lround            cproj
+      pow            fmin               nearbyint         creal
+<a name="B.22" href="#B.22"><b>B.22 Date and time &lt;time.h&gt;</b></a>
+      NULL                  size_t                  time_t
+      CLOCKS_PER_SEC        clock_t                 struct tm
+      clock_t clock(void);
+      double difftime(time_t time1, time_t time0);
+      time_t mktime(struct tm *timeptr);
+      time_t time(time_t *timer);
+      char *asctime(const struct tm *timeptr);
+      char *ctime(const time_t *timer);
+      struct tm *gmtime(const time_t *timer);
+      struct tm *localtime(const time_t *timer);
+      size_t strftime(char * restrict s,
+           size_t maxsize,
+           const char * restrict format,
+           const struct tm * restrict timeptr);
+
+[<a name="p434" href="#p434">page 434</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.23" href="#B.23"><b>B.23 Extended multibyte/wide character utilities &lt;wchar.h&gt;</b></a>
+        wchar_t       wint_t             WCHAR_MAX
+        size_t        struct tm          WCHAR_MIN
+        mbstate_t     NULL               WEOF
+        int fwprintf(FILE * restrict stream,
+             const wchar_t * restrict format, ...);
+        int fwscanf(FILE * restrict stream,
+             const wchar_t * restrict format, ...);
+        int swprintf(wchar_t * restrict s, size_t n,
+             const wchar_t * restrict format, ...);
+        int swscanf(const wchar_t * restrict s,
+             const wchar_t * restrict format, ...);
+        int vfwprintf(FILE * restrict stream,
+             const wchar_t * restrict format, va_list arg);
+        int vfwscanf(FILE * restrict stream,
+             const wchar_t * restrict format, va_list arg);
+        int vswprintf(wchar_t * restrict s, size_t n,
+             const wchar_t * restrict format, va_list arg);
+        int vswscanf(const wchar_t * restrict s,
+             const wchar_t * restrict format, va_list arg);
+        int vwprintf(const wchar_t * restrict format,
+             va_list arg);
+        int vwscanf(const wchar_t * restrict format,
+             va_list arg);
+        int wprintf(const wchar_t * restrict format, ...);
+        int wscanf(const wchar_t * restrict format, ...);
+        wint_t fgetwc(FILE *stream);
+        wchar_t *fgetws(wchar_t * restrict s, int n,
+             FILE * restrict stream);
+        wint_t fputwc(wchar_t c, FILE *stream);
+        int fputws(const wchar_t * restrict s,
+             FILE * restrict stream);
+        int fwide(FILE *stream, int mode);
+        wint_t getwc(FILE *stream);
+        wint_t getwchar(void);
+        wint_t putwc(wchar_t c, FILE *stream);
+        wint_t putwchar(wchar_t c);
+        wint_t ungetwc(wint_t c, FILE *stream);
+
+[<a name="p435" href="#p435">page 435</a>] (<a href="#Contents">Contents</a>)
+
+      double wcstod(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr);
+      float wcstof(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr);
+      long double wcstold(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr);
+      long int wcstol(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      long long int wcstoll(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      unsigned long int wcstoul(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      unsigned long long int wcstoull(
+           const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      wchar_t *wcscpy(wchar_t * restrict s1,
+           const wchar_t * restrict s2);
+      wchar_t *wcsncpy(wchar_t * restrict s1,
+           const wchar_t * restrict s2, size_t n);
+      wchar_t *wmemcpy(wchar_t * restrict s1,
+           const wchar_t * restrict s2, size_t n);
+      wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+           size_t n);
+      wchar_t *wcscat(wchar_t * restrict s1,
+           const wchar_t * restrict s2);
+      wchar_t *wcsncat(wchar_t * restrict s1,
+           const wchar_t * restrict s2, size_t n);
+      int wcscmp(const wchar_t *s1, const wchar_t *s2);
+      int wcscoll(const wchar_t *s1, const wchar_t *s2);
+      int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+           size_t n);
+      size_t wcsxfrm(wchar_t * restrict s1,
+           const wchar_t * restrict s2, size_t n);
+      int wmemcmp(const wchar_t *s1, const wchar_t *s2,
+           size_t n);
+      wchar_t *wcschr(const wchar_t *s, wchar_t c);
+      size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
+      wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2); *
+      wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
+      size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
+      wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
+
+[<a name="p436" href="#p436">page 436</a>] (<a href="#Contents">Contents</a>)
+
+        wchar_t *wcstok(wchar_t * restrict s1,
+             const wchar_t * restrict s2,
+             wchar_t ** restrict ptr);
+        wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
+        size_t wcslen(const wchar_t *s);
+        wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
+        size_t wcsftime(wchar_t * restrict s, size_t maxsize,
+             const wchar_t * restrict format,
+             const struct tm * restrict timeptr);
+        wint_t btowc(int c);
+        int wctob(wint_t c);
+        int mbsinit(const mbstate_t *ps);
+        size_t mbrlen(const char * restrict s, size_t n,
+             mbstate_t * restrict ps);
+        size_t mbrtowc(wchar_t * restrict pwc,
+             const char * restrict s, size_t n,
+             mbstate_t * restrict ps);
+        size_t wcrtomb(char * restrict s, wchar_t wc,
+             mbstate_t * restrict ps);
+        size_t mbsrtowcs(wchar_t * restrict dst,
+             const char ** restrict src, size_t len,
+             mbstate_t * restrict ps);
+        size_t wcsrtombs(char * restrict dst,
+             const wchar_t ** restrict src, size_t len,
+             mbstate_t * restrict ps);
+<a name="B.24" href="#B.24"><b>B.24 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
+        wint_t         wctrans_t          wctype_t          WEOF
+        int   iswalnum(wint_t wc);
+        int   iswalpha(wint_t wc);
+        int   iswblank(wint_t wc);
+        int   iswcntrl(wint_t wc);
+        int   iswdigit(wint_t wc);
+        int   iswgraph(wint_t wc);
+        int   iswlower(wint_t wc);
+        int   iswprint(wint_t wc);
+        int   iswpunct(wint_t wc);
+        int   iswspace(wint_t wc);
+        int   iswupper(wint_t wc);
+        int   iswxdigit(wint_t wc);
+        int   iswctype(wint_t wc, wctype_t desc);
+
+[<a name="p437" href="#p437">page 437</a>] (<a href="#Contents">Contents</a>)
+
+      wctype_t wctype(const char *property);
+      wint_t towlower(wint_t wc);
+      wint_t towupper(wint_t wc);
+      wint_t towctrans(wint_t wc, wctrans_t desc);
+      wctrans_t wctrans(const char *property);
+
+[<a name="p438" href="#p438">page 438</a>] (<a href="#Contents">Contents</a>)
+
+<a name="C" href="#C"><b>                                          Annex C</b></a>
+                                        (informative)
+                                      Sequence points
+1   The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
+    -- The call to a function, after the arguments have been evaluated (<a href="#6.5.2.2">6.5.2.2</a>).
+    -- The end of the first operand of the following operators: logical AND &amp;&amp; (<a href="#6.5.13">6.5.13</a>);
+      logical OR || (<a href="#6.5.14">6.5.14</a>); conditional ? (<a href="#6.5.15">6.5.15</a>); comma , (<a href="#6.5.17">6.5.17</a>).
+    -- The end of a full declarator: declarators (<a href="#6.7.5">6.7.5</a>);
+    -- The end of a full expression: an initializer (<a href="#6.7.8">6.7.8</a>); the expression in an expression
+      statement (<a href="#6.8.3">6.8.3</a>); the controlling expression of a selection statement (if or switch)
+      (<a href="#6.8.4">6.8.4</a>); the controlling expression of a while or do statement (<a href="#6.8.5">6.8.5</a>); each of the
+      expressions of a for statement (<a href="#6.8.5.3">6.8.5.3</a>); the expression in a return statement
+      (<a href="#6.8.6.4">6.8.6.4</a>).
+    -- Immediately before a library function returns (<a href="#7.1.4">7.1.4</a>).
+    -- After the actions associated with each formatted input/output function conversion
+      specifier (<a href="#7.19.6">7.19.6</a>, <a href="#7.24.2">7.24.2</a>).
+    -- Immediately before and immediately after each call to a comparison function, and
+      also between any call to a comparison function and any movement of the objects
+      passed as arguments to that call (<a href="#7.20.5">7.20.5</a>).
+
+[<a name="p439" href="#p439">page 439</a>] (<a href="#Contents">Contents</a>)
+
+<a name="D" href="#D"><b>                                         Annex D</b></a>
+                                        (normative)
+                   Universal character names for identifiers
+1   This clause lists the hexadecimal code values that are valid in universal character names
+    in identifiers.
+2   This table is reproduced unchanged from ISO/IEC TR 10176:1998, produced by ISO/IEC
+    JTC 1/SC 22/WG 20, except for the omission of ranges that are part of the basic character
+    sets.
+    Latin:            00AA, 00BA, 00C0-00D6, 00D8-00F6, 00F8-01F5, 01FA-0217,
+                      0250-02A8, 1E00-1E9B, 1EA0-1EF9, 207F
+    Greek:            0386, 0388-038A, 038C, 038E-03A1, 03A3-03CE, 03D0-03D6,
+                      03DA, 03DC, 03DE, 03E0, 03E2-03F3, 1F00-1F15, 1F18-1F1D,
+                      1F20-1F45, 1F48-1F4D, 1F50-1F57, 1F59, 1F5B, 1F5D,
+                      1F5F-1F7D, 1F80-1FB4, 1FB6-1FBC, 1FC2-1FC4, 1FC6-1FCC,
+                      1FD0-1FD3, 1FD6-1FDB, 1FE0-1FEC, 1FF2-1FF4, 1FF6-1FFC
+    Cyrillic:         0401-040C, 040E-044F, 0451-045C, 045E-0481, 0490-04C4,
+                      04C7-04C8, 04CB-04CC, 04D0-04EB, 04EE-04F5, 04F8-04F9
+    Armenian:         0531-0556, 0561-0587
+    Hebrew:           05B0-05B9,      05BB-05BD,       05BF,   05C1-05C2,      05D0-05EA,
+                      05F0-05F2
+    Arabic:           0621-063A, 0640-0652, 0670-06B7, 06BA-06BE, 06C0-06CE,
+                      06D0-06DC, 06E5-06E8, 06EA-06ED
+    Devanagari:       0901-0903, 0905-0939, 093E-094D, 0950-0952, 0958-0963
+    Bengali:          0981-0983, 0985-098C, 098F-0990, 0993-09A8, 09AA-09B0,
+                      09B2, 09B6-09B9, 09BE-09C4, 09C7-09C8, 09CB-09CD,
+                      09DC-09DD, 09DF-09E3, 09F0-09F1
+    Gurmukhi:         0A02, 0A05-0A0A, 0A0F-0A10, 0A13-0A28, 0A2A-0A30,
+                      0A32-0A33, 0A35-0A36, 0A38-0A39, 0A3E-0A42, 0A47-0A48,
+                      0A4B-0A4D, 0A59-0A5C, 0A5E, 0A74
+    Gujarati:         0A81-0A83, 0A85-0A8B, 0A8D, 0A8F-0A91, 0A93-0AA8,
+                      0AAA-0AB0,    0AB2-0AB3,     0AB5-0AB9, 0ABD-0AC5,
+                      0AC7-0AC9, 0ACB-0ACD, 0AD0, 0AE0
+    Oriya:            0B01-0B03, 0B05-0B0C, 0B0F-0B10, 0B13-0B28, 0B2A-0B30,
+                      0B32-0B33, 0B36-0B39, 0B3E-0B43, 0B47-0B48, 0B4B-0B4D,
+
+[<a name="p440" href="#p440">page 440</a>] (<a href="#Contents">Contents</a>)
+
+                0B5C-0B5D, 0B5F-0B61
+Tamil:          0B82-0B83, 0B85-0B8A, 0B8E-0B90, 0B92-0B95, 0B99-0B9A,
+                0B9C, 0B9E-0B9F, 0BA3-0BA4, 0BA8-0BAA, 0BAE-0BB5,
+                0BB7-0BB9, 0BBE-0BC2, 0BC6-0BC8, 0BCA-0BCD
+Telugu:         0C01-0C03, 0C05-0C0C, 0C0E-0C10, 0C12-0C28, 0C2A-0C33,
+                0C35-0C39, 0C3E-0C44, 0C46-0C48, 0C4A-0C4D, 0C60-0C61
+Kannada:        0C82-0C83, 0C85-0C8C, 0C8E-0C90, 0C92-0CA8, 0CAA-0CB3,
+                0CB5-0CB9, 0CBE-0CC4, 0CC6-0CC8, 0CCA-0CCD, 0CDE,
+                0CE0-0CE1
+Malayalam:      0D02-0D03, 0D05-0D0C, 0D0E-0D10, 0D12-0D28, 0D2A-0D39,
+                0D3E-0D43, 0D46-0D48, 0D4A-0D4D, 0D60-0D61
+Thai:           0E01-0E3A, 0E40-0E5B
+Lao:            0E81-0E82, 0E84, 0E87-0E88, 0E8A, 0E8D, 0E94-0E97,
+                0E99-0E9F,   0EA1-0EA3,  0EA5,  0EA7,  0EAA-0EAB,
+                0EAD-0EAE, 0EB0-0EB9, 0EBB-0EBD, 0EC0-0EC4, 0EC6,
+                0EC8-0ECD, 0EDC-0EDD
+Tibetan:        0F00, 0F18-0F19, 0F35, 0F37, 0F39, 0F3E-0F47, 0F49-0F69,
+                0F71-0F84, 0F86-0F8B, 0F90-0F95, 0F97, 0F99-0FAD,
+                0FB1-0FB7, 0FB9
+Georgian:       10A0-10C5, 10D0-10F6
+Hiragana:       3041-3093, 309B-309C
+Katakana:       30A1-30F6, 30FB-30FC
+Bopomofo:       3105-312C
+CJK Unified Ideographs: 4E00-9FA5
+Hangul:         AC00-D7A3
+Digits:         0660-0669, 06F0-06F9, 0966-096F, 09E6-09EF, 0A66-0A6F,
+                0AE6-0AEF, 0B66-0B6F, 0BE7-0BEF, 0C66-0C6F, 0CE6-0CEF,
+                0D66-0D6F, 0E50-0E59, 0ED0-0ED9, 0F20-0F33
+Special characters: 00B5, 00B7, 02B0-02B8, 02BB, 02BD-02C1, 02D0-02D1,
+                   02E0-02E4, 037A, 0559, 093D, 0B3D, 1FBE, 203F-2040, 2102,
+                   2107, 210A-2113, 2115, 2118-211D, 2124, 2126, 2128, 212A-2131,
+                   2133-2138, 2160-2182, 3005-3007, 3021-3029
+
+[<a name="p441" href="#p441">page 441</a>] (<a href="#Contents">Contents</a>)
+
+<a name="E" href="#E"><b>                                         Annex E</b></a>
+                                       (informative)
+                                Implementation limits
+1   The contents of the header <a href="#7.10">&lt;limits.h&gt;</a> are given below, in alphabetical order. The
+    minimum magnitudes shown shall be replaced by implementation-defined magnitudes
+    with the same sign. The values shall all be constant expressions suitable for use in #if
+    preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+           #define     CHAR_BIT                               8
+           #define     CHAR_MAX          UCHAR_MAX or SCHAR_MAX
+           #define     CHAR_MIN                  0 or SCHAR_MIN
+           #define     INT_MAX                           +32767
+           #define     INT_MIN                           -32767
+           #define     LONG_MAX                     +2147483647
+           #define     LONG_MIN                     -2147483647
+           #define     LLONG_MAX           +9223372036854775807
+           #define     LLONG_MIN           -9223372036854775807
+           #define     MB_LEN_MAX                             1
+           #define     SCHAR_MAX                           +127
+           #define     SCHAR_MIN                           -127
+           #define     SHRT_MAX                          +32767
+           #define     SHRT_MIN                          -32767
+           #define     UCHAR_MAX                            255
+           #define     USHRT_MAX                          65535
+           #define     UINT_MAX                           65535
+           #define     ULONG_MAX                     4294967295
+           #define     ULLONG_MAX          18446744073709551615
+2   The contents of the header <a href="#7.7">&lt;float.h&gt;</a> are given below. All integer values, except
+    FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
+    directives; all floating values shall be constant expressions. The components are
+    described further in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+3   The values given in the following list shall be replaced by implementation-defined
+    expressions:
+           #define FLT_EVAL_METHOD
+           #define FLT_ROUNDS
+4   The values given in the following list shall be replaced by implementation-defined
+    constant expressions that are greater or equal in magnitude (absolute value) to those
+    shown, with the same sign:
+
+[<a name="p442" href="#p442">page 442</a>] (<a href="#Contents">Contents</a>)
+
+           #define    DBL_DIG                                        10
+           #define    DBL_MANT_DIG
+           #define    DBL_MAX_10_EXP                               +37
+           #define    DBL_MAX_EXP
+           #define    DBL_MIN_10_EXP                               -37
+           #define    DBL_MIN_EXP
+           #define    DECIMAL_DIG                                    10
+           #define    FLT_DIG                                         6
+           #define    FLT_MANT_DIG
+           #define    FLT_MAX_10_EXP                               +37
+           #define    FLT_MAX_EXP
+           #define    FLT_MIN_10_EXP                               -37
+           #define    FLT_MIN_EXP
+           #define    FLT_RADIX                                       2
+           #define    LDBL_DIG                                       10
+           #define    LDBL_MANT_DIG
+           #define    LDBL_MAX_10_EXP                              +37
+           #define    LDBL_MAX_EXP
+           #define    LDBL_MIN_10_EXP                              -37
+           #define    LDBL_MIN_EXP
+5   The values given in the following list shall be replaced by implementation-defined
+    constant expressions with values that are greater than or equal to those shown:
+           #define DBL_MAX                                      1E+37
+           #define FLT_MAX                                      1E+37
+           #define LDBL_MAX                                     1E+37
+6   The values given in the following list shall be replaced by implementation-defined
+    constant expressions with (positive) values that are less than or equal to those shown:
+           #define    DBL_EPSILON                                1E-9
+           #define    DBL_MIN                                   1E-37
+           #define    FLT_EPSILON                                1E-5
+           #define    FLT_MIN                                   1E-37
+           #define    LDBL_EPSILON                               1E-9
+           #define    LDBL_MIN                                  1E-37
+
+[<a name="p443" href="#p443">page 443</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F" href="#F"><b>                                               Annex F</b></a>
+                                              (normative)
+                          IEC 60559 floating-point arithmetic
+<a name="F.1" href="#F.1"><b>    F.1 Introduction</b></a>
+1   This annex specifies C language support for the IEC 60559 floating-point standard. The
+    IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for
+    microprocessor systems, second edition (IEC 60559:1989), previously designated
+    IEC 559:1989 and as IEEE Standard for Binary Floating-Point Arithmetic
+    (ANSI/IEEE 754-1985). IEEE Standard for Radix-Independent Floating-Point
+    Arithmetic (ANSI/IEEE 854-1987) generalizes the binary standard to remove
+    dependencies on radix and word length. IEC 60559 generally refers to the floating-point
+    standard, as in IEC 60559 operation, IEC 60559 format, etc. An implementation that
+    defines __STDC_IEC_559__ shall conform to the specifications in this annex. Where
+    a binding between the C language and IEC 60559 is indicated, the IEC 60559-specified
+    behavior is adopted by reference, unless stated otherwise.
+<a name="F.2" href="#F.2"><b>    F.2 Types</b></a>
+1   The C floating types match the IEC 60559 formats as follows:
+    -- The float type matches the IEC 60559 single format.
+    -- The double type matches the IEC 60559 double format.
+    -- The long double type matches an IEC 60559 extended format,<sup><a href="#note307"><b>307)</b></a></sup> else a
+      non-IEC 60559 extended format, else the IEC 60559 double format.
+    Any non-IEC 60559 extended format used for the long double type shall have more
+    precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note308"><b>308)</b></a></sup>
+    Recommended practice
+2   The long double type should match an IEC 60559 extended format.
+
+
+
+
+    <sup><a name="note307" href="#note307"><b>307)</b></a></sup> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
+         and quadruple 128-bit IEC 60559 formats.
+    <sup><a name="note308" href="#note308"><b>308)</b></a></sup> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
+         all double values.
+
+[<a name="p444" href="#p444">page 444</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.2.1" href="#F.2.1"><b>    F.2.1 Infinities, signed zeros, and NaNs</b></a>
+1   This specification does not define the behavior of signaling NaNs.<sup><a href="#note309"><b>309)</b></a></sup> It generally uses
+    the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
+    functions in <a href="#7.12">&lt;math.h&gt;</a> provide designations for IEC 60559 NaNs and infinities.
+<a name="F.3" href="#F.3"><b>    F.3 Operators and functions</b></a>
+1   C operators and functions provide IEC 60559 required and recommended facilities as
+    listed below.
+    -- The +, -, *, and / operators provide the IEC 60559 add, subtract, multiply, and
+      divide operations.
+    -- The sqrt functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 square root operation.
+    -- The remainder functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 remainder
+      operation. The remquo functions in <a href="#7.12">&lt;math.h&gt;</a> provide the same operation but
+      with additional information.
+    -- The rint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 operation that rounds a
+      floating-point number to an integer value (in the same precision). The nearbyint
+      functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nearbyinteger function recommended in the
+      Appendix to ANSI/IEEE 854.
+    -- The conversions for floating types provide the IEC 60559 conversions between
+      floating-point precisions.
+    -- The conversions from integer to floating types provide the IEC 60559 conversions
+      from integer to floating point.
+    -- The conversions from floating to integer types provide IEC 60559-like conversions
+      but always round toward zero.
+    -- The lrint and llrint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559
+      conversions, which honor the directed rounding mode, from floating point to the
+      long int and long long int integer formats. The lrint and llrint
+      functions can be used to implement IEC 60559 conversions from floating to other
+      integer formats.
+    -- The translation time conversion of floating constants and the strtod, strtof,
+      strtold, fprintf, fscanf, and related library functions in <a href="#7.20">&lt;stdlib.h&gt;</a>,
+      <a href="#7.19">&lt;stdio.h&gt;</a>, and <a href="#7.24">&lt;wchar.h&gt;</a> provide IEC 60559 binary-decimal conversions. The
+      strtold function in <a href="#7.20">&lt;stdlib.h&gt;</a> provides the conv function recommended in the
+      Appendix to ANSI/IEEE 854.
+
+    <sup><a name="note309" href="#note309"><b>309)</b></a></sup> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
+         sufficient for closure of the arithmetic.
+
+[<a name="p445" href="#p445">page 445</a>] (<a href="#Contents">Contents</a>)
+
+-- The relational and equality operators provide IEC 60559 comparisons. IEC 60559
+  identifies a need for additional comparison predicates to facilitate writing code that
+  accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
+  isless, islessequal, islessgreater, and isunordered) in <a href="#7.12">&lt;math.h&gt;</a>
+  supplement the language operators to address this need. The islessgreater and
+  isunordered macros provide respectively a quiet version of the &lt;&gt; predicate and
+  the unordered predicate recommended in the Appendix to IEC 60559.
+-- The feclearexcept, feraiseexcept, and fetestexcept functions in
+  <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to test and alter the IEC 60559 floating-point
+  exception status flags. The fegetexceptflag and fesetexceptflag
+  functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to save and restore all five status flags at
+  one time. These functions are used in conjunction with the type fexcept_t and the
+  floating-point     exception      macros      (FE_INEXACT,         FE_DIVBYZERO,
+  FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in <a href="#7.6">&lt;fenv.h&gt;</a>.
+-- The fegetround and fesetround functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility
+  to select among the IEC 60559 directed rounding modes represented by the rounding
+  direction macros in <a href="#7.6">&lt;fenv.h&gt;</a> (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
+  FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the
+  IEC 60559 directed rounding modes.
+-- The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
+  <a href="#7.6">&lt;fenv.h&gt;</a> provide a facility to manage the floating-point environment, comprising
+  the IEC 60559 status flags and control modes.
+-- The copysign functions in <a href="#7.12">&lt;math.h&gt;</a> provide the copysign function
+  recommended in the Appendix to IEC 60559.
+-- The unary minus (-) operator provides the minus (-) operation recommended in the
+  Appendix to IEC 60559.
+-- The scalbn and scalbln functions in <a href="#7.12">&lt;math.h&gt;</a> provide the scalb function
+  recommended in the Appendix to IEC 60559.
+-- The logb functions in <a href="#7.12">&lt;math.h&gt;</a> provide the logb function recommended in the
+  Appendix to IEC 60559, but following the newer specifications in ANSI/IEEE 854.
+-- The nextafter and nexttoward functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nextafter
+  function recommended in the Appendix to IEC 60559 (but with a minor change to
+  better handle signed zeros).
+-- The isfinite macro in <a href="#7.12">&lt;math.h&gt;</a> provides the finite function recommended in
+  the Appendix to IEC 60559.
+-- The isnan macro in <a href="#7.12">&lt;math.h&gt;</a> provides the isnan function recommended in the
+  Appendix to IEC 60559.
+
+[<a name="p446" href="#p446">page 446</a>] (<a href="#Contents">Contents</a>)
+
+    -- The signbit macro and the fpclassify macro in <a href="#7.12">&lt;math.h&gt;</a>, used in
+      conjunction with the number classification macros (FP_NAN, FP_INFINITE,
+      FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
+      function recommended in the Appendix to IEC 60559 (except that the classification
+      macros defined in <a href="#7.12.3">7.12.3</a> do not distinguish signaling from quiet NaNs).
+<a name="F.4" href="#F.4"><b>    F.4 Floating to integer conversion</b></a>
+1   If the floating value is infinite or NaN or if the integral part of the floating value exceeds
+    the range of the integer type, then the ''invalid'' floating-point exception is raised and the
+    resulting value is unspecified. Whether conversion of non-integer floating values whose
+    integral part is within the range of the integer type raises the ''inexact'' floating-point
+    exception is unspecified.<sup><a href="#note310"><b>310)</b></a></sup>
+<a name="F.5" href="#F.5"><b>    F.5 Binary-decimal conversion</b></a>
+1   Conversion from the widest supported IEC 60559 format to decimal with
+    DECIMAL_DIG digits and back is the identity function.<sup><a href="#note311"><b>311)</b></a></sup>
+2   Conversions involving IEC 60559 formats follow all pertinent recommended practice. In
+    particular, conversion between any supported IEC 60559 format and decimal with
+    DECIMAL_DIG or fewer significant digits is correctly rounded (honoring the current
+    rounding mode), which assures that conversion from the widest supported IEC 60559
+    format to decimal with DECIMAL_DIG digits and back is the identity function.
+3   Functions such as strtod that convert character sequences to floating types honor the
+    rounding direction. Hence, if the rounding direction might be upward or downward, the
+    implementation cannot convert a minus-signed sequence by negating the converted
+    unsigned sequence.
+
+
+
+
+    <sup><a name="note310" href="#note310"><b>310)</b></a></sup> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
+         conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
+         cases where it matters, library functions can be used to effect such conversions with or without raising
+         the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
+         <a href="#7.12">&lt;math.h&gt;</a>.
+    <sup><a name="note311" href="#note311"><b>311)</b></a></sup> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
+         DECIMAL_DIG shall be at least 21. If IEC 60559 double (53 bits of precision) is the widest
+         IEC 60559 format supported, then DECIMAL_DIG shall be at least 17. (By contrast, LDBL_DIG and
+         DBL_DIG are 18 and 15, respectively, for these formats.)
+
+[<a name="p447" href="#p447">page 447</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.6" href="#F.6"><b>    F.6 Contracted expressions</b></a>
+1   A contracted expression treats infinities, NaNs, signed zeros, subnormals, and the
+    rounding directions in a manner consistent with the basic arithmetic operations covered
+    by IEC 60559.
+    Recommended practice
+2   A contracted expression should raise floating-point exceptions in a manner generally
+    consistent with the basic arithmetic operations. A contracted expression should deliver
+    the same value as its uncontracted counterpart, else should be correctly rounded (once).
+<a name="F.7" href="#F.7"><b>    F.7 Floating-point environment</b></a>
+1   The floating-point environment defined in <a href="#7.6">&lt;fenv.h&gt;</a> includes the IEC 60559 floating-
+    point exception status flags and directed-rounding control modes. It includes also
+    IEC 60559 dynamic rounding precision and trap enablement modes, if the
+    implementation supports them.<sup><a href="#note312"><b>312)</b></a></sup>
+<a name="F.7.1" href="#F.7.1"><b>    F.7.1 Environment management</b></a>
+1   IEC 60559 requires that floating-point operations implicitly raise floating-point exception
+    status flags, and that rounding control modes can be set explicitly to affect result values of
+    floating-point operations. When the state for the FENV_ACCESS pragma (defined in
+    <a href="#7.6">&lt;fenv.h&gt;</a>) is ''on'', these changes to the floating-point state are treated as side effects
+    which respect sequence points.<sup><a href="#note313"><b>313)</b></a></sup>
+<a name="F.7.2" href="#F.7.2"><b>    F.7.2 Translation</b></a>
+1   During translation the IEC 60559 default modes are in effect:
+    -- The rounding direction mode is rounding to nearest.
+    -- The rounding precision mode (if supported) is set so that results are not shortened.
+    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+    Recommended practice
+2   The implementation should produce a diagnostic message for each translation-time
+
+
+
+
+    <sup><a name="note312" href="#note312"><b>312)</b></a></sup> This specification does not require dynamic rounding precision nor trap enablement modes.
+    <sup><a name="note313" href="#note313"><b>313)</b></a></sup> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
+         point control modes will be the default ones and the floating-point status flags will not be tested,
+         which allows certain optimizations (see <a href="#F.8">F.8</a>).
+
+[<a name="p448" href="#p448">page 448</a>] (<a href="#Contents">Contents</a>)
+
+    floating-point exception, other than ''inexact'';<sup><a href="#note314"><b>314)</b></a></sup> the implementation should then
+    proceed with the translation of the program.
+<a name="F.7.3" href="#F.7.3"><b>    F.7.3 Execution</b></a>
+1   At program startup the floating-point environment is initialized as prescribed by
+    IEC 60559:
+    -- All floating-point exception status flags are cleared.
+    -- The rounding direction mode is rounding to nearest.
+    -- The dynamic rounding precision mode (if supported) is set so that results are not
+      shortened.
+    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+<a name="F.7.4" href="#F.7.4"><b>    F.7.4 Constant expressions</b></a>
+1   An arithmetic constant expression of floating type, other than one in an initializer for an
+    object that has static storage duration, is evaluated (as if) during execution; thus, it is
+    affected by any operative floating-point control modes and raises floating-point
+    exceptions as required by IEC 60559 (provided the state for the FENV_ACCESS pragma
+    is ''on'').<sup><a href="#note315"><b>315)</b></a></sup>
+2   EXAMPLE
+             #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             #pragma STDC FENV_ACCESS ON
+             void f(void)
+             {
+                   float w[] = { 0.0/0.0 };                  //   raises an exception
+                   static float x = 0.0/0.0;                 //   does not raise an exception
+                   float y = 0.0/0.0;                        //   raises an exception
+                   double z = 0.0/0.0;                       //   raises an exception
+                   /* ... */
+             }
+3   For the static initialization, the division is done at translation time, raising no (execution-time) floating-
+    point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
+
+
+    <sup><a name="note314" href="#note314"><b>314)</b></a></sup> As floating constants are converted to appropriate internal representations at translation time, their
+         conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
+         (even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
+         strtod, provide execution-time conversion of numeric strings.
+    <sup><a name="note315" href="#note315"><b>315)</b></a></sup> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
+         are affected by rounding modes set at execution time, and expressions such as 0.0/0.0 and
+         1.0/0.0 generate execution-time floating-point exceptions. The programmer can achieve the
+         efficiency of translation-time evaluation through static initialization, such as
+                  const static double one_third = 1.0/3.0;
+
+[<a name="p449" href="#p449">page 449</a>] (<a href="#Contents">Contents</a>)
+
+    execution time.
+
+<a name="F.7.5" href="#F.7.5"><b>    F.7.5 Initialization</b></a>
+1   All computation for automatic initialization is done (as if) at execution time; thus, it is
+    affected by any operative modes and raises floating-point exceptions as required by
+    IEC 60559 (provided the state for the FENV_ACCESS pragma is ''on''). All computation
+    for initialization of objects that have static storage duration is done (as if) at translation
+    time.
+2   EXAMPLE
+             #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             #pragma STDC FENV_ACCESS ON
+             void f(void)
+             {
+                   float u[] = { 1.1e75 };                  //   raises exceptions
+                   static float v = 1.1e75;                 //   does not raise exceptions
+                   float w = 1.1e75;                        //   raises exceptions
+                   double x = 1.1e75;                       //   may raise exceptions
+                   float y = 1.1e75f;                       //   may raise exceptions
+                   long double z = 1.1e75;                  //   does not raise exceptions
+                   /* ... */
+             }
+3   The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
+    done at translation time. The automatic initialization of u and w require an execution-time conversion to
+    float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
+    of x and y entail execution-time conversion; however, in some expression evaluation methods, the
+    conversions is not to a narrower format, in which case no floating-point exception is raised.<sup><a href="#note316"><b>316)</b></a></sup> The
+    automatic initialization of z entails execution-time conversion, but not to a narrower format, so no floating-
+    point exception is raised. Note that the conversions of the floating constants 1.1e75 and 1.1e75f to
+    their internal representations occur at translation time in all cases.
+
+
+
+
+    <sup><a name="note316" href="#note316"><b>316)</b></a></sup> Use of float_t and double_t variables increases the likelihood of translation-time computation.
+         For example, the automatic initialization
+                   double_t x = 1.1e75;
+          could be done at translation time, regardless of the expression evaluation method.
+
+[<a name="p450" href="#p450">page 450</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.7.6" href="#F.7.6"><b>    F.7.6 Changing the environment</b></a>
+1   Operations defined in <a href="#6.5">6.5</a> and functions and macros defined for the standard libraries
+    change floating-point status flags and control modes just as indicated by their
+    specifications (including conformance to IEC 60559). They do not change flags or modes
+    (so as to be detectable by the user) in any other cases.
+2   If the argument to the feraiseexcept function in <a href="#7.6">&lt;fenv.h&gt;</a> represents IEC 60559
+    valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
+    ''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
+    before ''inexact''.
+<a name="F.8" href="#F.8"><b>    F.8 Optimization</b></a>
+1   This section identifies code transformations that might subvert IEC 60559-specified
+    behavior, and others that do not.
+<a name="F.8.1" href="#F.8.1"><b>    F.8.1 Global transformations</b></a>
+1   Floating-point arithmetic operations and external function calls may entail side effects
+    which optimization shall honor, at least where the state of the FENV_ACCESS pragma is
+    ''on''. The flags and modes in the floating-point environment may be regarded as global
+    variables; floating-point operations (+, *, etc.) implicitly read the modes and write the
+    flags.
+2   Concern about side effects may inhibit code motion and removal of seemingly useless
+    code. For example, in
+             #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             #pragma STDC FENV_ACCESS ON
+             void f(double x)
+             {
+                  /* ... */
+                  for (i = 0; i &lt; n; i++) x + 1;
+                  /* ... */
+             }
+    x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
+    body might not execute (maybe 0 &gt;= n), x + 1 cannot be moved out of the loop. (Of
+    course these optimizations are valid if the implementation can rule out the nettlesome
+    cases.)
+3   This specification does not require support for trap handlers that maintain information
+    about the order or count of floating-point exceptions. Therefore, between function calls,
+    floating-point exceptions need not be precise: the actual order and number of occurrences
+    of floating-point exceptions (&gt; 1) may vary from what the source code expresses. Thus,
+    the preceding loop could be treated as
+
+[<a name="p451" href="#p451">page 451</a>] (<a href="#Contents">Contents</a>)
+
+            if (0 &lt; n) x + 1;
+<a name="F.8.2" href="#F.8.2"><b>    F.8.2 Expression transformations</b></a>
+1   x / 2 &lt;-&gt; x * 0.5                         Although similar transformations involving inexact
+                                            constants generally do not yield numerically equivalent
+                                            expressions, if the constants are exact then such
+                                            transformations can be made on IEC 60559 machines
+                                            and others that round perfectly.
+    1 * x and x / 1 -&gt; x                     The expressions 1 * x, x / 1, and x are equivalent
+                                            (on IEC 60559 machines, among others).<sup><a href="#note317"><b>317)</b></a></sup>
+    x / x -&gt; 1.0                             The expressions x / x and 1.0 are not equivalent if x
+                                            can be zero, infinite, or NaN.
+    x - y &lt;-&gt; x + (-y)                        The expressions x - y, x + (-y), and (-y) + x
+                                            are equivalent (on IEC 60559 machines, among others).
+    x - y &lt;-&gt; -(y - x)                        The expressions x - y and -(y - x) are not
+                                            equivalent because 1 - 1 is +0 but -(1 - 1) is -0 (in the
+                                            default rounding direction).<sup><a href="#note318"><b>318)</b></a></sup>
+    x - x -&gt; 0.0                             The expressions x - x and 0.0 are not equivalent if
+                                            x is a NaN or infinite.
+    0 * x -&gt; 0.0                             The expressions 0 * x and 0.0 are not equivalent if
+                                            x is a NaN, infinite, or -0.
+    x + 0-&gt;x                                 The expressions x + 0 and x are not equivalent if x is
+                                            -0, because (-0) + (+0) yields +0 (in the default
+                                            rounding direction), not -0.
+    x - 0-&gt;x                                 (+0) - (+0) yields -0 when rounding is downward
+                                            (toward -(inf)), but +0 otherwise, and (-0) - (+0) always
+                                            yields -0; so, if the state of the FENV_ACCESS pragma
+                                            is ''off'', promising default rounding, then the
+                                            implementation can replace x - 0 by x, even if x
+
+
+    <sup><a name="note317" href="#note317"><b>317)</b></a></sup> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
+         other transformations that remove arithmetic operators.
+    <sup><a name="note318" href="#note318"><b>318)</b></a></sup> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
+         Examples include:
+            1/(1/ (+-) (inf)) is (+-) (inf)
+         and
+            conj(csqrt(z)) is csqrt(conj(z)),
+         for complex z.
+
+[<a name="p452" href="#p452">page 452</a>] (<a href="#Contents">Contents</a>)
+
+                                             might be zero.
+    -x &lt;-&gt; 0 - x                               The expressions -x and 0 - x are not equivalent if x
+                                             is +0, because -(+0) yields -0, but 0 - (+0) yields +0
+                                             (unless rounding is downward).
+<a name="F.8.3" href="#F.8.3"><b>    F.8.3 Relational operators</b></a>
+1   x != x -&gt; false                           The statement x != x is true if x is a NaN.
+    x == x -&gt; true                            The statement x == x is false if x is a NaN.
+    x &lt; y -&gt; isless(x,y)                      (and similarly for &lt;=, &gt;, &gt;=) Though numerically
+                                             equal, these expressions are not equivalent because of
+                                             side effects when x or y is a NaN and the state of the
+                                             FENV_ACCESS pragma is ''on''. This transformation,
+                                             which would be desirable if extra code were required to
+                                             cause the ''invalid'' floating-point exception for
+                                             unordered cases, could be performed provided the state
+                                             of the FENV_ACCESS pragma is ''off''.
+    The sense of relational operators shall be maintained. This includes handling unordered
+    cases as expressed by the source code.
+2   EXAMPLE
+             // calls g and raises ''invalid'' if a and b are unordered
+             if (a &lt; b)
+                     f();
+             else
+                     g();
+    is not equivalent to
+             // calls f and raises ''invalid'' if a and b are unordered
+             if (a &gt;= b)
+                     g();
+             else
+                     f();
+    nor to
+             // calls f without raising ''invalid'' if a and b are unordered
+             if (isgreaterequal(a,b))
+                     g();
+             else
+                     f();
+    nor, unless the state of the FENV_ACCESS pragma is ''off'', to
+
+[<a name="p453" href="#p453">page 453</a>] (<a href="#Contents">Contents</a>)
+
+             // calls g without raising ''invalid'' if a and b are unordered
+             if (isless(a,b))
+                     f();
+             else
+                     g();
+    but is equivalent to
+             if (!(a &lt; b))
+                   g();
+             else
+                   f();
+
+<a name="F.8.4" href="#F.8.4"><b>    F.8.4 Constant arithmetic</b></a>
+1   The implementation shall honor floating-point exceptions raised by execution-time
+    constant arithmetic wherever the state of the FENV_ACCESS pragma is ''on''. (See <a href="#F.7.4">F.7.4</a>
+    and <a href="#F.7.5">F.7.5</a>.) An operation on constants that raises no floating-point exception can be
+    folded during translation, except, if the state of the FENV_ACCESS pragma is ''on'', a
+    further check is required to assure that changing the rounding direction to downward does
+    not alter the sign of the result,<sup><a href="#note319"><b>319)</b></a></sup> and implementations that support dynamic rounding
+    precision modes shall assure further that the result of the operation raises no floating-
+    point exception when converted to the semantic type of the operation.
+<a name="F.9" href="#F.9"><b>    F.9 Mathematics &lt;math.h&gt;</b></a>
+1   This subclause contains specifications of <a href="#7.12">&lt;math.h&gt;</a> facilities that are particularly suited
+    for IEC 60559 implementations.
+2   The Standard C macro HUGE_VAL and its float and long double analogs,
+    HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
+    infinities.
+3   Special cases for functions in <a href="#7.12">&lt;math.h&gt;</a> are covered directly or indirectly by
+    IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
+    other functions in <a href="#7.12">&lt;math.h&gt;</a> treat infinities, NaNs, signed zeros, subnormals, and
+    (provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
+    in a manner consistent with the basic arithmetic operations covered by IEC 60559.
+4   The expression math_errhandling &amp; MATH_ERREXCEPT shall evaluate to a
+    nonzero value.
+5   The ''invalid'' and ''divide-by-zero'' floating-point exceptions are raised as specified in
+    subsequent subclauses of this annex.
+6   The ''overflow'' floating-point exception is raised whenever an infinity -- or, because of
+    rounding direction, a maximal-magnitude finite number -- is returned in lieu of a value
+
+
+    <sup><a name="note319" href="#note319"><b>319)</b></a></sup> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
+
+[<a name="p454" href="#p454">page 454</a>] (<a href="#Contents">Contents</a>)
+
+     whose magnitude is too large.
+7    The ''underflow'' floating-point exception is raised whenever a result is tiny (essentially
+     subnormal or zero) and suffers loss of accuracy.<sup><a href="#note320"><b>320)</b></a></sup>
+8    Whether or when library functions raise the ''inexact'' floating-point exception is
+     unspecified, unless explicitly specified otherwise.
+9    Whether or when library functions raise an undeserved ''underflow'' floating-point
+     exception is unspecified.<sup><a href="#note321"><b>321)</b></a></sup> Otherwise, as implied by <a href="#F.7.6">F.7.6</a>, the <a href="#7.12">&lt;math.h&gt;</a> functions do
+     not raise spurious floating-point exceptions (detectable by the user), other than the
+     ''inexact'' floating-point exception.
+10   Whether the functions honor the rounding direction mode is implementation-defined,
+     unless explicitly specified otherwise.
+11   Functions with a NaN argument return a NaN result and raise no floating-point exception,
+     except where stated otherwise.
+12   The specifications in the following subclauses append to the definitions in <a href="#7.12">&lt;math.h&gt;</a>.
+     For families of functions, the specifications apply to all of the functions even though only
+     the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
+     occurs in both an argument and the result, the result has the same sign as the argument.
+     Recommended practice
+13   If a function with one or more NaN arguments returns a NaN result, the result should be
+     the same as one of the NaN arguments (after possible type conversion), except perhaps
+     for the sign.
+<a name="F.9.1" href="#F.9.1"><b>     F.9.1 Trigonometric functions</b></a>
+<a name="F.9.1.1" href="#F.9.1.1"><b>     F.9.1.1 The acos functions</b></a>
+1    -- acos(1) returns +0.
+     -- acos(x) returns a NaN and raises the ''invalid'' floating-point exception for
+       | x | &gt; 1.
+
+
+
+
+     <sup><a name="note320" href="#note320"><b>320)</b></a></sup> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
+          when the floating-point exception is raised.
+     <sup><a name="note321" href="#note321"><b>321)</b></a></sup> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
+          avoiding them would be too costly.
+
+[<a name="p455" href="#p455">page 455</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.1.2" href="#F.9.1.2"><b>    F.9.1.2 The asin functions</b></a>
+1   -- asin((+-)0) returns (+-)0.
+    -- asin(x) returns a NaN and raises the ''invalid'' floating-point exception for
+      | x | &gt; 1.
+<a name="F.9.1.3" href="#F.9.1.3"><b>    F.9.1.3 The atan functions</b></a>
+1   -- atan((+-)0) returns (+-)0.
+    -- atan((+-)(inf)) returns (+-)pi /2.
+<a name="F.9.1.4" href="#F.9.1.4"><b>    F.9.1.4 The atan2 functions</b></a>
+1   -- atan2((+-)0, -0) returns (+-)pi .<sup><a href="#note322"><b>322)</b></a></sup>
+    -- atan2((+-)0, +0) returns (+-)0.
+    -- atan2((+-)0, x) returns (+-)pi for x &lt; 0.
+    -- atan2((+-)0, x) returns (+-)0 for x &gt; 0.
+    -- atan2(y, (+-)0) returns -pi /2 for y &lt; 0.
+    -- atan2(y, (+-)0) returns pi /2 for y &gt; 0.
+    -- atan2((+-)y, -(inf)) returns (+-)pi for finite y &gt; 0.
+    -- atan2((+-)y, +(inf)) returns (+-)0 for finite y &gt; 0.
+    -- atan2((+-)(inf), x) returns (+-)pi /2 for finite x.
+    -- atan2((+-)(inf), -(inf)) returns (+-)3pi /4.
+    -- atan2((+-)(inf), +(inf)) returns (+-)pi /4.
+<a name="F.9.1.5" href="#F.9.1.5"><b>    F.9.1.5 The cos functions</b></a>
+1   -- cos((+-)0) returns 1.
+    -- cos((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+<a name="F.9.1.6" href="#F.9.1.6"><b>    F.9.1.6 The sin functions</b></a>
+1   -- sin((+-)0) returns (+-)0.
+    -- sin((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+
+
+
+
+    <sup><a name="note322" href="#note322"><b>322)</b></a></sup> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y ,    0) raise
+         the ''divide-by-zero'' floating-point exception.
+
+[<a name="p456" href="#p456">page 456</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.1.7" href="#F.9.1.7"><b>    F.9.1.7 The tan functions</b></a>
+1   -- tan((+-)0) returns (+-)0.
+    -- tan((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+<a name="F.9.2" href="#F.9.2"><b>    F.9.2 Hyperbolic functions</b></a>
+<a name="F.9.2.1" href="#F.9.2.1"><b>    F.9.2.1 The acosh functions</b></a>
+1   -- acosh(1) returns +0.
+    -- acosh(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 1.
+    -- acosh(+(inf)) returns +(inf).
+<a name="F.9.2.2" href="#F.9.2.2"><b>    F.9.2.2 The asinh functions</b></a>
+1   -- asinh((+-)0) returns (+-)0.
+    -- asinh((+-)(inf)) returns (+-)(inf).
+<a name="F.9.2.3" href="#F.9.2.3"><b>    F.9.2.3 The atanh functions</b></a>
+1   -- atanh((+-)0) returns (+-)0.
+    -- atanh((+-)1) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- atanh(x) returns a NaN and raises the ''invalid'' floating-point exception for
+      | x | &gt; 1.
+<a name="F.9.2.4" href="#F.9.2.4"><b>    F.9.2.4 The cosh functions</b></a>
+1   -- cosh((+-)0) returns 1.
+    -- cosh((+-)(inf)) returns +(inf).
+<a name="F.9.2.5" href="#F.9.2.5"><b>    F.9.2.5 The sinh functions</b></a>
+1   -- sinh((+-)0) returns (+-)0.
+    -- sinh((+-)(inf)) returns (+-)(inf).
+<a name="F.9.2.6" href="#F.9.2.6"><b>    F.9.2.6 The tanh functions</b></a>
+1   -- tanh((+-)0) returns (+-)0.
+    -- tanh((+-)(inf)) returns (+-)1.
+
+[<a name="p457" href="#p457">page 457</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.3" href="#F.9.3"><b>    F.9.3 Exponential and logarithmic functions</b></a>
+<a name="F.9.3.1" href="#F.9.3.1"><b>    F.9.3.1 The exp functions</b></a>
+1   -- exp((+-)0) returns 1.
+    -- exp(-(inf)) returns +0.
+    -- exp(+(inf)) returns +(inf).
+<a name="F.9.3.2" href="#F.9.3.2"><b>    F.9.3.2 The exp2 functions</b></a>
+1   -- exp2((+-)0) returns 1.
+    -- exp2(-(inf)) returns +0.
+    -- exp2(+(inf)) returns +(inf).
+<a name="F.9.3.3" href="#F.9.3.3"><b>    F.9.3.3 The expm1 functions</b></a>
+1   -- expm1((+-)0) returns (+-)0.
+    -- expm1(-(inf)) returns -1.
+    -- expm1(+(inf)) returns +(inf).
+<a name="F.9.3.4" href="#F.9.3.4"><b>    F.9.3.4 The frexp functions</b></a>
+1   -- frexp((+-)0, exp) returns (+-)0, and stores 0 in the object pointed to by exp.
+    -- frexp((+-)(inf), exp) returns (+-)(inf), and stores an unspecified value in the object
+      pointed to by exp.
+    -- frexp(NaN, exp) stores an unspecified value in the object pointed to by exp
+      (and returns a NaN).
+2   frexp raises no floating-point exceptions.
+3   On a binary system, the body of the frexp function might be
+           {
+                  *exp = (value == 0) ? 0 : (int)(1 + logb(value));
+                  return scalbn(value, -(*exp));
+           }
+<a name="F.9.3.5" href="#F.9.3.5"><b>    F.9.3.5 The ilogb functions</b></a>
+1   If the correct result is outside the range of the return type, the numeric result is
+    unspecified and the ''invalid'' floating-point exception is raised.
+
+[<a name="p458" href="#p458">page 458</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.3.6" href="#F.9.3.6"><b>    F.9.3.6 The ldexp functions</b></a>
+1   On a binary system, ldexp(x, exp) is equivalent to scalbn(x, exp).
+<a name="F.9.3.7" href="#F.9.3.7"><b>    F.9.3.7 The log functions</b></a>
+1   -- log((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log(1) returns +0.
+    -- log(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+    -- log(+(inf)) returns +(inf).
+<a name="F.9.3.8" href="#F.9.3.8"><b>    F.9.3.8 The log10 functions</b></a>
+1   -- log10((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log10(1) returns +0.
+    -- log10(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+    -- log10(+(inf)) returns +(inf).
+<a name="F.9.3.9" href="#F.9.3.9"><b>    F.9.3.9 The log1p functions</b></a>
+1   -- log1p((+-)0) returns (+-)0.
+    -- log1p(-1) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log1p(x) returns a NaN and raises the ''invalid'' floating-point exception for
+      x &lt; -1.
+    -- log1p(+(inf)) returns +(inf).
+<a name="F.9.3.10" href="#F.9.3.10"><b>    F.9.3.10 The log2 functions</b></a>
+1   -- log2((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log2(1) returns +0.
+    -- log2(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+    -- log2(+(inf)) returns +(inf).
+<a name="F.9.3.11" href="#F.9.3.11"><b>    F.9.3.11 The logb functions</b></a>
+1   -- logb((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- logb((+-)(inf)) returns +(inf).
+
+[<a name="p459" href="#p459">page 459</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.3.12" href="#F.9.3.12"><b>    F.9.3.12 The modf functions</b></a>
+1   -- modf((+-)x, iptr) returns a result with the same sign as x.
+    -- modf((+-)(inf), iptr) returns (+-)0 and stores (+-)(inf) in the object pointed to by iptr.
+    -- modf(NaN, iptr) stores a NaN in the object pointed to by iptr (and returns a
+      NaN).
+2   modf behaves as though implemented by
+          #include <a href="#7.12">&lt;math.h&gt;</a>
+          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+          #pragma STDC FENV_ACCESS ON
+          double modf(double value, double *iptr)
+          {
+               int save_round = fegetround();
+               fesetround(FE_TOWARDZERO);
+               *iptr = nearbyint(value);
+               fesetround(save_round);
+               return copysign(
+                    isinf(value) ? 0.0 :
+                         value - (*iptr), value);
+          }
+<a name="F.9.3.13" href="#F.9.3.13"><b>    F.9.3.13 The scalbn and scalbln functions</b></a>
+1   -- scalbn((+-)0, n) returns (+-)0.
+    -- scalbn(x, 0) returns x.
+    -- scalbn((+-)(inf), n) returns (+-)(inf).
+<a name="F.9.4" href="#F.9.4"><b>    F.9.4 Power and absolute value functions</b></a>
+<a name="F.9.4.1" href="#F.9.4.1"><b>    F.9.4.1 The cbrt functions</b></a>
+1   -- cbrt((+-)0) returns (+-)0.
+    -- cbrt((+-)(inf)) returns (+-)(inf).
+<a name="F.9.4.2" href="#F.9.4.2"><b>    F.9.4.2 The fabs functions</b></a>
+1   -- fabs((+-)0) returns +0.
+    -- fabs((+-)(inf)) returns +(inf).
+
+[<a name="p460" href="#p460">page 460</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.4.3" href="#F.9.4.3"><b>    F.9.4.3 The hypot functions</b></a>
+1   -- hypot(x, y), hypot(y, x), and hypot(x, -y) are equivalent.
+    -- hypot(x, (+-)0) is equivalent to fabs(x).
+    -- hypot((+-)(inf), y) returns +(inf), even if y is a NaN.
+<a name="F.9.4.4" href="#F.9.4.4"><b>    F.9.4.4 The pow functions</b></a>
+1   -- pow((+-)0, y) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception
+      for y an odd integer &lt; 0.
+    -- pow((+-)0, y) returns +(inf) and raises the ''divide-by-zero'' floating-point exception
+      for y &lt; 0 and not an odd integer.
+    -- pow((+-)0, y) returns (+-)0 for y an odd integer &gt; 0.
+    -- pow((+-)0, y) returns +0 for y &gt; 0 and not an odd integer.
+    -- pow(-1, (+-)(inf)) returns 1.
+    -- pow(+1, y) returns 1 for any y, even a NaN.
+    -- pow(x, (+-)0) returns 1 for any x, even a NaN.
+    -- pow(x, y) returns a NaN and raises the ''invalid'' floating-point exception for
+      finite x &lt; 0 and finite non-integer y.
+    -- pow(x, -(inf)) returns +(inf) for | x | &lt; 1.
+    -- pow(x, -(inf)) returns +0 for | x | &gt; 1.
+    -- pow(x, +(inf)) returns +0 for | x | &lt; 1.
+    -- pow(x, +(inf)) returns +(inf) for | x | &gt; 1.
+    -- pow(-(inf), y) returns -0 for y an odd integer &lt; 0.
+    -- pow(-(inf), y) returns +0 for y &lt; 0 and not an odd integer.
+    -- pow(-(inf), y) returns -(inf) for y an odd integer &gt; 0.
+    -- pow(-(inf), y) returns +(inf) for y &gt; 0 and not an odd integer.
+    -- pow(+(inf), y) returns +0 for y &lt; 0.
+    -- pow(+(inf), y) returns +(inf) for y &gt; 0.
+
+[<a name="p461" href="#p461">page 461</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.4.5" href="#F.9.4.5"><b>    F.9.4.5 The sqrt functions</b></a>
+1   sqrt is fully specified as a basic arithmetic operation in IEC 60559.
+<a name="F.9.5" href="#F.9.5"><b>    F.9.5 Error and gamma functions</b></a>
+<a name="F.9.5.1" href="#F.9.5.1"><b>    F.9.5.1 The erf functions</b></a>
+1   -- erf((+-)0) returns (+-)0.
+    -- erf((+-)(inf)) returns (+-)1.
+<a name="F.9.5.2" href="#F.9.5.2"><b>    F.9.5.2 The erfc functions</b></a>
+1   -- erfc(-(inf)) returns 2.
+    -- erfc(+(inf)) returns +0.
+<a name="F.9.5.3" href="#F.9.5.3"><b>    F.9.5.3 The lgamma functions</b></a>
+1   -- lgamma(1) returns +0.
+    -- lgamma(2) returns +0.
+    -- lgamma(x) returns +(inf) and raises the ''divide-by-zero'' floating-point exception for
+      x a negative integer or zero.
+    -- lgamma(-(inf)) returns +(inf).
+    -- lgamma(+(inf)) returns +(inf).
+<a name="F.9.5.4" href="#F.9.5.4"><b>    F.9.5.4 The tgamma functions</b></a>
+1   -- tgamma((+-)0) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- tgamma(x) returns a NaN and raises the ''invalid'' floating-point exception for x a
+      negative integer.
+    -- tgamma(-(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+    -- tgamma(+(inf)) returns +(inf).
+<a name="F.9.6" href="#F.9.6"><b>    F.9.6 Nearest integer functions</b></a>
+<a name="F.9.6.1" href="#F.9.6.1"><b>    F.9.6.1 The ceil functions</b></a>
+1   -- ceil((+-)0) returns (+-)0.
+    -- ceil((+-)(inf)) returns (+-)(inf).
+2   The double version of ceil behaves as though implemented by
+
+[<a name="p462" href="#p462">page 462</a>] (<a href="#Contents">Contents</a>)
+
+           #include <a href="#7.12">&lt;math.h&gt;</a>
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           #pragma STDC FENV_ACCESS ON
+           double ceil(double x)
+           {
+                double result;
+                int save_round = fegetround();
+                fesetround(FE_UPWARD);
+                result = rint(x); // or nearbyint instead of rint
+                fesetround(save_round);
+                return result;
+           }
+<a name="F.9.6.2" href="#F.9.6.2"><b>    F.9.6.2 The floor functions</b></a>
+1   -- floor((+-)0) returns (+-)0.
+    -- floor((+-)(inf)) returns (+-)(inf).
+2   See the sample implementation for ceil in <a href="#F.9.6.1">F.9.6.1</a>.
+<a name="F.9.6.3" href="#F.9.6.3"><b>    F.9.6.3 The nearbyint functions</b></a>
+1   The nearbyint functions use IEC 60559 rounding according to the current rounding
+    direction. They do not raise the ''inexact'' floating-point exception if the result differs in
+    value from the argument.
+    -- nearbyint((+-)0) returns (+-)0 (for all rounding directions).
+    -- nearbyint((+-)(inf)) returns (+-)(inf) (for all rounding directions).
+<a name="F.9.6.4" href="#F.9.6.4"><b>    F.9.6.4 The rint functions</b></a>
+1   The rint functions differ from the nearbyint functions only in that they do raise the
+    ''inexact'' floating-point exception if the result differs in value from the argument.
+<a name="F.9.6.5" href="#F.9.6.5"><b>    F.9.6.5 The lrint and llrint functions</b></a>
+1   The lrint and llrint functions provide floating-to-integer conversion as prescribed
+    by IEC 60559. They round according to the current rounding direction. If the rounded
+    value is outside the range of the return type, the numeric result is unspecified and the
+    ''invalid'' floating-point exception is raised. When they raise no other floating-point
+    exception and the result differs from the argument, they raise the ''inexact'' floating-point
+    exception.
+
+[<a name="p463" href="#p463">page 463</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.6.6" href="#F.9.6.6"><b>    F.9.6.6 The round functions</b></a>
+1   -- round((+-)0) returns (+-)0.
+    -- round((+-)(inf)) returns (+-)(inf).
+2   The double version of round behaves as though implemented by
+           #include <a href="#7.12">&lt;math.h&gt;</a>
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           #pragma STDC FENV_ACCESS ON
+           double round(double x)
+           {
+                double result;
+                fenv_t save_env;
+                feholdexcept(&amp;save_env);
+                result = rint(x);
+                if (fetestexcept(FE_INEXACT)) {
+                     fesetround(FE_TOWARDZERO);
+                     result = rint(copysign(0.5 + fabs(x), x));
+                }
+                feupdateenv(&amp;save_env);
+                return result;
+           }
+    The round functions may, but are not required to, raise the ''inexact'' floating-point
+    exception for non-integer numeric arguments, as this implementation does.
+<a name="F.9.6.7" href="#F.9.6.7"><b>    F.9.6.7 The lround and llround functions</b></a>
+1   The lround and llround functions differ from the lrint and llrint functions
+    with the default rounding direction just in that the lround and llround functions
+    round halfway cases away from zero and need not raise the ''inexact'' floating-point
+    exception for non-integer arguments that round to within the range of the return type.
+<a name="F.9.6.8" href="#F.9.6.8"><b>    F.9.6.8 The trunc functions</b></a>
+1   The trunc functions use IEC 60559 rounding toward zero (regardless of the current
+    rounding direction).
+    -- trunc((+-)0) returns (+-)0.
+    -- trunc((+-)(inf)) returns (+-)(inf).
+
+[<a name="p464" href="#p464">page 464</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.7" href="#F.9.7"><b>    F.9.7 Remainder functions</b></a>
+<a name="F.9.7.1" href="#F.9.7.1"><b>    F.9.7.1 The fmod functions</b></a>
+1   -- fmod((+-)0, y) returns (+-)0 for y not zero.
+    -- fmod(x, y) returns a NaN and raises the ''invalid'' floating-point exception for x
+      infinite or y zero.
+    -- fmod(x, (+-)(inf)) returns x for x not infinite.
+2   The double version of fmod behaves as though implemented by
+           #include <a href="#7.12">&lt;math.h&gt;</a>
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           #pragma STDC FENV_ACCESS ON
+           double fmod(double x, double y)
+           {
+                double result;
+                result = remainder(fabs(x), (y = fabs(y)));
+                if (signbit(result)) result += y;
+                return copysign(result, x);
+           }
+<a name="F.9.7.2" href="#F.9.7.2"><b>    F.9.7.2 The remainder functions</b></a>
+1   The remainder functions are fully specified as a basic arithmetic operation in
+    IEC 60559.
+<a name="F.9.7.3" href="#F.9.7.3"><b>    F.9.7.3 The remquo functions</b></a>
+1   The remquo functions follow the specifications for the remainder functions. They
+    have no further specifications special to IEC 60559 implementations.
+<a name="F.9.8" href="#F.9.8"><b>    F.9.8 Manipulation functions</b></a>
+<a name="F.9.8.1" href="#F.9.8.1"><b>    F.9.8.1 The copysign functions</b></a>
+1   copysign is specified in the Appendix to IEC 60559.
+<a name="F.9.8.2" href="#F.9.8.2"><b>    F.9.8.2 The nan functions</b></a>
+1   All IEC 60559 implementations support quiet NaNs, in all floating formats.
+
+[<a name="p465" href="#p465">page 465</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.8.3" href="#F.9.8.3"><b>    F.9.8.3 The nextafter functions</b></a>
+1   -- nextafter(x, y) raises the ''overflow'' and ''inexact'' floating-point exceptions
+      for x finite and the function value infinite.
+    -- nextafter(x, y) raises the ''underflow'' and ''inexact'' floating-point
+      exceptions for the function value subnormal or zero and x != y.
+<a name="F.9.8.4" href="#F.9.8.4"><b>    F.9.8.4 The nexttoward functions</b></a>
+1   No additional requirements beyond those on nextafter.
+<a name="F.9.9" href="#F.9.9"><b>    F.9.9 Maximum, minimum, and positive difference functions</b></a>
+<a name="F.9.9.1" href="#F.9.9.1"><b>    F.9.9.1 The fdim functions</b></a>
+1   No additional requirements.
+<a name="F.9.9.2" href="#F.9.9.2"><b>    F.9.9.2 The fmax functions</b></a>
+1   If just one argument is a NaN, the fmax functions return the other argument (if both
+    arguments are NaNs, the functions return a NaN).
+2   The body of the fmax function might be<sup><a href="#note323"><b>323)</b></a></sup>
+           { return (isgreaterequal(x, y) ||
+                isnan(y)) ? x : y; }
+<a name="F.9.9.3" href="#F.9.9.3"><b>    F.9.9.3 The fmin functions</b></a>
+1   The fmin functions are analogous to the fmax functions (see <a href="#F.9.9.2">F.9.9.2</a>).
+<a name="F.9.10" href="#F.9.10"><b>    F.9.10 Floating multiply-add</b></a>
+<a name="F.9.10.1" href="#F.9.10.1"><b>    F.9.10.1 The fma functions</b></a>
+1   -- fma(x, y, z) computes xy + z, correctly rounded once.
+    -- fma(x, y, z) returns a NaN and optionally raises the ''invalid'' floating-point
+      exception if one of x and y is infinite, the other is zero, and z is a NaN.
+    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if
+      one of x and y is infinite, the other is zero, and z is not a NaN.
+    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if x
+      times y is an exact infinity and z is also an infinity but with the opposite sign.
+
+
+
+
+    <sup><a name="note323" href="#note323"><b>323)</b></a></sup> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
+         return +0; however, implementation in software might be impractical.
+
+[<a name="p466" href="#p466">page 466</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G" href="#G"><b>                                          Annex G</b></a>
+                                        (informative)
+                  IEC 60559-compatible complex arithmetic
+<a name="G.1" href="#G.1"><b>    G.1 Introduction</b></a>
+1   This annex supplements <a href="#F">annex F</a> to specify complex arithmetic for compatibility with
+    IEC 60559 real floating-point arithmetic. Although these specifications have been
+    carefully designed, there is little existing practice to validate the design decisions.
+    Therefore, these specifications are not normative, but should be viewed more as
+    recommended          practice.       An         implementation        that     defines
+    __STDC_IEC_559_COMPLEX__ should conform to the specifications in this annex.
+<a name="G.2" href="#G.2"><b>    G.2 Types</b></a>
+1   There is a new keyword _Imaginary, which is used to specify imaginary types. It is
+    used as a type specifier within declaration specifiers in the same way as _Complex is
+    (thus, _Imaginary float is a valid type name).
+2   There are three imaginary types, designated as float _Imaginary, double
+    _Imaginary, and long double _Imaginary. The imaginary types (along with
+    the real floating and complex types) are floating types.
+3   For imaginary types, the corresponding real type is given by deleting the keyword
+    _Imaginary from the type name.
+4   Each imaginary type has the same representation and alignment requirements as the
+    corresponding real type. The value of an object of imaginary type is the value of the real
+    representation times the imaginary unit.
+5   The imaginary type domain comprises the imaginary types.
+<a name="G.3" href="#G.3"><b>    G.3 Conventions</b></a>
+1   A complex or imaginary value with at least one infinite part is regarded as an infinity
+    (even if its other part is a NaN). A complex or imaginary value is a finite number if each
+    of its parts is a finite number (neither infinite nor NaN). A complex or imaginary value is
+    a zero if each of its parts is a zero.
+
+[<a name="p467" href="#p467">page 467</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.4" href="#G.4"><b>    G.4 Conversions</b></a>
+<a name="G.4.1" href="#G.4.1"><b>    G.4.1 Imaginary types</b></a>
+1   Conversions among imaginary types follow rules analogous to those for real floating
+    types.
+<a name="G.4.2" href="#G.4.2"><b>    G.4.2 Real and imaginary</b></a>
+1   When a value of imaginary type is converted to a real type other than _Bool,<sup><a href="#note324"><b>324)</b></a></sup> the
+    result is a positive zero.
+2   When a value of real type is converted to an imaginary type, the result is a positive
+    imaginary zero.
+<a name="G.4.3" href="#G.4.3"><b>    G.4.3 Imaginary and complex</b></a>
+1   When a value of imaginary type is converted to a complex type, the real part of the
+    complex result value is a positive zero and the imaginary part of the complex result value
+    is determined by the conversion rules for the corresponding real types.
+2   When a value of complex type is converted to an imaginary type, the real part of the
+    complex value is discarded and the value of the imaginary part is converted according to
+    the conversion rules for the corresponding real types.
+<a name="G.5" href="#G.5"><b>    G.5 Binary operators</b></a>
+1   The following subclauses supplement <a href="#6.5">6.5</a> in order to specify the type of the result for an
+    operation with an imaginary operand.
+2   For most operand types, the value of the result of a binary operator with an imaginary or
+    complex operand is completely determined, with reference to real arithmetic, by the usual
+    mathematical formula. For some operand types, the usual mathematical formula is
+    problematic because of its treatment of infinities and because of undue overflow or
+    underflow; in these cases the result satisfies certain properties (specified in <a href="#G.5.1">G.5.1</a>), but is
+    not completely determined.
+
+
+
+
+    <sup><a name="note324" href="#note324"><b>324)</b></a></sup> See <a href="#6.3.1.2">6.3.1.2</a>.
+
+[<a name="p468" href="#p468">page 468</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.5.1" href="#G.5.1"><b>    G.5.1 Multiplicative operators</b></a>
+<b>    Semantics</b>
+1   If one operand has real type and the other operand has imaginary type, then the result has
+    imaginary type. If both operands have imaginary type, then the result has real type. (If
+    either operand has complex type, then the result has complex type.)
+2   If the operands are not both complex, then the result and floating-point exception
+    behavior of the * operator is defined by the usual mathematical formula:
+           *                  u                   iv                 u + iv
+
+           x                  xu                i(xv)            (xu) + i(xv)
+
+           iy               i(yu)                -yv            (-yv) + i(yu)
+
+           x + iy       (xu) + i(yu)        (-yv) + i(xv)
+3   If the second operand is not complex, then the result and floating-point exception
+    behavior of the / operator is defined by the usual mathematical formula:
+           /                   u                       iv
+
+           x                  x/u                 i(-x/v)
+
+           iy               i(y/u)                     y/v
+
+           x + iy       (x/u) + i(y/u)        (y/v) + i(-x/v)
+4   The * and / operators satisfy the following infinity properties for all real, imaginary, and
+    complex operands:<sup><a href="#note325"><b>325)</b></a></sup>
+    -- if one operand is an infinity and the other operand is a nonzero finite number or an
+      infinity, then the result of the * operator is an infinity;
+    -- if the first operand is an infinity and the second operand is a finite number, then the
+      result of the / operator is an infinity;
+    -- if the first operand is a finite number and the second operand is an infinity, then the
+      result of the / operator is a zero;
+
+
+
+
+    <sup><a name="note325" href="#note325"><b>325)</b></a></sup> These properties are already implied for those cases covered in the tables, but are required for all cases
+         (at least where the state for CX_LIMITED_RANGE is ''off'').
+
+[<a name="p469" href="#p469">page 469</a>] (<a href="#Contents">Contents</a>)
+
+    -- if the first operand is a nonzero finite number or an infinity and the second operand is
+      a zero, then the result of the / operator is an infinity.
+5   If both operands of the * operator are complex or if the second operand of the / operator
+    is complex, the operator raises floating-point exceptions if appropriate for the calculation
+    of the parts of the result, and may raise spurious floating-point exceptions.
+6   EXAMPLE 1 Multiplication of double _Complex operands could be implemented as follows. Note
+    that the imaginary unit I has imaginary type (see <a href="#G.6">G.6</a>).
+           #include <a href="#7.12">&lt;math.h&gt;</a>
+           #include <a href="#7.3">&lt;complex.h&gt;</a>
+           /* Multiply z * w ... */
+           double complex _Cmultd(double complex z, double complex w)
+           {
+                  #pragma STDC FP_CONTRACT OFF
+                  double a, b, c, d, ac, bd, ad, bc, x, y;
+                  a = creal(z); b = cimag(z);
+                  c = creal(w); d = cimag(w);
+                  ac = a * c;       bd = b * d;
+                  ad = a * d;       bc = b * c;
+                  x = ac - bd; y = ad + bc;
+                  if (isnan(x) &amp;&amp; isnan(y)) {
+                          /* Recover infinities that computed as NaN+iNaN ... */
+                          int recalc = 0;
+                          if ( isinf(a) || isinf(b) ) { // z is infinite
+                                  /* "Box" the infinity and change NaNs in the other factor to 0 */
+                                  a = copysign(isinf(a) ? 1.0 : 0.0, a);
+                                  b = copysign(isinf(b) ? 1.0 : 0.0, b);
+                                  if (isnan(c)) c = copysign(0.0, c);
+                                  if (isnan(d)) d = copysign(0.0, d);
+                                  recalc = 1;
+                          }
+                          if ( isinf(c) || isinf(d) ) { // w is infinite
+                                  /* "Box" the infinity and change NaNs in the other factor to 0 */
+                                  c = copysign(isinf(c) ? 1.0 : 0.0, c);
+                                  d = copysign(isinf(d) ? 1.0 : 0.0, d);
+                                  if (isnan(a)) a = copysign(0.0, a);
+                                  if (isnan(b)) b = copysign(0.0, b);
+                                  recalc = 1;
+                          }
+                          if (!recalc &amp;&amp; (isinf(ac) || isinf(bd) ||
+                                                 isinf(ad) || isinf(bc))) {
+                                  /* Recover infinities from overflow by changing NaNs to 0 ... */
+                                  if (isnan(a)) a = copysign(0.0, a);
+                                  if (isnan(b)) b = copysign(0.0, b);
+                                  if (isnan(c)) c = copysign(0.0, c);
+                                  if (isnan(d)) d = copysign(0.0, d);
+                                  recalc = 1;
+                          }
+                          if (recalc) {
+
+[<a name="p470" href="#p470">page 470</a>] (<a href="#Contents">Contents</a>)
+
+                                      x = INFINITY * ( a * c - b * d );
+                                      y = INFINITY * ( a * d + b * c );
+                           }
+                     }
+                     return x + I * y;
+             }
+7   This implementation achieves the required treatment of infinities at the cost of only one isnan test in
+    ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
+
+8   EXAMPLE 2      Division of two double _Complex operands could be implemented as follows.
+             #include <a href="#7.12">&lt;math.h&gt;</a>
+             #include <a href="#7.3">&lt;complex.h&gt;</a>
+             /* Divide z / w ... */
+             double complex _Cdivd(double complex z, double complex w)
+             {
+                    #pragma STDC FP_CONTRACT OFF
+                    double a, b, c, d, logbw, denom, x, y;
+                    int ilogbw = 0;
+                    a = creal(z); b = cimag(z);
+                    c = creal(w); d = cimag(w);
+                    logbw = logb(fmax(fabs(c), fabs(d)));
+                    if (isfinite(logbw)) {
+                           ilogbw = (int)logbw;
+                           c = scalbn(c, -ilogbw); d = scalbn(d, -ilogbw);
+                    }
+                    denom = c * c + d * d;
+                    x = scalbn((a * c + b * d) / denom, -ilogbw);
+                    y = scalbn((b * c - a * d) / denom, -ilogbw);
+                     /* Recover infinities and zeros that computed as NaN+iNaN;                 */
+                     /* the only cases are nonzero/zero, infinite/finite, and finite/infinite, ... */
+                     if (isnan(x) &amp;&amp; isnan(y)) {
+                           if ((denom == 0.0) &amp;&amp;
+                                 (!isnan(a) || !isnan(b))) {
+                                 x = copysign(INFINITY, c) * a;
+                                 y = copysign(INFINITY, c) * b;
+                           }
+                           else if ((isinf(a) || isinf(b)) &amp;&amp;
+                                 isfinite(c) &amp;&amp; isfinite(d)) {
+                                 a = copysign(isinf(a) ? 1.0 : 0.0,                        a);
+                                 b = copysign(isinf(b) ? 1.0 : 0.0,                        b);
+                                 x = INFINITY * ( a * c + b * d );
+                                 y = INFINITY * ( b * c - a * d );
+                           }
+                           else if (isinf(logbw) &amp;&amp;
+                                 isfinite(a) &amp;&amp; isfinite(b)) {
+                                 c = copysign(isinf(c) ? 1.0 : 0.0,                        c);
+                                 d = copysign(isinf(d) ? 1.0 : 0.0,                        d);
+                                 x = 0.0 * ( a * c + b * d );
+                                 y = 0.0 * ( b * c - a * d );
+
+[<a name="p471" href="#p471">page 471</a>] (<a href="#Contents">Contents</a>)
+
+                           }
+                     }
+                     return x + I * y;
+            }
+9   Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
+    for multiplication. In the spirit of the multiplication example above, this code does not defend against
+    overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
+    with division, provides better roundoff characteristics.
+
+<a name="G.5.2" href="#G.5.2"><b>    G.5.2 Additive operators</b></a>
+<b>    Semantics</b>
+1   If both operands have imaginary type, then the result has imaginary type. (If one operand
+    has real type and the other operand has imaginary type, or if either operand has complex
+    type, then the result has complex type.)
+2   In all cases the result and floating-point exception behavior of a + or - operator is defined
+    by the usual mathematical formula:
+           + or -              u                       iv                    u + iv
+
+           x                 x(+-)u                     x (+-) iv              (x (+-) u) (+-) iv
+
+           iy               (+-)u + iy                 i(y (+-) v)             (+-)u + i(y (+-) v)
+
+           x + iy         (x (+-) u) + iy            x + i(y (+-) v)        (x (+-) u) + i(y (+-) v)
+<a name="G.6" href="#G.6"><b>    G.6 Complex arithmetic &lt;complex.h&gt;</b></a>
+1   The macros
+            imaginary
+    and
+            _Imaginary_I
+    are defined, respectively, as _Imaginary and a constant expression of type const
+    float _Imaginary with the value of the imaginary unit. The macro
+            I
+    is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
+    the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
+    imaginary.
+2   This subclause contains specifications for the <a href="#7.3">&lt;complex.h&gt;</a> functions that are
+    particularly suited to IEC 60559 implementations. For families of functions, the
+    specifications apply to all of the functions even though only the principal function is
+
+[<a name="p472" href="#p472">page 472</a>] (<a href="#Contents">Contents</a>)
+
+    shown. Unless otherwise specified, where the symbol ''(+-)'' occurs in both an argument
+    and the result, the result has the same sign as the argument.
+3   The functions are continuous onto both sides of their branch cuts, taking into account the
+    sign of zero. For example, csqrt(-2 (+-) i0) = (+-)i(sqrt)2.  ???
+4   Since complex and imaginary values are composed of real values, each function may be
+    regarded as computing real values from real values. Except as noted, the functions treat
+    real infinities, NaNs, signed zeros, subnormals, and the floating-point exception flags in a
+    manner consistent with the specifications for real functions in F.9.<sup><a href="#note326"><b>326)</b></a></sup>
+5   The functions cimag, conj, cproj, and creal are fully specified for all
+    implementations, including IEC 60559 ones, in <a href="#7.3.9">7.3.9</a>. These functions raise no floating-
+    point exceptions.
+6   Each of the functions cabs and carg is specified by a formula in terms of a real
+    function (whose special cases are covered in <a href="#F">annex F</a>):
+            cabs(x + iy) = hypot(x, y)
+            carg(x + iy) = atan2(y, x)
+7   Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
+    a formula in terms of other complex functions (whose special cases are specified below):
+            casin(z)        =   -i casinh(iz)
+            catan(z)        =   -i catanh(iz)
+            ccos(z)         =   ccosh(iz)
+            csin(z)         =   -i csinh(iz)
+            ctan(z)         =   -i ctanh(iz)
+8   For the other functions, the following subclauses specify behavior for special cases,
+    including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
+    families of functions, the specifications apply to all of the functions even though only the
+    principal function is shown. For a function f satisfying f (conj(z)) = conj( f (z)), the
+    specifications for the upper half-plane imply the specifications for the lower half-plane; if
+    the function f is also either even, f (-z) = f (z), or odd, f (-z) = - f (z), then the
+    specifications for the first quadrant imply the specifications for the other three quadrants.
+9   In the following subclauses, cis(y) is defined as cos(y) + i sin(y).
+
+
+
+
+    <sup><a name="note326" href="#note326"><b>326)</b></a></sup> As noted in <a href="#G.3">G.3</a>, a complex value with at least one infinite part is regarded as an infinity even if its
+         other part is a NaN.
+
+[<a name="p473" href="#p473">page 473</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.6.1" href="#G.6.1"><b>    G.6.1 Trigonometric functions</b></a>
+<a name="G.6.1.1" href="#G.6.1.1"><b>    G.6.1.1 The cacos functions</b></a>
+1   -- cacos(conj(z)) = conj(cacos(z)).
+    -- cacos((+-)0 + i0) returns pi /2 - i0.
+    -- cacos((+-)0 + iNaN) returns pi /2 + iNaN.
+    -- cacos(x + i (inf)) returns pi /2 - i (inf), for finite x.
+    -- cacos(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for nonzero finite x.
+    -- cacos(-(inf) + iy) returns pi - i (inf), for positive-signed finite y.
+    -- cacos(+(inf) + iy) returns +0 - i (inf), for positive-signed finite y.
+    -- cacos(-(inf) + i (inf)) returns 3pi /4 - i (inf).
+    -- cacos(+(inf) + i (inf)) returns pi /4 - i (inf).
+    -- cacos((+-)(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+      result is unspecified).
+    -- cacos(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite y.
+    -- cacos(NaN + i (inf)) returns NaN - i (inf).
+    -- cacos(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2" href="#G.6.2"><b>    G.6.2 Hyperbolic functions</b></a>
+<a name="G.6.2.1" href="#G.6.2.1"><b>    G.6.2.1 The cacosh functions</b></a>
+1   -- cacosh(conj(z)) = conj(cacosh(z)).
+    -- cacosh((+-)0 + i0) returns +0 + ipi /2.
+    -- cacosh(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+    -- cacosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite x.
+    -- cacosh(-(inf) + iy) returns +(inf) + ipi , for positive-signed finite y.
+    -- cacosh(+(inf) + iy) returns +(inf) + i0, for positive-signed finite y.
+    -- cacosh(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+    -- cacosh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+    -- cacosh((+-)(inf) + iNaN) returns +(inf) + iNaN.
+
+[<a name="p474" href="#p474">page 474</a>] (<a href="#Contents">Contents</a>)
+
+    -- cacosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite y.
+    -- cacosh(NaN + i (inf)) returns +(inf) + iNaN.
+    -- cacosh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.2" href="#G.6.2.2"><b>    G.6.2.2 The casinh functions</b></a>
+1   -- casinh(conj(z)) = conj(casinh(z)) and casinh is odd.
+    -- casinh(+0 + i0) returns 0 + i0.
+    -- casinh(x + i (inf)) returns +(inf) + ipi /2 for positive-signed finite x.
+    -- casinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite x.
+    -- casinh(+(inf) + iy) returns +(inf) + i0 for positive-signed finite y.
+    -- casinh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+    -- casinh(+(inf) + iNaN) returns +(inf) + iNaN.
+    -- casinh(NaN + i0) returns NaN + i0.
+    -- casinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite nonzero y.
+    -- casinh(NaN + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+      is unspecified).
+    -- casinh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.3" href="#G.6.2.3"><b>    G.6.2.3 The catanh functions</b></a>
+1   -- catanh(conj(z)) = conj(catanh(z)) and catanh is odd.
+    -- catanh(+0 + i0) returns +0 + i0.
+    -- catanh(+0 + iNaN) returns +0 + iNaN.
+    -- catanh(+1 + i0) returns +(inf) + i0 and raises the ''divide-by-zero'' floating-point
+      exception.
+    -- catanh(x + i (inf)) returns +0 + ipi /2, for finite positive-signed x.
+    -- catanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for nonzero finite x.
+    -- catanh(+(inf) + iy) returns +0 + ipi /2, for finite positive-signed y.
+    -- catanh(+(inf) + i (inf)) returns +0 + ipi /2.
+    -- catanh(+(inf) + iNaN) returns +0 + iNaN.
+
+[<a name="p475" href="#p475">page 475</a>] (<a href="#Contents">Contents</a>)
+
+    -- catanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite y.
+    -- catanh(NaN + i (inf)) returns (+-)0 + ipi /2 (where the sign of the real part of the result is
+      unspecified).
+    -- catanh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.4" href="#G.6.2.4"><b>    G.6.2.4 The ccosh functions</b></a>
+1   -- ccosh(conj(z)) = conj(ccosh(z)) and ccosh is even.
+    -- ccosh(+0 + i0) returns 1 + i0.
+    -- ccosh(+0 + i (inf)) returns NaN (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified) and raises the ''invalid'' floating-point exception.
+    -- ccosh(+0 + iNaN) returns NaN (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified).
+    -- ccosh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for finite nonzero x.
+    -- ccosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite nonzero x.
+    -- ccosh(+(inf) + i0) returns +(inf) + i0.
+    -- ccosh(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+    -- ccosh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+      unspecified) and raises the ''invalid'' floating-point exception.
+    -- ccosh(+(inf) + iNaN) returns +(inf) + iNaN.
+    -- ccosh(NaN + i0) returns NaN (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified).
+    -- ccosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- ccosh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.5" href="#G.6.2.5"><b>    G.6.2.5 The csinh functions</b></a>
+1   -- csinh(conj(z)) = conj(csinh(z)) and csinh is odd.
+    -- csinh(+0 + i0) returns +0 + i0.
+    -- csinh(+0 + i (inf)) returns (+-)0 + iNaN (where the sign of the real part of the result is
+      unspecified) and raises the ''invalid'' floating-point exception.
+    -- csinh(+0 + iNaN) returns (+-)0 + iNaN (where the sign of the real part of the result is
+      unspecified).
+
+[<a name="p476" href="#p476">page 476</a>] (<a href="#Contents">Contents</a>)
+
+    -- csinh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for positive finite x.
+    -- csinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite nonzero x.
+    -- csinh(+(inf) + i0) returns +(inf) + i0.
+    -- csinh(+(inf) + iy) returns +(inf) cis(y), for positive finite y.
+    -- csinh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+      unspecified) and raises the ''invalid'' floating-point exception.
+    -- csinh(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+      is unspecified).
+    -- csinh(NaN + i0) returns NaN + i0.
+    -- csinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- csinh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.6" href="#G.6.2.6"><b>    G.6.2.6 The ctanh functions</b></a>
+1   -- ctanh(conj(z)) = conj(ctanh(z))and ctanh is odd.
+    -- ctanh(+0 + i0) returns +0 + i0.
+    -- ctanh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for finite x.
+    -- ctanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+    -- ctanh(+(inf) + iy) returns 1 + i0 sin(2y), for positive-signed finite y.
+    -- ctanh(+(inf) + i (inf)) returns 1 (+-) i0 (where the sign of the imaginary part of the result
+      is unspecified).
+    -- ctanh(+(inf) + iNaN) returns 1 (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified).
+    -- ctanh(NaN + i0) returns NaN + i0.
+    -- ctanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- ctanh(NaN + iNaN) returns NaN + iNaN.
+
+[<a name="p477" href="#p477">page 477</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.6.3" href="#G.6.3"><b>    G.6.3 Exponential and logarithmic functions</b></a>
+<a name="G.6.3.1" href="#G.6.3.1"><b>    G.6.3.1 The cexp functions</b></a>
+1   -- cexp(conj(z)) = conj(cexp(z)).
+    -- cexp((+-)0 + i0) returns 1 + i0.
+    -- cexp(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for finite x.
+    -- cexp(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+    -- cexp(+(inf) + i0) returns +(inf) + i0.
+    -- cexp(-(inf) + iy) returns +0 cis(y), for finite y.
+    -- cexp(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+    -- cexp(-(inf) + i (inf)) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts of
+      the result are unspecified).
+    -- cexp(+(inf) + i (inf)) returns (+-)(inf) + iNaN and raises the ''invalid'' floating-point
+      exception (where the sign of the real part of the result is unspecified).
+    -- cexp(-(inf) + iNaN) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts
+      of the result are unspecified).
+    -- cexp(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+      is unspecified).
+    -- cexp(NaN + i0) returns NaN + i0.
+    -- cexp(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- cexp(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.3.2" href="#G.6.3.2"><b>    G.6.3.2 The clog functions</b></a>
+1   -- clog(conj(z)) = conj(clog(z)).
+    -- clog(-0 + i0) returns -(inf) + ipi and raises the ''divide-by-zero'' floating-point
+      exception.
+    -- clog(+0 + i0) returns -(inf) + i0 and raises the ''divide-by-zero'' floating-point
+      exception.
+    -- clog(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+    -- clog(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+
+[<a name="p478" href="#p478">page 478</a>] (<a href="#Contents">Contents</a>)
+
+    -- clog(-(inf) + iy) returns +(inf) + ipi , for finite positive-signed y.
+    -- clog(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+    -- clog(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+    -- clog(+(inf) + i (inf)) returns +(inf) + ipi /4.
+    -- clog((+-)(inf) + iNaN) returns +(inf) + iNaN.
+    -- clog(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite y.
+    -- clog(NaN + i (inf)) returns +(inf) + iNaN.
+    -- clog(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.4" href="#G.6.4"><b>    G.6.4 Power and absolute-value functions</b></a>
+<a name="G.6.4.1" href="#G.6.4.1"><b>    G.6.4.1 The cpow functions</b></a>
+1   The cpow functions raise floating-point exceptions if appropriate for the calculation of
+    the parts of the result, and may raise spurious exceptions.<sup><a href="#note327"><b>327)</b></a></sup>
+<a name="G.6.4.2" href="#G.6.4.2"><b>    G.6.4.2 The csqrt functions</b></a>
+1   -- csqrt(conj(z)) = conj(csqrt(z)).
+    -- csqrt((+-)0 + i0) returns +0 + i0.
+    -- csqrt(x + i (inf)) returns +(inf) + i (inf), for all x (including NaN).
+    -- csqrt(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+    -- csqrt(-(inf) + iy) returns +0 + i (inf), for finite positive-signed y.
+    -- csqrt(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+    -- csqrt(-(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+      result is unspecified).
+    -- csqrt(+(inf) + iNaN) returns +(inf) + iNaN.
+    -- csqrt(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite y.
+    -- csqrt(NaN + iNaN) returns NaN + iNaN.
+
+
+
+
+    <sup><a name="note327" href="#note327"><b>327)</b></a></sup> This allows cpow( z , c ) to be implemented as cexp(c      clog( z )) without precluding
+         implementations that treat special cases more carefully.
+
+[<a name="p479" href="#p479">page 479</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.7" href="#G.7"><b>    G.7 Type-generic math &lt;tgmath.h&gt;</b></a>
+1   Type-generic macros that accept complex arguments also accept imaginary arguments. If
+    an argument is imaginary, the macro expands to an expression whose type is real,
+    imaginary, or complex, as appropriate for the particular function: if the argument is
+    imaginary, then the types of cos, cosh, fabs, carg, cimag, and creal are real; the
+    types of sin, tan, sinh, tanh, asin, atan, asinh, and atanh are imaginary; and
+    the types of the others are complex.
+2   Given an imaginary argument, each of the type-generic macros cos, sin, tan, cosh,
+    sinh, tanh, asin, atan, asinh, atanh is specified by a formula in terms of real
+    functions:
+           cos(iy)      =   cosh(y)
+           sin(iy)      =   i sinh(y)
+           tan(iy)      =   i tanh(y)
+           cosh(iy)     =   cos(y)
+           sinh(iy)     =   i sin(y)
+           tanh(iy)     =   i tan(y)
+           asin(iy)     =   i asinh(y)
+           atan(iy)     =   i atanh(y)
+           asinh(iy)    =   i asin(y)
+           atanh(iy)    =   i atan(y)
+
+[<a name="p480" href="#p480">page 480</a>] (<a href="#Contents">Contents</a>)
+
+<a name="H" href="#H"><b>                                          Annex H</b></a>
+                                        (informative)
+                        Language independent arithmetic
+<a name="H.1" href="#H.1"><b>    H.1 Introduction</b></a>
+1   This annex documents the extent to which the C language supports the ISO/IEC 10967-1
+    standard for language-independent arithmetic (LIA-1). LIA-1 is more general than
+    IEC 60559 (<a href="#F">annex F</a>) in that it covers integer and diverse floating-point arithmetics.
+<a name="H.2" href="#H.2"><b>    H.2 Types</b></a>
+1   The relevant C arithmetic types meet the requirements of LIA-1 types if an
+    implementation adds notification of exceptional arithmetic operations and meets the 1
+    unit in the last place (ULP) accuracy requirement (LIA-1 subclause <a href="#5.2.8">5.2.8</a>).
+<a name="H.2.1" href="#H.2.1"><b>    H.2.1 Boolean type</b></a>
+1   The LIA-1 data type Boolean is implemented by the C data type bool with values of
+    true and false, all from <a href="#7.16">&lt;stdbool.h&gt;</a>.
+<a name="H.2.2" href="#H.2.2"><b>    H.2.2 Integer types</b></a>
+1   The signed C integer types int, long int, long long int, and the corresponding
+    unsigned types are compatible with LIA-1. If an implementation adds support for the
+    LIA-1 exceptional values ''integer_overflow'' and ''undefined'', then those types are
+    LIA-1 conformant types. C's unsigned integer types are ''modulo'' in the LIA-1 sense
+    in that overflows or out-of-bounds results silently wrap. An implementation that defines
+    signed integer types as also being modulo need not detect integer overflow, in which case,
+    only integer divide-by-zero need be detected.
+2   The parameters for the integer data types can be accessed by the following:
+    maxint        INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
+                  ULLONG_MAX
+    minint        INT_MIN, LONG_MIN, LLONG_MIN
+3   The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
+    is always 0 for the unsigned types, and is not provided for those types.
+
+[<a name="p481" href="#p481">page 481</a>] (<a href="#Contents">Contents</a>)
+
+<a name="H.2.2.1" href="#H.2.2.1"><b>    H.2.2.1 Integer operations</b></a>
+1   The integer operations on integer types are the following:
+    addI           x + y
+    subI           x - y
+    mulI           x * y
+    divI, divtI    x / y
+    remI, remtI    x % y
+    negI           -x
+    absI           abs(x), labs(x), llabs(x)
+    eqI            x == y
+    neqI           x != y
+    lssI           x &lt; y
+    leqI           x &lt;= y
+    gtrI           x &gt; y
+    geqI           x &gt;= y
+    where x and y are expressions of the same integer type.
+<a name="H.2.3" href="#H.2.3"><b>    H.2.3 Floating-point types</b></a>
+1   The C floating-point types float, double, and long double are compatible with
+    LIA-1. If an implementation adds support for the LIA-1 exceptional values
+    ''underflow'', ''floating_overflow'', and ''"undefined'', then those types are conformant
+    with LIA-1. An implementation that uses IEC 60559 floating-point formats and
+    operations (see <a href="#F">annex F</a>) along with IEC 60559 status flags and traps has LIA-1
+    conformant types.
+<a name="H.2.3.1" href="#H.2.3.1"><b>    H.2.3.1 Floating-point parameters</b></a>
+1   The parameters for a floating point data type can be accessed by the following:
+    r              FLT_RADIX
+    p              FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG
+    emax           FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP
+    emin           FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP
+2   The derived constants for the floating point types are accessed by the following:
+
+[<a name="p482" href="#p482">page 482</a>] (<a href="#Contents">Contents</a>)
+
+    fmax          FLT_MAX, DBL_MAX, LDBL_MAX
+    fminN         FLT_MIN, DBL_MIN, LDBL_MIN
+    epsilon       FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON
+    rnd_style     FLT_ROUNDS
+<a name="H.2.3.2" href="#H.2.3.2"><b>    H.2.3.2 Floating-point operations</b></a>
+1   The floating-point operations on floating-point types are the following:
+    addF          x + y
+    subF          x - y
+    mulF          x * y
+    divF          x / y
+    negF          -x
+    absF          fabsf(x), fabs(x), fabsl(x)
+    exponentF     1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
+    scaleF        scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
+                  scalblnf(x, li), scalbln(x, li), scalblnl(x, li)
+    intpartF      modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+    fractpartF    modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+    eqF           x == y
+    neqF          x != y
+    lssF          x &lt; y
+    leqF          x &lt;= y
+    gtrF          x &gt; y
+    geqF          x &gt;= y
+    where x and y are expressions of the same floating point type, n is of type int, and li
+    is of type long int.
+<a name="H.2.3.3" href="#H.2.3.3"><b>    H.2.3.3 Rounding styles</b></a>
+1   The C Standard requires all floating types to use the same radix and rounding style, so
+    that only one identifier for each is provided to map to LIA-1.
+2   The FLT_ROUNDS parameter can be used to indicate the LIA-1 rounding styles:
+    truncate      FLT_ROUNDS == 0
+
+[<a name="p483" href="#p483">page 483</a>] (<a href="#Contents">Contents</a>)
+
+    nearest        FLT_ROUNDS == 1
+    other          FLT_ROUNDS != 0 &amp;&amp; FLT_ROUNDS != 1
+    provided that an implementation extends FLT_ROUNDS to cover the rounding style used
+    in all relevant LIA-1 operations, not just addition as in C.
+<a name="H.2.4" href="#H.2.4"><b>    H.2.4 Type conversions</b></a>
+1   The LIA-1 type conversions are the following type casts:
+    cvtI' -&gt; I      (int)i, (long int)i, (long long int)i,
+                   (unsigned int)i, (unsigned long int)i,
+                   (unsigned long long int)i
+    cvtF -&gt; I       (int)x, (long int)x, (long long int)x,
+                   (unsigned int)x, (unsigned long int)x,
+                   (unsigned long long int)x
+    cvtI -&gt; F       (float)i, (double)i, (long double)i
+    cvtF' -&gt; F      (float)x, (double)x, (long double)x
+2   In the above conversions from floating to integer, the use of (cast)x can be replaced with
+    (cast)round(x), (cast)rint(x), (cast)nearbyint(x), (cast)trunc(x),
+    (cast)ceil(x), or (cast)floor(x). In addition, C's floating-point to integer
+    conversion functions, lrint(), llrint(), lround(), and llround(), can be
+    used. They all meet LIA-1's requirements on floating to integer rounding for in-range
+    values. For out-of-range values, the conversions shall silently wrap for the modulo types.
+3   The fmod() function is useful for doing silent wrapping to unsigned integer types, e.g.,
+    fmod( fabs(rint(x)), 65536.0 ) or (0.0 &lt;= (y = fmod( rint(x),
+    65536.0 )) ? y : 65536.0 + y) will compute an integer value in the range 0.0
+    to 65535.0 which can then be cast to unsigned short int. But, the
+    remainder() function is not useful for doing silent wrapping to signed integer types,
+    e.g., remainder( rint(x), 65536.0 ) will compute an integer value in the
+    range -32767.0 to +32768.0 which is not, in general, in the range of signed short
+    int.
+4   C's conversions (casts) from floating-point to floating-point can meet LIA-1
+    requirements if an implementation uses round-to-nearest (IEC 60559 default).
+5   C's conversions (casts) from integer to floating-point can meet LIA-1 requirements if an
+    implementation uses round-to-nearest.
+
+[<a name="p484" href="#p484">page 484</a>] (<a href="#Contents">Contents</a>)
+
+<a name="H.3" href="#H.3"><b>    H.3 Notification</b></a>
+1   Notification is the process by which a user or program is informed that an exceptional
+    arithmetic operation has occurred. C's operations are compatible with LIA-1 in that C
+    allows an implementation to cause a notification to occur when any arithmetic operation
+    returns an exceptional value as defined in LIA-1 clause 5.
+<a name="H.3.1" href="#H.3.1"><b>    H.3.1 Notification alternatives</b></a>
+1   LIA-1 requires at least the following two alternatives for handling of notifications:
+    setting indicators or trap-and-terminate. LIA-1 allows a third alternative: trap-and-
+    resume.
+2   An implementation need only support a given notification alternative for the entire
+    program. An implementation may support the ability to switch between notification
+    alternatives during execution, but is not required to do so. An implementation can
+    provide separate selection for each kind of notification, but this is not required.
+3   C allows an implementation to provide notification. C's SIGFPE (for traps) and
+    FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW (for indicators)
+    can provide LIA-1 notification.
+4   C's signal handlers are compatible with LIA-1. Default handling of SIGFPE can
+    provide trap-and-terminate behavior, except for those LIA-1 operations implemented by
+    math library function calls. User-provided signal handlers for SIGFPE allow for trap-
+    and-resume behavior with the same constraint.
+<a name="H.3.1.1" href="#H.3.1.1"><b>    H.3.1.1 Indicators</b></a>
+1   C's <a href="#7.6">&lt;fenv.h&gt;</a> status flags are compatible with the LIA-1 indicators.
+2   The following mapping is for floating-point types:
+    undefined                FE_INVALID, FE_DIVBYZERO
+    floating_overflow         FE_OVERFLOW
+    underflow                FE_UNDERFLOW
+3   The floating-point indicator interrogation and manipulation operations are:
+    set_indicators          feraiseexcept(i)
+    clear_indicators        feclearexcept(i)
+    test_indicators         fetestexcept(i)
+    current_indicators      fetestexcept(FE_ALL_EXCEPT)
+    where i is an expression of type int representing a subset of the LIA-1 indicators.
+4   C allows an implementation to provide the following LIA-1 required behavior: at
+    program termination if any indicator is set the implementation shall send an unambiguous
+
+[<a name="p485" href="#p485">page 485</a>] (<a href="#Contents">Contents</a>)
+
+    and ''hard to ignore'' message (see LIA-1 subclause <a href="#6.1.2">6.1.2</a>)
+5   LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
+    This documentation makes that distinction because <a href="#7.6">&lt;fenv.h&gt;</a> covers only the floating-
+    point indicators.
+<a name="H.3.1.2" href="#H.3.1.2"><b>    H.3.1.2 Traps</b></a>
+1   C is compatible with LIA-1's trap requirements for arithmetic operations, but not for
+    math library functions (which are not permitted to generate any externally visible
+    exceptional conditions). An implementation can provide an alternative of notification
+    through termination with a ''hard-to-ignore'' message (see LIA-1 subclause <a href="#6.1.3">6.1.3</a>).
+2   LIA-1 does not require that traps be precise.
+3   C does require that SIGFPE be the signal corresponding to arithmetic exceptions, if there
+    is any signal raised for them.
+4   C supports signal handlers for SIGFPE and allows trapping of arithmetic exceptions.
+    When arithmetic exceptions do trap, C's signal-handler mechanism allows trap-and-
+    terminate (either default implementation behavior or user replacement for it) or trap-and-
+    resume, at the programmer's option.
+
+[<a name="p486" href="#p486">page 486</a>] (<a href="#Contents">Contents</a>)
+
+<a name="I" href="#I"><b>                                           Annex I</b></a>
+                                        (informative)
+                                   Common warnings
+1   An implementation may generate warnings in many situations, none of which are
+    specified as part of this International Standard. The following are a few of the more
+    common situations.
+2   -- A new struct or union type appears in a function prototype (<a href="#6.2.1">6.2.1</a>, <a href="#6.7.2.3">6.7.2.3</a>).
+    -- A block with initialization of an object that has automatic storage duration is jumped
+      into (<a href="#6.2.4">6.2.4</a>).
+    -- An implicit narrowing conversion is encountered, such as the assignment of a long
+      int or a double to an int, or a pointer to void to a pointer to any type other than
+      a character type (<a href="#6.3">6.3</a>).
+    -- A hexadecimal floating constant cannot be represented exactly in its evaluation format
+      (<a href="#6.4.4.2">6.4.4.2</a>).
+    -- An integer character constant includes more than one character or a wide character
+      constant includes more than one multibyte character (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- The characters /* are found in a comment (<a href="#6.4.7">6.4.7</a>).
+    -- An ''unordered'' binary operator (not comma, &amp;&amp;, or ||) contains a side effect to an
+      lvalue in one operand, and a side effect to, or an access to the value of, the identical
+      lvalue in the other operand (<a href="#6.5">6.5</a>).
+    -- A function is called but no prototype has been supplied (<a href="#6.5.2.2">6.5.2.2</a>).
+    -- The arguments in a function call do not agree in number and type with those of the
+      parameters in a function definition that is not a prototype (<a href="#6.5.2.2">6.5.2.2</a>).
+    -- An object is defined but not used (<a href="#6.7">6.7</a>).
+    -- A value is given to an object of an enumerated type other than by assignment of an
+      enumeration constant that is a member of that type, or an enumeration object that has
+      the same type, or the value of a function that returns the same enumerated type
+      (<a href="#6.7.2.2">6.7.2.2</a>).
+    -- An aggregate has a partly bracketed initialization (<a href="#6.7.7">6.7.7</a>).
+    -- A statement cannot be reached (<a href="#6.8">6.8</a>).
+    -- A statement with no apparent effect is encountered (<a href="#6.8">6.8</a>).
+    -- A constant expression is used as the controlling expression of a selection statement
+      (<a href="#6.8.4">6.8.4</a>).
+
+[<a name="p487" href="#p487">page 487</a>] (<a href="#Contents">Contents</a>)
+
+-- An incorrectly formed preprocessing group is encountered while skipping a
+  preprocessing group (<a href="#6.10.1">6.10.1</a>).
+-- An unrecognized #pragma directive is encountered (<a href="#6.10.6">6.10.6</a>).
+
+[<a name="p488" href="#p488">page 488</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J" href="#J"><b>                                            Annex J</b></a>
+                                         (informative)
+                                      Portability issues
+1   This annex collects some information about portability that appears in this International
+    Standard.
+<a name="J.1" href="#J.1"><b>    J.1 Unspecified behavior</b></a>
+1   The following are unspecified:
+    -- The manner and timing of static initialization (<a href="#5.1.2">5.1.2</a>).
+    -- The termination status returned to the hosted environment if the return type of main
+      is not compatible with int (<a href="#5.1.2.2.3">5.1.2.2.3</a>).
+    -- The behavior of the display device if a printing character is written when the active
+      position is at the final position of a line (<a href="#5.2.2">5.2.2</a>).
+    -- The behavior of the display device if a backspace character is written when the active
+      position is at the initial position of a line (<a href="#5.2.2">5.2.2</a>).
+    -- The behavior of the display device if a horizontal tab character is written when the
+      active position is at or past the last defined horizontal tabulation position (<a href="#5.2.2">5.2.2</a>).
+    -- The behavior of the display device if a vertical tab character is written when the active
+      position is at or past the last defined vertical tabulation position (<a href="#5.2.2">5.2.2</a>).
+    -- How an extended source character that does not correspond to a universal character
+      name counts toward the significant initial characters in an external identifier (<a href="#5.2.4.1">5.2.4.1</a>).
+    -- Many aspects of the representations of types (<a href="#6.2.6">6.2.6</a>).
+    -- The value of padding bytes when storing values in structures or unions (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- The value of a union member other than the last one stored into (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- The representation used when storing a value in an object that has more than one
+      object representation for that value (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- The values of any padding bits in integer representations (<a href="#6.2.6.2">6.2.6.2</a>).
+    -- Whether certain operators can generate negative zeros and whether a negative zero
+      becomes a normal zero when stored in an object (<a href="#6.2.6.2">6.2.6.2</a>).
+    -- Whether two string literals result in distinct arrays (<a href="#6.4.5">6.4.5</a>).
+    -- The order in which subexpressions are evaluated and the order in which side effects
+      take place, except as specified for the function-call (), &amp;&amp;, ||, ?:, and comma
+      operators (<a href="#6.5">6.5</a>).
+
+[<a name="p489" href="#p489">page 489</a>] (<a href="#Contents">Contents</a>)
+
+-- The order in which the function designator, arguments, and subexpressions within the
+  arguments are evaluated in a function call (<a href="#6.5.2.2">6.5.2.2</a>).
+-- The order of side effects among compound literal initialization list expressions
+  (<a href="#6.5.2.5">6.5.2.5</a>).
+-- The order in which the operands of an assignment operator are evaluated (<a href="#6.5.16">6.5.16</a>).
+-- The alignment of the addressable storage unit allocated to hold a bit-field (<a href="#6.7.2.1">6.7.2.1</a>).
+-- Whether a call to an inline function uses the inline definition or the external definition
+  of the function (<a href="#6.7.4">6.7.4</a>).
+-- Whether or not a size expression is evaluated when it is part of the operand of a
+  sizeof operator and changing the value of the size expression would not affect the
+  result of the operator (<a href="#6.7.5.2">6.7.5.2</a>).
+-- The order in which any side effects occur among the initialization list expressions in
+  an initializer (<a href="#6.7.8">6.7.8</a>).
+-- The layout of storage for function parameters (<a href="#6.9.1">6.9.1</a>).
+-- When a fully expanded macro replacement list contains a function-like macro name
+  as its last preprocessing token and the next preprocessing token from the source file is
+  a (, and the fully expanded replacement of that macro ends with the name of the first
+  macro and the next preprocessing token from the source file is again a (, whether that
+  is considered a nested replacement (<a href="#6.10.3">6.10.3</a>).
+-- The order in which # and ## operations are evaluated during macro substitution
+  (<a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>).
+-- Whether errno is a macro or an identifier with external linkage (<a href="#7.5">7.5</a>).
+-- The state of the floating-point status flags when execution passes from a part of the
+  program translated with FENV_ACCESS ''off'' to a part translated with
+  FENV_ACCESS ''on'' (<a href="#7.6.1">7.6.1</a>).
+-- The order in which feraiseexcept raises floating-point exceptions, except as
+  stated in <a href="#F.7.6">F.7.6</a> (<a href="#7.6.2.3">7.6.2.3</a>).
+-- Whether math_errhandling is a macro or an identifier with external linkage
+  (<a href="#7.12">7.12</a>).
+-- The results of the frexp functions when the specified value is not a floating-point
+  number (<a href="#7.12.6.4">7.12.6.4</a>).
+-- The numeric result of the ilogb functions when the correct value is outside the
+  range of the return type (<a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.9.3.5">F.9.3.5</a>).
+-- The result of rounding when the value is out of range (<a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.5">F.9.6.5</a>).
+
+[<a name="p490" href="#p490">page 490</a>] (<a href="#Contents">Contents</a>)
+
+-- The value stored by the remquo functions in the object pointed to by quo when y is
+  zero (<a href="#7.12.10.3">7.12.10.3</a>).
+-- Whether setjmp is a macro or an identifier with external linkage (<a href="#7.13">7.13</a>).
+-- Whether va_copy and va_end are macros or identifiers with external linkage
+  (<a href="#7.15.1">7.15.1</a>).
+-- The hexadecimal digit before the decimal point when a non-normalized floating-point
+  number is printed with an a or A conversion specifier (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+-- The value of the file position indicator after a successful call to the ungetc function
+  for a text stream, or the ungetwc function for any stream, until all pushed-back
+  characters are read or discarded (<a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.24.3.10">7.24.3.10</a>).
+-- The details of the value stored by the fgetpos function (<a href="#7.19.9.1">7.19.9.1</a>).
+-- The details of the value returned by the ftell function for a text stream (<a href="#7.19.9.4">7.19.9.4</a>).
+-- Whether the strtod, strtof, strtold, wcstod, wcstof, and wcstold
+  functions convert a minus-signed sequence to a negative number directly or by
+  negating the value resulting from converting the corresponding unsigned sequence
+  (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
+-- The order and contiguity of storage allocated by successive calls to the calloc,
+  malloc, and realloc functions (<a href="#7.20.3">7.20.3</a>).
+-- The amount of storage allocated by a successful call to the calloc, malloc, or
+  realloc function when 0 bytes was requested (<a href="#7.20.3">7.20.3</a>).
+-- Which of two elements that compare as equal is matched by the bsearch function
+  (<a href="#7.20.5.1">7.20.5.1</a>).
+-- The order of two elements that compare as equal in an array sorted by the qsort
+  function (<a href="#7.20.5.2">7.20.5.2</a>).
+-- The encoding of the calendar time returned by the time function (<a href="#7.23.2.4">7.23.2.4</a>).
+-- The characters stored by the strftime or wcsftime function if any of the time
+  values being converted is outside the normal range (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+-- The conversion state after an encoding error occurs (<a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>,
+  <a href="#7.24.6.4.2">7.24.6.4.2</a>,
+-- The resulting value when the ''invalid'' floating-point exception is raised during
+  IEC 60559 floating to integer conversion (<a href="#F.4">F.4</a>).
+-- Whether conversion of non-integer IEC 60559 floating values to integer raises the
+  ''inexact'' floating-point exception (<a href="#F.4">F.4</a>).
+
+[<a name="p491" href="#p491">page 491</a>] (<a href="#Contents">Contents</a>)
+
+    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise the ''inexact'' floating-point
+      exception in an IEC 60559 conformant implementation (<a href="#F.9">F.9</a>).
+    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise an undeserved ''underflow''
+      floating-point exception in an IEC 60559 conformant implementation (<a href="#F.9">F.9</a>).
+    -- The exponent value stored by frexp for a NaN or infinity (<a href="#F.9.3.4">F.9.3.4</a>).
+    -- The numeric result returned by the lrint, llrint, lround, and llround
+      functions if the rounded value is outside the range of the return type (<a href="#F.9.6.5">F.9.6.5</a>, <a href="#F.9.6.7">F.9.6.7</a>).
+    -- The sign of one part of the complex result of several math functions for certain
+      exceptional values in IEC 60559 compatible implementations (<a href="#G.6.1.1">G.6.1.1</a>, <a href="#G.6.2.2">G.6.2.2</a>,
+      <a href="#G.6.2.3">G.6.2.3</a>, <a href="#G.6.2.4">G.6.2.4</a>, <a href="#G.6.2.5">G.6.2.5</a>, <a href="#G.6.2.6">G.6.2.6</a>, <a href="#G.6.3.1">G.6.3.1</a>, <a href="#G.6.4.2">G.6.4.2</a>).
+<a name="J.2" href="#J.2"><b>    J.2 Undefined behavior</b></a>
+1   The behavior is undefined in the following circumstances:
+    -- A ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated
+      (clause 4).
+    -- A nonempty source file does not end in a new-line character which is not immediately
+      preceded by a backslash character or ends in a partial preprocessing token or
+      comment (<a href="#5.1.1.2">5.1.1.2</a>).
+    -- Token concatenation produces a character sequence matching the syntax of a
+      universal character name (<a href="#5.1.1.2">5.1.1.2</a>).
+    -- A program in a hosted environment does not define a function named main using one
+      of the specified forms (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+    -- A character not in the basic source character set is encountered in a source file, except
+      in an identifier, a character constant, a string literal, a header name, a comment, or a
+      preprocessing token that is never converted to a token (<a href="#5.2.1">5.2.1</a>).
+    -- An identifier, comment, string literal, character constant, or header name contains an
+      invalid multibyte character or does not begin and end in the initial shift state (<a href="#5.2.1.2">5.2.1.2</a>).
+    -- The same identifier has both internal and external linkage in the same translation unit
+      (<a href="#6.2.2">6.2.2</a>).
+    -- An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
+    -- The value of a pointer to an object whose lifetime has ended is used (<a href="#6.2.4">6.2.4</a>).
+    -- The value of an object with automatic storage duration is used while it is
+      indeterminate (<a href="#6.2.4">6.2.4</a>, <a href="#6.7.8">6.7.8</a>, <a href="#6.8">6.8</a>).
+    -- A trap representation is read by an lvalue expression that does not have character type
+      (<a href="#6.2.6.1">6.2.6.1</a>).
+
+[<a name="p492" href="#p492">page 492</a>] (<a href="#Contents">Contents</a>)
+
+-- A trap representation is produced by a side effect that modifies any part of the object
+  using an lvalue expression that does not have character type (<a href="#6.2.6.1">6.2.6.1</a>).
+-- The arguments to certain operators are such that could produce a negative zero result,
+  but the implementation does not support negative zeros (<a href="#6.2.6.2">6.2.6.2</a>).
+-- Two declarations of the same object or function specify types that are not compatible
+  (<a href="#6.2.7">6.2.7</a>).
+-- Conversion to or from an integer type produces a value outside the range that can be
+  represented (<a href="#6.3.1.4">6.3.1.4</a>).
+-- Demotion of one real floating type to another produces a value outside the range that
+  can be represented (<a href="#6.3.1.5">6.3.1.5</a>).
+-- An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
+-- A non-array lvalue with an incomplete type is used in a context that requires the value
+  of the designated object (<a href="#6.3.2.1">6.3.2.1</a>).
+-- An lvalue having array type is converted to a pointer to the initial element of the
+  array, and the array object has register storage class (<a href="#6.3.2.1">6.3.2.1</a>).
+-- An attempt is made to use the value of a void expression, or an implicit or explicit
+  conversion (except to void) is applied to a void expression (<a href="#6.3.2.2">6.3.2.2</a>).
+-- Conversion of a pointer to an integer type produces a value outside the range that can
+  be represented (<a href="#6.3.2.3">6.3.2.3</a>).
+-- Conversion between two pointer types produces a result that is incorrectly aligned
+  (<a href="#6.3.2.3">6.3.2.3</a>).
+-- A pointer is used to call a function whose type is not compatible with the pointed-to
+  type (<a href="#6.3.2.3">6.3.2.3</a>).
+-- An unmatched ' or " character is encountered on a logical source line during
+  tokenization (<a href="#6.4">6.4</a>).
+-- A reserved keyword token is used in translation phase 7 or 8 for some purpose other
+  than as a keyword (<a href="#6.4.1">6.4.1</a>).
+-- A universal character name in an identifier does not designate a character whose
+  encoding falls into one of the specified ranges (<a href="#6.4.2.1">6.4.2.1</a>).
+-- The initial character of an identifier is a universal character name designating a digit
+  (<a href="#6.4.2.1">6.4.2.1</a>).
+-- Two identifiers differ only in nonsignificant characters (<a href="#6.4.2.1">6.4.2.1</a>).
+-- The identifier __func__ is explicitly declared (<a href="#6.4.2.2">6.4.2.2</a>).
+
+[<a name="p493" href="#p493">page 493</a>] (<a href="#Contents">Contents</a>)
+
+-- The program attempts to modify a string literal (<a href="#6.4.5">6.4.5</a>).
+-- The characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt;
+  delimiters, or the characters ', \, //, or /* occur in the sequence between the "
+  delimiters, in a header name preprocessing token (<a href="#6.4.7">6.4.7</a>).
+-- Between two sequence points, an object is modified more than once, or is modified
+  and the prior value is read other than to determine the value to be stored (<a href="#6.5">6.5</a>).
+-- An exceptional condition occurs during the evaluation of an expression (<a href="#6.5">6.5</a>).
+-- An object has its stored value accessed other than by an lvalue of an allowable type
+  (<a href="#6.5">6.5</a>).
+-- An attempt is made to modify the result of a function call, a conditional operator, an
+  assignment operator, or a comma operator, or to access it after the next sequence
+  point (<a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.15">6.5.15</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.5.17">6.5.17</a>).
+-- For a call to a function without a function prototype in scope, the number of
+  arguments does not equal the number of parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+-- For call to a function without a function prototype in scope where the function is
+  defined with a function prototype, either the prototype ends with an ellipsis or the
+  types of the arguments after promotion are not compatible with the types of the
+  parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+-- For a call to a function without a function prototype in scope where the function is not
+  defined with a function prototype, the types of the arguments after promotion are not
+  compatible with those of the parameters after promotion (with certain exceptions)
+  (<a href="#6.5.2.2">6.5.2.2</a>).
+-- A function is defined with a type that is not compatible with the type (of the
+  expression) pointed to by the expression that denotes the called function (<a href="#6.5.2.2">6.5.2.2</a>).
+-- The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
+-- A pointer is converted to other than an integer or pointer type (<a href="#6.5.4">6.5.4</a>).
+-- The value of the second operand of the / or % operator is zero (<a href="#6.5.5">6.5.5</a>).
+-- Addition or subtraction of a pointer into, or just beyond, an array object and an
+  integer type produces a result that does not point into, or just beyond, the same array
+  object (<a href="#6.5.6">6.5.6</a>).
+-- Addition or subtraction of a pointer into, or just beyond, an array object and an
+  integer type produces a result that points just beyond the array object and is used as
+  the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
+-- Pointers that do not point into, or just beyond, the same array object are subtracted
+  (<a href="#6.5.6">6.5.6</a>).
+
+[<a name="p494" href="#p494">page 494</a>] (<a href="#Contents">Contents</a>)
+
+-- An array subscript is out of range, even if an object is apparently accessible with the
+  given subscript (as in the lvalue expression a[1][7] given the declaration int
+  a[4][5]) (<a href="#6.5.6">6.5.6</a>).
+-- The result of subtracting two pointers is not representable in an object of type
+  ptrdiff_t (<a href="#6.5.6">6.5.6</a>).
+-- An expression is shifted by a negative number or by an amount greater than or equal
+  to the width of the promoted expression (<a href="#6.5.7">6.5.7</a>).
+-- An expression having signed promoted type is left-shifted and either the value of the
+  expression is negative or the result of shifting would be not be representable in the
+  promoted type (<a href="#6.5.7">6.5.7</a>).
+-- Pointers that do not point to the same aggregate or union (nor just beyond the same
+  array object) are compared using relational operators (<a href="#6.5.8">6.5.8</a>).
+-- An object is assigned to an inexactly overlapping object or to an exactly overlapping
+  object with incompatible type (<a href="#6.5.16.1">6.5.16.1</a>).
+-- An expression that is required to be an integer constant expression does not have an
+  integer type; has operands that are not integer constants, enumeration constants,
+  character constants, sizeof expressions whose results are integer constants, or
+  immediately-cast floating constants; or contains casts (outside operands to sizeof
+  operators) other than conversions of arithmetic types to integer types (<a href="#6.6">6.6</a>).
+-- A constant expression in an initializer is not, or does not evaluate to, one of the
+  following: an arithmetic constant expression, a null pointer constant, an address
+  constant, or an address constant for an object type plus or minus an integer constant
+  expression (<a href="#6.6">6.6</a>).
+-- An arithmetic constant expression does not have arithmetic type; has operands that
+  are not integer constants, floating constants, enumeration constants, character
+  constants, or sizeof expressions; or contains casts (outside operands to sizeof
+  operators) other than conversions of arithmetic types to arithmetic types (<a href="#6.6">6.6</a>).
+-- The value of an object is accessed by an array-subscript [], member-access . or -&gt;,
+  address &amp;, or indirection * operator or a pointer cast in creating an address constant
+  (<a href="#6.6">6.6</a>).
+-- An identifier for an object is declared with no linkage and the type of the object is
+  incomplete after its declarator, or after its init-declarator if it has an initializer (<a href="#6.7">6.7</a>).
+-- A function is declared at block scope with an explicit storage-class specifier other
+  than extern (<a href="#6.7.1">6.7.1</a>).
+-- A structure or union is defined as containing no named members (<a href="#6.7.2.1">6.7.2.1</a>).
+
+[<a name="p495" href="#p495">page 495</a>] (<a href="#Contents">Contents</a>)
+
+-- An attempt is made to access, or generate a pointer to just past, a flexible array
+  member of a structure when the referenced object provides no elements for that array
+  (<a href="#6.7.2.1">6.7.2.1</a>).
+-- When the complete type is needed, an incomplete structure or union type is not
+  completed in the same scope by another declaration of the tag that defines the content
+  (<a href="#6.7.2.3">6.7.2.3</a>).
+-- An attempt is made to modify an object defined with a const-qualified type through
+  use of an lvalue with non-const-qualified type (<a href="#6.7.3">6.7.3</a>).
+-- An attempt is made to refer to an object defined with a volatile-qualified type through
+  use of an lvalue with non-volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+-- The specification of a function type includes any type qualifiers (<a href="#6.7.3">6.7.3</a>).
+-- Two qualified types that are required to be compatible do not have the identically
+  qualified version of a compatible type (<a href="#6.7.3">6.7.3</a>).
+-- An object which has been modified is accessed through a restrict-qualified pointer to
+  a const-qualified type, or through a restrict-qualified pointer and another pointer that
+  are not both based on the same object (<a href="#6.7.3.1">6.7.3.1</a>).
+-- A restrict-qualified pointer is assigned a value based on another restricted pointer
+  whose associated block neither began execution before the block associated with this
+  pointer, nor ended before the assignment (<a href="#6.7.3.1">6.7.3.1</a>).
+-- A function with external linkage is declared with an inline function specifier, but is
+  not also defined in the same translation unit (<a href="#6.7.4">6.7.4</a>).
+-- Two pointer types that are required to be compatible are not identically qualified, or
+  are not pointers to compatible types (<a href="#6.7.5.1">6.7.5.1</a>).
+-- The size expression in an array declaration is not a constant expression and evaluates
+  at program execution time to a nonpositive value (<a href="#6.7.5.2">6.7.5.2</a>).
+-- In a context requiring two array types to be compatible, they do not have compatible
+  element types, or their size specifiers evaluate to unequal values (<a href="#6.7.5.2">6.7.5.2</a>).
+-- A declaration of an array parameter includes the keyword static within the [ and
+  ] and the corresponding argument does not provide access to the first element of an
+  array with at least the specified number of elements (<a href="#6.7.5.3">6.7.5.3</a>).
+-- A storage-class specifier or type qualifier modifies the keyword void as a function
+  parameter type list (<a href="#6.7.5.3">6.7.5.3</a>).
+-- In a context requiring two function types to be compatible, they do not have
+   compatible return types, or their parameters disagree in use of the ellipsis terminator
+   or the number and type of parameters (after default argument promotion, when there
+    is no parameter type list or when one type is specified by a function definition with an
+
+[<a name="p496" href="#p496">page 496</a>] (<a href="#Contents">Contents</a>)
+
+   identifier list) (<a href="#6.7.5.3">6.7.5.3</a>).
+-- The value of an unnamed member of a structure or union is used (<a href="#6.7.8">6.7.8</a>).
+-- The initializer for a scalar is neither a single expression nor a single expression
+  enclosed in braces (<a href="#6.7.8">6.7.8</a>).
+-- The initializer for a structure or union object that has automatic storage duration is
+  neither an initializer list nor a single expression that has compatible structure or union
+  type (<a href="#6.7.8">6.7.8</a>).
+-- The initializer for an aggregate or union, other than an array initialized by a string
+  literal, is not a brace-enclosed list of initializers for its elements or members (<a href="#6.7.8">6.7.8</a>).
+-- An identifier with external linkage is used, but in the program there does not exist
+  exactly one external definition for the identifier, or the identifier is not used and there
+  exist multiple external definitions for the identifier (<a href="#6.9">6.9</a>).
+-- A function definition includes an identifier list, but the types of the parameters are not
+  declared in a following declaration list (<a href="#6.9.1">6.9.1</a>).
+-- An adjusted parameter type in a function definition is not an object type (<a href="#6.9.1">6.9.1</a>).
+-- A function that accepts a variable number of arguments is defined without a
+  parameter type list that ends with the ellipsis notation (<a href="#6.9.1">6.9.1</a>).
+-- The } that terminates a function is reached, and the value of the function call is used
+  by the caller (<a href="#6.9.1">6.9.1</a>).
+-- An identifier for an object with internal linkage and an incomplete type is declared
+  with a tentative definition (<a href="#6.9.2">6.9.2</a>).
+-- The token defined is generated during the expansion of a #if or #elif
+  preprocessing directive, or the use of the defined unary operator does not match
+  one of the two specified forms prior to macro replacement (<a href="#6.10.1">6.10.1</a>).
+-- The #include preprocessing directive that results after expansion does not match
+  one of the two header name forms (<a href="#6.10.2">6.10.2</a>).
+-- The character sequence in an #include preprocessing directive does not start with a
+  letter (<a href="#6.10.2">6.10.2</a>).
+-- There are sequences of preprocessing tokens within the list of macro arguments that
+  would otherwise act as preprocessing directives (<a href="#6.10.3">6.10.3</a>).
+-- The result of the preprocessing operator # is not a valid character string literal
+  (<a href="#6.10.3.2">6.10.3.2</a>).
+-- The result of the preprocessing operator ## is not a valid preprocessing token
+  (<a href="#6.10.3.3">6.10.3.3</a>).
+
+[<a name="p497" href="#p497">page 497</a>] (<a href="#Contents">Contents</a>)
+
+-- The #line preprocessing directive that results after expansion does not match one of
+  the two well-defined forms, or its digit sequence specifies zero or a number greater
+  than 2147483647 (<a href="#6.10.4">6.10.4</a>).
+-- A non-STDC #pragma preprocessing directive that is documented as causing
+  translation failure or some other form of undefined behavior is encountered (<a href="#6.10.6">6.10.6</a>).
+-- A #pragma STDC preprocessing directive does not match one of the well-defined
+  forms (<a href="#6.10.6">6.10.6</a>).
+-- The name of a predefined macro, or the identifier defined, is the subject of a
+  #define or #undef preprocessing directive (<a href="#6.10.8">6.10.8</a>).
+-- An attempt is made to copy an object to an overlapping object by use of a library
+  function, other than as explicitly allowed (e.g., memmove) (clause 7).
+-- A file with the same name as one of the standard headers, not provided as part of the
+  implementation, is placed in any of the standard places that are searched for included
+  source files (<a href="#7.1.2">7.1.2</a>).
+-- A header is included within an external declaration or definition (<a href="#7.1.2">7.1.2</a>).
+-- A function, object, type, or macro that is specified as being declared or defined by
+  some standard header is used before any header that declares or defines it is included
+  (<a href="#7.1.2">7.1.2</a>).
+-- A standard header is included while a macro is defined with the same name as a
+  keyword (<a href="#7.1.2">7.1.2</a>).
+-- The program attempts to declare a library function itself, rather than via a standard
+  header, but the declaration does not have external linkage (<a href="#7.1.2">7.1.2</a>).
+-- The program declares or defines a reserved identifier, other than as allowed by <a href="#7.1.4">7.1.4</a>
+  (<a href="#7.1.3">7.1.3</a>).
+-- The program removes the definition of a macro whose name begins with an
+  underscore and either an uppercase letter or another underscore (<a href="#7.1.3">7.1.3</a>).
+-- An argument to a library function has an invalid value or a type not expected by a
+  function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
+-- The pointer passed to a library function array parameter does not have a value such
+  that all address computations and object accesses are valid (<a href="#7.1.4">7.1.4</a>).
+-- The macro definition of assert is suppressed in order to access an actual function
+  (<a href="#7.2">7.2</a>).
+-- The argument to the assert macro does not have a scalar type (<a href="#7.2">7.2</a>).
+-- The CX_LIMITED_RANGE, FENV_ACCESS, or FP_CONTRACT pragma is used in
+  any context other than outside all external declarations or preceding all explicit
+
+[<a name="p498" href="#p498">page 498</a>] (<a href="#Contents">Contents</a>)
+
+   declarations and statements inside a compound statement (<a href="#7.3.4">7.3.4</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.12.2">7.12.2</a>).
+-- The value of an argument to a character handling function is neither equal to the value
+  of EOF nor representable as an unsigned char (<a href="#7.4">7.4</a>).
+-- A macro definition of errno is suppressed in order to access an actual object, or the
+  program defines an identifier with the name errno (<a href="#7.5">7.5</a>).
+-- Part of the program tests floating-point status flags, sets floating-point control modes,
+  or runs under non-default mode settings, but was translated with the state for the
+  FENV_ACCESS pragma ''off'' (<a href="#7.6.1">7.6.1</a>).
+-- The exception-mask argument for one of the functions that provide access to the
+  floating-point status flags has a nonzero value not obtained by bitwise OR of the
+  floating-point exception macros (<a href="#7.6.2">7.6.2</a>).
+-- The fesetexceptflag function is used to set floating-point status flags that were
+  not specified in the call to the fegetexceptflag function that provided the value
+  of the corresponding fexcept_t object (<a href="#7.6.2.4">7.6.2.4</a>).
+-- The argument to fesetenv or feupdateenv is neither an object set by a call to
+  fegetenv or feholdexcept, nor is it an environment macro (<a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>).
+-- The value of the result of an integer arithmetic or conversion function cannot be
+  represented (<a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.6.1">7.20.6.1</a>, <a href="#7.20.6.2">7.20.6.2</a>, <a href="#7.20.1">7.20.1</a>).
+-- The program modifies the string pointed to by the value returned by the setlocale
+  function (<a href="#7.11.1.1">7.11.1.1</a>).
+-- The program modifies the structure pointed to by the value returned by the
+  localeconv function (<a href="#7.11.2.1">7.11.2.1</a>).
+-- A macro definition of math_errhandling is suppressed or the program defines
+  an identifier with the name math_errhandling (<a href="#7.12">7.12</a>).
+-- An argument to a floating-point classification or comparison macro is not of real
+  floating type (<a href="#7.12.3">7.12.3</a>, <a href="#7.12.14">7.12.14</a>).
+-- A macro definition of setjmp is suppressed in order to access an actual function, or
+  the program defines an external identifier with the name setjmp (<a href="#7.13">7.13</a>).
+-- An invocation of the setjmp macro occurs other than in an allowed context
+  (<a href="#7.13.2.1">7.13.2.1</a>).
+-- The longjmp function is invoked to restore a nonexistent environment (<a href="#7.13.2.1">7.13.2.1</a>).
+-- After a longjmp, there is an attempt to access the value of an object of automatic
+  storage class with non-volatile-qualified type, local to the function containing the
+  invocation of the corresponding setjmp macro, that was changed between the
+  setjmp invocation and longjmp call (<a href="#7.13.2.1">7.13.2.1</a>).
+
+[<a name="p499" href="#p499">page 499</a>] (<a href="#Contents">Contents</a>)
+
+-- The program specifies an invalid pointer to a signal handler function (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal handler returns when the signal corresponded to a computational exception
+  (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal occurs as the result of calling the abort or raise function, and the signal
+  handler calls the raise function (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal occurs other than as the result of calling the abort or raise function, and
+  the signal handler refers to an object with static storage duration other than by
+  assigning a value to an object declared as volatile sig_atomic_t, or calls any
+  function in the standard library other than the abort function, the _Exit function,
+  or the signal function (for the same signal number) (<a href="#7.14.1.1">7.14.1.1</a>).
+-- The value of errno is referred to after a signal occurred other than as the result of
+  calling the abort or raise function and the corresponding signal handler obtained
+  a SIG_ERR return from a call to the signal function (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal is generated by an asynchronous signal handler (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A function with a variable number of arguments attempts to access its varying
+  arguments other than through a properly declared and initialized va_list object, or
+  before the va_start macro is invoked (<a href="#7.15">7.15</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.4">7.15.1.4</a>).
+-- The macro va_arg is invoked using the parameter ap that was passed to a function
+  that invoked the macro va_arg with the same parameter (<a href="#7.15">7.15</a>).
+-- A macro definition of va_start, va_arg, va_copy, or va_end is suppressed in
+  order to access an actual function, or the program defines an external identifier with
+  the name va_copy or va_end (<a href="#7.15.1">7.15.1</a>).
+-- The va_start or va_copy macro is invoked without a corresponding invocation
+  of the va_end macro in the same function, or vice versa (<a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.3">7.15.1.3</a>,
+  <a href="#7.15.1.4">7.15.1.4</a>).
+-- The type parameter to the va_arg macro is not such that a pointer to an object of
+  that type can be obtained simply by postfixing a * (<a href="#7.15.1.1">7.15.1.1</a>).
+-- The va_arg macro is invoked when there is no actual next argument, or with a
+  specified type that is not compatible with the promoted type of the actual next
+  argument, with certain exceptions (<a href="#7.15.1.1">7.15.1.1</a>).
+-- The va_copy or va_start macro is called to initialize a va_list that was
+  previously initialized by either macro without an intervening invocation of the
+  va_end macro for the same va_list (<a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.4">7.15.1.4</a>).
+-- The parameter parmN of a va_start macro is declared with the register
+  storage class, with a function or array type, or with a type that is not compatible with
+  the type that results after application of the default argument promotions (<a href="#7.15.1.4">7.15.1.4</a>).
+
+[<a name="p500" href="#p500">page 500</a>] (<a href="#Contents">Contents</a>)
+
+-- The member designator parameter of an offsetof macro is an invalid right
+  operand of the . operator for the type parameter, or designates a bit-field (<a href="#7.17">7.17</a>).
+-- The argument in an instance of one of the integer-constant macros is not a decimal,
+  octal, or hexadecimal constant, or it has a value that exceeds the limits for the
+  corresponding type (<a href="#7.18.4">7.18.4</a>).
+-- A byte input/output function is applied to a wide-oriented stream, or a wide character
+  input/output function is applied to a byte-oriented stream (<a href="#7.19.2">7.19.2</a>).
+-- Use is made of any portion of a file beyond the most recent wide character written to
+  a wide-oriented stream (<a href="#7.19.2">7.19.2</a>).
+-- The value of a pointer to a FILE object is used after the associated file is closed
+  (<a href="#7.19.3">7.19.3</a>).
+-- The stream for the fflush function points to an input stream or to an update stream
+  in which the most recent operation was input (<a href="#7.19.5.2">7.19.5.2</a>).
+-- The string pointed to by the mode argument in a call to the fopen function does not
+  exactly match one of the specified character sequences (<a href="#7.19.5.3">7.19.5.3</a>).
+-- An output operation on an update stream is followed by an input operation without an
+  intervening call to the fflush function or a file positioning function, or an input
+  operation on an update stream is followed by an output operation with an intervening
+  call to a file positioning function (<a href="#7.19.5.3">7.19.5.3</a>).
+-- An attempt is made to use the contents of the array that was supplied in a call to the
+  setvbuf function (<a href="#7.19.5.6">7.19.5.6</a>).
+-- There are insufficient arguments for the format in a call to one of the formatted
+  input/output functions, or an argument does not have an appropriate type (<a href="#7.19.6.1">7.19.6.1</a>,
+  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- The format in a call to one of the formatted input/output functions or to the
+  strftime or wcsftime function is not a valid multibyte character sequence that
+  begins and ends in its initial shift state (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>,
+  <a href="#7.24.5.1">7.24.5.1</a>).
+-- In a call to one of the formatted output functions, a precision appears with a
+  conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+-- A conversion specification for a formatted output function uses an asterisk to denote
+  an argument-supplied field width or precision, but the corresponding argument is not
+  provided (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+-- A conversion specification for a formatted output function uses a # or 0 flag with a
+  conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+
+[<a name="p501" href="#p501">page 501</a>] (<a href="#Contents">Contents</a>)
+
+-- A conversion specification for one of the formatted input/output functions uses a
+  length modifier with a conversion specifier other than those described (<a href="#7.19.6.1">7.19.6.1</a>,
+  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- An s conversion specifier is encountered by one of the formatted output functions,
+  and the argument is missing the null terminator (unless a precision is specified that
+  does not require null termination) (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+-- An n conversion specification for one of the formatted input/output functions includes
+  any flags, an assignment-suppressing character, a field width, or a precision (<a href="#7.19.6.1">7.19.6.1</a>,
+  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- A % conversion specifier is encountered by one of the formatted input/output
+  functions, but the complete conversion specification is not exactly %% (<a href="#7.19.6.1">7.19.6.1</a>,
+  <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- An invalid conversion specification is found in the format for one of the formatted
+  input/output functions, or the strftime or wcsftime function (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,
+  <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+-- The number of characters transmitted by a formatted output function is greater than
+  INT_MAX (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.10">7.19.6.10</a>).
+-- The result of a conversion by one of the formatted input functions cannot be
+  represented in the corresponding object, or the receiving object does not have an
+  appropriate type (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- A c, s, or [ conversion specifier is encountered by one of the formatted input
+  functions, and the array pointed to by the corresponding argument is not large enough
+  to accept the input sequence (and a null terminator if the conversion specifier is s or
+  [) (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- A c, s, or [ conversion specifier with an l qualifier is encountered by one of the
+  formatted input functions, but the input is not a valid multibyte character sequence
+  that begins in the initial shift state (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- The input item for a %p conversion by one of the formatted input functions is not a
+  value converted earlier during the same program execution (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+-- The vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf,
+  vsscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, or
+  vwscanf function is called with an improperly initialized va_list argument, or
+  the argument is used (other than in an invocation of va_end) after the function
+  returns (<a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>, <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
+  <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>).
+-- The contents of the array supplied in a call to the fgets, gets, or fgetws function
+  are used after a read error occurred (<a href="#7.19.7.2">7.19.7.2</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.24.3.2">7.24.3.2</a>).
+
+[<a name="p502" href="#p502">page 502</a>] (<a href="#Contents">Contents</a>)
+
+-- The file position indicator for a binary stream is used after a call to the ungetc
+  function where its value was zero before the call (<a href="#7.19.7.11">7.19.7.11</a>).
+-- The file position indicator for a stream is used after an error occurred during a call to
+  the fread or fwrite function (<a href="#7.19.8.1">7.19.8.1</a>, <a href="#7.19.8.2">7.19.8.2</a>).
+-- A partial element read by a call to the fread function is used (<a href="#7.19.8.1">7.19.8.1</a>).
+-- The fseek function is called for a text stream with a nonzero offset and either the
+  offset was not returned by a previous successful call to the ftell function on a
+  stream associated with the same file or whence is not SEEK_SET (<a href="#7.19.9.2">7.19.9.2</a>).
+-- The fsetpos function is called to set a position that was not returned by a previous
+  successful call to the fgetpos function on a stream associated with the same file
+  (<a href="#7.19.9.3">7.19.9.3</a>).
+-- A non-null pointer returned by a call to the calloc, malloc, or realloc function
+  with a zero requested size is used to access an object (<a href="#7.20.3">7.20.3</a>).
+-- The value of a pointer that refers to space deallocated by a call to the free or
+  realloc function is used (<a href="#7.20.3">7.20.3</a>).
+-- The pointer argument to the free or realloc function does not match a pointer
+  earlier returned by calloc, malloc, or realloc, or the space has been
+  deallocated by a call to free or realloc (<a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>).
+-- The value of the object allocated by the malloc function is used (<a href="#7.20.3.3">7.20.3.3</a>).
+-- The value of any bytes in a new object allocated by the realloc function beyond
+  the size of the old object are used (<a href="#7.20.3.4">7.20.3.4</a>).
+-- The program executes more than one call to the exit function (<a href="#7.20.4.3">7.20.4.3</a>).
+-- During the call to a function registered with the atexit function, a call is made to
+  the longjmp function that would terminate the call to the registered function
+  (<a href="#7.20.4.3">7.20.4.3</a>).
+-- The string set up by the getenv or strerror function is modified by the program
+  (<a href="#7.20.4.5">7.20.4.5</a>, <a href="#7.21.6.2">7.21.6.2</a>).
+-- A command is executed through the system function in a way that is documented as
+  causing termination or some other form of undefined behavior (<a href="#7.20.4.6">7.20.4.6</a>).
+-- A searching or sorting utility function is called with an invalid pointer argument, even
+  if the number of elements is zero (<a href="#7.20.5">7.20.5</a>).
+-- The comparison function called by a searching or sorting utility function alters the
+  contents of the array being searched or sorted, or returns ordering values
+  inconsistently (<a href="#7.20.5">7.20.5</a>).
+
+[<a name="p503" href="#p503">page 503</a>] (<a href="#Contents">Contents</a>)
+
+-- The array being searched by the bsearch function does not have its elements in
+  proper order (<a href="#7.20.5.1">7.20.5.1</a>).
+-- The current conversion state is used by a multibyte/wide character conversion
+  function after changing the LC_CTYPE category (<a href="#7.20.7">7.20.7</a>).
+-- A string or wide string utility function is instructed to access an array beyond the end
+  of an object (<a href="#7.21.1">7.21.1</a>, <a href="#7.24.4">7.24.4</a>).
+-- A string or wide string utility function is called with an invalid pointer argument, even
+  if the length is zero (<a href="#7.21.1">7.21.1</a>, <a href="#7.24.4">7.24.4</a>).
+-- The contents of the destination array are used after a call to the strxfrm,
+  strftime, wcsxfrm, or wcsftime function in which the specified length was
+  too small to hold the entire null-terminated result (<a href="#7.21.4.5">7.21.4.5</a>, <a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>,
+  <a href="#7.24.5.1">7.24.5.1</a>).
+-- The first argument in the very first call to the strtok or wcstok is a null pointer
+  (<a href="#7.21.5.8">7.21.5.8</a>, <a href="#7.24.4.5.7">7.24.4.5.7</a>).
+-- The type of an argument to a type-generic macro is not compatible with the type of
+  the corresponding parameter of the selected function (<a href="#7.22">7.22</a>).
+-- A complex argument is supplied for a generic parameter of a type-generic macro that
+  has no corresponding complex function (<a href="#7.22">7.22</a>).
+-- The argument corresponding to an s specifier without an l qualifier in a call to the
+  fwprintf function does not point to a valid multibyte character sequence that
+  begins in the initial shift state (<a href="#7.24.2.11">7.24.2.11</a>).
+-- In a call to the wcstok function, the object pointed to by ptr does not have the
+  value stored by the previous call for the same wide string (<a href="#7.24.4.5.7">7.24.4.5.7</a>).
+-- An mbstate_t object is used inappropriately (<a href="#7.24.6">7.24.6</a>).
+-- The value of an argument of type wint_t to a wide character classification or case
+  mapping function is neither equal to the value of WEOF nor representable as a
+  wchar_t (<a href="#7.25.1">7.25.1</a>).
+-- The iswctype function is called using a different LC_CTYPE category from the
+  one in effect for the call to the wctype function that returned the description
+  (<a href="#7.25.2.2.1">7.25.2.2.1</a>).
+-- The towctrans function is called using a different LC_CTYPE category from the
+  one in effect for the call to the wctrans function that returned the description
+  (<a href="#7.25.3.2.1">7.25.3.2.1</a>).
+
+[<a name="p504" href="#p504">page 504</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3" href="#J.3"><b>    J.3 Implementation-defined behavior</b></a>
+1   A conforming implementation is required to document its choice of behavior in each of
+    the areas listed in this subclause. The following are implementation-defined:
+<a name="J.3.1" href="#J.3.1"><b>    J.3.1 Translation</b></a>
+1   -- How a diagnostic is identified (<a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>).
+    -- Whether each nonempty sequence of white-space characters other than new-line is
+      retained or replaced by one space character in translation phase 3 (<a href="#5.1.1.2">5.1.1.2</a>).
+<a name="J.3.2" href="#J.3.2"><b>    J.3.2 Environment</b></a>
+1   -- The mapping between physical source file multibyte characters and the source
+      character set in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>).
+    -- The name and type of the function called at program startup in a freestanding
+      environment (<a href="#5.1.2.1">5.1.2.1</a>).
+    -- The effect of program termination in a freestanding environment (<a href="#5.1.2.1">5.1.2.1</a>).
+    -- An alternative manner in which the main function may be defined (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+    -- The values given to the strings pointed to by the argv argument to main (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+    -- What constitutes an interactive device (<a href="#5.1.2.3">5.1.2.3</a>).
+    -- The set of signals, their semantics, and their default handling (<a href="#7.14">7.14</a>).
+    -- Signal values other than SIGFPE, SIGILL, and SIGSEGV that correspond to a
+      computational exception (<a href="#7.14.1.1">7.14.1.1</a>).
+    -- Signals for which the equivalent of signal(sig, SIG_IGN); is executed at
+      program startup (<a href="#7.14.1.1">7.14.1.1</a>).
+    -- The set of environment names and the method for altering the environment list used
+      by the getenv function (<a href="#7.20.4.5">7.20.4.5</a>).
+    -- The manner of execution of the string by the system function (<a href="#7.20.4.6">7.20.4.6</a>).
+<a name="J.3.3" href="#J.3.3"><b>    J.3.3 Identifiers</b></a>
+1   -- Which additional multibyte characters may appear in identifiers and their
+      correspondence to universal character names (<a href="#6.4.2">6.4.2</a>).
+    -- The number of significant initial characters in an identifier (<a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2">6.4.2</a>).
+
+[<a name="p505" href="#p505">page 505</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3.4" href="#J.3.4"><b>    J.3.4 Characters</b></a>
+1   -- The number of bits in a byte (<a href="#3.6">3.6</a>).
+    -- The values of the members of the execution character set (<a href="#5.2.1">5.2.1</a>).
+    -- The unique value of the member of the execution character set produced for each of
+      the standard alphabetic escape sequences (<a href="#5.2.2">5.2.2</a>).
+    -- The value of a char object into which has been stored any character other than a
+      member of the basic execution character set (<a href="#6.2.5">6.2.5</a>).
+    -- Which of signed char or unsigned char has the same range, representation,
+      and behavior as ''plain'' char (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>).
+    -- The mapping of members of the source character set (in character constants and string
+      literals) to members of the execution character set (<a href="#6.4.4.4">6.4.4.4</a>, <a href="#5.1.1.2">5.1.1.2</a>).
+    -- The value of an integer character constant containing more than one character or
+      containing a character or escape sequence that does not map to a single-byte
+      execution character (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- The value of a wide character constant containing more than one multibyte character,
+      or containing a multibyte character or escape sequence not represented in the
+      extended execution character set (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- The current locale used to convert a wide character constant consisting of a single
+      multibyte character that maps to a member of the extended execution character set
+      into a corresponding wide character code (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- The current locale used to convert a wide string literal into corresponding wide
+      character codes (<a href="#6.4.5">6.4.5</a>).
+    -- The value of a string literal containing a multibyte character or escape sequence not
+      represented in the execution character set (<a href="#6.4.5">6.4.5</a>).
+<a name="J.3.5" href="#J.3.5"><b>    J.3.5 Integers</b></a>
+1   -- Any extended integer types that exist in the implementation (<a href="#6.2.5">6.2.5</a>).
+    -- Whether signed integer types are represented using sign and magnitude, two's
+      complement, or ones' complement, and whether the extraordinary value is a trap
+      representation or an ordinary value (<a href="#6.2.6.2">6.2.6.2</a>).
+    -- The rank of any extended integer type relative to another extended integer type with
+      the same precision (<a href="#6.3.1.1">6.3.1.1</a>).
+    -- The result of, or the signal raised by, converting an integer to a signed integer type
+      when the value cannot be represented in an object of that type (<a href="#6.3.1.3">6.3.1.3</a>).
+
+[<a name="p506" href="#p506">page 506</a>] (<a href="#Contents">Contents</a>)
+
+    -- The results of some bitwise operations on signed integers (<a href="#6.5">6.5</a>).
+<a name="J.3.6" href="#J.3.6"><b>    J.3.6 Floating point</b></a>
+1   -- The accuracy of the floating-point operations and of the library functions in
+      <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The accuracy of the conversions between floating-point internal representations and
+      string representations performed by the library functions in <a href="#7.19">&lt;stdio.h&gt;</a>,
+      <a href="#7.20">&lt;stdlib.h&gt;</a>, and <a href="#7.24">&lt;wchar.h&gt;</a> (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The rounding behaviors characterized by non-standard values of FLT_ROUNDS
+      (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The evaluation methods characterized by non-standard negative values of
+      FLT_EVAL_METHOD (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The direction of rounding when an integer is converted to a floating-point number that
+      cannot exactly represent the original value (<a href="#6.3.1.4">6.3.1.4</a>).
+    -- The direction of rounding when a floating-point number is converted to a narrower
+      floating-point number (<a href="#6.3.1.5">6.3.1.5</a>).
+    -- How the nearest representable value or the larger or smaller representable value
+      immediately adjacent to the nearest representable value is chosen for certain floating
+      constants (<a href="#6.4.4.2">6.4.4.2</a>).
+    -- Whether and how floating expressions are contracted when not disallowed by the
+      FP_CONTRACT pragma (<a href="#6.5">6.5</a>).
+    -- The default state for the FENV_ACCESS pragma (<a href="#7.6.1">7.6.1</a>).
+    -- Additional floating-point exceptions, rounding             modes,    environments,   and
+      classifications, and their macro names (<a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>).
+    -- The default state for the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>).                                    *
+<a name="J.3.7" href="#J.3.7"><b>    J.3.7 Arrays and pointers</b></a>
+1   -- The result of converting a pointer to an integer or vice versa (<a href="#6.3.2.3">6.3.2.3</a>).
+    -- The size of the result of subtracting two pointers to elements of the same array
+      (<a href="#6.5.6">6.5.6</a>).
+
+[<a name="p507" href="#p507">page 507</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3.8" href="#J.3.8"><b>    J.3.8 Hints</b></a>
+1   -- The extent to which suggestions made by using the register storage-class
+      specifier are effective (<a href="#6.7.1">6.7.1</a>).
+    -- The extent to which suggestions made by using the inline function specifier are
+      effective (<a href="#6.7.4">6.7.4</a>).
+<a name="J.3.9" href="#J.3.9"><b>    J.3.9 Structures, unions, enumerations, and bit-fields</b></a>
+1   -- Whether a ''plain'' int bit-field is treated as a signed int bit-field or as an
+      unsigned int bit-field (<a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.1">6.7.2.1</a>).
+    -- Allowable bit-field types other than _Bool, signed int, and unsigned int
+      (<a href="#6.7.2.1">6.7.2.1</a>).
+    -- Whether a bit-field can straddle a storage-unit boundary (<a href="#6.7.2.1">6.7.2.1</a>).
+    -- The order of allocation of bit-fields within a unit (<a href="#6.7.2.1">6.7.2.1</a>).
+    -- The alignment of non-bit-field members of structures (<a href="#6.7.2.1">6.7.2.1</a>). This should present
+      no problem unless binary data written by one implementation is read by another.
+    -- The integer type compatible with each enumerated type (<a href="#6.7.2.2">6.7.2.2</a>).
+<a name="J.3.10" href="#J.3.10"><b>    J.3.10 Qualifiers</b></a>
+1   -- What constitutes an access to an object that has volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+<a name="J.3.11" href="#J.3.11"><b>    J.3.11 Preprocessing directives</b></a>
+1   -- The locations within #pragma directives where header name preprocessing tokens
+      are recognized (<a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>).
+    -- How sequences in both forms of header names are mapped to headers or external
+      source file names (<a href="#6.4.7">6.4.7</a>).
+    -- Whether the value of a character constant in a constant expression that controls
+      conditional inclusion matches the value of the same character constant in the
+      execution character set (<a href="#6.10.1">6.10.1</a>).
+    -- Whether the value of a single-character character constant in a constant expression
+      that controls conditional inclusion may have a negative value (<a href="#6.10.1">6.10.1</a>).
+    -- The places that are searched for an included &lt; &gt; delimited header, and how the places
+      are specified or the header is identified (<a href="#6.10.2">6.10.2</a>).
+    -- How the named source file is searched for in an included " " delimited header
+      (<a href="#6.10.2">6.10.2</a>).
+    -- The method by which preprocessing tokens (possibly resulting from macro
+      expansion) in a #include directive are combined into a header name (<a href="#6.10.2">6.10.2</a>).
+
+[<a name="p508" href="#p508">page 508</a>] (<a href="#Contents">Contents</a>)
+
+    -- The nesting limit for #include processing (<a href="#6.10.2">6.10.2</a>).
+    -- Whether the # operator inserts a \ character before the \ character that begins a
+      universal character name in a character constant or string literal (<a href="#6.10.3.2">6.10.3.2</a>).
+    -- The behavior on each recognized non-STDC #pragma directive (<a href="#6.10.6">6.10.6</a>).
+    -- The definitions for __DATE__ and __TIME__ when respectively, the date and
+      time of translation are not available (<a href="#6.10.8">6.10.8</a>).
+<a name="J.3.12" href="#J.3.12"><b>    J.3.12 Library functions</b></a>
+1   -- Any library facilities available to a freestanding program, other than the minimal set
+      required by clause 4 (<a href="#5.1.2.1">5.1.2.1</a>).
+    -- The format of the diagnostic printed by the assert macro (<a href="#7.2.1.1">7.2.1.1</a>).
+    -- The representation of the floating-point               status   flags     stored   by   the
+      fegetexceptflag function (<a href="#7.6.2.2">7.6.2.2</a>).
+    -- Whether the feraiseexcept function raises the ''inexact'' floating-point
+      exception in addition to the ''overflow'' or ''underflow'' floating-point exception
+      (<a href="#7.6.2.3">7.6.2.3</a>).
+    -- Strings other than "C" and "" that may be passed as the second argument to the
+      setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+    -- The types defined for float_t and double_t when the value of the
+      FLT_EVAL_METHOD macro is less than 0 (<a href="#7.12">7.12</a>).
+    -- Domain errors for the mathematics functions, other than those required by this
+      International Standard (<a href="#7.12.1">7.12.1</a>).
+    -- The values returned by the mathematics functions on domain errors (<a href="#7.12.1">7.12.1</a>).
+    -- The values returned by the mathematics functions on underflow range errors, whether
+      errno is set to the value of the macro ERANGE when the integer expression
+      math_errhandling &amp; MATH_ERRNO is nonzero, and whether the ''underflow''
+      floating-point exception is raised when the integer expression math_errhandling
+      &amp; MATH_ERREXCEPT is nonzero. (<a href="#7.12.1">7.12.1</a>).
+    -- Whether a domain error occurs or zero is returned when an fmod function has a
+      second argument of zero (<a href="#7.12.10.1">7.12.10.1</a>).
+    -- Whether a domain error occurs or zero is returned when a remainder function has
+      a second argument of zero (<a href="#7.12.10.2">7.12.10.2</a>).
+    -- The base-2 logarithm of the modulus used by the remquo functions in reducing the
+      quotient (<a href="#7.12.10.3">7.12.10.3</a>).
+
+[<a name="p509" href="#p509">page 509</a>] (<a href="#Contents">Contents</a>)
+
+-- Whether a domain error occurs or zero is returned when a remquo function has a
+  second argument of zero (<a href="#7.12.10.3">7.12.10.3</a>).
+-- Whether the equivalent of signal(sig, SIG_DFL); is executed prior to the call
+  of a signal handler, and, if not, the blocking of signals that is performed (<a href="#7.14.1.1">7.14.1.1</a>).
+-- The null pointer constant to which the macro NULL expands (<a href="#7.17">7.17</a>).
+-- Whether the last line of a text stream requires a terminating new-line character
+  (<a href="#7.19.2">7.19.2</a>).
+-- Whether space characters that are written out to a text stream immediately before a
+  new-line character appear when read in (<a href="#7.19.2">7.19.2</a>).
+-- The number of null characters that may be appended to data written to a binary
+  stream (<a href="#7.19.2">7.19.2</a>).
+-- Whether the file position indicator of an append-mode stream is initially positioned at
+  the beginning or end of the file (<a href="#7.19.3">7.19.3</a>).
+-- Whether a write on a text stream causes the associated file to be truncated beyond that
+  point (<a href="#7.19.3">7.19.3</a>).
+-- The characteristics of file buffering (<a href="#7.19.3">7.19.3</a>).
+-- Whether a zero-length file actually exists (<a href="#7.19.3">7.19.3</a>).
+-- The rules for composing valid file names (<a href="#7.19.3">7.19.3</a>).
+-- Whether the same file can be simultaneously open multiple times (<a href="#7.19.3">7.19.3</a>).
+-- The nature and choice of encodings used for multibyte characters in files (<a href="#7.19.3">7.19.3</a>).
+-- The effect of the remove function on an open file (<a href="#7.19.4.1">7.19.4.1</a>).
+-- The effect if a file with the new name exists prior to a call to the rename function
+  (<a href="#7.19.4.2">7.19.4.2</a>).
+-- Whether an open temporary file is removed upon abnormal program termination
+  (<a href="#7.19.4.3">7.19.4.3</a>).
+-- Which changes of mode are permitted (if any), and under what circumstances
+  (<a href="#7.19.5.4">7.19.5.4</a>).
+-- The style used to print an infinity or NaN, and the meaning of any n-char or n-wchar
+  sequence printed for a NaN (<a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+-- The output for %p conversion in the fprintf or fwprintf function (<a href="#7.19.6.1">7.19.6.1</a>,
+  <a href="#7.24.2.1">7.24.2.1</a>).
+-- The interpretation of a - character that is neither the first nor the last character, nor
+    the second where a ^ character is the first, in the scanlist for %[ conversion in the
+   fscanf or fwscanf function (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>).
+
+[<a name="p510" href="#p510">page 510</a>] (<a href="#Contents">Contents</a>)
+
+    -- The set of sequences matched by a %p conversion and the interpretation of the
+      corresponding input item in the fscanf or fwscanf function (<a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>).
+    -- The value to which the macro errno is set by the fgetpos, fsetpos, or ftell
+      functions on failure (<a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.9.4">7.19.9.4</a>).
+    -- The meaning of any n-char or n-wchar sequence in a string representing a NaN that is
+      converted by the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+      function (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
+    -- Whether or not the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+      function sets errno to ERANGE when underflow occurs (<a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>).
+    -- Whether the calloc, malloc, and realloc functions return a null pointer or a
+      pointer to an allocated object when the size requested is zero (<a href="#7.20.3">7.20.3</a>).
+    -- Whether open streams with unwritten buffered data are flushed, open streams are
+      closed, or temporary files are removed when the abort or _Exit function is called
+      (<a href="#7.20.4.1">7.20.4.1</a>, <a href="#7.20.4.4">7.20.4.4</a>).
+    -- The termination status returned to the host environment by the abort, exit, or
+      _Exit function (<a href="#7.20.4.1">7.20.4.1</a>, <a href="#7.20.4.3">7.20.4.3</a>, <a href="#7.20.4.4">7.20.4.4</a>).
+    -- The value returned by the system function when its argument is not a null pointer
+      (<a href="#7.20.4.6">7.20.4.6</a>).
+    -- The local time zone and Daylight Saving Time (<a href="#7.23.1">7.23.1</a>).
+    -- The range and precision of times representable in clock_t and time_t (<a href="#7.23">7.23</a>).
+    -- The era for the clock function (<a href="#7.23.2.1">7.23.2.1</a>).
+    -- The replacement string for the %Z specifier to the strftime, and wcsftime
+      functions in the "C" locale (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+    -- Whether the functions in <a href="#7.12">&lt;math.h&gt;</a> honor the rounding direction mode in an
+      IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.9">F.9</a>).
+<a name="J.3.13" href="#J.3.13"><b>    J.3.13 Architecture</b></a>
+1   -- The values or expressions assigned to the macros specified in the headers
+      <a href="#7.7">&lt;float.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, and <a href="#7.18">&lt;stdint.h&gt;</a> (<a href="#5.2.4.2">5.2.4.2</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>).
+    -- The number, order, and encoding of bytes in any object (when not explicitly specified
+      in this International Standard) (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- The value of the result of the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>).
+
+[<a name="p511" href="#p511">page 511</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.4" href="#J.4"><b>    J.4 Locale-specific behavior</b></a>
+1   The following characteristics of a hosted environment are locale-specific and are required
+    to be documented by the implementation:
+    -- Additional members of the source and execution character sets beyond the basic
+      character set (<a href="#5.2.1">5.2.1</a>).
+    -- The presence, meaning, and representation of additional multibyte characters in the
+      execution character set beyond the basic character set (<a href="#5.2.1.2">5.2.1.2</a>).
+    -- The shift states used for the encoding of multibyte characters (<a href="#5.2.1.2">5.2.1.2</a>).
+    -- The direction of writing of successive printing characters (<a href="#5.2.2">5.2.2</a>).
+    -- The decimal-point character (<a href="#7.1.1">7.1.1</a>).
+    -- The set of printing characters (<a href="#7.4">7.4</a>, <a href="#7.25.2">7.25.2</a>).
+    -- The set of control characters (<a href="#7.4">7.4</a>, <a href="#7.25.2">7.25.2</a>).
+    -- The sets of characters tested for by the isalpha, isblank, islower, ispunct,
+      isspace, isupper, iswalpha, iswblank, iswlower, iswpunct,
+      iswspace, or iswupper functions (<a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+      <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>).
+    -- The native environment (<a href="#7.11.1.1">7.11.1.1</a>).
+    -- Additional subject sequences accepted by the numeric conversion functions (<a href="#7.20.1">7.20.1</a>,
+      <a href="#7.24.4.1">7.24.4.1</a>).
+    -- The collation sequence of the execution character set (<a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.24.4.4.2">7.24.4.4.2</a>).
+    -- The contents of the error message strings set up by the strerror function
+      (<a href="#7.21.6.2">7.21.6.2</a>).
+    -- The formats for time and date (<a href="#7.23.3.5">7.23.3.5</a>, <a href="#7.24.5.1">7.24.5.1</a>).
+    -- Character mappings that are supported by the towctrans function (<a href="#7.25.1">7.25.1</a>).
+    -- Character classifications that are supported by the iswctype function (<a href="#7.25.1">7.25.1</a>).
+
+[<a name="p512" href="#p512">page 512</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.5" href="#J.5"><b>    J.5 Common extensions</b></a>
+1   The following extensions are widely used in many systems, but are not portable to all
+    implementations. The inclusion of any extension that may cause a strictly conforming
+    program to become invalid renders an implementation nonconforming. Examples of such
+    extensions are new keywords, extra library functions declared in standard headers, or
+    predefined macros with names that do not begin with an underscore.
+<a name="J.5.1" href="#J.5.1"><b>    J.5.1 Environment arguments</b></a>
+1   In a hosted environment, the main function receives a third argument, char *envp[],
+    that points to a null-terminated array of pointers to char, each of which points to a string
+    that provides information about the environment for this execution of the program
+    (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<a name="J.5.2" href="#J.5.2"><b>    J.5.2 Specialized identifiers</b></a>
+1   Characters other than the underscore _, letters, and digits, that are not part of the basic
+    source character set (such as the dollar sign $, or characters in national character sets)
+    may appear in an identifier (<a href="#6.4.2">6.4.2</a>).
+<a name="J.5.3" href="#J.5.3"><b>    J.5.3 Lengths and cases of identifiers</b></a>
+1   All characters in identifiers (with or without external linkage) are significant (<a href="#6.4.2">6.4.2</a>).
+<a name="J.5.4" href="#J.5.4"><b>    J.5.4 Scopes of identifiers</b></a>
+1   A function identifier, or the identifier of an object the declaration of which contains the
+    keyword extern, has file scope (<a href="#6.2.1">6.2.1</a>).
+<a name="J.5.5" href="#J.5.5"><b>    J.5.5 Writable string literals</b></a>
+1   String literals are modifiable (in which case, identical string literals should denote distinct
+    objects) (<a href="#6.4.5">6.4.5</a>).
+<a name="J.5.6" href="#J.5.6"><b>    J.5.6 Other arithmetic types</b></a>
+1   Additional arithmetic types, such as __int128 or double double, and their
+    appropriate conversions are defined (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1">6.3.1</a>). Additional floating types may have
+    more range or precision than long double, may be used for evaluating expressions of
+    other floating types, and may be used to define float_t or double_t.
+
+[<a name="p513" href="#p513">page 513</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.5.7" href="#J.5.7"><b>    J.5.7 Function pointer casts</b></a>
+1   A pointer to an object or to void may be cast to a pointer to a function, allowing data to
+    be invoked as a function (<a href="#6.5.4">6.5.4</a>).
+2   A pointer to a function may be cast to a pointer to an object or to void, allowing a
+    function to be inspected or modified (for example, by a debugger) (<a href="#6.5.4">6.5.4</a>).
+<a name="J.5.8" href="#J.5.8"><b>    J.5.8 Extended bit-field types</b></a>
+1   A bit-field may be declared with a type other than _Bool, unsigned int, or
+    signed int, with an appropriate maximum width (<a href="#6.7.2.1">6.7.2.1</a>).
+<a name="J.5.9" href="#J.5.9"><b>    J.5.9 The fortran keyword</b></a>
+1   The fortran function specifier may be used in a function declaration to indicate that
+    calls suitable for FORTRAN should be generated, or that a different representation for the
+    external name is to be generated (<a href="#6.7.4">6.7.4</a>).
+<a name="J.5.10" href="#J.5.10"><b>    J.5.10 The asm keyword</b></a>
+1   The asm keyword may be used to insert assembly language directly into the translator
+    output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
+           asm ( character-string-literal );
+<a name="J.5.11" href="#J.5.11"><b>    J.5.11 Multiple external definitions</b></a>
+1   There may be more than one external definition for the identifier of an object, with or
+    without the explicit use of the keyword extern; if the definitions disagree, or more than
+    one is initialized, the behavior is undefined (<a href="#6.9.2">6.9.2</a>).
+<a name="J.5.12" href="#J.5.12"><b>    J.5.12 Predefined macro names</b></a>
+1   Macro names that do not begin with an underscore, describing the translation and
+    execution environments, are defined by the implementation before translation begins
+    (<a href="#6.10.8">6.10.8</a>).
+<a name="J.5.13" href="#J.5.13"><b>    J.5.13 Floating-point status flags</b></a>
+1   If any floating-point status flags are set on normal termination after all calls to functions
+    registered by the atexit function have been made (see <a href="#7.20.4.3">7.20.4.3</a>), the implementation
+    writes some diagnostics indicating the fact to the stderr stream, if it is still open,
+
+[<a name="p514" href="#p514">page 514</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.5.14" href="#J.5.14"><b>    J.5.14 Extra arguments for signal handlers</b></a>
+1   Handlers for specific signals are called with extra arguments in addition to the signal
+    number (<a href="#7.14.1.1">7.14.1.1</a>).
+<a name="J.5.15" href="#J.5.15"><b>    J.5.15 Additional stream types and file-opening modes</b></a>
+1   Additional mappings from files to streams are supported (<a href="#7.19.2">7.19.2</a>).
+2   Additional file-opening modes may be specified by characters appended to the mode
+    argument of the fopen function (<a href="#7.19.5.3">7.19.5.3</a>).
+<a name="J.5.16" href="#J.5.16"><b>    J.5.16 Defined file position indicator</b></a>
+1   The file position indicator is decremented by each successful call to the ungetc or
+    ungetwc function for a text stream, except if its value was zero before a call (<a href="#7.19.7.11">7.19.7.11</a>,
+<a name="7.24.3.10)" href="#7.24.3.10)"><b>    7.24.3.10).</b></a>
+<a name="J.5.17" href="#J.5.17"><b>    J.5.17 Math error reporting</b></a>
+1   Functions declared in <a href="#7.3">&lt;complex.h&gt;</a> and <a href="#7.12">&lt;math.h&gt;</a> raise SIGFPE to report errors
+    instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
+<a name="7.12)" href="#7.12)"><b>    7.12).</b></a>
+
+[<a name="p515" href="#p515">page 515</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="Bibliography" href="#Bibliography"><b>                                 Bibliography</b></a>
+  1. ''The C Reference Manual'' by Dennis M. Ritchie, a version of which was
+     published in The C Programming Language by Brian W. Kernighan and Dennis
+     M. Ritchie, Prentice-Hall, Inc., (1978). Copyright owned by AT&amp;T.
+  2.   1984 /usr/group Standard by the /usr/group Standards Committee, Santa Clara,
+       California, USA, November 1984.
+  3.   ANSI X3/TR-1-82 (1982), American National Dictionary for Information
+       Processing Systems, Information Processing Systems Technical Report.
+  4.   ANSI/IEEE 754-1985, American National Standard for Binary Floating-Point
+       Arithmetic.
+  5.   ANSI/IEEE 854-1988, American National Standard for Radix-Independent
+       Floating-Point Arithmetic.
+  6.   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems,
+       second edition (previously designated IEC 559:1989).
+  7.   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and
+       symbols for use in the physical sciences and technology.
+  8. ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character set for
+     information interchange.
+  9. ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1:
+     Fundamental terms.
+ 10. ISO 4217:1995, Codes for the representation of currencies and funds.
+ 11. ISO 8601:1988, Data elements and interchange formats -- Information
+     interchange -- Representation of dates and times.
+ 12.   ISO/IEC 9899:1990, Programming languages -- C.
+ 13. ISO/IEC 9899/COR1:1994, Technical Corrigendum 1.
+ 14. ISO/IEC 9899/COR2:1996, Technical Corrigendum 2.
+ 15.   ISO/IEC 9899/AMD1:1995, Amendment 1 to ISO/IEC 9899:1990 C Integrity.
+ 16.   ISO/IEC 9945-2:1993, Information technology -- Portable Operating System
+       Interface (POSIX) -- Part 2: Shell and Utilities.
+ 17.   ISO/IEC TR 10176:1998, Information technology -- Guidelines for the
+       preparation of programming language standards.
+ 18. ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet
+     Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.
+
+[<a name="p516" href="#p516">page 516</a>] (<a href="#Contents">Contents</a>)
+
+ 19. ISO/IEC 10646-1/COR1:1996,      Technical       Corrigendum      1      to
+     ISO/IEC 10646-1:1993.
+ 20. ISO/IEC 10646-1/COR2:1998,      Technical       Corrigendum      2      to
+     ISO/IEC 10646-1:1993.
+ 21.   ISO/IEC 10646-1/AMD1:1996, Amendment 1 to ISO/IEC 10646-1:1993
+       Transformation Format for 16 planes of group 00 (UTF-16).
+ 22.   ISO/IEC 10646-1/AMD2:1996, Amendment 2 to ISO/IEC 10646-1:1993 UCS
+       Transformation Format 8 (UTF-8).
+ 23. ISO/IEC 10646-1/AMD3:1996, Amendment 3 to ISO/IEC 10646-1:1993.
+ 24. ISO/IEC 10646-1/AMD4:1996, Amendment 4 to ISO/IEC 10646-1:1993.
+ 25. ISO/IEC 10646-1/AMD5:1998, Amendment 5 to ISO/IEC 10646-1:1993 Hangul
+     syllables.
+ 26. ISO/IEC 10646-1/AMD6:1997, Amendment 6 to ISO/IEC 10646-1:1993 Tibetan.
+ 27. ISO/IEC 10646-1/AMD7:1997, Amendment 7 to ISO/IEC 10646-1:1993 33
+     additional characters.
+ 28. ISO/IEC 10646-1/AMD8:1997, Amendment 8 to ISO/IEC 10646-1:1993.
+ 29. ISO/IEC 10646-1/AMD9:1997,    Amendment     9   to    ISO/IEC 10646-1:1993
+     Identifiers for characters.
+ 30.   ISO/IEC 10646-1/AMD10:1998, Amendment 10 to ISO/IEC 10646-1:1993
+       Ethiopic.
+ 31. ISO/IEC 10646-1/AMD11:1998, Amendment 11 to ISO/IEC 10646-1:1993
+     Unified Canadian Aboriginal Syllabics.
+ 32. ISO/IEC 10646-1/AMD12:1998, Amendment 12 to ISO/IEC 10646-1:1993
+     Cherokee.
+ 33. ISO/IEC 10967-1:1994, Information technology -- Language independent
+     arithmetic -- Part 1: Integer and floating point arithmetic.
+
+[<a name="p517" href="#p517">page 517</a>] (<a href="#Contents">Contents</a>)
+
+
+[<a name="p518" href="#p518">page 518</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="Index" href="#Index"><b>Index</b></a>
+??? x ???, <a href="#3.18">3.18</a>                                                    , (comma punctuator), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,
+                                                                    <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>
+??? x ???, <a href="#3.19">3.19</a>                                                    - (subtraction operator), <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
+! (logical negation operator), <a href="#6.5.3.3">6.5.3.3</a>                         - (unary minus operator), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
+!= (inequality operator), <a href="#6.5.9">6.5.9</a>                                -- (postfix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
+# operator, <a href="#6.10.3.2">6.10.3.2</a>                                           -- (prefix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
+# preprocessing directive, <a href="#6.10.7">6.10.7</a>                              -= (subtraction assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+# punctuator, <a href="#6.10">6.10</a>                                             -&gt; (structure/union pointer operator), <a href="#6.5.2.3">6.5.2.3</a>
+## operator, <a href="#6.10.3.3">6.10.3.3</a>                                          . (structure/union member operator), <a href="#6.3.2.1">6.3.2.1</a>,
+#define preprocessing directive, <a href="#6.10.3">6.10.3</a>                             <a href="#6.5.2.3">6.5.2.3</a>
+#elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                          . punctuator, <a href="#6.7.8">6.7.8</a>
+#else preprocessing directive, <a href="#6.10.1">6.10.1</a>                          ... (ellipsis punctuator), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>
+#endif preprocessing directive, <a href="#6.10.1">6.10.1</a>                         / (division operator), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
+#error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                      /* */ (comment delimiters), <a href="#6.4.9">6.4.9</a>
+#if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,             // (comment delimiter), <a href="#6.4.9">6.4.9</a>
+     <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             /= (division assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+#ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                         : (colon punctuator), <a href="#6.7.2.1">6.7.2.1</a>
+#ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                        :&gt; (alternative spelling of ]), <a href="#6.4.6">6.4.6</a>
+#include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>,                     ; (semicolon punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
+     <a href="#6.10.2">6.10.2</a>                                                         <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
+#line preprocessing directive, <a href="#6.10.4">6.10.4</a>                          &lt; (less-than operator), <a href="#6.5.8">6.5.8</a>
+#pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>                        &lt;% (alternative spelling of {), <a href="#6.4.6">6.4.6</a>
+#undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,               &lt;: (alternative spelling of [), <a href="#6.4.6">6.4.6</a>
+     <a href="#7.1.4">7.1.4</a>                                                     &lt;&lt; (left-shift operator), <a href="#6.5.7">6.5.7</a>
+% (remainder operator), <a href="#6.5.5">6.5.5</a>                                  &lt;&lt;= (left-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+%: (alternative spelling of #), <a href="#6.4.6">6.4.6</a>                          &lt;= (less-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>
+%:%: (alternative spelling of ##), <a href="#6.4.6">6.4.6</a>                       <a href="#7.2">&lt;assert.h&gt;</a> header, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
+%= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                   <a href="#7.3">&lt;complex.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>,
+%&gt; (alternative spelling of }), <a href="#6.4.6">6.4.6</a>                               <a href="#7.26.1">7.26.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+&amp; (address operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                         <a href="#7.4">&lt;ctype.h&gt;</a> header, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
+&amp; (bitwise AND operator), <a href="#6.5.10">6.5.10</a>                               <a href="#7.5">&lt;errno.h&gt;</a> header, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
+&amp;&amp; (logical AND operator), <a href="#6.5.13">6.5.13</a>                              <a href="#7.6">&lt;fenv.h&gt;</a> header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>,
+&amp;= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                      <a href="#H">H</a>
+' ' (space character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,           <a href="#7.7">&lt;float.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+     <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>                                           <a href="#7.24.4.1.1">7.24.4.1.1</a>
+( ) (cast operator), <a href="#6.5.4">6.5.4</a>                                     <a href="#7.8">&lt;inttypes.h&gt;</a> header, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>
+( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a>                          <a href="#7.9">&lt;iso646.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
+( ) (parentheses punctuator), <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>            <a href="#7.10">&lt;limits.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
+( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                    <a href="#7.11">&lt;locale.h&gt;</a> header, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
+* (asterisk punctuator), <a href="#6.7.5.1">6.7.5.1</a>, <a href="#6.7.5.2">6.7.5.2</a>                      <a href="#7.12">&lt;math.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>,
+* (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                          <a href="#F.9">F.9</a>, <a href="#J.5.17">J.5.17</a>
+* (multiplication operator), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>                 <a href="#7.13">&lt;setjmp.h&gt;</a> header, <a href="#7.13">7.13</a>
+*= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              <a href="#7.14">&lt;signal.h&gt;</a> header, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>
++ (addition operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>,           <a href="#7.15">&lt;stdarg.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>
+     <a href="#G.5.2">G.5.2</a>                                                     <a href="#7.16">&lt;stdbool.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>
++ (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a>                               <a href="#7.17">&lt;stddef.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+++ (postfix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>                    <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>
+++ (prefix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>                <a href="#7.18">&lt;stdint.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>,
++= (addition assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                         <a href="#7.18">7.18</a>, <a href="#7.26.8">7.26.8</a>
+, (comma operator), <a href="#6.5.17">6.5.17</a>
+
+[<a name="p519" href="#p519">page 519</a>] (<a href="#Contents">Contents</a>)
+
+<a href="#7.19">&lt;stdio.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>                 __cplusplus macro, <a href="#6.10.8">6.10.8</a>
+<a href="#7.20">&lt;stdlib.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>               __DATE__ macro, <a href="#6.10.8">6.10.8</a>
+<a href="#7.21">&lt;string.h&gt;</a> header, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>                             __FILE__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#7.2.1.1">7.2.1.1</a>
+<a href="#7.22">&lt;tgmath.h&gt;</a> header, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                 __func__ identifier, <a href="#6.4.2.2">6.4.2.2</a>, <a href="#7.2.1.1">7.2.1.1</a>
+<a href="#7.23">&lt;time.h&gt;</a> header, <a href="#7.23">7.23</a>                                        __LINE__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#7.2.1.1">7.2.1.1</a>
+<a href="#7.24">&lt;wchar.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>,                   __STDC_, <a href="#6.11.9">6.11.9</a>
+     <a href="#7.26.12">7.26.12</a>, <a href="#F">F</a>                                              __STDC__ macro, <a href="#6.10.8">6.10.8</a>
+<a href="#7.25">&lt;wctype.h&gt;</a> header, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>                             __STDC_CONSTANT_MACROS macro, <a href="#7.18.4">7.18.4</a>
+= (equal-sign punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.8">6.7.8</a>               __STDC_FORMAT_MACROS macro, <a href="#7.8.1">7.8.1</a>
+= (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a>                     __STDC_HOSTED__ macro, <a href="#6.10.8">6.10.8</a>
+== (equality operator), <a href="#6.5.9">6.5.9</a>                                __STDC_IEC_559__ macro, <a href="#6.10.8">6.10.8</a>, <a href="#F.1">F.1</a>
+&gt; (greater-than operator), <a href="#6.5.8">6.5.8</a>                             __STDC_IEC_559_COMPLEX__ macro,
+&gt;= (greater-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>                     <a href="#6.10.8">6.10.8</a>, <a href="#G.1">G.1</a>
+&gt;&gt; (right-shift operator), <a href="#6.5.7">6.5.7</a>                             __STDC_ISO_10646__ macro, <a href="#6.10.8">6.10.8</a>
+&gt;&gt;= (right-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              __STDC_LIMIT_MACROS macro, <a href="#7.18.2">7.18.2</a>,
+? : (conditional operator), <a href="#6.5.15">6.5.15</a>                                <a href="#7.18.3">7.18.3</a>
+?? (trigraph sequences), <a href="#5.2.1.1">5.2.1.1</a>                             __STDC_MB_MIGHT_NEQ_WC__ macro,
+[ ] (array subscript operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                  <a href="#6.10.8">6.10.8</a>, <a href="#7.17">7.17</a>
+[ ] (brackets punctuator), <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.8">6.7.8</a>                    __STDC_VERSION__ macro, <a href="#6.10.8">6.10.8</a>
+\ (backslash character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>             __TIME__ macro, <a href="#6.10.8">6.10.8</a>
+\ (escape character), <a href="#6.4.4.4">6.4.4.4</a>                                __VA_ARGS__ identifier, <a href="#6.10.3">6.10.3</a>, <a href="#6.10.3.1">6.10.3.1</a>
+\" (double-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>,                  _Bool type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>, <a href="#6.7.2">6.7.2</a>
+     <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                           _Bool type conversions, <a href="#6.3.1.2">6.3.1.2</a>
+\\ (backslash escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>              _Complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+\' (single-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>            _Complex_I macro, <a href="#7.3.1">7.3.1</a>
+\0 (null character), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                   _Exit function, <a href="#7.20.4.4">7.20.4.4</a>
+  padding of binary stream, <a href="#7.19.2">7.19.2</a>                           _Imaginary keyword, <a href="#G.2">G.2</a>
+\? (question-mark escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                  _Imaginary types, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+\a (alert escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                   _Imaginary_I macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
+\b (backspace escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>               _IOFBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
+\f (form-feed escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,              _IOLBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.6">7.19.5.6</a>
+     <a href="#7.4.1.10">7.4.1.10</a>                                                _IONBF macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
+\n (new-line escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               _Pragma operator, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>
+     <a href="#7.4.1.10">7.4.1.10</a>                                                { } (braces punctuator), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>,
+\octal digits (octal-character escape sequence),                  <a href="#6.8.2">6.8.2</a>
+     <a href="#6.4.4.4">6.4.4.4</a>                                                 { } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>
+\r (carriage-return escape sequence), <a href="#5.2.2">5.2.2</a>,                 | (bitwise inclusive OR operator), <a href="#6.5.12">6.5.12</a>
+     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                       |= (bitwise inclusive OR assignment operator),
+\t (horizontal-tab escape sequence), <a href="#5.2.2">5.2.2</a>,                       <a href="#6.5.16.2">6.5.16.2</a>
+     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>                  || (logical OR operator), <a href="#6.5.14">6.5.14</a>
+\U (universal character names), <a href="#6.4.3">6.4.3</a>                        ~ (bitwise complement operator), <a href="#6.5.3.3">6.5.3.3</a>
+\u (universal character names), <a href="#6.4.3">6.4.3</a>
+\v (vertical-tab escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           abort function, <a href="#7.2.1.1">7.2.1.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.19.3">7.19.3</a>,
+     <a href="#7.4.1.10">7.4.1.10</a>                                                     <a href="#7.20.4.1">7.20.4.1</a>
+\x hexadecimal digits (hexadecimal-character                 abs function, <a href="#7.20.6.1">7.20.6.1</a>
+     escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                               absolute-value functions
+^ (bitwise exclusive OR operator), <a href="#6.5.11">6.5.11</a>                      complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>
+^= (bitwise exclusive OR assignment operator),                 integer, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.20.6.1">7.20.6.1</a>
+     <a href="#6.5.16.2">6.5.16.2</a>                                                  real, <a href="#7.12.7">7.12.7</a>, <a href="#F.9.4">F.9.4</a>
+__bool_true_false_are_defined                               abstract declarator, <a href="#6.7.6">6.7.6</a>
+     macro, <a href="#7.16">7.16</a>                                             abstract machine, <a href="#5.1.2.3">5.1.2.3</a>
+
+[<a name="p520" href="#p520">page 520</a>] (<a href="#Contents">Contents</a>)
+
+access, <a href="#3.1">3.1</a>, <a href="#6.7.3">6.7.3</a>                                             array
+accuracy, see floating-point accuracy                              argument, <a href="#6.9.1">6.9.1</a>
+acos functions, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#F.9.1.1">F.9.1.1</a>                                 declarator, <a href="#6.7.5.2">6.7.5.2</a>
+acos type-generic macro, <a href="#7.22">7.22</a>                                     initialization, <a href="#6.7.8">6.7.8</a>
+acosh functions, <a href="#7.12.5.1">7.12.5.1</a>, <a href="#F.9.2.1">F.9.2.1</a>                                multidimensional, <a href="#6.5.2.1">6.5.2.1</a>
+acosh type-generic macro, <a href="#7.22">7.22</a>                                    parameter, <a href="#6.9.1">6.9.1</a>
+active position, <a href="#5.2.2">5.2.2</a>                                            storage order, <a href="#6.5.2.1">6.5.2.1</a>
+actual argument, <a href="#3.3">3.3</a>                                              subscript operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+actual parameter (deprecated), <a href="#3.3">3.3</a>                                subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+addition assignment operator (+=), <a href="#6.5.16.2">6.5.16.2</a>                       type, <a href="#6.2.5">6.2.5</a>
+addition operator (+), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>,              type conversion, <a href="#6.3.2.1">6.3.2.1</a>
+      <a href="#G.5.2">G.5.2</a>                                                       variable length, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
+additive expressions, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                             arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+address constant, <a href="#6.6">6.6</a>                                          as-if rule, <a href="#5.1.2.3">5.1.2.3</a>
+address operator (&amp;), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                         ASCII code set, <a href="#5.2.1.1">5.2.1.1</a>
+aggregate initialization, <a href="#6.7.8">6.7.8</a>                                asctime function, <a href="#7.23.3.1">7.23.3.1</a>
+aggregate types, <a href="#6.2.5">6.2.5</a>                                         asin functions, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#F.9.1.2">F.9.1.2</a>
+alert escape sequence (\a), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                     asin type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+aliasing, <a href="#6.5">6.5</a>                                                  asinh functions, <a href="#7.12.5.2">7.12.5.2</a>, <a href="#F.9.2.2">F.9.2.2</a>
+alignment, <a href="#3.2">3.2</a>                                                 asinh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+   pointer, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.3">6.3.2.3</a>                                     asm keyword, <a href="#J.5.10">J.5.10</a>
+   structure/union member, <a href="#6.7.2.1">6.7.2.1</a>                             assert macro, <a href="#7.2.1.1">7.2.1.1</a>
+allocated storage, order and contiguity, <a href="#7.20.3">7.20.3</a>                assert.h header, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
+and macro, <a href="#7.9">7.9</a>                                                 assignment
+AND operators                                                     compound, <a href="#6.5.16.2">6.5.16.2</a>
+   bitwise (&amp;), <a href="#6.5.10">6.5.10</a>                                            conversion, <a href="#6.5.16.1">6.5.16.1</a>
+   bitwise assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>                              expression, <a href="#6.5.16">6.5.16</a>
+   logical (&amp;&amp;), <a href="#6.5.13">6.5.13</a>                                           operators, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>
+and_eq macro, <a href="#7.9">7.9</a>                                                 simple, <a href="#6.5.16.1">6.5.16.1</a>
+ANSI/IEEE 754, <a href="#F.1">F.1</a>                                             associativity of operators, <a href="#6.5">6.5</a>
+ANSI/IEEE 854, <a href="#F.1">F.1</a>                                             asterisk punctuator (*), <a href="#6.7.5.1">6.7.5.1</a>, <a href="#6.7.5.2">6.7.5.2</a>
+argc (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>                      atan functions, <a href="#7.12.4.3">7.12.4.3</a>, <a href="#F.9.1.3">F.9.1.3</a>
+argument, <a href="#3.3">3.3</a>                                                  atan type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+   array, <a href="#6.9.1">6.9.1</a>                                                atan2 functions, <a href="#7.12.4.4">7.12.4.4</a>, <a href="#F.9.1.4">F.9.1.4</a>
+   default promotions, <a href="#6.5.2.2">6.5.2.2</a>                                 atan2 type-generic macro, <a href="#7.22">7.22</a>
+   function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>                                    atanh functions, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#F.9.2.3">F.9.2.3</a>
+   macro, substitution, <a href="#6.10.3.1">6.10.3.1</a>                               atanh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+argument, complex, <a href="#7.3.9.1">7.3.9.1</a>                                     atexit function, <a href="#7.20.4.2">7.20.4.2</a>, <a href="#7.20.4.3">7.20.4.3</a>, <a href="#7.20.4.4">7.20.4.4</a>,
+argv (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>                            <a href="#J.5.13">J.5.13</a>
+arithmetic constant expression, <a href="#6.6">6.6</a>                            atof function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.1">7.20.1.1</a>
+arithmetic conversions, usual, see usual arithmetic            atoi function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
+      conversions                                              atol function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
+arithmetic operators                                           atoll function, <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.2">7.20.1.2</a>
+   additive, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                                      auto storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
+   bitwise, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>                             automatic storage duration, <a href="#5.2.3">5.2.3</a>, <a href="#6.2.4">6.2.4</a>
+   increment and decrement, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>
+   multiplicative, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>                                backslash character (\), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+   shift, <a href="#6.5.7">6.5.7</a>                                                backslash escape sequence (\\), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>
+   unary, <a href="#6.5.3.3">6.5.3.3</a>                                              backspace escape sequence (\b), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+arithmetic types, <a href="#6.2.5">6.2.5</a>                                        basic character set, <a href="#3.6">3.6</a>, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>
+arithmetic, pointer, <a href="#6.5.6">6.5.6</a>                                     basic types, <a href="#6.2.5">6.2.5</a>
+
+[<a name="p521" href="#p521">page 521</a>] (<a href="#Contents">Contents</a>)
+
+behavior, <a href="#3.4">3.4</a>                                                  call by value, <a href="#6.5.2.2">6.5.2.2</a>
+binary streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,                   calloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.1">7.20.3.1</a>, <a href="#7.20.3.2">7.20.3.2</a>,
+      <a href="#7.19.9.4">7.19.9.4</a>                                                       <a href="#7.20.3.4">7.20.3.4</a>
+bit, <a href="#3.5">3.5</a>                                                       carg functions, <a href="#7.3.9.1">7.3.9.1</a>, <a href="#G.6">G.6</a>
+   high order, <a href="#3.6">3.6</a>                                             carg type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+   low order, <a href="#3.6">3.6</a>                                              carriage-return escape sequence (\r), <a href="#5.2.2">5.2.2</a>,
+bit-field, <a href="#6.7.2.1">6.7.2.1</a>                                                    <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>
+bitand macro, <a href="#7.9">7.9</a>                                              case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+bitor macro, <a href="#7.9">7.9</a>                                               case mapping functions
+bitwise operators, <a href="#6.5">6.5</a>                                           character, <a href="#7.4.2">7.4.2</a>
+   AND, <a href="#6.5.10">6.5.10</a>                                                   wide character, <a href="#7.25.3.1">7.25.3.1</a>
+   AND assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>                                     extensible, <a href="#7.25.3.2">7.25.3.2</a>
+   complement (~), <a href="#6.5.3.3">6.5.3.3</a>                                     casin functions, <a href="#7.3.5.2">7.3.5.2</a>, <a href="#G.6">G.6</a>
+   exclusive OR, <a href="#6.5.11">6.5.11</a>                                          type-generic macro for, <a href="#7.22">7.22</a>
+   exclusive OR assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                      casinh functions, <a href="#7.3.6.2">7.3.6.2</a>, <a href="#G.6.2.2">G.6.2.2</a>
+   inclusive OR, <a href="#6.5.12">6.5.12</a>                                          type-generic macro for, <a href="#7.22">7.22</a>
+   inclusive OR assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>                      cast expression, <a href="#6.5.4">6.5.4</a>
+   shift, <a href="#6.5.7">6.5.7</a>                                                cast operator (( )), <a href="#6.5.4">6.5.4</a>
+blank character, <a href="#7.4.1.3">7.4.1.3</a>                                       catan functions, <a href="#7.3.5.3">7.3.5.3</a>, <a href="#G.6">G.6</a>
+block, <a href="#6.8">6.8</a>, <a href="#6.8.2">6.8.2</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>                                  type-generic macro for, <a href="#7.22">7.22</a>
+block scope, <a href="#6.2.1">6.2.1</a>                                             catanh functions, <a href="#7.3.6.3">7.3.6.3</a>, <a href="#G.6.2.3">G.6.2.3</a>
+block structure, <a href="#6.2.1">6.2.1</a>                                           type-generic macro for, <a href="#7.22">7.22</a>
+bold type convention, <a href="#6.1">6.1</a>                                      cbrt functions, <a href="#7.12.7.1">7.12.7.1</a>, <a href="#F.9.4.1">F.9.4.1</a>
+bool macro, <a href="#7.16">7.16</a>                                               cbrt type-generic macro, <a href="#7.22">7.22</a>
+boolean type, <a href="#6.3.1.2">6.3.1.2</a>                                          ccos functions, <a href="#7.3.5.4">7.3.5.4</a>, <a href="#G.6">G.6</a>
+boolean type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>                        type-generic macro for, <a href="#7.22">7.22</a>
+braces punctuator ({ }), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>,              ccosh functions, <a href="#7.3.6.4">7.3.6.4</a>, <a href="#G.6.2.4">G.6.2.4</a>
+      <a href="#6.8.2">6.8.2</a>                                                      type-generic macro for, <a href="#7.22">7.22</a>
+brackets operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                      ceil functions, <a href="#7.12.9.1">7.12.9.1</a>, <a href="#F.9.6.1">F.9.6.1</a>
+brackets punctuator ([ ]), <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.8">6.7.8</a>                      ceil type-generic macro, <a href="#7.22">7.22</a>
+branch cuts, <a href="#7.3.3">7.3.3</a>                                             cerf function, <a href="#7.26.1">7.26.1</a>
+break statement, <a href="#6.8.6.3">6.8.6.3</a>                                       cerfc function, <a href="#7.26.1">7.26.1</a>
+broken-down time, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.3">7.23.3</a>,                    cexp functions, <a href="#7.3.7.1">7.3.7.1</a>, <a href="#G.6.3.1">G.6.3.1</a>
+      <a href="#7.23.3.1">7.23.3.1</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>, <a href="#7.23.3.5">7.23.3.5</a>                     type-generic macro for, <a href="#7.22">7.22</a>
+bsearch function, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.1">7.20.5.1</a>                             cexp2 function, <a href="#7.26.1">7.26.1</a>
+btowc function, <a href="#7.24.6.1.1">7.24.6.1.1</a>                                     cexpm1 function, <a href="#7.26.1">7.26.1</a>
+BUFSIZ macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.5">7.19.5.5</a>                         char type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>
+byte, <a href="#3.6">3.6</a>, <a href="#6.5.3.4">6.5.3.4</a>                                             char type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+byte input/output functions, <a href="#7.19.1">7.19.1</a>                                  <a href="#6.3.1.8">6.3.1.8</a>
+byte-oriented stream, <a href="#7.19.2">7.19.2</a>                                   CHAR_BIT macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+                                                               CHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+C program, <a href="#5.1.1.1">5.1.1.1</a>                                             CHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+C++, <a href="#7.8.1">7.8.1</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.18.4">7.18.4</a>                             character, <a href="#3.7">3.7</a>, <a href="#3.7.1">3.7.1</a>
+cabs functions, <a href="#7.3.8.1">7.3.8.1</a>, <a href="#G.6">G.6</a>                                   character array initialization, <a href="#6.7.8">6.7.8</a>
+  type-generic macro for, <a href="#7.22">7.22</a>                                 character case mapping functions, <a href="#7.4.2">7.4.2</a>
+cacos functions, <a href="#7.3.5.1">7.3.5.1</a>, <a href="#G.6.1.1">G.6.1.1</a>                                wide character, <a href="#7.25.3.1">7.25.3.1</a>
+  type-generic macro for, <a href="#7.22">7.22</a>                                       extensible, <a href="#7.25.3.2">7.25.3.2</a>
+cacosh functions, <a href="#7.3.6.1">7.3.6.1</a>, <a href="#G.6.2.1">G.6.2.1</a>                             character classification functions, <a href="#7.4.1">7.4.1</a>
+  type-generic macro for, <a href="#7.22">7.22</a>                                   wide character, <a href="#7.25.2.1">7.25.2.1</a>
+calendar time, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.2">7.23.2.2</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.2.4">7.23.2.4</a>,                 extensible, <a href="#7.25.2.2">7.25.2.2</a>
+     <a href="#7.23.3.2">7.23.3.2</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>                              character constant, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+
+[<a name="p522" href="#p522">page 522</a>] (<a href="#Contents">Contents</a>)
+
+character display semantics, <a href="#5.2.2">5.2.2</a>                            complex.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>, <a href="#7.26.1">7.26.1</a>,
+character handling header, <a href="#7.4">7.4</a>, <a href="#7.11.1.1">7.11.1.1</a>                           <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+character input/output functions, <a href="#7.19.7">7.19.7</a>                      compliance, see conformance
+   wide character, <a href="#7.24.3">7.24.3</a>                                     components of time, <a href="#7.23.1">7.23.1</a>
+character sets, <a href="#5.2.1">5.2.1</a>                                         composite type, <a href="#6.2.7">6.2.7</a>
+character string literal, see string literal                  compound assignment, <a href="#6.5.16.2">6.5.16.2</a>
+character type conversion, <a href="#6.3.1.1">6.3.1.1</a>                            compound literals, <a href="#6.5.2.5">6.5.2.5</a>
+character types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.8">6.7.8</a>                                 compound statement, <a href="#6.8.2">6.8.2</a>
+cimag functions, <a href="#7.3.9.2">7.3.9.2</a>, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                        compound-literal operator (( ){ }), <a href="#6.5.2.5">6.5.2.5</a>
+cimag type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                           concatenation functions
+cis function, <a href="#G.6">G.6</a>                                               string, <a href="#7.21.3">7.21.3</a>
+classification functions                                         wide string, <a href="#7.24.4.3">7.24.4.3</a>
+   character, <a href="#7.4.1">7.4.1</a>                                           concatenation, preprocessing, see preprocessing
+   floating-point, <a href="#7.12.3">7.12.3</a>                                           concatenation
+   wide character, <a href="#7.25.2.1">7.25.2.1</a>                                   conceptual models, <a href="#5.1">5.1</a>
+      extensible, <a href="#7.25.2.2">7.25.2.2</a>                                    conditional inclusion, <a href="#6.10.1">6.10.1</a>
+clearerr function, <a href="#7.19.10.1">7.19.10.1</a>                                  conditional operator (? :), <a href="#6.5.15">6.5.15</a>
+clgamma function, <a href="#7.26.1">7.26.1</a>                                      conformance, <a href="#4">4</a>
+clock function, <a href="#7.23.2.1">7.23.2.1</a>                                      conj functions, <a href="#7.3.9.3">7.3.9.3</a>, <a href="#G.6">G.6</a>
+clock_t type, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.1">7.23.2.1</a>                                conj type-generic macro, <a href="#7.22">7.22</a>
+CLOCKS_PER_SEC macro, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.1">7.23.2.1</a>                        const type qualifier, <a href="#6.7.3">6.7.3</a>
+clog functions, <a href="#7.3.7.2">7.3.7.2</a>, <a href="#G.6.3.2">G.6.3.2</a>                              const-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.7.3">6.7.3</a>
+   type-generic macro for, <a href="#7.22">7.22</a>                               constant expression, <a href="#6.6">6.6</a>, <a href="#F.7.4">F.7.4</a>
+clog10 function, <a href="#7.26.1">7.26.1</a>                                       constants, <a href="#6.4.4">6.4.4</a>
+clog1p function, <a href="#7.26.1">7.26.1</a>                                         as primary expression, <a href="#6.5.1">6.5.1</a>
+clog2 function, <a href="#7.26.1">7.26.1</a>                                          character, <a href="#6.4.4.4">6.4.4.4</a>
+collating sequences, <a href="#5.2.1">5.2.1</a>                                      enumeration, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+colon punctuator (:), <a href="#6.7.2.1">6.7.2.1</a>                                   floating, <a href="#6.4.4.2">6.4.4.2</a>
+comma operator (,), <a href="#6.5.17">6.5.17</a>                                      hexadecimal, <a href="#6.4.4.1">6.4.4.1</a>
+comma punctuator (,), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,             integer, <a href="#6.4.4.1">6.4.4.1</a>
+      <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.8">6.7.8</a>                                            octal, <a href="#6.4.4.1">6.4.4.1</a>
+command processor, <a href="#7.20.4.6">7.20.4.6</a>                                   constraint, <a href="#3.8">3.8</a>, <a href="#4">4</a>
+comment delimiters (/* */ and //), <a href="#6.4.9">6.4.9</a>                      content of structure/union/enumeration, <a href="#6.7.2.3">6.7.2.3</a>
+comments, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.4.9">6.4.9</a>                                 contiguity of allocated storage, <a href="#7.20.3">7.20.3</a>
+common extensions, <a href="#J.5">J.5</a>                                        continue statement, <a href="#6.8.6.2">6.8.6.2</a>
+common initial sequence, <a href="#6.5.2.3">6.5.2.3</a>                              contracted expression, <a href="#6.5">6.5</a>, <a href="#7.12.2">7.12.2</a>, <a href="#F.6">F.6</a>
+common real type, <a href="#6.3.1.8">6.3.1.8</a>                                     control character, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
+common warnings, <a href="#I">I</a>                                            control wide character, <a href="#7.25.2">7.25.2</a>
+comparison functions, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.1">7.20.5.1</a>, <a href="#7.20.5.2">7.20.5.2</a>              conversion, <a href="#6.3">6.3</a>
+   string, <a href="#7.21.4">7.21.4</a>                                               arithmetic operands, <a href="#6.3.1">6.3.1</a>
+   wide string, <a href="#7.24.4.4">7.24.4.4</a>                                        array argument, <a href="#6.9.1">6.9.1</a>                           *
+comparison macros, <a href="#7.12.14">7.12.14</a>                                      array parameter, <a href="#6.9.1">6.9.1</a>
+comparison, pointer, <a href="#6.5.8">6.5.8</a>                                      arrays, <a href="#6.3.2.1">6.3.2.1</a>
+compatible type, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.5">6.7.5</a>                     boolean, <a href="#6.3.1.2">6.3.1.2</a>
+compl macro, <a href="#7.9">7.9</a>                                                boolean, characters, and integers, <a href="#6.3.1.1">6.3.1.1</a>
+complement operator (~), <a href="#6.5.3.3">6.5.3.3</a>                                by assignment, <a href="#6.5.16.1">6.5.16.1</a>
+complex macro, <a href="#7.3.1">7.3.1</a>                                            by return statement, <a href="#6.8.6.4">6.8.6.4</a>
+complex numbers, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>                                       complex types, <a href="#6.3.1.6">6.3.1.6</a>
+complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>                       explicit, <a href="#6.3">6.3</a>
+complex type domain, <a href="#6.2.5">6.2.5</a>                                      function, <a href="#6.3.2.1">6.3.2.1</a>
+complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#G">G</a>                                  function argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+
+[<a name="p523" href="#p523">page 523</a>] (<a href="#Contents">Contents</a>)
+
+  function designators, <a href="#6.3.2.1">6.3.2.1</a>                                type-generic macro for, <a href="#7.22">7.22</a>
+  function parameter, <a href="#6.9.1">6.9.1</a>                                  csinh functions, <a href="#7.3.6.5">7.3.6.5</a>, <a href="#G.6.2.5">G.6.2.5</a>
+  imaginary, <a href="#G.4.1">G.4.1</a>                                             type-generic macro for, <a href="#7.22">7.22</a>
+  imaginary and complex, <a href="#G.4.3">G.4.3</a>                               csqrt functions, <a href="#7.3.8.3">7.3.8.3</a>, <a href="#G.6.4.2">G.6.4.2</a>
+  implicit, <a href="#6.3">6.3</a>                                                type-generic macro for, <a href="#7.22">7.22</a>
+  lvalues, <a href="#6.3.2.1">6.3.2.1</a>                                           ctan functions, <a href="#7.3.5.6">7.3.5.6</a>, <a href="#G.6">G.6</a>
+  pointer, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                                    type-generic macro for, <a href="#7.22">7.22</a>
+  real and complex, <a href="#6.3.1.7">6.3.1.7</a>                                  ctanh functions, <a href="#7.3.6.6">7.3.6.6</a>, <a href="#G.6.2.6">G.6.2.6</a>
+  real and imaginary, <a href="#G.4.2">G.4.2</a>                                    type-generic macro for, <a href="#7.22">7.22</a>
+  real floating and integer, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                ctgamma function, <a href="#7.26.1">7.26.1</a>
+  real floating types, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#F.3">F.3</a>                           ctime function, <a href="#7.23.3.2">7.23.3.2</a>
+  signed and unsigned integers, <a href="#6.3.1.3">6.3.1.3</a>                      ctype.h header, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
+  usual arithmetic, see usual arithmetic                     current object, <a href="#6.7.8">6.7.8</a>
+        conversions                                          CX_LIMITED_RANGE pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.3.4">7.3.4</a>
+  void type, <a href="#6.3.2.2">6.3.2.2</a>
+conversion functions                                         data stream, see streams
+  multibyte/wide character, <a href="#7.20.7">7.20.7</a>                           date and time header, <a href="#7.23">7.23</a>
+     extended, <a href="#7.24.6">7.24.6</a>                                        Daylight Saving Time, <a href="#7.23.1">7.23.1</a>
+     restartable, <a href="#7.24.6.3">7.24.6.3</a>                                   DBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  multibyte/wide string, <a href="#7.20.8">7.20.8</a>                              DBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+     restartable, <a href="#7.24.6.4">7.24.6.4</a>                                   DBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  numeric, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>                                   DBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+     wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1">7.24.4.1</a>                          DBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  single byte/wide character, <a href="#7.24.6.1">7.24.6.1</a>                       DBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  time, <a href="#7.23.3">7.23.3</a>                                               DBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+     wide character, <a href="#7.24.5">7.24.5</a>                                  DBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+conversion specifier, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>,           DBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+     <a href="#7.24.2.2">7.24.2.2</a>                                                decimal constant, <a href="#6.4.4.1">6.4.4.1</a>
+conversion state, <a href="#7.20.7">7.20.7</a>, <a href="#7.24.6">7.24.6</a>, <a href="#7.24.6.2.1">7.24.6.2.1</a>,                decimal digit, <a href="#5.2.1">5.2.1</a>
+     <a href="#7.24.6.3">7.24.6.3</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4">7.24.6.4</a>,             decimal-point character, <a href="#7.1.1">7.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+     <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                  DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+conversion state functions, <a href="#7.24.6.2">7.24.6.2</a>                              <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.5">F.5</a>
+copying functions                                            declaration specifiers, <a href="#6.7">6.7</a>
+  string, <a href="#7.21.2">7.21.2</a>                                             declarations, <a href="#6.7">6.7</a>
+  wide string, <a href="#7.24.4.2">7.24.4.2</a>                                        function, <a href="#6.7.5.3">6.7.5.3</a>
+copysign functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#7.12.11.1">7.12.11.1</a>, <a href="#F.3">F.3</a>,                   pointer, <a href="#6.7.5.1">6.7.5.1</a>
+     <a href="#F.9.8.1">F.9.8.1</a>                                                   structure/union, <a href="#6.7.2.1">6.7.2.1</a>
+copysign type-generic macro, <a href="#7.22">7.22</a>                              typedef, <a href="#6.7.7">6.7.7</a>
+correctly rounded result, <a href="#3.9">3.9</a>                                declarator, <a href="#6.7.5">6.7.5</a>
+corresponding real type, <a href="#6.2.5">6.2.5</a>                                 abstract, <a href="#6.7.6">6.7.6</a>
+cos functions, <a href="#7.12.4.5">7.12.4.5</a>, <a href="#F.9.1.5">F.9.1.5</a>                             declarator type derivation, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.5">6.7.5</a>
+cos type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            decrement operators, see arithmetic operators,
+cosh functions, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#F.9.2.4">F.9.2.4</a>                                 increment and decrement
+cosh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                           default argument promotions, <a href="#6.5.2.2">6.5.2.2</a>
+cpow functions, <a href="#7.3.8.2">7.3.8.2</a>, <a href="#G.6.4.1">G.6.4.1</a>                             default initialization, <a href="#6.7.8">6.7.8</a>
+  type-generic macro for, <a href="#7.22">7.22</a>                               default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+cproj functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                                define preprocessing directive, <a href="#6.10.3">6.10.3</a>
+cproj type-generic macro, <a href="#7.22">7.22</a>                               defined operator, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.8">6.10.8</a>
+creal functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                definition, <a href="#6.7">6.7</a>
+creal type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            function, <a href="#6.9.1">6.9.1</a>
+csin functions, <a href="#7.3.5.5">7.3.5.5</a>, <a href="#G.6">G.6</a>                                 derived declarator types, <a href="#6.2.5">6.2.5</a>
+
+[<a name="p524" href="#p524">page 524</a>] (<a href="#Contents">Contents</a>)
+
+derived types, <a href="#6.2.5">6.2.5</a>                                            end-of-file indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,
+designated initializer, <a href="#6.7.8">6.7.8</a>                                         <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,
+destringizing, <a href="#6.10.9">6.10.9</a>                                                 <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.10.1">7.19.10.1</a>, <a href="#7.19.10.2">7.19.10.2</a>, <a href="#7.24.3.1">7.24.3.1</a>,
+device input/output, <a href="#5.1.2.3">5.1.2.3</a>                                          <a href="#7.24.3.10">7.24.3.10</a>
+diagnostic message, <a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>                               end-of-file macro, see EOF macro
+diagnostics, <a href="#5.1.1.3">5.1.1.3</a>                                            end-of-line indicator, <a href="#5.2.1">5.2.1</a>
+diagnostics header, <a href="#7.2">7.2</a>                                         endif preprocessing directive, <a href="#6.10.1">6.10.1</a>
+difftime function, <a href="#7.23.2.2">7.23.2.2</a>                                     enum type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.2">6.7.2.2</a>
+digit, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                               enumerated type, <a href="#6.2.5">6.2.5</a>
+digraphs, <a href="#6.4.6">6.4.6</a>                                                 enumeration, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.2">6.7.2.2</a>
+direct input/output functions, <a href="#7.19.8">7.19.8</a>                           enumeration constant, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+display device, <a href="#5.2.2">5.2.2</a>                                           enumeration content, <a href="#6.7.2.3">6.7.2.3</a>
+div function, <a href="#7.20.6.2">7.20.6.2</a>                                          enumeration members, <a href="#6.7.2.2">6.7.2.2</a>
+div_t type, <a href="#7.20">7.20</a>                                                enumeration specifiers, <a href="#6.7.2.2">6.7.2.2</a>
+division assignment operator (/=), <a href="#6.5.16.2">6.5.16.2</a>                     enumeration tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+division operator (/), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>                        enumerator, <a href="#6.7.2.2">6.7.2.2</a>
+do statement, <a href="#6.8.5.2">6.8.5.2</a>                                           environment, <a href="#5">5</a>
+documentation of implementation, <a href="#4">4</a>                              environment functions, <a href="#7.20.4">7.20.4</a>
+domain error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#7.12.4.4">7.12.4.4</a>,             environment list, <a href="#7.20.4.5">7.20.4.5</a>
+      <a href="#7.12.5.1">7.12.5.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.7">7.12.6.7</a>,                   environmental considerations, <a href="#5.2">5.2</a>
+      <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>,                 environmental limits, <a href="#5.2.4">5.2.4</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.19.2">7.19.2</a>,
+      <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>,                         <a href="#7.19.3">7.19.3</a>, <a href="#7.19.4.4">7.19.4.4</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.20.2.1">7.20.2.1</a>, <a href="#7.20.4.2">7.20.4.2</a>,
+      <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>                       <a href="#7.24.2.1">7.24.2.1</a>
+dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                       EOF macro, <a href="#7.4">7.4</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.1">7.19.5.1</a>, <a href="#7.19.5.2">7.19.5.2</a>,
+double _Complex type, <a href="#6.2.5">6.2.5</a>                                           <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.11">7.19.6.11</a>,
+double _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                             <a href="#7.19.6.14">7.19.6.14</a>, <a href="#7.19.7.1">7.19.7.1</a>, <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.4">7.19.7.4</a>,
+      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                                <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.7.10">7.19.7.10</a>,
+double _Imaginary type, <a href="#G.2">G.2</a>                                           <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.2.4">7.24.2.4</a>,
+double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.2">7.19.6.2</a>,                         <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.2.12">7.24.2.12</a>,
+      <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.2">F.2</a>                                                   <a href="#7.24.3.4">7.24.3.4</a>, <a href="#7.24.6.1.1">7.24.6.1.1</a>, <a href="#7.24.6.1.2">7.24.6.1.2</a>
+double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,              equal-sign punctuator (=), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.8">6.7.8</a>
+      <a href="#6.3.1.8">6.3.1.8</a>                                                   equal-to operator, see equality operator
+double-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                            equality expressions, <a href="#6.5.9">6.5.9</a>
+double-quote escape sequence (\"), <a href="#6.4.4.4">6.4.4.4</a>,                     equality operator (==), <a href="#6.5.9">6.5.9</a>
+      <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                             ERANGE macro, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.12.1">7.12.1</a>,
+double_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                            <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, see
+                                                                      also range error
+EDOM macro, <a href="#7.5">7.5</a>, <a href="#7.12.1">7.12.1</a>, see also domain error                  erf functions, <a href="#7.12.8.1">7.12.8.1</a>, <a href="#F.9.5.1">F.9.5.1</a>
+effective type, <a href="#6.5">6.5</a>                                             erf type-generic macro, <a href="#7.22">7.22</a>
+EILSEQ macro, <a href="#7.5">7.5</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>,                  erfc functions, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#F.9.5.2">F.9.5.2</a>
+      <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>,           erfc type-generic macro, <a href="#7.22">7.22</a>
+      see also encoding error                                   errno macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.3.2">7.3.2</a>, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>,
+element type, <a href="#6.2.5">6.2.5</a>                                                   <a href="#7.12.1">7.12.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.10.4">7.19.10.4</a>,
+elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                                  <a href="#7.20.1">7.20.1</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.24.3.1">7.24.3.1</a>,
+ellipsis punctuator (...), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>                   <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>,
+else preprocessing directive, <a href="#6.10.1">6.10.1</a>                                  <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>, <a href="#J.5.17">J.5.17</a>
+else statement, <a href="#6.8.4.1">6.8.4.1</a>                                         errno.h header, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
+empty statement, <a href="#6.8.3">6.8.3</a>                                          error
+encoding error, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>,                        domain, see domain error
+      <a href="#7.24.6.3.2">7.24.6.3.2</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.1">7.24.6.4.1</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>               encoding, see encoding error
+end-of-file, <a href="#7.24.1">7.24.1</a>                                                 range, see range error
+
+[<a name="p525" href="#p525">page 525</a>] (<a href="#Contents">Contents</a>)
+
+error conditions, <a href="#7.12.1">7.12.1</a>                                     extended characters, <a href="#5.2.1">5.2.1</a>
+error functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.9.5">F.9.5</a>                               extended integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>,
+error indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,                      <a href="#7.18">7.18</a>
+      <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.8">7.19.7.8</a>,                extended multibyte/wide character conversion
+      <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.10.1">7.19.10.1</a>, <a href="#7.19.10.3">7.19.10.3</a>,                   utilities, <a href="#7.24.6">7.24.6</a>
+      <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>                                     extensible wide character case mapping functions,
+error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                          <a href="#7.25.3.2">7.25.3.2</a>
+error-handling functions, <a href="#7.19.10">7.19.10</a>, <a href="#7.21.6.2">7.21.6.2</a>                  extensible wide character classification functions,
+escape character (\), <a href="#6.4.4.4">6.4.4.4</a>                                     <a href="#7.25.2.2">7.25.2.2</a>
+escape sequences, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.11.4">6.11.4</a>              extern storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.7.1">6.7.1</a>
+evaluation format, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#7.12">7.12</a>                  external definition, <a href="#6.9">6.9</a>
+evaluation method, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#F.7.5">F.7.5</a>                     external identifiers, underscore, <a href="#7.1.3">7.1.3</a>
+evaluation order, <a href="#6.5">6.5</a>                                        external linkage, <a href="#6.2.2">6.2.2</a>
+exceptional condition, <a href="#6.5">6.5</a>, <a href="#7.12.1">7.12.1</a>                           external name, <a href="#6.4.2.1">6.4.2.1</a>
+excess precision, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>,               external object definitions, <a href="#6.9.2">6.9.2</a>
+      <a href="#6.8.6.4">6.8.6.4</a>
+excess range, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>           fabs functions, <a href="#7.12.7.2">7.12.7.2</a>, <a href="#F.9.4.2">F.9.4.2</a>
+exclusive OR operators                                       fabs type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+   bitwise (^), <a href="#6.5.11">6.5.11</a>                                       false macro, <a href="#7.16">7.16</a>
+   bitwise assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                         fclose function, <a href="#7.19.5.1">7.19.5.1</a>
+executable program, <a href="#5.1.1.1">5.1.1.1</a>                                  fdim functions, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#F.9.9.1">F.9.9.1</a>
+execution character set, <a href="#5.2.1">5.2.1</a>                               fdim type-generic macro, <a href="#7.22">7.22</a>
+execution environment, <a href="#5">5</a>, <a href="#5.1.2">5.1.2</a>, see also                    FE_ALL_EXCEPT macro, <a href="#7.6">7.6</a>
+      environmental limits                                   FE_DFL_ENV macro, <a href="#7.6">7.6</a>
+execution sequence, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.8">6.8</a>                             FE_DIVBYZERO macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+exit function, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>,            FE_DOWNWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+      <a href="#7.20.4.4">7.20.4.4</a>                                               FE_INEXACT macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+EXIT_FAILURE macro, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>                           FE_INVALID macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+EXIT_SUCCESS macro, <a href="#7.20">7.20</a>, <a href="#7.20.4.3">7.20.4.3</a>                           FE_OVERFLOW macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+exp functions, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#F.9.3.1">F.9.3.1</a>                             FE_TONEAREST macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+exp type-generic macro, <a href="#7.22">7.22</a>                                 FE_TOWARDZERO macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+exp2 functions, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#F.9.3.2">F.9.3.2</a>                            FE_UNDERFLOW macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+exp2 type-generic macro, <a href="#7.22">7.22</a>                                FE_UPWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+explicit conversion, <a href="#6.3">6.3</a>                                     feclearexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.1">7.6.2.1</a>, <a href="#F.3">F.3</a>
+expm1 functions, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#F.9.3.3">F.9.3.3</a>                           fegetenv function, <a href="#7.6.4.1">7.6.4.1</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
+expm1 type-generic macro, <a href="#7.22">7.22</a>                               fegetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.2">7.6.2.2</a>, <a href="#F.3">F.3</a>
+exponent part, <a href="#6.4.4.2">6.4.4.2</a>                                       fegetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.1">7.6.3.1</a>, <a href="#F.3">F.3</a>
+exponential functions                                        feholdexcept function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.3">7.6.4.3</a>,
+   complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>                                        <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
+   real, <a href="#7.12.6">7.12.6</a>, <a href="#F.9.3">F.9.3</a>                                       fenv.h header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>
+expression, <a href="#6.5">6.5</a>                                              FENV_ACCESS pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#F.7">F.7</a>, <a href="#F.8">F.8</a>,
+   assignment, <a href="#6.5.16">6.5.16</a>                                           <a href="#F.9">F.9</a>
+   cast, <a href="#6.5.4">6.5.4</a>                                               fenv_t type, <a href="#7.6">7.6</a>
+   constant, <a href="#6.6">6.6</a>                                             feof function, <a href="#7.19.10.2">7.19.10.2</a>
+   full, <a href="#6.8">6.8</a>                                                 feraiseexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.3">7.6.2.3</a>, <a href="#F.3">F.3</a>
+   order of evaluation, <a href="#6.5">6.5</a>                                  ferror function, <a href="#7.19.10.3">7.19.10.3</a>
+   parenthesized, <a href="#6.5.1">6.5.1</a>                                      fesetenv function, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#F.3">F.3</a>
+   primary, <a href="#6.5.1">6.5.1</a>                                            fesetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.4">7.6.2.4</a>, <a href="#F.3">F.3</a>
+   unary, <a href="#6.5.3">6.5.3</a>                                              fesetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.2">7.6.3.2</a>, <a href="#F.3">F.3</a>
+expression statement, <a href="#6.8.3">6.8.3</a>                                  fetestexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.5">7.6.2.5</a>, <a href="#F.3">F.3</a>
+extended character set, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.1.2">5.2.1.2</a>                feupdateenv function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>
+
+[<a name="p526" href="#p526">page 526</a>] (<a href="#Contents">Contents</a>)
+
+fexcept_t type, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                      floating-point status flag, <a href="#7.6">7.6</a>, <a href="#F.7.6">F.7.6</a>
+fflush function, <a href="#7.19.5.2">7.19.5.2</a>, <a href="#7.19.5.3">7.19.5.3</a>                           floor functions, <a href="#7.12.9.2">7.12.9.2</a>, <a href="#F.9.6.2">F.9.6.2</a>
+fgetc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.7.1">7.19.7.1</a>,                     floor type-generic macro, <a href="#7.22">7.22</a>
+     <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.8.1">7.19.8.1</a>                                       FLT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+fgetpos function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>                  FLT_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+fgets function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.2">7.19.7.2</a>                              FLT_EVAL_METHOD macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.8.6.4">6.8.6.4</a>,
+fgetwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.1">7.24.3.1</a>,                         <a href="#7.12">7.12</a>
+     <a href="#7.24.3.6">7.24.3.6</a>                                                 FLT_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+fgetws function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.2">7.24.3.2</a>                             FLT_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+field width, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>                                FLT_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+file, <a href="#7.19.3">7.19.3</a>                                                   FLT_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  access functions, <a href="#7.19.5">7.19.5</a>                                    FLT_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  name, <a href="#7.19.3">7.19.3</a>                                                FLT_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  operations, <a href="#7.19.4">7.19.4</a>                                          FLT_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  position indicator, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>,                 FLT_RADIX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+        <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.1">7.19.7.1</a>, <a href="#7.19.7.3">7.19.7.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                   <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.4.1.1">7.24.4.1.1</a>
+        <a href="#7.19.8.1">7.19.8.1</a>, <a href="#7.19.8.2">7.19.8.2</a>, <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.2">7.19.9.2</a>,               FLT_ROUNDS macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+        <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.19.9.4">7.19.9.4</a>, <a href="#7.19.9.5">7.19.9.5</a>, <a href="#7.24.3.1">7.24.3.1</a>,               fma functions, <a href="#7.12">7.12</a>, <a href="#7.12.13.1">7.12.13.1</a>, <a href="#F.9.10.1">F.9.10.1</a>
+        <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.3.10">7.24.3.10</a>                                   fma type-generic macro, <a href="#7.22">7.22</a>
+  positioning functions, <a href="#7.19.9">7.19.9</a>                               fmax functions, <a href="#7.12.12.2">7.12.12.2</a>, <a href="#F.9.9.2">F.9.9.2</a>
+file scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.9">6.9</a>                                         fmax type-generic macro, <a href="#7.22">7.22</a>
+FILE type, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                                     fmin functions, <a href="#7.12.12.3">7.12.12.3</a>, <a href="#F.9.9.3">F.9.9.3</a>
+FILENAME_MAX macro, <a href="#7.19.1">7.19.1</a>                                    fmin type-generic macro, <a href="#7.22">7.22</a>
+flags, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>                                      fmod functions, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#F.9.7.1">F.9.7.1</a>
+  floating-point status, see floating-point status              fmod type-generic macro, <a href="#7.22">7.22</a>
+        flag                                                   fopen function, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.5.4">7.19.5.4</a>
+flexible array member, <a href="#6.7.2.1">6.7.2.1</a>                                 FOPEN_MAX macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.4.3">7.19.4.3</a>
+float _Complex type, <a href="#6.2.5">6.2.5</a>                                    for statement, <a href="#6.8.5">6.8.5</a>, <a href="#6.8.5.3">6.8.5.3</a>
+float _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                      form-feed character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+     <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                         form-feed escape sequence (\f), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+float _Imaginary type, <a href="#G.2">G.2</a>                                         <a href="#7.4.1.10">7.4.1.10</a>
+float type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.2">F.2</a>                        formal argument (deprecated), <a href="#3.15">3.15</a>
+float type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,             formal parameter, <a href="#3.15">3.15</a>
+     <a href="#6.3.1.8">6.3.1.8</a>                                                  formatted input/output functions, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.19.6">7.19.6</a>
+float.h header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,                     wide character, <a href="#7.24.2">7.24.2</a>
+     <a href="#7.24.4.1.1">7.24.4.1.1</a>                                               fortran keyword, <a href="#J.5.9">J.5.9</a>
+float_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                     forward reference, <a href="#3.11">3.11</a>
+floating constant, <a href="#6.4.4.2">6.4.4.2</a>                                     FP_CONTRACT pragma, <a href="#6.5">6.5</a>, <a href="#6.10.6">6.10.6</a>, <a href="#7.12.2">7.12.2</a>, see
+floating suffix, f or <a href="#F">F</a>, <a href="#6.4.4.2">6.4.4.2</a>                                     also contracted expression
+floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,           FP_FAST_FMA macro, <a href="#7.12">7.12</a>
+     <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                                 FP_FAST_FMAF macro, <a href="#7.12">7.12</a>
+floating types, <a href="#6.2.5">6.2.5</a>, <a href="#6.11.1">6.11.1</a>                                  FP_FAST_FMAL macro, <a href="#7.12">7.12</a>
+floating-point accuracy, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.5">6.5</a>,              FP_ILOGB0 macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
+     <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.5">F.5</a>, see also contracted expression            FP_ILOGBNAN macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
+floating-point arithmetic functions, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                 FP_INFINITE macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+floating-point classification functions, <a href="#7.12.3">7.12.3</a>                 FP_NAN macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+floating-point control mode, <a href="#7.6">7.6</a>, <a href="#F.7.6">F.7.6</a>                        FP_NORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+floating-point environment, <a href="#7.6">7.6</a>, <a href="#F.7">F.7</a>, <a href="#F.7.6">F.7.6</a>                    FP_SUBNORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+floating-point exception, <a href="#7.6">7.6</a>, <a href="#7.6.2">7.6.2</a>, <a href="#F.9">F.9</a>                      FP_ZERO macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+floating-point number, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.2.5">6.2.5</a>                        fpclassify macro, <a href="#7.12.3.1">7.12.3.1</a>, <a href="#F.3">F.3</a>
+floating-point rounding mode, <a href="#5.2.4.2.2">5.2.4.2.2</a>                        fpos_t type, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>
+
+[<a name="p527" href="#p527">page 527</a>] (<a href="#Contents">Contents</a>)
+
+fprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.1">7.19.6.1</a>,                       language, <a href="#6.11">6.11</a>
+      <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.5">7.19.6.5</a>, <a href="#7.19.6.6">7.19.6.6</a>,                    library, <a href="#7.26">7.26</a>
+      <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.3">F.3</a>                                  fwide function, <a href="#7.19.2">7.19.2</a>, <a href="#7.24.3.5">7.24.3.5</a>
+fputc function, <a href="#5.2.2">5.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.7.3">7.19.7.3</a>,               fwprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,
+      <a href="#7.19.7.8">7.19.7.8</a>, <a href="#7.19.8.2">7.19.8.2</a>                                            <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.2.3">7.24.2.3</a>, <a href="#7.24.2.5">7.24.2.5</a>,
+fputs function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.4">7.19.7.4</a>                                    <a href="#7.24.2.11">7.24.2.11</a>
+fputwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.24.3.3">7.24.3.3</a>,                     fwrite function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.8.2">7.19.8.2</a>
+      <a href="#7.24.3.8">7.24.3.8</a>                                                 fwscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.2">7.24.2.2</a>,
+fputws function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.4">7.24.3.4</a>                                   <a href="#7.24.2.4">7.24.2.4</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.12">7.24.2.12</a>, <a href="#7.24.3.10">7.24.3.10</a>
+fread function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.8.1">7.19.8.1</a>
+free function, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>                              gamma functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.9.5">F.9.5</a>
+freestanding execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>,                  general utilities, <a href="#7.20">7.20</a>
+      <a href="#5.1.2.1">5.1.2.1</a>                                                    wide string, <a href="#7.24.4">7.24.4</a>
+freopen function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.4">7.19.5.4</a>                             general wide string utilities, <a href="#7.24.4">7.24.4</a>
+frexp functions, <a href="#7.12.6.4">7.12.6.4</a>, <a href="#F.9.3.4">F.9.3.4</a>                             generic parameters, <a href="#7.22">7.22</a>
+frexp type-generic macro, <a href="#7.22">7.22</a>                                 getc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.5">7.19.7.5</a>, <a href="#7.19.7.6">7.19.7.6</a>
+fscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                      getchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.6">7.19.7.6</a>
+      <a href="#7.19.6.4">7.19.6.4</a>, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#F.3">F.3</a>                        getenv function, <a href="#7.20.4.5">7.20.4.5</a>
+fseek function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                   gets function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.26.9">7.26.9</a>
+      <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>, <a href="#7.19.9.5">7.19.9.5</a>, <a href="#7.24.3.10">7.24.3.10</a>                  getwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.6">7.24.3.6</a>, <a href="#7.24.3.7">7.24.3.7</a>
+fsetpos function, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>,                 getwchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.7">7.24.3.7</a>
+      <a href="#7.19.9.1">7.19.9.1</a>, <a href="#7.19.9.3">7.19.9.3</a>, <a href="#7.24.3.10">7.24.3.10</a>                            gmtime function, <a href="#7.23.3.3">7.23.3.3</a>
+ftell function, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>                             goto statement, <a href="#6.2.1">6.2.1</a>, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.6.1">6.8.6.1</a>
+full declarator, <a href="#6.7.5">6.7.5</a>                                         graphic characters, <a href="#5.2.1">5.2.1</a>
+full expression, <a href="#6.8">6.8</a>                                           greater-than operator (&gt;), <a href="#6.5.8">6.5.8</a>
+fully buffered stream, <a href="#7.19.3">7.19.3</a>                                  greater-than-or-equal-to operator (&gt;=), <a href="#6.5.8">6.5.8</a>
+function
+   argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>                                    header, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.2">7.1.2</a>, see also standard headers
+   body, <a href="#6.9.1">6.9.1</a>                                                 header names, <a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>, <a href="#6.10.2">6.10.2</a>
+   call, <a href="#6.5.2.2">6.5.2.2</a>                                               hexadecimal constant, <a href="#6.4.4.1">6.4.4.1</a>
+      library, <a href="#7.1.4">7.1.4</a>                                           hexadecimal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+   declarator, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.11.6">6.11.6</a>                                 hexadecimal prefix, <a href="#6.4.4.1">6.4.4.1</a>
+   definition, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.7">6.11.7</a>                           hexadecimal-character escape sequence
+   designator, <a href="#6.3.2.1">6.3.2.1</a>                                              (\x hexadecimal digits), <a href="#6.4.4.4">6.4.4.4</a>
+   image, <a href="#5.2.3">5.2.3</a>                                                high-order bit, <a href="#3.6">3.6</a>
+   library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.4">7.1.4</a>                                     horizontal-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+   name length, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                       horizontal-tab escape sequence (\r), <a href="#7.25.2.1.3">7.25.2.1.3</a>
+   parameter, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>                   horizontal-tab escape sequence (\t), <a href="#5.2.2">5.2.2</a>,
+   prototype, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.7">6.2.7</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>,                <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>
+         <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.6">6.11.6</a>, <a href="#6.11.7">6.11.7</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.12">7.12</a>           hosted execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.2">5.1.2.2</a>
+   prototype scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.7.5.2">6.7.5.2</a>                             HUGE_VAL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+   recursive call, <a href="#6.5.2.2">6.5.2.2</a>                                          <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
+   return, <a href="#6.8.6.4">6.8.6.4</a>                                             HUGE_VALF macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+   scope, <a href="#6.2.1">6.2.1</a>                                                     <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
+   type, <a href="#6.2.5">6.2.5</a>                                                 HUGE_VALL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+   type conversion, <a href="#6.3.2.1">6.3.2.1</a>                                         <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#F.9">F.9</a>
+function specifiers, <a href="#6.7.4">6.7.4</a>                                      hyperbolic functions
+function type, <a href="#6.2.5">6.2.5</a>                                             complex, <a href="#7.3.6">7.3.6</a>, <a href="#G.6.2">G.6.2</a>
+function-call operator (( )), <a href="#6.5.2.2">6.5.2.2</a>                            real, <a href="#7.12.5">7.12.5</a>, <a href="#F.9.2">F.9.2</a>
+function-like macro, <a href="#6.10.3">6.10.3</a>                                    hypot functions, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#F.9.4.3">F.9.4.3</a>
+future directions                                              hypot type-generic macro, <a href="#7.22">7.22</a>
+
+[<a name="p528" href="#p528">page 528</a>] (<a href="#Contents">Contents</a>)
+
+I macro, <a href="#7.3.1">7.3.1</a>, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>                                    initial position, <a href="#5.2.2">5.2.2</a>
+identifier, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.5.1">6.5.1</a>                                       initial shift state, <a href="#5.2.1.2">5.2.1.2</a>
+   linkage, see linkage                                         initialization, <a href="#5.1.2">5.1.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.5">6.5.2.5</a>, <a href="#6.7.8">6.7.8</a>,
+  maximum length, <a href="#6.4.2.1">6.4.2.1</a>                                             <a href="#F.7.5">F.7.5</a>
+   name spaces, <a href="#6.2.3">6.2.3</a>                                              in blocks, <a href="#6.8">6.8</a>
+   reserved, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>                                       initializer, <a href="#6.7.8">6.7.8</a>
+  scope, <a href="#6.2.1">6.2.1</a>                                                     permitted form, <a href="#6.6">6.6</a>
+   type, <a href="#6.2.5">6.2.5</a>                                                     string literal, <a href="#6.3.2.1">6.3.2.1</a>
+identifier list, <a href="#6.7.5">6.7.5</a>                                           inline, <a href="#6.7.4">6.7.4</a>
+identifier nondigit, <a href="#6.4.2.1">6.4.2.1</a>                                     inner scope, <a href="#6.2.1">6.2.1</a>
+IEC 559, <a href="#F.1">F.1</a>                                                    input failure, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>
+IEC 60559, <a href="#2">2</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8">6.10.8</a>, <a href="#7.3.3">7.3.3</a>, <a href="#7.6">7.6</a>,           input/output functions
+      <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.14">7.12.14</a>, <a href="#F">F</a>, <a href="#G">G</a>, <a href="#H.1">H.1</a>               character, <a href="#7.19.7">7.19.7</a>
+IEEE 754, <a href="#F.1">F.1</a>                                                      direct, <a href="#7.19.8">7.19.8</a>
+IEEE 854, <a href="#F.1">F.1</a>                                                      formatted, <a href="#7.19.6">7.19.6</a>
+IEEE floating-point arithmetic standard, see                           wide character, <a href="#7.24.2">7.24.2</a>
+      IEC 60559, ANSI/IEEE 754,                                    wide character, <a href="#7.24.3">7.24.3</a>
+      ANSI/IEEE 854                                                   formatted, <a href="#7.24.2">7.24.2</a>
+if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,               input/output header, <a href="#7.19">7.19</a>
+      <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             input/output, device, <a href="#5.1.2.3">5.1.2.3</a>
+if statement, <a href="#6.8.4.1">6.8.4.1</a>                                           int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.7.2">6.7.2</a>
+ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                           int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                                <a href="#6.3.1.8">6.3.1.8</a>
+ilogb functions, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.9.3.5">F.9.3.5</a>                        INT_FASTN_MAX macros, <a href="#7.18.2.3">7.18.2.3</a>
+ilogb type-generic macro, <a href="#7.22">7.22</a>                                  INT_FASTN_MIN macros, <a href="#7.18.2.3">7.18.2.3</a>
+imaginary macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>                                     int_fastN_t types, <a href="#7.18.1.3">7.18.1.3</a>
+imaginary numbers, <a href="#G">G</a>                                            INT_LEASTN_MAX macros, <a href="#7.18.2.2">7.18.2.2</a>
+imaginary type domain, <a href="#G.2">G.2</a>                                      INT_LEASTN_MIN macros, <a href="#7.18.2.2">7.18.2.2</a>
+imaginary types, <a href="#G">G</a>                                              int_leastN_t types, <a href="#7.18.1.2">7.18.1.2</a>
+imaxabs function, <a href="#7.8.2.1">7.8.2.1</a>                                       INT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>
+imaxdiv function, <a href="#7.8">7.8</a>, <a href="#7.8.2.2">7.8.2.2</a>                                  INT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>
+imaxdiv_t type, <a href="#7.8">7.8</a>                                             integer arithmetic functions, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>,
+implementation, <a href="#3.12">3.12</a>                                                  <a href="#7.20.6">7.20.6</a>
+implementation limit, <a href="#3.13">3.13</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.4.2.1">6.4.2.1</a>,                integer character constant, <a href="#6.4.4.4">6.4.4.4</a>
+      <a href="#6.7.5">6.7.5</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#E">E</a>, see also environmental                 integer constant, <a href="#6.4.4.1">6.4.4.1</a>
+      limits                                                    integer constant expression, <a href="#6.6">6.6</a>
+implementation-defined behavior, <a href="#3.4.1">3.4.1</a>, <a href="#4">4</a>, <a href="#J.3">J.3</a>                   integer conversion rank, <a href="#6.3.1.1">6.3.1.1</a>
+implementation-defined value, <a href="#3.17.1">3.17.1</a>                             integer promotions, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.3.1.1">6.3.1.1</a>,
+implicit conversion, <a href="#6.3">6.3</a>                                              <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.7">6.5.7</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#7.18.2">7.18.2</a>, <a href="#7.18.3">7.18.3</a>,
+implicit initialization, <a href="#6.7.8">6.7.8</a>                                        <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>
+include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.2">6.10.2</a>                integer suffix, <a href="#6.4.4.1">6.4.4.1</a>
+inclusive OR operators                                          integer type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+   bitwise (|), <a href="#6.5.12">6.5.12</a>                                                <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
+   bitwise assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>                            integer types, <a href="#6.2.5">6.2.5</a>, <a href="#7.18">7.18</a>
+incomplete type, <a href="#6.2.5">6.2.5</a>                                             extended, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#7.18">7.18</a>
+increment operators, see arithmetic operators,                  interactive device, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.3">7.19.5.3</a>
+      increment and decrement                                   internal linkage, <a href="#6.2.2">6.2.2</a>
+indeterminate value, <a href="#3.17.2">3.17.2</a>                                     internal name, <a href="#6.4.2.1">6.4.2.1</a>
+indirection operator (*), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                      interrupt, <a href="#5.2.3">5.2.3</a>
+inequality operator (!=), <a href="#6.5.9">6.5.9</a>                                 INTMAX_C macro, <a href="#7.18.4.2">7.18.4.2</a>
+INFINITY macro, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                            INTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>
+
+[<a name="p529" href="#p529">page 529</a>] (<a href="#Contents">Contents</a>)
+
+INTMAX_MIN macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>            iswalpha function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
+intmax_t type, <a href="#7.18.1.5">7.18.1.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                  <a href="#7.25.2.2.1">7.25.2.2.1</a>
+    <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  iswblank function, <a href="#7.25.2.1.3">7.25.2.1.3</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+INTN_C macros, <a href="#7.18.4.1">7.18.4.1</a>                                 iswcntrl function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.4">7.25.2.1.4</a>,
+INTN_MAX macros, <a href="#7.18.2.1">7.18.2.1</a>                                     <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+INTN_MIN macros, <a href="#7.18.2.1">7.18.2.1</a>                               iswctype function, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
+intN_t types, <a href="#7.18.1.1">7.18.1.1</a>                                  iswdigit function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
+INTPTR_MAX macro, <a href="#7.18.2.4">7.18.2.4</a>                                    <a href="#7.25.2.1.5">7.25.2.1.5</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+INTPTR_MIN macro, <a href="#7.18.2.4">7.18.2.4</a>                              iswgraph function, <a href="#7.25.2.1">7.25.2.1</a>, <a href="#7.25.2.1.6">7.25.2.1.6</a>,
+intptr_t type, <a href="#7.18.1.4">7.18.1.4</a>                                       <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+inttypes.h header, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>                          iswlower function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.7">7.25.2.1.7</a>,
+isalnum function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>                  <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.1.2">7.25.3.1.2</a>
+isalpha function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>                      iswprint function, <a href="#7.25.2.1.6">7.25.2.1.6</a>, <a href="#7.25.2.1.8">7.25.2.1.8</a>,
+isblank function, <a href="#7.4.1.3">7.4.1.3</a>                                     <a href="#7.25.2.2.1">7.25.2.2.1</a>
+iscntrl function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.4">7.4.1.4</a>, <a href="#7.4.1.7">7.4.1.7</a>,            iswpunct function, <a href="#7.25.2.1">7.25.2.1</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>,
+    <a href="#7.4.1.11">7.4.1.11</a>                                                  <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>,
+isdigit function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.5">7.4.1.5</a>,                  <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+    <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.11.1.1">7.11.1.1</a>                         iswspace function, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,
+isfinite macro, <a href="#7.12.3.2">7.12.3.2</a>, <a href="#F.3">F.3</a>                                 <a href="#7.24.4.1.1">7.24.4.1.1</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.6">7.25.2.1.6</a>,
+isgraph function, <a href="#7.4.1.6">7.4.1.6</a>                                     <a href="#7.25.2.1.7">7.25.2.1.7</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>, <a href="#7.25.2.1.10">7.25.2.1.10</a>,
+isgreater macro, <a href="#7.12.14.1">7.12.14.1</a>, <a href="#F.3">F.3</a>                               <a href="#7.25.2.1.11">7.25.2.1.11</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+isgreaterequal macro, <a href="#7.12.14.2">7.12.14.2</a>, <a href="#F.3">F.3</a>                    iswupper function, <a href="#7.25.2.1.2">7.25.2.1.2</a>, <a href="#7.25.2.1.11">7.25.2.1.11</a>,
+isinf macro, <a href="#7.12.3.3">7.12.3.3</a>                                         <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.1.2">7.25.3.1.2</a>
+isless macro, <a href="#7.12.14.3">7.12.14.3</a>, <a href="#F.3">F.3</a>                            iswxdigit function, <a href="#7.25.2.1.12">7.25.2.1.12</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>
+islessequal macro, <a href="#7.12.14.4">7.12.14.4</a>, <a href="#F.3">F.3</a>                       isxdigit function, <a href="#7.4.1.12">7.4.1.12</a>, <a href="#7.11.1.1">7.11.1.1</a>
+islessgreater macro, <a href="#7.12.14.5">7.12.14.5</a>, <a href="#F.3">F.3</a>                     italic type convention, <a href="#3">3</a>, <a href="#6.1">6.1</a>
+islower function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.2.1">7.4.2.1</a>,            iteration statements, <a href="#6.8.5">6.8.5</a>
+    <a href="#7.4.2.2">7.4.2.2</a>
+isnan macro, <a href="#7.12.3.4">7.12.3.4</a>, <a href="#F.3">F.3</a>                              jmp_buf type, <a href="#7.13">7.13</a>
+isnormal macro, <a href="#7.12.3.5">7.12.3.5</a>                                jump statements, <a href="#6.8.6">6.8.6</a>
+ISO 31-11, <a href="#2">2</a>, <a href="#3">3</a>
+ISO 4217, <a href="#2">2</a>, <a href="#7.11.2.1">7.11.2.1</a>                                   keywords, <a href="#6.4.1">6.4.1</a>, <a href="#G.2">G.2</a>, <a href="#J.5.9">J.5.9</a>, <a href="#J.5.10">J.5.10</a>
+ISO 8601, <a href="#2">2</a>, <a href="#7.23.3.5">7.23.3.5</a>                                   known constant size, <a href="#6.2.5">6.2.5</a>
+ISO/IEC 10646, <a href="#2">2</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.4.3">6.4.3</a>, <a href="#6.10.8">6.10.8</a>
+ISO/IEC 10976-1, <a href="#H.1">H.1</a>                                    <a href="#L">L</a>_tmpnam macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.4">7.19.4.4</a>
+ISO/IEC 2382-1, <a href="#2">2</a>, <a href="#3">3</a>                                    label name, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.3">6.2.3</a>
+ISO/IEC 646, <a href="#2">2</a>, <a href="#5.2.1.1">5.2.1.1</a>                                 labeled statement, <a href="#6.8.1">6.8.1</a>
+ISO/IEC 9945-2, <a href="#7.11">7.11</a>                                    labs function, <a href="#7.20.6.1">7.20.6.1</a>
+ISO/IEC TR 10176, <a href="#D">D</a>                                     language, <a href="#6">6</a>
+iso646.h header, <a href="#4">4</a>, <a href="#7.9">7.9</a>                                    future directions, <a href="#6.11">6.11</a>
+isprint function, <a href="#5.2.2">5.2.2</a>, <a href="#7.4.1.8">7.4.1.8</a>                           syntax summary, <a href="#A">A</a>
+ispunct function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,            Latin alphabet, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+    <a href="#7.4.1.11">7.4.1.11</a>                                            LC_ALL macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+isspace function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,            LC_COLLATE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.3">7.21.4.3</a>,
+    <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.3">7.20.1.3</a>,                   <a href="#7.24.4.4.2">7.24.4.4.2</a>
+    <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  LC_CTYPE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.20">7.20</a>, <a href="#7.20.7">7.20.7</a>,
+isunordered macro, <a href="#7.12.14.6">7.12.14.6</a>, <a href="#F.3">F.3</a>                             <a href="#7.20.8">7.20.8</a>, <a href="#7.24.6">7.24.6</a>, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>,
+isupper function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.4.2.1">7.4.2.1</a>,                 <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+    <a href="#7.4.2.2">7.4.2.2</a>                                             LC_MONETARY macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+iswalnum function, <a href="#7.25.2.1.1">7.25.2.1.1</a>, <a href="#7.25.2.1.9">7.25.2.1.9</a>,              LC_NUMERIC macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+    <a href="#7.25.2.1.10">7.25.2.1.10</a>, <a href="#7.25.2.2.1">7.25.2.2.1</a>                             LC_TIME macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.3.5">7.23.3.5</a>
+
+[<a name="p530" href="#p530">page 530</a>] (<a href="#Contents">Contents</a>)
+
+lconv structure type, <a href="#7.11">7.11</a>                                 llabs function, <a href="#7.20.6.1">7.20.6.1</a>
+LDBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                  lldiv function, <a href="#7.20.6.2">7.20.6.2</a>
+LDBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                              lldiv_t type, <a href="#7.20">7.20</a>
+LDBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                             LLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,
+LDBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                       <a href="#7.24.4.1.2">7.24.4.1.2</a>
+LDBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                           LLONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,
+LDBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                   <a href="#7.24.4.1.2">7.24.4.1.2</a>
+LDBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                  llrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.5">F.9.6.5</a>
+LDBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                           llrint type-generic macro, <a href="#7.22">7.22</a>
+LDBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>                              llround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.7">F.9.6.7</a>
+ldexp functions, <a href="#7.12.6.6">7.12.6.6</a>, <a href="#F.9.3.6">F.9.3.6</a>                         llround type-generic macro, <a href="#7.22">7.22</a>
+ldexp type-generic macro, <a href="#7.22">7.22</a>                             local time, <a href="#7.23.1">7.23.1</a>
+ldiv function, <a href="#7.20.6.2">7.20.6.2</a>                                    locale, <a href="#3.4.2">3.4.2</a>
+ldiv_t type, <a href="#7.20">7.20</a>                                          locale-specific behavior, <a href="#3.4.2">3.4.2</a>, <a href="#J.4">J.4</a>
+leading underscore in identifiers, <a href="#7.1.3">7.1.3</a>                    locale.h header, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
+left-shift assignment operator (&lt;&lt;=), <a href="#6.5.16.2">6.5.16.2</a>             localeconv function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+left-shift operator (&lt;&lt;), <a href="#6.5.7">6.5.7</a>                            localization, <a href="#7.11">7.11</a>
+length                                                     localtime function, <a href="#7.23.3.4">7.23.3.4</a>
+   external name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                 log functions, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#F.9.3.7">F.9.3.7</a>
+   function name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>                 log type-generic macro, <a href="#7.22">7.22</a>
+   identifier, <a href="#6.4.2.1">6.4.2.1</a>                                      log10 functions, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#F.9.3.8">F.9.3.8</a>
+   internal name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>                         log10 type-generic macro, <a href="#7.22">7.22</a>
+length function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.24.4.6.1">7.24.4.6.1</a>,           log1p functions, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#F.9.3.9">F.9.3.9</a>
+      <a href="#7.24.6.3.1">7.24.6.3.1</a>                                           log1p type-generic macro, <a href="#7.22">7.22</a>
+length modifier, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>,              log2 functions, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#F.9.3.10">F.9.3.10</a>
+      <a href="#7.24.2.2">7.24.2.2</a>                                             log2 type-generic macro, <a href="#7.22">7.22</a>
+less-than operator (&lt;), <a href="#6.5.8">6.5.8</a>                              logarithmic functions
+less-than-or-equal-to operator (&lt;=), <a href="#6.5.8">6.5.8</a>                   complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
+letter, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                           real, <a href="#7.12.6">7.12.6</a>, <a href="#F.9.3">F.9.3</a>
+lexical elements, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>                             logb functions, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.11">F.9.3.11</a>
+lgamma functions, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#F.9.5.3">F.9.5.3</a>                        logb type-generic macro, <a href="#7.22">7.22</a>
+lgamma type-generic macro, <a href="#7.22">7.22</a>                            logical operators
+library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7">7</a>                                          AND (&amp;&amp;), <a href="#6.5.13">6.5.13</a>
+   future directions, <a href="#7.26">7.26</a>                                   negation (!), <a href="#6.5.3.3">6.5.3.3</a>
+   summary, <a href="#B">B</a>                                                OR (||), <a href="#6.5.14">6.5.14</a>
+   terms, <a href="#7.1.1">7.1.1</a>                                            logical source lines, <a href="#5.1.1.2">5.1.1.2</a>
+   use of functions, <a href="#7.1.4">7.1.4</a>                                 long double _Complex type, <a href="#6.2.5">6.2.5</a>
+lifetime, <a href="#6.2.4">6.2.4</a>                                            long double _Complex type conversion,
+limits                                                          <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+   environmental, see environmental limits                 long double _Imaginary type, <a href="#G.2">G.2</a>
+   implementation, see implementation limits               long double suffix, l or <a href="#L">L</a>, <a href="#6.4.4.2">6.4.4.2</a>
+   numerical, see numerical limits                         long double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>,
+   translation, see translation limits                          <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.2">F.2</a>
+limits.h header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                 long double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,
+line buffered stream, <a href="#7.19.3">7.19.3</a>                                    <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+line number, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8">6.10.8</a>                                long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+line preprocessing directive, <a href="#6.10.4">6.10.4</a>                            <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
+lines, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#7.19.2">7.19.2</a>                                     long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+   preprocessing directive, <a href="#6.10">6.10</a>                                <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+linkage, <a href="#6.2.2">6.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.4">6.7.4</a>, <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.9">6.9</a>, <a href="#6.9.2">6.9.2</a>,           long integer suffix, l or <a href="#L">L</a>, <a href="#6.4.4.1">6.4.4.1</a>
+      <a href="#6.11.2">6.11.2</a>                                               long long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>,
+
+[<a name="p531" href="#p531">page 531</a>] (<a href="#Contents">Contents</a>)
+
+     <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                    mbsinit function, <a href="#7.24.6.2.1">7.24.6.2.1</a>
+long long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>,                        mbsrtowcs function, <a href="#7.24.6.4.1">7.24.6.4.1</a>
+     <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                 mbstate_t type, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+long long integer suffix, ll or LL, <a href="#6.4.4.1">6.4.4.1</a>                          <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.6">7.24.6</a>,
+LONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                     <a href="#7.24.6.2.1">7.24.6.2.1</a>, <a href="#7.24.6.3">7.24.6.3</a>, <a href="#7.24.6.3.1">7.24.6.3.1</a>, <a href="#7.24.6.4">7.24.6.4</a>
+LONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                mbstowcs function, <a href="#6.4.5">6.4.5</a>, <a href="#7.20.8.1">7.20.8.1</a>, <a href="#7.24.6.4">7.24.6.4</a>
+longjmp function, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>, <a href="#7.20.4.3">7.20.4.3</a>                 mbtowc function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.20.7.2">7.20.7.2</a>, <a href="#7.20.8.1">7.20.8.1</a>,
+loop body, <a href="#6.8.5">6.8.5</a>                                                    <a href="#7.24.6.3">7.24.6.3</a>
+low-order bit, <a href="#3.6">3.6</a>                                             member access operators (. and -&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+lowercase letter, <a href="#5.2.1">5.2.1</a>                                        member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+lrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.5">F.9.6.5</a>                        memchr function, <a href="#7.21.5.1">7.21.5.1</a>
+lrint type-generic macro, <a href="#7.22">7.22</a>                                 memcmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.1">7.21.4.1</a>
+lround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.9.6.7">F.9.6.7</a>                            memcpy function, <a href="#7.21.2.1">7.21.2.1</a>
+lround type-generic macro, <a href="#7.22">7.22</a>                                memmove function, <a href="#7.21.2.2">7.21.2.2</a>
+lvalue, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>, <a href="#6.5.16">6.5.16</a>               memory management functions, <a href="#7.20.3">7.20.3</a>
+                                                               memset function, <a href="#7.21.6.1">7.21.6.1</a>
+macro argument substitution, <a href="#6.10.3.1">6.10.3.1</a>                          minimum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>
+macro definition                                                minus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>
+  library function, <a href="#7.1.4">7.1.4</a>                                      miscellaneous functions
+macro invocation, <a href="#6.10.3">6.10.3</a>                                         string, <a href="#7.21.6">7.21.6</a>
+macro name, <a href="#6.10.3">6.10.3</a>                                               wide string, <a href="#7.24.4.6">7.24.4.6</a>
+  length, <a href="#5.2.4.1">5.2.4.1</a>                                              mktime function, <a href="#7.23.2.3">7.23.2.3</a>
+  predefined, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>                                    modf functions, <a href="#7.12.6.12">7.12.6.12</a>, <a href="#F.9.3.12">F.9.3.12</a>
+  redefinition, <a href="#6.10.3">6.10.3</a>                                          modifiable lvalue, <a href="#6.3.2.1">6.3.2.1</a>
+  scope, <a href="#6.10.3.5">6.10.3.5</a>                                              modulus functions, <a href="#7.12.6.12">7.12.6.12</a>
+macro parameter, <a href="#6.10.3">6.10.3</a>                                        modulus, complex, <a href="#7.3.8.1">7.3.8.1</a>
+macro preprocessor, <a href="#6.10">6.10</a>                                       multibyte character, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+macro replacement, <a href="#6.10.3">6.10.3</a>                                      multibyte conversion functions
+magnitude, complex, <a href="#7.3.8.1">7.3.8.1</a>                                      wide character, <a href="#7.20.7">7.20.7</a>
+main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.4">6.7.4</a>,                extended, <a href="#7.24.6">7.24.6</a>
+     <a href="#7.19.3">7.19.3</a>                                                         restartable, <a href="#7.24.6.3">7.24.6.3</a>
+malloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.3">7.20.3.3</a>,                     wide string, <a href="#7.20.8">7.20.8</a>
+     <a href="#7.20.3.4">7.20.3.4</a>                                                       restartable, <a href="#7.24.6.4">7.24.6.4</a>
+manipulation functions                                         multibyte string, <a href="#7.1.1">7.1.1</a>
+  complex, <a href="#7.3.9">7.3.9</a>                                               multibyte/wide character conversion functions,
+  real, <a href="#7.12.11">7.12.11</a>, <a href="#F.9.8">F.9.8</a>                                              <a href="#7.20.7">7.20.7</a>
+matching failure, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.10">7.24.2.10</a>                  extended, <a href="#7.24.6">7.24.6</a>
+math.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>, <a href="#F.9">F.9</a>,               restartable, <a href="#7.24.6.3">7.24.6.3</a>
+     <a href="#J.5.17">J.5.17</a>                                                    multibyte/wide string conversion functions, <a href="#7.20.8">7.20.8</a>
+MATH_ERREXCEPT macro, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                                  restartable, <a href="#7.24.6.4">7.24.6.4</a>
+math_errhandling macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.12">7.12</a>, <a href="#F.9">F.9</a>                       multidimensional array, <a href="#6.5.2.1">6.5.2.1</a>
+MATH_ERRNO macro, <a href="#7.12">7.12</a>                                         multiplication assignment operator (*=), <a href="#6.5.16.2">6.5.16.2</a>
+maximum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>                              multiplication operator (*), <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
+MB_CUR_MAX macro, <a href="#7.1.1">7.1.1</a>, <a href="#7.20">7.20</a>, <a href="#7.20.7.2">7.20.7.2</a>,                       multiplicative expressions, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+     <a href="#7.20.7.3">7.20.7.3</a>, <a href="#7.24.6.3.3">7.24.6.3.3</a>
+MB_LEN_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.1.1">7.1.1</a>, <a href="#7.20">7.20</a>                       n-char sequence, <a href="#7.20.1.3">7.20.1.3</a>
+mblen function, <a href="#7.20.7.1">7.20.7.1</a>, <a href="#7.24.6.3">7.24.6.3</a>                             n-wchar sequence, <a href="#7.24.4.1.1">7.24.4.1.1</a>
+mbrlen function, <a href="#7.24.6.3.1">7.24.6.3.1</a>                                    name
+mbrtowc function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                    external, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>, <a href="#7.24.6.3.1">7.24.6.3.1</a>, <a href="#7.24.6.3.2">7.24.6.3.2</a>,                 file, <a href="#7.19.3">7.19.3</a>
+     <a href="#7.24.6.4.1">7.24.6.4.1</a>                                                  internal, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+
+[<a name="p532" href="#p532">page 532</a>] (<a href="#Contents">Contents</a>)
+
+  label, <a href="#6.2.3">6.2.3</a>                                                  octal-character escape sequence (\octal digits),
+  structure/union member, <a href="#6.2.3">6.2.3</a>                                       <a href="#6.4.4.4">6.4.4.4</a>
+name spaces, <a href="#6.2.3">6.2.3</a>                                              offsetof macro, <a href="#7.17">7.17</a>
+named label, <a href="#6.8.1">6.8.1</a>                                              on-off switch, <a href="#6.10.6">6.10.6</a>
+NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>                                                  ones' complement, <a href="#6.2.6.2">6.2.6.2</a>
+nan functions, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#F.2.1">F.2.1</a>, <a href="#F.9.8.2">F.9.8.2</a>                        operand, <a href="#6.4.6">6.4.6</a>, <a href="#6.5">6.5</a>
+NAN macro, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                                          operating system, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#7.20.4.6">7.20.4.6</a>
+NDEBUG macro, <a href="#7.2">7.2</a>                                               operations on files, <a href="#7.19.4">7.19.4</a>
+nearbyint functions, <a href="#7.12.9.3">7.12.9.3</a>, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>,                   operator, <a href="#6.4.6">6.4.6</a>
+     <a href="#F.9.6.3">F.9.6.3</a>                                                    operators, <a href="#6.5">6.5</a>
+nearbyint type-generic macro, <a href="#7.22">7.22</a>                                 assignment, <a href="#6.5.16">6.5.16</a>
+nearest integer functions, <a href="#7.12.9">7.12.9</a>, <a href="#F.9.6">F.9.6</a>                           associativity, <a href="#6.5">6.5</a>
+negation operator (!), <a href="#6.5.3.3">6.5.3.3</a>                                     equality, <a href="#6.5.9">6.5.9</a>
+negative zero, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.12.11.1">7.12.11.1</a>                                  multiplicative, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+new-line character, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#6.10.4">6.10.4</a>              postfix, <a href="#6.5.2">6.5.2</a>
+new-line escape sequence (\n), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,                     precedence, <a href="#6.5">6.5</a>
+     <a href="#7.4.1.10">7.4.1.10</a>                                                      preprocessing, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, <a href="#6.10.9">6.10.9</a>
+nextafter functions, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>,                    relational, <a href="#6.5.8">6.5.8</a>
+     <a href="#F.9.8.3">F.9.8.3</a>                                                       shift, <a href="#6.5.7">6.5.7</a>
+nextafter type-generic macro, <a href="#7.22">7.22</a>                                 unary, <a href="#6.5.3">6.5.3</a>
+nexttoward functions, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, <a href="#F.9.8.4">F.9.8.4</a>                      unary arithmetic, <a href="#6.5.3.3">6.5.3.3</a>
+nexttoward type-generic macro, <a href="#7.22">7.22</a>                             or macro, <a href="#7.9">7.9</a>
+no linkage, <a href="#6.2.2">6.2.2</a>                                               OR operators
+non-stop floating-point control mode, <a href="#7.6.4.2">7.6.4.2</a>                       bitwise exclusive (^), <a href="#6.5.11">6.5.11</a>
+nongraphic characters, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                              bitwise exclusive assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
+nonlocal jumps header, <a href="#7.13">7.13</a>                                        bitwise inclusive (|), <a href="#6.5.12">6.5.12</a>
+norm, complex, <a href="#7.3.8.1">7.3.8.1</a>                                             bitwise inclusive assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+not macro, <a href="#7.9">7.9</a>                                                     logical (||), <a href="#6.5.14">6.5.14</a>
+not-equal-to operator, see inequality operator                  or_eq macro, <a href="#7.9">7.9</a>
+not_eq macro, <a href="#7.9">7.9</a>                                               order of allocated storage, <a href="#7.20.3">7.20.3</a>
+null character (\0), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                      order of evaluation, <a href="#6.5">6.5</a>
+  padding of binary stream, <a href="#7.19.2">7.19.2</a>                              ordinary identifier name space, <a href="#6.2.3">6.2.3</a>
+NULL macro, <a href="#7.11">7.11</a>, <a href="#7.17">7.17</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.20">7.20</a>, <a href="#7.21.1">7.21.1</a>,                   orientation of stream, <a href="#7.19.2">7.19.2</a>, <a href="#7.24.3.5">7.24.3.5</a>
+     <a href="#7.23.1">7.23.1</a>, <a href="#7.24.1">7.24.1</a>                                             outer scope, <a href="#6.2.1">6.2.1</a>
+null pointer, <a href="#6.3.2.3">6.3.2.3</a>
+null pointer constant, <a href="#6.3.2.3">6.3.2.3</a>                                  padding
+null preprocessing directive, <a href="#6.10.7">6.10.7</a>                              binary stream, <a href="#7.19.2">7.19.2</a>
+null statement, <a href="#6.8.3">6.8.3</a>                                             bits, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.18.1.1">7.18.1.1</a>
+null wide character, <a href="#7.1.1">7.1.1</a>                                        structure/union, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+number classification macros, <a href="#7.12">7.12</a>, <a href="#7.12.3.1">7.12.3.1</a>                     parameter, <a href="#3.15">3.15</a>
+numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>                     array, <a href="#6.9.1">6.9.1</a>
+  wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1">7.24.4.1</a>                                  ellipsis, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.10.3">6.10.3</a>
+numerical limits, <a href="#5.2.4.2">5.2.4.2</a>                                         function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
+                                                                  macro, <a href="#6.10.3">6.10.3</a>
+object, <a href="#3.14">3.14</a>                                                      main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+object representation, <a href="#6.2.6.1">6.2.6.1</a>                                    program, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+object type, <a href="#6.2.5">6.2.5</a>                                              parameter type list, <a href="#6.7.5.3">6.7.5.3</a>
+object-like macro, <a href="#6.10.3">6.10.3</a>                                       parentheses punctuator (( )), <a href="#6.7.5.3">6.7.5.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
+obsolescence, <a href="#6.11">6.11</a>, <a href="#7.26">7.26</a>                                        parenthesized expression, <a href="#6.5.1">6.5.1</a>
+octal constant, <a href="#6.4.4.1">6.4.4.1</a>                                         parse state, <a href="#7.19.2">7.19.2</a>
+octal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.4">6.4.4.4</a>                                   permitted form of initializer, <a href="#6.6">6.6</a>
+
+[<a name="p533" href="#p533">page 533</a>] (<a href="#Contents">Contents</a>)
+
+perror function, <a href="#7.19.10.4">7.19.10.4</a>                                    PRIcPTR macros, <a href="#7.8.1">7.8.1</a>
+phase angle, complex, <a href="#7.3.9.1">7.3.9.1</a>                                 primary expression, <a href="#6.5.1">6.5.1</a>
+physical source lines, <a href="#5.1.1.2">5.1.1.2</a>                                printf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.3">7.19.6.3</a>, <a href="#7.19.6.10">7.19.6.10</a>
+placemarker, <a href="#6.10.3.3">6.10.3.3</a>                                         printing character, <a href="#5.2.2">5.2.2</a>, <a href="#7.4">7.4</a>, <a href="#7.4.1.8">7.4.1.8</a>
+plus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                                 printing wide character, <a href="#7.25.2">7.25.2</a>
+pointer arithmetic, <a href="#6.5.6">6.5.6</a>                                     program diagnostics, <a href="#7.2.1">7.2.1</a>
+pointer comparison, <a href="#6.5.8">6.5.8</a>                                     program execution, <a href="#5.1.2.2.2">5.1.2.2.2</a>, <a href="#5.1.2.3">5.1.2.3</a>
+pointer declarator, <a href="#6.7.5.1">6.7.5.1</a>                                   program file, <a href="#5.1.1.1">5.1.1.1</a>
+pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                program image, <a href="#5.1.1.2">5.1.1.2</a>
+pointer to function, <a href="#6.5.2.2">6.5.2.2</a>                                  program name (argv[0]), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+pointer type, <a href="#6.2.5">6.2.5</a>                                           program parameters, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+pointer type conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                     program startup, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+pointer, null, <a href="#6.3.2.3">6.3.2.3</a>                                        program structure, <a href="#5.1.1.1">5.1.1.1</a>
+portability, <a href="#4">4</a>, <a href="#J">J</a>                                             program termination, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>,
+position indicator, file, see file position indicator                 <a href="#5.1.2.3">5.1.2.3</a>
+positive difference, <a href="#7.12.12.1">7.12.12.1</a>                                program, conforming, <a href="#4">4</a>
+positive difference functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.9.9">F.9.9</a>                 program, strictly conforming, <a href="#4">4</a>
+postfix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              promotions
+postfix expressions, <a href="#6.5.2">6.5.2</a>                                        default argument, <a href="#6.5.2.2">6.5.2.2</a>
+postfix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>                 integer, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.3.1.1">6.3.1.1</a>
+pow functions, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#F.9.4.4">F.9.4.4</a>                              prototype, see function prototype
+pow type-generic macro, <a href="#7.22">7.22</a>                                  pseudo-random sequence functions, <a href="#7.20.2">7.20.2</a>
+power functions                                               PTRDIFF_MAX macro, <a href="#7.18.3">7.18.3</a>
+  complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                       PTRDIFF_MIN macro, <a href="#7.18.3">7.18.3</a>
+  real, <a href="#7.12.7">7.12.7</a>, <a href="#F.9.4">F.9.4</a>                                         ptrdiff_t type, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+pp-number, <a href="#6.4.8">6.4.8</a>                                                    <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
+pragma operator, <a href="#6.10.9">6.10.9</a>                                       punctuators, <a href="#6.4.6">6.4.6</a>
+pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                putc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.8">7.19.7.8</a>, <a href="#7.19.7.9">7.19.7.9</a>
+precedence of operators, <a href="#6.5">6.5</a>                                  putchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.9">7.19.7.9</a>
+precedence of syntax rules, <a href="#5.1.1.2">5.1.1.2</a>                           puts function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.10">7.19.7.10</a>
+precision, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.2.1">7.24.2.1</a>               putwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.8">7.24.3.8</a>, <a href="#7.24.3.9">7.24.3.9</a>
+   excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>               putwchar function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.9">7.24.3.9</a>
+predefined macro names, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>
+prefix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               qsort function, <a href="#7.20.5">7.20.5</a>, <a href="#7.20.5.2">7.20.5.2</a>
+prefix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               qualified types, <a href="#6.2.5">6.2.5</a>
+preprocessing concatenation, <a href="#6.10.3.3">6.10.3.3</a>                         qualified version of type, <a href="#6.2.5">6.2.5</a>
+preprocessing directives, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10">6.10</a>                       question-mark escape sequence (\?), <a href="#6.4.4.4">6.4.4.4</a>
+preprocessing file, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.10">6.10</a>                              quiet NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+preprocessing numbers, <a href="#6.4">6.4</a>, <a href="#6.4.8">6.4.8</a>
+preprocessing operators                                       raise function, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>, <a href="#7.20.4.1">7.20.4.1</a>
+   #, <a href="#6.10.3.2">6.10.3.2</a>                                                rand function, <a href="#7.20">7.20</a>, <a href="#7.20.2.1">7.20.2.1</a>, <a href="#7.20.2.2">7.20.2.2</a>
+   ##, <a href="#6.10.3.3">6.10.3.3</a>                                               RAND_MAX macro, <a href="#7.20">7.20</a>, <a href="#7.20.2.1">7.20.2.1</a>
+   _Pragma, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>                                   range
+   defined, <a href="#6.10.1">6.10.1</a>                                              excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>
+preprocessing tokens, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>                      range error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#7.12.5.5">7.12.5.5</a>,
+preprocessing translation unit, <a href="#5.1.1.1">5.1.1.1</a>                            <a href="#7.12.6.1">7.12.6.1</a>, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#7.12.6.5">7.12.6.5</a>,
+preprocessor, <a href="#6.10">6.10</a>                                                 <a href="#7.12.6.6">7.12.6.6</a>, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>,
+PRIcFASTN macros, <a href="#7.8.1">7.8.1</a>                                            <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#7.12.7.3">7.12.7.3</a>,
+PRIcLEASTN macros, <a href="#7.8.1">7.8.1</a>                                           <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>,
+PRIcMAX macros, <a href="#7.8.1">7.8.1</a>                                              <a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.12.1">7.12.12.1</a>,
+PRIcN macros, <a href="#7.8.1">7.8.1</a>                                                <a href="#7.12.13.1">7.12.13.1</a>
+
+[<a name="p534" href="#p534">page 534</a>] (<a href="#Contents">Contents</a>)
+
+rank, see integer conversion rank                         same scope, <a href="#6.2.1">6.2.1</a>
+real floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,           save calling environment function, <a href="#7.13.1">7.13.1</a>
+      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                   scalar types, <a href="#6.2.5">6.2.5</a>
+real floating types, <a href="#6.2.5">6.2.5</a>                                 scalbln function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.13">F.9.3.13</a>
+real type domain, <a href="#6.2.5">6.2.5</a>                                   scalbln type-generic macro, <a href="#7.22">7.22</a>
+real types, <a href="#6.2.5">6.2.5</a>                                         scalbn function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.9.3.13">F.9.3.13</a>
+real-floating, <a href="#7.12.3">7.12.3</a>                                      scalbn type-generic macro, <a href="#7.22">7.22</a>
+realloc function, <a href="#7.20.3">7.20.3</a>, <a href="#7.20.3.2">7.20.3.2</a>, <a href="#7.20.3.4">7.20.3.4</a>              scanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.4">7.19.6.4</a>, <a href="#7.19.6.11">7.19.6.11</a>
+recommended practice, <a href="#3.16">3.16</a>                                scanlist, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>
+recursion, <a href="#6.5.2.2">6.5.2.2</a>                                        scanset, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>
+recursive function call, <a href="#6.5.2.2">6.5.2.2</a>                          SCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+redefinition of macro, <a href="#6.10.3">6.10.3</a>                              SCHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+reentrancy, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>                                SCNcFASTN macros, <a href="#7.8.1">7.8.1</a>
+   library functions, <a href="#7.1.4">7.1.4</a>                               SCNcLEASTN macros, <a href="#7.8.1">7.8.1</a>
+referenced type, <a href="#6.2.5">6.2.5</a>                                    SCNcMAX macros, <a href="#7.8.1">7.8.1</a>
+register storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>               SCNcN macros, <a href="#7.8.1">7.8.1</a>
+relational expressions, <a href="#6.5.8">6.5.8</a>                             SCNcPTR macros, <a href="#7.8.1">7.8.1</a>
+reliability of data, interrupted, <a href="#5.1.2.3">5.1.2.3</a>                 scope of identifier, <a href="#6.2.1">6.2.1</a>, <a href="#6.9.2">6.9.2</a>
+remainder assignment operator (%=), <a href="#6.5.16.2">6.5.16.2</a>              search functions
+remainder functions, <a href="#7.12.10">7.12.10</a>, <a href="#F.9.7">F.9.7</a>                          string, <a href="#7.21.5">7.21.5</a>
+remainder functions, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>,              utility, <a href="#7.20.5">7.20.5</a>
+      <a href="#F.9.7.2">F.9.7.2</a>                                                wide string, <a href="#7.24.4.5">7.24.4.5</a>
+remainder operator (%), <a href="#6.5.5">6.5.5</a>                             SEEK_CUR macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
+remainder type-generic macro, <a href="#7.22">7.22</a>                        SEEK_END macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
+remove function, <a href="#7.19.4.1">7.19.4.1</a>, <a href="#7.19.4.4">7.19.4.4</a>                       SEEK_SET macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.9.2">7.19.9.2</a>
+remquo functions, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>, <a href="#F.9.7.3">F.9.7.3</a>                 selection statements, <a href="#6.8.4">6.8.4</a>
+remquo type-generic macro, <a href="#7.22">7.22</a>                           self-referential structure, <a href="#6.7.2.3">6.7.2.3</a>
+rename function, <a href="#7.19.4.2">7.19.4.2</a>                                 semicolon punctuator (;), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
+representations of types, <a href="#6.2.6">6.2.6</a>                                 <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
+   pointer, <a href="#6.2.5">6.2.5</a>                                         separate compilation, <a href="#5.1.1.1">5.1.1.1</a>
+rescanning and replacement, <a href="#6.10.3.4">6.10.3.4</a>                      separate translation, <a href="#5.1.1.1">5.1.1.1</a>
+reserved identifiers, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>                         sequence points, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.8">6.8</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.19.6">7.19.6</a>,
+restartable multibyte/wide character conversion                 <a href="#7.20.5">7.20.5</a>, <a href="#7.24.2">7.24.2</a>, <a href="#C">C</a>
+      functions, <a href="#7.24.6.3">7.24.6.3</a>                                 sequencing of statements, <a href="#6.8">6.8</a>
+restartable multibyte/wide string conversion              setbuf function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.1">7.19.5.1</a>, <a href="#7.19.5.5">7.19.5.5</a>
+      functions, <a href="#7.24.6.4">7.24.6.4</a>                                 setjmp macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>
+restore calling environment function, <a href="#7.13.2">7.13.2</a>              setjmp.h header, <a href="#7.13">7.13</a>
+restrict type qualifier, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>                    setlocale function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+restrict-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>                      setvbuf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.1">7.19.5.1</a>,
+return statement, <a href="#6.8.6.4">6.8.6.4</a>                                       <a href="#7.19.5.5">7.19.5.5</a>, <a href="#7.19.5.6">7.19.5.6</a>
+rewind function, <a href="#7.19.5.3">7.19.5.3</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.5">7.19.9.5</a>,           shall, <a href="#4">4</a>
+      <a href="#7.24.3.10">7.24.3.10</a>                                           shift expressions, <a href="#6.5.7">6.5.7</a>
+right-shift assignment operator (&gt;&gt;=), <a href="#6.5.16.2">6.5.16.2</a>           shift sequence, <a href="#7.1.1">7.1.1</a>
+right-shift operator (&gt;&gt;), <a href="#6.5.7">6.5.7</a>                          shift states, <a href="#5.2.1.2">5.2.1.2</a>
+rint functions, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, <a href="#F.9.6.4">F.9.6.4</a>                    short identifier, character, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.3">6.4.3</a>
+rint type-generic macro, <a href="#7.22">7.22</a>                             short int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>,
+round functions, <a href="#7.12.9.6">7.12.9.6</a>, <a href="#F.9.6.6">F.9.6.6</a>                              <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>
+round type-generic macro, <a href="#7.22">7.22</a>                            short int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+rounding mode, floating point, <a href="#5.2.4.2.2">5.2.4.2.2</a>                         <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+rvalue, <a href="#6.3.2.1">6.3.2.1</a>                                           SHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+                                                          SHRT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+
+[<a name="p535" href="#p535">page 535</a>] (<a href="#Contents">Contents</a>)
+
+side effects, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>                                   source lines, <a href="#5.1.1.2">5.1.1.2</a>
+SIG_ATOMIC_MAX macro, <a href="#7.18.3">7.18.3</a>                                 source text, <a href="#5.1.1.2">5.1.1.2</a>
+SIG_ATOMIC_MIN macro, <a href="#7.18.3">7.18.3</a>                                 space character (' '), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,
+sig_atomic_t type, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.18.3">7.18.3</a>                         <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.25.2.1.3">7.25.2.1.3</a>
+SIG_DFL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sprintf function, <a href="#7.19.6.6">7.19.6.6</a>, <a href="#7.19.6.13">7.19.6.13</a>
+SIG_ERR macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sqrt functions, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#F.3">F.3</a>, <a href="#F.9.4.5">F.9.4.5</a>
+SIG_IGN macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                sqrt type-generic macro, <a href="#7.22">7.22</a>
+SIGABRT macro, <a href="#7.14">7.14</a>, <a href="#7.20.4.1">7.20.4.1</a>                                srand function, <a href="#7.20.2.2">7.20.2.2</a>
+SIGFPE macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.5.17">J.5.17</a>                         sscanf function, <a href="#7.19.6.7">7.19.6.7</a>, <a href="#7.19.6.14">7.19.6.14</a>
+SIGILL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                 standard error stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.10.4">7.19.10.4</a>
+SIGINT macro, <a href="#7.14">7.14</a>                                           standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a>
+sign and magnitude, <a href="#6.2.6.2">6.2.6.2</a>                                     <a href="#7.2">&lt;assert.h&gt;</a>, <a href="#7.2">7.2</a>, <a href="#B.1">B.1</a>
+sign bit, <a href="#6.2.6.2">6.2.6.2</a>                                               <a href="#7.3">&lt;complex.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.3">7.3</a>, <a href="#7.22">7.22</a>, <a href="#7.26.1">7.26.1</a>,
+signal function, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.20.4.4">7.20.4.4</a>                                  <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+signal handler, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>              <a href="#7.4">&lt;ctype.h&gt;</a>, <a href="#7.4">7.4</a>, <a href="#7.26.2">7.26.2</a>
+signal handling functions, <a href="#7.14.1">7.14.1</a>                               <a href="#7.5">&lt;errno.h&gt;</a>, <a href="#7.5">7.5</a>, <a href="#7.26.3">7.26.3</a>
+signal.h header, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>                                   <a href="#7.6">&lt;fenv.h&gt;</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>
+signaling NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#F.2.1">F.2.1</a>                                 <a href="#7.7">&lt;float.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+signals, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1">7.14.1</a>                                      <a href="#7.24.4.1.1">7.24.4.1.1</a>
+signbit macro, <a href="#7.12.3.6">7.12.3.6</a>, <a href="#F.3">F.3</a>                                    <a href="#7.8">&lt;inttypes.h&gt;</a>, <a href="#7.8">7.8</a>, <a href="#7.26.4">7.26.4</a>
+signed char type, <a href="#6.2.5">6.2.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,                    <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#4">4</a>, <a href="#7.9">7.9</a>
+     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                         <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
+signed character, <a href="#6.3.1.1">6.3.1.1</a>                                       <a href="#7.11">&lt;locale.h&gt;</a>, <a href="#7.11">7.11</a>, <a href="#7.26.5">7.26.5</a>
+signed integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>                   <a href="#7.12">&lt;math.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.22">7.22</a>, <a href="#F">F</a>, <a href="#F.9">F.9</a>,
+signed type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,                   <a href="#J.5.17">J.5.17</a>
+     <a href="#6.3.1.8">6.3.1.8</a>                                                    <a href="#7.13">&lt;setjmp.h&gt;</a>, <a href="#7.13">7.13</a>
+signed types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>                                      <a href="#7.14">&lt;signal.h&gt;</a>, <a href="#7.14">7.14</a>, <a href="#7.26.6">7.26.6</a>
+significand part, <a href="#6.4.4.2">6.4.4.2</a>                                        <a href="#7.15">&lt;stdarg.h&gt;</a>, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>
+SIGSEGV macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                   <a href="#7.16">&lt;stdbool.h&gt;</a>, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>
+SIGTERM macro, <a href="#7.14">7.14</a>                                             <a href="#7.17">&lt;stddef.h&gt;</a>, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+simple assignment operator (=), <a href="#6.5.16.1">6.5.16.1</a>                             <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>
+sin functions, <a href="#7.12.4.6">7.12.4.6</a>, <a href="#F.9.1.6">F.9.1.6</a>                                <a href="#7.18">&lt;stdint.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.18">7.18</a>,
+sin type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                    <a href="#7.26.8">7.26.8</a>
+single-byte character, <a href="#3.7.1">3.7.1</a>, <a href="#5.2.1.2">5.2.1.2</a>                           <a href="#7.19">&lt;stdio.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>
+single-byte/wide character conversion functions,                <a href="#7.20">&lt;stdlib.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>
+     <a href="#7.24.6.1">7.24.6.1</a>                                                   <a href="#7.21">&lt;string.h&gt;</a>, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>
+single-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                            <a href="#7.22">&lt;tgmath.h&gt;</a>, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+single-quote escape sequence (\'), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>               <a href="#7.23">&lt;time.h&gt;</a>, <a href="#7.23">7.23</a>
+sinh functions, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#F.9.2.5">F.9.2.5</a>                               <a href="#7.24">&lt;wchar.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>, <a href="#7.26.12">7.26.12</a>,
+sinh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                   <a href="#F">F</a>
+SIZE_MAX macro, <a href="#7.18.3">7.18.3</a>                                          <a href="#7.25">&lt;wctype.h&gt;</a>, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>
+size_t type, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.1">7.19.1</a>,                  standard input stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>
+     <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20">7.20</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.23.1">7.23.1</a>,               standard integer types, <a href="#6.2.5">6.2.5</a>
+     <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                              standard output stream, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>
+sizeof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>                     standard signed integer types, <a href="#6.2.5">6.2.5</a>
+snprintf function, <a href="#7.19.6.5">7.19.6.5</a>, <a href="#7.19.6.12">7.19.6.12</a>                       state-dependent encoding, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#7.20.7">7.20.7</a>
+sorting utility functions, <a href="#7.20.5">7.20.5</a>                            statements, <a href="#6.8">6.8</a>
+source character set, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>                            break, <a href="#6.8.6.3">6.8.6.3</a>
+source file, <a href="#5.1.1.1">5.1.1.1</a>                                             compound, <a href="#6.8.2">6.8.2</a>
+   name, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8">6.10.8</a>                                         continue, <a href="#6.8.6.2">6.8.6.2</a>
+source file inclusion, <a href="#6.10.2">6.10.2</a>                                    do, <a href="#6.8.5.2">6.8.5.2</a>
+
+[<a name="p536" href="#p536">page 536</a>] (<a href="#Contents">Contents</a>)
+
+   else, <a href="#6.8.4.1">6.8.4.1</a>                                             strictly conforming program, <a href="#4">4</a>
+   expression, <a href="#6.8.3">6.8.3</a>                                         string, <a href="#7.1.1">7.1.1</a>
+   for, <a href="#6.8.5.3">6.8.5.3</a>                                                 comparison functions, <a href="#7.21.4">7.21.4</a>
+   goto, <a href="#6.8.6.1">6.8.6.1</a>                                                concatenation functions, <a href="#7.21.3">7.21.3</a>
+   if, <a href="#6.8.4.1">6.8.4.1</a>                                                  conversion functions, <a href="#7.11.1.1">7.11.1.1</a>
+   iteration, <a href="#6.8.5">6.8.5</a>                                             copying functions, <a href="#7.21.2">7.21.2</a>
+   jump, <a href="#6.8.6">6.8.6</a>                                                  library function conventions, <a href="#7.21.1">7.21.1</a>
+   labeled, <a href="#6.8.1">6.8.1</a>                                               literal, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.7.8">6.7.8</a>
+   null, <a href="#6.8.3">6.8.3</a>                                                  miscellaneous functions, <a href="#7.21.6">7.21.6</a>
+   return, <a href="#6.8.6.4">6.8.6.4</a>                                              numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1">7.20.1</a>
+   selection, <a href="#6.8.4">6.8.4</a>                                             search functions, <a href="#7.21.5">7.21.5</a>
+   sequencing, <a href="#6.8">6.8</a>                                           string handling header, <a href="#7.21">7.21</a>
+   switch, <a href="#6.8.4.2">6.8.4.2</a>                                           string.h header, <a href="#7.21">7.21</a>, <a href="#7.26.11">7.26.11</a>
+   while, <a href="#6.8.5.1">6.8.5.1</a>                                            stringizing, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.9">6.10.9</a>
+static storage duration, <a href="#6.2.4">6.2.4</a>                               strlen function, <a href="#7.21.6.3">7.21.6.3</a>
+static storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.7.1">6.7.1</a>           strncat function, <a href="#7.21.3.2">7.21.3.2</a>
+static, in array declarators, <a href="#6.7.5.2">6.7.5.2</a>, <a href="#6.7.5.3">6.7.5.3</a>               strncmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.4">7.21.4.4</a>
+stdarg.h header, <a href="#4">4</a>, <a href="#6.7.5.3">6.7.5.3</a>, <a href="#7.15">7.15</a>                            strncpy function, <a href="#7.21.2.4">7.21.2.4</a>
+stdbool.h header, <a href="#4">4</a>, <a href="#7.16">7.16</a>, <a href="#7.26.7">7.26.7</a>, <a href="#H">H</a>                         strpbrk function, <a href="#7.21.5.4">7.21.5.4</a>
+STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                                         strrchr function, <a href="#7.21.5.5">7.21.5.5</a>
+stddef.h header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,               strspn function, <a href="#7.21.5.6">7.21.5.6</a>
+      <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.17">7.17</a>                            strstr function, <a href="#7.21.5.7">7.21.5.7</a>
+stderr macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>                         strtod function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.3">7.20.1.3</a>,
+stdin macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.4">7.19.6.4</a>,                     <a href="#7.24.2.2">7.24.2.2</a>, <a href="#F.3">F.3</a>
+      <a href="#7.19.7.6">7.19.7.6</a>, <a href="#7.19.7.7">7.19.7.7</a>, <a href="#7.24.2.12">7.24.2.12</a>, <a href="#7.24.3.7">7.24.3.7</a>                strtof function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.3">F.3</a>
+stdint.h header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.18">7.18</a>,              strtoimax function, <a href="#7.8.2.3">7.8.2.3</a>
+      <a href="#7.26.8">7.26.8</a>                                                 strtok function, <a href="#7.21.5.8">7.21.5.8</a>
+stdio.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19">7.19</a>, <a href="#7.26.9">7.26.9</a>, <a href="#F">F</a>                   strtol function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.2">7.20.1.2</a>,
+stdlib.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.20">7.20</a>, <a href="#7.26.10">7.26.10</a>, <a href="#F">F</a>                       <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>
+stdout macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.3">7.19.6.3</a>,              strtold function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.20.1.3">7.20.1.3</a>, <a href="#F.3">F.3</a>
+      <a href="#7.19.7.9">7.19.7.9</a>, <a href="#7.19.7.10">7.19.7.10</a>, <a href="#7.24.2.11">7.24.2.11</a>, <a href="#7.24.3.9">7.24.3.9</a>               strtoll function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1.2">7.20.1.2</a>, <a href="#7.20.1.4">7.20.1.4</a>
+storage duration, <a href="#6.2.4">6.2.4</a>                                      strtoul function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20.1.2">7.20.1.2</a>,
+storage order of array, <a href="#6.5.2.1">6.5.2.1</a>                                    <a href="#7.20.1.4">7.20.1.4</a>, <a href="#7.24.2.2">7.24.2.2</a>
+storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a>                       strtoull function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.20.1.2">7.20.1.2</a>, <a href="#7.20.1.4">7.20.1.4</a>
+strcat function, <a href="#7.21.3.1">7.21.3.1</a>                                    strtoumax function, <a href="#7.8.2.3">7.8.2.3</a>
+strchr function, <a href="#7.21.5.2">7.21.5.2</a>                                    struct hack, see flexible array member
+strcmp function, <a href="#7.21.4">7.21.4</a>, <a href="#7.21.4.2">7.21.4.2</a>                            structure
+strcoll function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.5">7.21.4.5</a>                  arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+strcpy function, <a href="#7.21.2.3">7.21.2.3</a>                                       content, <a href="#6.7.2.3">6.7.2.3</a>
+strcspn function, <a href="#7.21.5.3">7.21.5.3</a>                                      dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>
+streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.20.4.3">7.20.4.3</a>                                       initialization, <a href="#6.7.8">6.7.8</a>
+   fully buffered, <a href="#7.19.3">7.19.3</a>                                       member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+   line buffered, <a href="#7.19.3">7.19.3</a>                                        member name space, <a href="#6.2.3">6.2.3</a>
+   orientation, <a href="#7.19.2">7.19.2</a>                                          member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>
+   standard error, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                               pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+   standard input, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                               specifier, <a href="#6.7.2.1">6.7.2.1</a>
+   standard output, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.3">7.19.3</a>                              tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+   unbuffered, <a href="#7.19.3">7.19.3</a>                                           type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>
+strerror function, <a href="#7.19.10.4">7.19.10.4</a>, <a href="#7.21.6.2">7.21.6.2</a>                       strxfrm function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.4.5">7.21.4.5</a>
+strftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.3">7.23.3</a>, <a href="#7.23.3.5">7.23.3.5</a>,               subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+      <a href="#7.24.5.1">7.24.5.1</a>                                               subtraction assignment operator (-=), <a href="#6.5.16.2">6.5.16.2</a>
+
+[<a name="p537" href="#p537">page 537</a>] (<a href="#Contents">Contents</a>)
+
+subtraction operator (-), <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                   tolower function, <a href="#7.4.2.1">7.4.2.1</a>
+suffix                                                         toupper function, <a href="#7.4.2.2">7.4.2.2</a>
+  floating constant, <a href="#6.4.4.2">6.4.4.2</a>                                   towctrans function, <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+  integer constant, <a href="#6.4.4.1">6.4.4.1</a>                                   towlower function, <a href="#7.25.3.1.1">7.25.3.1.1</a>, <a href="#7.25.3.2.1">7.25.3.2.1</a>
+switch body, <a href="#6.8.4.2">6.8.4.2</a>                                          towupper function, <a href="#7.25.3.1.2">7.25.3.1.2</a>, <a href="#7.25.3.2.1">7.25.3.2.1</a>
+switch case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                             translation environment, <a href="#5">5</a>, <a href="#5.1.1">5.1.1</a>
+switch default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                          translation limits, <a href="#5.2.4.1">5.2.4.1</a>
+switch statement, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                              translation phases, <a href="#5.1.1.2">5.1.1.2</a>
+swprintf function, <a href="#7.24.2.3">7.24.2.3</a>, <a href="#7.24.2.7">7.24.2.7</a>                         translation unit, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.9">6.9</a>
+swscanf function, <a href="#7.24.2.4">7.24.2.4</a>, <a href="#7.24.2.8">7.24.2.8</a>                          trap representation, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.2.3">6.3.2.3</a>,
+symbols, <a href="#3">3</a>                                                          <a href="#6.5.2.3">6.5.2.3</a>
+syntactic categories, <a href="#6.1">6.1</a>                                     trigonometric functions
+syntax notation, <a href="#6.1">6.1</a>                                             complex, <a href="#7.3.5">7.3.5</a>, <a href="#G.6.1">G.6.1</a>
+syntax rule precedence, <a href="#5.1.1.2">5.1.1.2</a>                                  real, <a href="#7.12.4">7.12.4</a>, <a href="#F.9.1">F.9.1</a>
+syntax summary, language, <a href="#A">A</a>                                   trigraph sequences, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1.1">5.2.1.1</a>
+system function, <a href="#7.20.4.6">7.20.4.6</a>                                     true macro, <a href="#7.16">7.16</a>
+                                                              trunc functions, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#F.9.6.8">F.9.6.8</a>
+tab characters, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                                    trunc type-generic macro, <a href="#7.22">7.22</a>
+tag compatibility, <a href="#6.2.7">6.2.7</a>                                      truncation, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.5.3">7.19.5.3</a>
+tag name space, <a href="#6.2.3">6.2.3</a>                                         truncation toward zero, <a href="#6.5.5">6.5.5</a>
+tags, <a href="#6.7.2.3">6.7.2.3</a>                                                 two's complement, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.18.1.1">7.18.1.1</a>
+tan functions, <a href="#7.12.4.7">7.12.4.7</a>, <a href="#F.9.1.7">F.9.1.7</a>                              type category, <a href="#6.2.5">6.2.5</a>
+tan type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                             type conversion, <a href="#6.3">6.3</a>
+tanh functions, <a href="#7.12.5.6">7.12.5.6</a>, <a href="#F.9.2.6">F.9.2.6</a>                             type definitions, <a href="#6.7.7">6.7.7</a>
+tanh type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                            type domain, <a href="#6.2.5">6.2.5</a>, <a href="#G.2">G.2</a>
+tentative definition, <a href="#6.9.2">6.9.2</a>                                    type names, <a href="#6.7.6">6.7.6</a>
+terms, <a href="#3">3</a>                                                      type punning, <a href="#6.5.2.3">6.5.2.3</a>
+text streams, <a href="#7.19.2">7.19.2</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>, <a href="#7.19.9.4">7.19.9.4</a>           type qualifiers, <a href="#6.7.3">6.7.3</a>
+tgamma functions, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#F.9.5.4">F.9.5.4</a>                           type specifiers, <a href="#6.7.2">6.7.2</a>
+tgamma type-generic macro, <a href="#7.22">7.22</a>                               type-generic macro, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>
+tgmath.h header, <a href="#7.22">7.22</a>, <a href="#G.7">G.7</a>                                    typedef declaration, <a href="#6.7.7">6.7.7</a>
+time                                                          typedef storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.7.7">6.7.7</a>
+   broken down, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.3">7.23.3</a>, <a href="#7.23.3.1">7.23.3.1</a>,           types, <a href="#6.2.5">6.2.5</a>
+         <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>, <a href="#7.23.3.5">7.23.3.5</a>                            character, <a href="#6.7.8">6.7.8</a>
+   calendar, <a href="#7.23.1">7.23.1</a>, <a href="#7.23.2.2">7.23.2.2</a>, <a href="#7.23.2.3">7.23.2.3</a>, <a href="#7.23.2.4">7.23.2.4</a>,               compatible, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.5">6.7.5</a>
+         <a href="#7.23.3.2">7.23.3.2</a>, <a href="#7.23.3.3">7.23.3.3</a>, <a href="#7.23.3.4">7.23.3.4</a>                            complex, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>
+   components, <a href="#7.23.1">7.23.1</a>                                            composite, <a href="#6.2.7">6.2.7</a>
+   conversion functions, <a href="#7.23.3">7.23.3</a>                                  const qualified, <a href="#6.7.3">6.7.3</a>
+      wide character, <a href="#7.24.5">7.24.5</a>                                     conversions, <a href="#6.3">6.3</a>
+   local, <a href="#7.23.1">7.23.1</a>                                                 imaginary, <a href="#G">G</a>
+   manipulation functions, <a href="#7.23.2">7.23.2</a>                                restrict qualified, <a href="#6.7.3">6.7.3</a>
+time function, <a href="#7.23.2.4">7.23.2.4</a>                                          volatile qualified, <a href="#6.7.3">6.7.3</a>
+time.h header, <a href="#7.23">7.23</a>
+time_t type, <a href="#7.23.1">7.23.1</a>                                           UCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+tm structure type, <a href="#7.23.1">7.23.1</a>, <a href="#7.24.1">7.24.1</a>                             UINT_FASTN_MAX macros, <a href="#7.18.2.3">7.18.2.3</a>
+TMP_MAX macro, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.19.4.4">7.19.4.4</a>                     uint_fastN_t types, <a href="#7.18.1.3">7.18.1.3</a>
+tmpfile function, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.20.4.3">7.20.4.3</a>                          UINT_LEASTN_MAX macros, <a href="#7.18.2.2">7.18.2.2</a>
+tmpnam function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.4.3">7.19.4.3</a>, <a href="#7.19.4.4">7.19.4.4</a>                   uint_leastN_t types, <a href="#7.18.1.2">7.18.1.2</a>
+token, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, see also preprocessing tokens            UINT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+token concatenation, <a href="#6.10.3.3">6.10.3.3</a>                                 UINTMAX_C macro, <a href="#7.18.4.2">7.18.4.2</a>
+token pasting, <a href="#6.10.3.3">6.10.3.3</a>                                       UINTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.18.2.5">7.18.2.5</a>
+
+[<a name="p538" href="#p538">page 538</a>] (<a href="#Contents">Contents</a>)
+
+uintmax_t type, <a href="#7.18.1.5">7.18.1.5</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,               USHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                     usual arithmetic conversions, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.5.5">6.5.5</a>, <a href="#6.5.6">6.5.6</a>,
+UINTN_C macros, <a href="#7.18.4.1">7.18.4.1</a>                                          <a href="#6.5.8">6.5.8</a>, <a href="#6.5.9">6.5.9</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>, <a href="#6.5.15">6.5.15</a>
+UINTN_MAX macros, <a href="#7.18.2.1">7.18.2.1</a>                                  utilities, general, <a href="#7.20">7.20</a>
+uintN_t types, <a href="#7.18.1.1">7.18.1.1</a>                                        wide string, <a href="#7.24.4">7.24.4</a>
+UINTPTR_MAX macro, <a href="#7.18.2.4">7.18.2.4</a>
+uintptr_t type, <a href="#7.18.1.4">7.18.1.4</a>                                    va_arg macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.2">7.15.1.2</a>,
+ULLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,                           <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>,
+     <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                  <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
+ULONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.20.1.4">7.20.1.4</a>,                            <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>,
+     <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                  <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
+unary arithmetic operators, <a href="#6.5.3.3">6.5.3.3</a>                         va_copy macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>, <a href="#7.15.1.2">7.15.1.2</a>,
+unary expression, <a href="#6.5.3">6.5.3</a>                                          <a href="#7.15.1.3">7.15.1.3</a>
+unary minus operator (-), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>                      va_end macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.3">7.15.1.3</a>,
+unary operators, <a href="#6.5.3">6.5.3</a>                                           <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>,
+unary plus operator (+), <a href="#6.5.3.3">6.5.3.3</a>                                 <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>, <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>,
+unbuffered stream, <a href="#7.19.3">7.19.3</a>                                        <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>,
+undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,                  <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
+     <a href="#7.1.4">7.1.4</a>                                                  va_list type, <a href="#7.15">7.15</a>, <a href="#7.15.1.3">7.15.1.3</a>
+undefined behavior, <a href="#3.4.3">3.4.3</a>, <a href="#4">4</a>, <a href="#J.2">J.2</a>                            va_start macro, <a href="#7.15">7.15</a>, <a href="#7.15.1">7.15.1</a>, <a href="#7.15.1.1">7.15.1.1</a>,
+underscore character, <a href="#6.4.2.1">6.4.2.1</a>                                    <a href="#7.15.1.2">7.15.1.2</a>, <a href="#7.15.1.3">7.15.1.3</a>, <a href="#7.15.1.4">7.15.1.4</a>, <a href="#7.19.6.8">7.19.6.8</a>,
+underscore, leading, in identifier, <a href="#7.1.3">7.1.3</a>                         <a href="#7.19.6.9">7.19.6.9</a>, <a href="#7.19.6.10">7.19.6.10</a>, <a href="#7.19.6.11">7.19.6.11</a>, <a href="#7.19.6.12">7.19.6.12</a>,
+ungetc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.7.11">7.19.7.11</a>, <a href="#7.19.9.2">7.19.9.2</a>,                    <a href="#7.19.6.13">7.19.6.13</a>, <a href="#7.19.6.14">7.19.6.14</a>, <a href="#7.24.2.5">7.24.2.5</a>, <a href="#7.24.2.6">7.24.2.6</a>,
+     <a href="#7.19.9.3">7.19.9.3</a>                                                    <a href="#7.24.2.7">7.24.2.7</a>, <a href="#7.24.2.8">7.24.2.8</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.10">7.24.2.10</a>
+ungetwc function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3.10">7.24.3.10</a>                         value, <a href="#3.17">3.17</a>
+Unicode required set, <a href="#6.10.8">6.10.8</a>                                value bits, <a href="#6.2.6.2">6.2.6.2</a>
+union                                                       variable arguments, <a href="#6.10.3">6.10.3</a>, <a href="#7.15">7.15</a>
+  arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                              variable arguments header, <a href="#7.15">7.15</a>
+  content, <a href="#6.7.2.3">6.7.2.3</a>                                          variable length array, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
+  dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                 variably modified type, <a href="#6.7.5">6.7.5</a>, <a href="#6.7.5.2">6.7.5.2</a>
+  initialization, <a href="#6.7.8">6.7.8</a>                                     vertical-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+  member alignment, <a href="#6.7.2.1">6.7.2.1</a>                                 vertical-tab escape sequence (\v), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+  member name space, <a href="#6.2.3">6.2.3</a>                                       <a href="#7.4.1.10">7.4.1.10</a>
+  member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>                     vfprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>
+  pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                            vfscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.9">7.19.6.9</a>
+  specifier, <a href="#6.7.2.1">6.7.2.1</a>                                         vfwprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.5">7.24.2.5</a>
+  tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>                                       vfwscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.6">7.24.2.6</a>, <a href="#7.24.3.10">7.24.3.10</a>
+  type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>                                      visibility of identifier, <a href="#6.2.1">6.2.1</a>
+universal character name, <a href="#6.4.3">6.4.3</a>                             VLA, see variable length array
+unqualified type, <a href="#6.2.5">6.2.5</a>                                      void expression, <a href="#6.3.2.2">6.3.2.2</a>
+unqualified version of type, <a href="#6.2.5">6.2.5</a>                           void function parameter, <a href="#6.7.5.3">6.7.5.3</a>
+unsigned integer suffix, u or <a href="#U">U</a>, <a href="#6.4.4.1">6.4.4.1</a>                     void type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.7.2">6.7.2</a>
+unsigned integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>             void type conversion, <a href="#6.3.2.2">6.3.2.2</a>
+unsigned type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,                 volatile storage, <a href="#5.1.2.3">5.1.2.3</a>
+     <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                       volatile type qualifier, <a href="#6.7.3">6.7.3</a>
+unsigned types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>,           volatile-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
+     <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                     vprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.10">7.19.6.10</a>
+unspecified behavior, <a href="#3.4.4">3.4.4</a>, <a href="#4">4</a>, <a href="#J.1">J.1</a>                          vscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.11">7.19.6.11</a>
+unspecified value, <a href="#3.17.3">3.17.3</a>                                    vsnprintf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.12">7.19.6.12</a>
+uppercase letter, <a href="#5.2.1">5.2.1</a>                                     vsprintf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.13">7.19.6.13</a>
+use of library functions, <a href="#7.1.4">7.1.4</a>                             vsscanf function, <a href="#7.19.6.8">7.19.6.8</a>, <a href="#7.19.6.14">7.19.6.14</a>
+
+[<a name="p539" href="#p539">page 539</a>] (<a href="#Contents">Contents</a>)
+
+vswprintf function, <a href="#7.24.2.7">7.24.2.7</a>                                  wctype.h header, <a href="#7.25">7.25</a>, <a href="#7.26.13">7.26.13</a>
+vswscanf function, <a href="#7.24.2.8">7.24.2.8</a>                                   wctype_t type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
+vwprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.9">7.24.2.9</a>                           WEOF macro, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.3.1">7.24.3.1</a>, <a href="#7.24.3.3">7.24.3.3</a>, <a href="#7.24.3.6">7.24.3.6</a>,
+vwscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.3.10">7.24.3.10</a>                     <a href="#7.24.3.7">7.24.3.7</a>, <a href="#7.24.3.8">7.24.3.8</a>, <a href="#7.24.3.9">7.24.3.9</a>, <a href="#7.24.3.10">7.24.3.10</a>,
+                                                                   <a href="#7.24.6.1.1">7.24.6.1.1</a>, <a href="#7.25.1">7.25.1</a>
+warnings, <a href="#I">I</a>                                                   while statement, <a href="#6.8.5.1">6.8.5.1</a>
+wchar.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.19.1">7.19.1</a>, <a href="#7.24">7.24</a>, <a href="#7.26.12">7.26.12</a>,             white space, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+    <a href="#F">F</a>                                                              <a href="#7.25.2.1.10">7.25.2.1.10</a>
+WCHAR_MAX macro, <a href="#7.18.3">7.18.3</a>, <a href="#7.24.1">7.24.1</a>                               white-space characters, <a href="#6.4">6.4</a>
+WCHAR_MIN macro, <a href="#7.18.3">7.18.3</a>, <a href="#7.24.1">7.24.1</a>                               wide character, <a href="#3.7.3">3.7.3</a>
+wchar_t type, <a href="#3.7.3">3.7.3</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.8">6.7.8</a>,                     case mapping functions, <a href="#7.25.3.1">7.25.3.1</a>
+    <a href="#6.10.8">6.10.8</a>, <a href="#7.17">7.17</a>, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.20">7.20</a>,                extensible, <a href="#7.25.3.2">7.25.3.2</a>
+    <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>, <a href="#7.24.2.2">7.24.2.2</a>                                  classification functions, <a href="#7.25.2.1">7.25.2.1</a>
+wcrtomb function, <a href="#7.19.3">7.19.3</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                      extensible, <a href="#7.25.2.2">7.25.2.2</a>
+    <a href="#7.24.6.3.3">7.24.6.3.3</a>, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                      constant, <a href="#6.4.4.4">6.4.4.4</a>
+wcscat function, <a href="#7.24.4.3.1">7.24.4.3.1</a>                                     formatted input/output functions, <a href="#7.24.2">7.24.2</a>
+wcschr function, <a href="#7.24.4.5.1">7.24.4.5.1</a>                                     input functions, <a href="#7.19.1">7.19.1</a>
+wcscmp function, <a href="#7.24.4.4.1">7.24.4.4.1</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>                         input/output functions, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.3">7.24.3</a>
+wcscoll function, <a href="#7.24.4.4.2">7.24.4.4.2</a>, <a href="#7.24.4.4.4">7.24.4.4.4</a>                        output functions, <a href="#7.19.1">7.19.1</a>
+wcscpy function, <a href="#7.24.4.2.1">7.24.4.2.1</a>                                     single-byte conversion functions, <a href="#7.24.6.1">7.24.6.1</a>
+wcscspn function, <a href="#7.24.4.5.2">7.24.4.5.2</a>                                  wide string, <a href="#7.1.1">7.1.1</a>
+wcsftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.24.5.1">7.24.5.1</a>                         wide string comparison functions, <a href="#7.24.4.4">7.24.4.4</a>
+wcslen function, <a href="#7.24.4.6.1">7.24.4.6.1</a>                                   wide string concatenation functions, <a href="#7.24.4.3">7.24.4.3</a>
+wcsncat function, <a href="#7.24.4.3.2">7.24.4.3.2</a>                                  wide string copying functions, <a href="#7.24.4.2">7.24.4.2</a>
+wcsncmp function, <a href="#7.24.4.4.3">7.24.4.4.3</a>                                  wide string literal, see string literal
+wcsncpy function, <a href="#7.24.4.2.2">7.24.4.2.2</a>                                  wide string miscellaneous functions, <a href="#7.24.4.6">7.24.4.6</a>
+wcspbrk function, <a href="#7.24.4.5.3">7.24.4.5.3</a>                                  wide string numeric conversion functions, <a href="#7.8.2.4">7.8.2.4</a>,
+wcsrchr function, <a href="#7.24.4.5.4">7.24.4.5.4</a>                                       <a href="#7.24.4.1">7.24.4.1</a>
+wcsrtombs function, <a href="#7.24.6.4.2">7.24.6.4.2</a>                                wide string search functions, <a href="#7.24.4.5">7.24.4.5</a>
+wcsspn function, <a href="#7.24.4.5.5">7.24.4.5.5</a>                                   wide-oriented stream, <a href="#7.19.2">7.19.2</a>
+wcsstr function, <a href="#7.24.4.5.6">7.24.4.5.6</a>                                   width, <a href="#6.2.6.2">6.2.6.2</a>
+wcstod function, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>                           WINT_MAX macro, <a href="#7.18.3">7.18.3</a>
+wcstod function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                   WINT_MIN macro, <a href="#7.18.3">7.18.3</a>
+wcstof function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                   wint_t type, <a href="#7.18.3">7.18.3</a>, <a href="#7.19.6.1">7.19.6.1</a>, <a href="#7.24.1">7.24.1</a>, <a href="#7.24.2.1">7.24.2.1</a>,
+wcstoimax function, <a href="#7.8.2.4">7.8.2.4</a>                                        <a href="#7.25.1">7.25.1</a>
+wcstok function, <a href="#7.24.4.5.7">7.24.4.5.7</a>                                   wmemchr function, <a href="#7.24.4.5.8">7.24.4.5.8</a>
+wcstol function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                 wmemcmp function, <a href="#7.24.4.4.5">7.24.4.4.5</a>
+    <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                wmemcpy function, <a href="#7.24.4.2.3">7.24.4.2.3</a>
+wcstold function, <a href="#7.24.4.1.1">7.24.4.1.1</a>                                  wmemmove function, <a href="#7.24.4.2.4">7.24.4.2.4</a>
+wcstoll function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>                         wmemset function, <a href="#7.24.4.6.2">7.24.4.6.2</a>
+wcstombs function, <a href="#7.20.8.2">7.20.8.2</a>, <a href="#7.24.6.4">7.24.6.4</a>                         wprintf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.9">7.24.2.9</a>, <a href="#7.24.2.11">7.24.2.11</a>
+wcstoul function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.19.6.2">7.19.6.2</a>, <a href="#7.24.2.2">7.24.2.2</a>,                wscanf function, <a href="#7.19.1">7.19.1</a>, <a href="#7.24.2.10">7.24.2.10</a>, <a href="#7.24.2.12">7.24.2.12</a>,
+    <a href="#7.24.4.1.2">7.24.4.1.2</a>                                                     <a href="#7.24.3.10">7.24.3.10</a>
+wcstoull function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.24.4.1.2">7.24.4.1.2</a>
+wcstoumax function, <a href="#7.8.2.4">7.8.2.4</a>                                   xor macro, <a href="#7.9">7.9</a>
+wcsxfrm function, <a href="#7.24.4.4.4">7.24.4.4.4</a>                                  xor_eq macro, <a href="#7.9">7.9</a>
+wctob function, <a href="#7.24.6.1.2">7.24.6.1.2</a>, <a href="#7.25.2.1">7.25.2.1</a>
+wctomb function, <a href="#7.20.7.3">7.20.7.3</a>, <a href="#7.20.8.2">7.20.8.2</a>, <a href="#7.24.6.3">7.24.6.3</a>
+wctrans function, <a href="#7.25.3.2.1">7.25.3.2.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+wctrans_t type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.3.2.2">7.25.3.2.2</a>
+wctype function, <a href="#7.25.2.2.1">7.25.2.2.1</a>, <a href="#7.25.2.2.2">7.25.2.2.2</a>
+
+[<a name="p540" href="#p540">page 540</a>] (<a href="#Contents">Contents</a>)
+</pre></body></html>
diff --git a/n1548.html b/n1548.html
index 8ef750a..2c86244 100644
--- a/n1548.html
+++ b/n1548.html
@@ -1,4 +1,5 @@
-<html><head><title>N1548                    Committee Draft -- December 2, 2010          ISO/IEC 9899:201x</title></head><body><pre>
+<html><head><title>C</title></head><body>
+<pre><!--page 1 indent 0-->
 N1548                    Committee Draft -- December 2, 2010          ISO/IEC 9899:201x
 
 
@@ -9,7 +10,10 @@ INTERNATIONAL STANDARD                         (C)ISO/IEC              ISO/IEC 9
 
 
 
-Programming languages -- C
+</pre>
+
+<h1>Programming languages -- C</h1>
+<pre>
 
 
                                        ABSTRACT
@@ -36,26288 +40,31864 @@ relevant patent rights of which they are aware and to provide supporting documen
 
 Changes from the previous draft (N1256) are indicated by ''diff marks'' in the right
 margin: deleted text is marked with ''*'', new or changed text with '' ''.
-
-[page i]
-
-
-[page ii]
-
-<a name="Contents" href="#Contents">Contents</a>
-<a href="#Foreword">Foreword       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                 xiii</a>
-<a href="#Introduction">Introduction    . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii</a>
-<a href="#1">1. Scope       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                   1</a>
-<a href="#2">2. Normative references     . . . . . . . . . . . . . . . . . . . . . . .                                  2</a>
-<a href="#3">3. Terms, definitions, and symbols    . . . . . . . . . . . . . . . . . . .                                 3</a>
-<a href="#4">4. Conformance       . . . . . . . . . . . . . . . . . . . . . . . . . .                                   8</a>
-<a href="#5">5. Environment    . . . . . . . . . . .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10</a>
-<a href="#5.1">   5.1 Conceptual models       . . . . . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10</a>
-<a href="#5.1.1">        5.1.1  Translation environment .      . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10</a>
-<a href="#5.1.2">        5.1.2  Execution environments     .   . .   .   .   .   .   .   .   .    .   .   .   .   .   .    12</a>
-<a href="#5.2">   5.2 Environmental considerations    . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    22</a>
-<a href="#5.2.1">        5.2.1  Character sets    . . . . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    22</a>
-<a href="#5.2.2">        5.2.2  Character display semantics      .   .   .   .   .   .   .   .    .   .   .   .   .   .    24</a>
-<a href="#5.2.3">        5.2.3  Signals and interrupts . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .    25</a>
-<a href="#5.2.4">        5.2.4  Environmental limits    . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    25</a>
-<a href="#6">6. Language . . . . . . . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .    35</a>
-<a href="#6.1">   6.1 Notation . . . . . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .    35</a>
-<a href="#6.2">   6.2 Concepts       . . . . . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .    35</a>
-<a href="#6.2.1">        6.2.1   Scopes of identifiers     . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    35</a>
-<a href="#6.2.2">        6.2.2   Linkages of identifiers . . . . .        .   .   .   .   .   .    .   .   .   .   .   .    36</a>
-<a href="#6.2.3">        6.2.3   Name spaces of identifiers      . . .    .   .   .   .   .   .    .   .   .   .   .   .    37</a>
-<a href="#6.2.4">        6.2.4   Storage durations of objects     . .    .   .   .   .   .   .    .   .   .   .   .   .    38</a>
-<a href="#6.2.5">        6.2.5   Types       . . . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    39</a>
-<a href="#6.2.6">        6.2.6   Representations of types . . . .        .   .   .   .   .   .    .   .   .   .   .   .    44</a>
-<a href="#6.2.7">        6.2.7   Compatible type and composite type          .   .   .   .   .    .   .   .   .   .   .    47</a>
-<a href="#6.2.8">        6.2.8   Alignment of objects     . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    48</a>
-<a href="#6.3">   6.3 Conversions       . . . . . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .    50</a>
-<a href="#6.3.1">        6.3.1   Arithmetic operands      . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    50</a>
-<a href="#6.3.2">        6.3.2   Other operands       . . . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    54</a>
-<a href="#6.4">   6.4 Lexical elements       . . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    57</a>
-<a href="#6.4.1">        6.4.1   Keywords . . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .    58</a>
-<a href="#6.4.2">        6.4.2   Identifiers . . . . . . . . . .          .   .   .   .   .   .    .   .   .   .   .   .    59</a>
-<a href="#6.4.3">        6.4.3   Universal character names      . . .    .   .   .   .   .   .    .   .   .   .   .   .    61</a>
-<a href="#6.4.4">        6.4.4   Constants . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .    62</a>
-<a href="#6.4.5">        6.4.5   String literals   . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    70</a>
-<a href="#6.4.6">        6.4.6   Punctuators . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .    72</a>
-<a href="#6.4.7">        6.4.7   Header names      . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    73</a>
-<a href="#6.4.8">        6.4.8   Preprocessing numbers        . . . .    .   .   .   .   .   .    .   .   .   .   .   .    74</a>
-<a href="#6.4.9">        6.4.9   Comments        . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    75</a>
-
-[page iii]
-
-<a href="#6.5">     6.5  Expressions      . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    76</a>
-<a href="#6.5.1">          6.5.1   Primary expressions      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    78</a>
-<a href="#6.5.2">          6.5.2   Postfix operators . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    79</a>
-<a href="#6.5.3">          6.5.3   Unary operators      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    88</a>
-<a href="#6.5.4">          6.5.4   Cast operators . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    91</a>
-<a href="#6.5.5">          6.5.5   Multiplicative operators   . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    92</a>
-<a href="#6.5.6">          6.5.6   Additive operators     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    92</a>
-<a href="#6.5.7">          6.5.7   Bitwise shift operators . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .    94</a>
-<a href="#6.5.8">          6.5.8   Relational operators . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    95</a>
-<a href="#6.5.9">          6.5.9   Equality operators     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    96</a>
-<a href="#6.5.10">          6.5.10 Bitwise AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    97</a>
-<a href="#6.5.11">          6.5.11 Bitwise exclusive OR operator         .   .   .   .   .   .   .   .   .   .   .   .   .    98</a>
-<a href="#6.5.12">          6.5.12 Bitwise inclusive OR operator     .   .   .   .   .   .   .   .   .   .   .   .   .   .    98</a>
-<a href="#6.5.13">          6.5.13 Logical AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    99</a>
-<a href="#6.5.14">          6.5.14 Logical OR operator       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    99</a>
-<a href="#6.5.15">          6.5.15 Conditional operator      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   100</a>
-<a href="#6.5.16">          6.5.16 Assignment operators . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   101</a>
-<a href="#6.5.17">          6.5.17 Comma operator . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .   104</a>
-<a href="#6.6">     6.6 Constant expressions . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   105</a>
-<a href="#6.7">     6.7 Declarations      . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   107</a>
-<a href="#6.7.1">          6.7.1   Storage-class specifiers    . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   108</a>
-<a href="#6.7.2">          6.7.2   Type specifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   109</a>
-<a href="#6.7.3">          6.7.3   Type qualifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   120</a>
-<a href="#6.7.4">          6.7.4   Function specifiers     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   124</a>
-<a href="#6.7.5">          6.7.5   Alignment specifier . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   126</a>
-<a href="#6.7.6">          6.7.6   Declarators     . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   127</a>
-<a href="#6.7.7">          6.7.7   Type names . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   135</a>
-<a href="#6.7.8">          6.7.8   Type definitions      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   136</a>
-<a href="#6.7.9">          6.7.9   Initialization    . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   138</a>
-<a href="#6.7.10">          6.7.10 Static assertions     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   144</a>
-<a href="#6.8">     6.8 Statements and blocks      . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   145</a>
-<a href="#6.8.1">          6.8.1   Labeled statements     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   145</a>
-<a href="#6.8.2">          6.8.2   Compound statement       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   146</a>
-<a href="#6.8.3">          6.8.3   Expression and null statements       .   .   .   .   .   .   .   .   .   .   .   .   .   146</a>
-<a href="#6.8.4">          6.8.4   Selection statements     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147</a>
-<a href="#6.8.5">          6.8.5   Iteration statements . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   149</a>
-<a href="#6.8.6">          6.8.6   Jump statements      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   150</a>
-<a href="#6.9">     6.9 External definitions      . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   154</a>
-<a href="#6.9.1">          6.9.1   Function definitions . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   155</a>
-<a href="#6.9.2">          6.9.2   External object definitions   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   157</a>
-<a href="#6.10">     6.10 Preprocessing directives     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   159</a>
-<a href="#6.10.1">          6.10.1 Conditional inclusion     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   161</a>
-<a href="#6.10.2">          6.10.2 Source file inclusion      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   163</a>
-<a href="#6.10.3">          6.10.3 Macro replacement . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   165</a>
-
-[page iv]
-
-<a href="#6.10.4">       6.10.4 Line control . . . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   172</a>
-<a href="#6.10.5">       6.10.5 Error directive . . . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   173</a>
-<a href="#6.10.6">       6.10.6 Pragma directive . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   173</a>
-<a href="#6.10.7">       6.10.7 Null directive      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174</a>
-<a href="#6.10.8">       6.10.8 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174</a>
-<a href="#6.10.9">       6.10.9 Pragma operator       . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   176</a>
-<a href="#6.11">  6.11 Future language directions     . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.1">       6.11.1 Floating types      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.2">       6.11.2 Linkages of identifiers . .      .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.3">       6.11.3 External names        . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.4">       6.11.4 Character escape sequences          .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.5">       6.11.5 Storage-class specifiers     .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.6">       6.11.6 Function declarators      . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.7">       6.11.7 Function definitions . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.8">       6.11.8 Pragma directives       . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#6.11.9">       6.11.9 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
-<a href="#7">7. Library . . . . . . . . . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   179</a>
-<a href="#7.1">   7.1 Introduction     . . . . . . . . . . . . .             .   .   .   .   .    .   .   .   .   .   .   179</a>
-<a href="#7.1.1">         7.1.1 Definitions of terms . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   179</a>
-<a href="#7.1.2">         7.1.2 Standard headers . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   180</a>
-<a href="#7.1.3">         7.1.3 Reserved identifiers . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   181</a>
-<a href="#7.1.4">         7.1.4 Use of library functions    . . . . .          .   .   .   .   .    .   .   .   .   .   .   182</a>
-<a href="#7.2">   7.2 Diagnostics &lt;assert.h&gt;          . . . . . . .          .   .   .   .   .    .   .   .   .   .   .   185</a>
-<a href="#7.2.1">         7.2.1 Program diagnostics       . . . . . .          .   .   .   .   .    .   .   .   .   .   .   185</a>
-<a href="#7.3">   7.3 Complex arithmetic &lt;complex.h&gt;           . . .         .   .   .   .   .    .   .   .   .   .   .   187</a>
-<a href="#7.3.1">         7.3.1 Introduction . . . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   187</a>
-<a href="#7.3.2">         7.3.2 Conventions . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   188</a>
-<a href="#7.3.3">         7.3.3 Branch cuts . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   188</a>
-<a href="#7.3.4">         7.3.4 The CX_LIMITED_RANGE pragma                    .   .   .   .   .    .   .   .   .   .   .   188</a>
-<a href="#7.3.5">         7.3.5 Trigonometric functions . . . . .              .   .   .   .   .    .   .   .   .   .   .   189</a>
-<a href="#7.3.6">         7.3.6 Hyperbolic functions      . . . . . .          .   .   .   .   .    .   .   .   .   .   .   191</a>
-<a href="#7.3.7">         7.3.7 Exponential and logarithmic functions              .   .   .   .    .   .   .   .   .   .   193</a>
-<a href="#7.3.8">         7.3.8 Power and absolute-value functions             .   .   .   .   .    .   .   .   .   .   .   194</a>
-<a href="#7.3.9">         7.3.9 Manipulation functions      . . . . .          .   .   .   .   .    .   .   .   .   .   .   195</a>
-<a href="#7.4">   7.4 Character handling &lt;ctype.h&gt; . . . . .                 .   .   .   .   .    .   .   .   .   .   .   199</a>
-<a href="#7.4.1">         7.4.1 Character classification functions    .         .   .   .   .   .    .   .   .   .   .   .   199</a>
-<a href="#7.4.2">         7.4.2 Character case mapping functions     .         .   .   .   .   .    .   .   .   .   .   .   202</a>
-<a href="#7.5">   7.5 Errors &lt;errno.h&gt;         . . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   204</a>
-<a href="#7.6">   7.6 Floating-point environment &lt;fenv.h&gt;        . .         .   .   .   .   .    .   .   .   .   .   .   205</a>
-<a href="#7.6.1">         7.6.1 The FENV_ACCESS pragma           . . .         .   .   .   .   .    .   .   .   .   .   .   207</a>
-<a href="#7.6.2">         7.6.2 Floating-point exceptions      . . . .         .   .   .   .   .    .   .   .   .   .   .   208</a>
-<a href="#7.6.3">         7.6.3 Rounding . . . . . . . . . . .                 .   .   .   .   .    .   .   .   .   .   .   211</a>
-<a href="#7.6.4">         7.6.4 Environment        . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   212</a>
-<a href="#7.7">   7.7 Characteristics of floating types &lt;float.h&gt;             .   .   .   .   .    .   .   .   .   .   .   215</a>
-
-[page v]
-
-<a href="#7.8">     7.8    Format conversion of integer types &lt;inttypes.h&gt; . . . .           .   .   .   .   216</a>
-<a href="#7.8.1">            7.8.1    Macros for format specifiers      . . . . . . . . . .     .   .   .   .   216</a>
-<a href="#7.8.2">            7.8.2    Functions for greatest-width integer types   . . . . .   .   .   .   .   217</a>
-<a href="#7.9">     7.9    Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . .            .   .   .   .   220</a>
-<a href="#7.10">     7.10   Sizes of integer types &lt;limits.h&gt;         . . . . . . . . . .     .   .   .   .   221</a>
-<a href="#7.11">     7.11   Localization &lt;locale.h&gt; . . . . . . . . . . . . . .               .   .   .   .   222</a>
-<a href="#7.11.1">            7.11.1 Locale control . . . . . . . . . . . . . . . .             .   .   .   .   223</a>
-<a href="#7.11.2">            7.11.2 Numeric formatting convention inquiry . . . . . .          .   .   .   .   224</a>
-<a href="#7.12">     7.12   Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                .   .   .   .   230</a>
-<a href="#7.12.1">            7.12.1 Treatment of error conditions . . . . . . . . . .          .   .   .   .   232</a>
-<a href="#7.12.2">            7.12.2 The FP_CONTRACT pragma             . . . . . . . . . .     .   .   .   .   234</a>
-<a href="#7.12.3">            7.12.3 Classification macros       . . . . . . . . . . . . .       .   .   .   .   234</a>
-<a href="#7.12.4">            7.12.4 Trigonometric functions . . . . . . . . . . . .            .   .   .   .   237</a>
-<a href="#7.12.5">            7.12.5 Hyperbolic functions       . . . . . . . . . . . . .       .   .   .   .   239</a>
-<a href="#7.12.6">            7.12.6 Exponential and logarithmic functions        . . . . . .   .   .   .   .   241</a>
-<a href="#7.12.7">            7.12.7 Power and absolute-value functions         . . . . . . .   .   .   .   .   246</a>
-<a href="#7.12.8">            7.12.8 Error and gamma functions . . . . . . . . . . .            .   .   .   .   248</a>
-<a href="#7.12.9">            7.12.9 Nearest integer functions . . . . . . . . . . . .          .   .   .   .   250</a>
-<a href="#7.12.10">            7.12.10 Remainder functions       . . . . . . . . . . . . .       .   .   .   .   253</a>
-<a href="#7.12.11">            7.12.11 Manipulation functions       . . . . . . . . . . . .      .   .   .   .   254</a>
-<a href="#7.12.12">            7.12.12 Maximum, minimum, and positive difference functions           .   .   .   256</a>
-<a href="#7.12.13">            7.12.13 Floating multiply-add . . . . . . . . . . . . .           .   .   .   .   257</a>
-<a href="#7.12.14">            7.12.14 Comparison macros . . . . . . . . . . . . . .             .   .   .   .   258</a>
-<a href="#7.13">     7.13   Nonlocal jumps &lt;setjmp.h&gt;            . . . . . . . . . . . .      .   .   .   .   261</a>
-<a href="#7.13.1">            7.13.1 Save calling environment         . . . . . . . . . . .     .   .   .   .   261</a>
-<a href="#7.13.2">            7.13.2 Restore calling environment        . . . . . . . . . .     .   .   .   .   262</a>
-<a href="#7.14">     7.14   Signal handling &lt;signal.h&gt; . . . . . . . . . . . . .              .   .   .   .   264</a>
-<a href="#7.14.1">            7.14.1 Specify signal handling       . . . . . . . . . . . .      .   .   .   .   265</a>
-<a href="#7.14.2">            7.14.2 Send signal      . . . . . . . . . . . . . . . . .         .   .   .   .   266</a>
-<a href="#7.15">     7.15   Alignment &lt;stdalign.h&gt;            . . . . . . . . . . . . .       .   .   .   .   267</a>
-<a href="#7.16">     7.16   Variable arguments &lt;stdarg.h&gt;           . . . . . . . . . . .     .   .   .   .   268</a>
-<a href="#7.16.1">            7.16.1 Variable argument list access macros . . . . . . .         .   .   .   .   268</a>
-<a href="#7.17">     7.17   Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . .                 .   .   .   .   272</a>
-<a href="#7.17.1">            7.17.1 Introduction . . . . . . . . . . . . . . . . .             .   .   .   .   272</a>
-<a href="#7.17.2">            7.17.2 Initialization      . . . . . . . . . . . . . . . .        .   .   .   .   273</a>
-<a href="#7.17.3">            7.17.3 Order and consistency . . . . . . . . . . . . .            .   .   .   .   274</a>
-<a href="#7.17.4">            7.17.4 Fences . . . . . . . . . . . . . . . . . . .               .   .   .   .   277</a>
-<a href="#7.17.5">            7.17.5 Lock-free property       . . . . . . . . . . . . . .       .   .   .   .   278</a>
-<a href="#7.17.6">            7.17.6 Atomic integer and address types         . . . . . . . .   .   .   .   .   279</a>
-<a href="#7.17.7">            7.17.7 Operations on atomic types . . . . . . . . . . .           .   .   .   .   281</a>
-<a href="#7.17.8">            7.17.8 Atomic flag type and operations . . . . . . . . .           .   .   .   .   284</a>
-<a href="#7.18">     7.18   Boolean type and values &lt;stdbool.h&gt;             . . . . . . . .   .   .   .   .   286</a>
-<a href="#7.19">     7.19   Common definitions &lt;stddef.h&gt; . . . . . . . . . . .                .   .   .   .   287</a>
-<a href="#7.20">     7.20   Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . .              .   .   .   .   289</a>
-
-[page vi]
-
-<a href="#7.20.1">         7.20.1 Integer types      . . . . . . . . . . . .      .   .    .   .   .   .   .   .   289</a>
-<a href="#7.20.2">         7.20.2 Limits of specified-width integer types    . .   .   .    .   .   .   .   .   .   291</a>
-<a href="#7.20.3">         7.20.3 Limits of other integer types    . . . . . .    .   .    .   .   .   .   .   .   293</a>
-<a href="#7.20.4">         7.20.4 Macros for integer constants     . . . . . .    .   .    .   .   .   .   .   .   294</a>
-<a href="#7.21">  7.21   Input/output &lt;stdio.h&gt;         . . . . . . . . . .     .   .    .   .   .   .   .   .   296</a>
-<a href="#7.21.1">         7.21.1 Introduction . . . . . . . . . . . . .          .   .    .   .   .   .   .   .   296</a>
-<a href="#7.21.2">         7.21.2 Streams       . . . . . . . . . . . . . .       .   .    .   .   .   .   .   .   298</a>
-<a href="#7.21.3">         7.21.3 Files . . . . . . . . . . . . . . . .           .   .    .   .   .   .   .   .   300</a>
-<a href="#7.21.4">         7.21.4 Operations on files      . . . . . . . . . .     .   .    .   .   .   .   .   .   302</a>
-<a href="#7.21.5">         7.21.5 File access functions     . . . . . . . . .     .   .    .   .   .   .   .   .   304</a>
-<a href="#7.21.6">         7.21.6 Formatted input/output functions     . . . .    .   .    .   .   .   .   .   .   309</a>
-<a href="#7.21.7">         7.21.7 Character input/output functions . . . . .      .   .    .   .   .   .   .   .   330</a>
-<a href="#7.21.8">         7.21.8 Direct input/output functions    . . . . . .    .   .    .   .   .   .   .   .   334</a>
-<a href="#7.21.9">         7.21.9 File positioning functions     . . . . . . .    .   .    .   .   .   .   .   .   335</a>
-<a href="#7.21.10">         7.21.10 Error-handling functions . . . . . . . .       .   .    .   .   .   .   .   .   338</a>
-<a href="#7.22">  7.22   General utilities &lt;stdlib.h&gt;        . . . . . . . .    .   .    .   .   .   .   .   .   340</a>
-<a href="#7.22.1">         7.22.1 Numeric conversion functions . . . . . .        .   .    .   .   .   .   .   .   341</a>
-<a href="#7.22.2">         7.22.2 Pseudo-random sequence generation functions         .    .   .   .   .   .   .   346</a>
-<a href="#7.22.3">         7.22.3 Memory management functions . . . . .           .   .    .   .   .   .   .   .   347</a>
-<a href="#7.22.4">         7.22.4 Communication with the environment        . .   .   .    .   .   .   .   .   .   349</a>
-<a href="#7.22.5">         7.22.5 Searching and sorting utilities . . . . . .     .   .    .   .   .   .   .   .   353</a>
-<a href="#7.22.6">         7.22.6 Integer arithmetic functions     . . . . . .    .   .    .   .   .   .   .   .   355</a>
-<a href="#7.22.7">         7.22.7 Multibyte/wide character conversion functions       .    .   .   .   .   .   .   356</a>
-<a href="#7.22.8">         7.22.8 Multibyte/wide string conversion functions      .   .    .   .   .   .   .   .   358</a>
-<a href="#7.23">  7.23   String handling &lt;string.h&gt; . . . . . . . . .           .   .    .   .   .   .   .   .   360</a>
-<a href="#7.23.1">         7.23.1 String function conventions . . . . . . .       .   .    .   .   .   .   .   .   360</a>
-<a href="#7.23.2">         7.23.2 Copying functions       . . . . . . . . . .     .   .    .   .   .   .   .   .   360</a>
-<a href="#7.23.3">         7.23.3 Concatenation functions . . . . . . . .         .   .    .   .   .   .   .   .   362</a>
-<a href="#7.23.4">         7.23.4 Comparison functions . . . . . . . . .          .   .    .   .   .   .   .   .   363</a>
-<a href="#7.23.5">         7.23.5 Search functions      . . . . . . . . . . .     .   .    .   .   .   .   .   .   365</a>
-<a href="#7.23.6">         7.23.6 Miscellaneous functions . . . . . . . .         .   .    .   .   .   .   .   .   368</a>
-<a href="#7.24">  7.24   Type-generic math &lt;tgmath.h&gt;          . . . . . . .    .   .    .   .   .   .   .   .   370</a>
-<a href="#7.25">  7.25   Threads &lt;threads.h&gt;          . . . . . . . . . . .     .   .    .   .   .   .   .   .   373</a>
-<a href="#7.25.1">         7.25.1 Introduction . . . . . . . . . . . . .          .   .    .   .   .   .   .   .   373</a>
-<a href="#7.25.2">         7.25.2 Initialization functions . . . . . . . . .      .   .    .   .   .   .   .   .   375</a>
-<a href="#7.25.3">         7.25.3 Condition variable functions     . . . . . .    .   .    .   .   .   .   .   .   375</a>
-<a href="#7.25.4">         7.25.4 Mutex functions       . . . . . . . . . . .     .   .    .   .   .   .   .   .   377</a>
-<a href="#7.25.5">         7.25.5 Thread functions . . . . . . . . . . .          .   .    .   .   .   .   .   .   380</a>
-<a href="#7.25.6">         7.25.6 Thread-specific storage functions     . . . .    .   .    .   .   .   .   .   .   382</a>
-<a href="#7.25.7">         7.25.7 Time functions . . . . . . . . . . . .          .   .    .   .   .   .   .   .   384</a>
-<a href="#7.26">  7.26   Date and time &lt;time.h&gt;         . . . . . . . . . .     .   .    .   .   .   .   .   .   385</a>
-<a href="#7.26.1">         7.26.1 Components of time        . . . . . . . . .     .   .    .   .   .   .   .   .   385</a>
-<a href="#7.26.2">         7.26.2 Time manipulation functions      . . . . . .    .   .    .   .   .   .   .   .   386</a>
-<a href="#7.26.3">         7.26.3 Time conversion functions      . . . . . . .    .   .    .   .   .   .   .   .   388</a>
-
-[page vii]
-
-<a href="#7.27">   7.27 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .               . .     .   395</a>
-<a href="#7.27.1">        7.27.1 Restartable multibyte/wide character conversion functions        .     .   395</a>
-<a href="#7.28">   7.28 Extended multibyte and wide character utilities &lt;wchar.h&gt; . .         . .     .   399</a>
-<a href="#7.28.1">        7.28.1 Introduction . . . . . . . . . . . . . . . . . .               . .     .   399</a>
-<a href="#7.28.2">        7.28.2 Formatted wide character input/output functions       . . .    . .     .   400</a>
-<a href="#7.28.3">        7.28.3 Wide character input/output functions        . . . . . . .     . .     .   418</a>
-<a href="#7.28.4">        7.28.4 General wide string utilities     . . . . . . . . . . .        . .     .   422</a>
-<a href="#7.28.4.1">                 7.28.4.1 Wide string numeric conversion functions     . .    . .     .   423</a>
-<a href="#7.28.4.2">                 7.28.4.2 Wide string copying functions . . . . . . .         . .     .   427</a>
-<a href="#7.28.4.3">                 7.28.4.3 Wide string concatenation functions      . . . .    . .     .   429</a>
-<a href="#7.28.4.4">                 7.28.4.4 Wide string comparison functions      . . . . .     . .     .   430</a>
-<a href="#7.28.4.5">                 7.28.4.5 Wide string search functions      . . . . . . .     . .     .   432</a>
-<a href="#7.28.4.6">                 7.28.4.6 Miscellaneous functions      . . . . . . . . .      . .     .   436</a>
-<a href="#7.28.5">        7.28.5 Wide character time conversion functions       . . . . . .     . .     .   436</a>
-<a href="#7.28.6">        7.28.6 Extended multibyte/wide character conversion utilities .       . .     .   437</a>
-<a href="#7.28.6.1">                 7.28.6.1 Single-byte/wide character conversion functions     . .     .   438</a>
-<a href="#7.28.6.2">                 7.28.6.2 Conversion state functions     . . . . . . . .      . .     .   438</a>
-<a href="#7.28.6.3">                 7.28.6.3 Restartable multibyte/wide character conversion
-                           functions   . . . . . . . . . . . . . . .          . . . 439</a>
-<a href="#7.28.6.4">                 7.28.6.4 Restartable multibyte/wide string conversion
-                           functions   . . . . . . . . . . . . . . .          .   .   .   441</a>
-<a href="#7.29">   7.29 Wide character classification and mapping utilities &lt;wctype.h&gt;         .   .   .   444</a>
-<a href="#7.29.1">        7.29.1 Introduction . . . . . . . . . . . . . . . . . .               .   .   .   444</a>
-<a href="#7.29.2">        7.29.2 Wide character classification utilities . . . . . . . .         .   .   .   445</a>
-<a href="#7.29.2.1">                 7.29.2.1 Wide character classification functions     . . .    .   .   .   445</a>
-<a href="#7.29.2.2">                 7.29.2.2 Extensible wide character classification
-                           functions   . . . . . . . . . . . . . . .          . . . 448</a>
-<a href="#7.29.3">        7.29.3 Wide character case mapping utilities . . . . . . . .          . . . 450</a>
-<a href="#7.29.3.1">                 7.29.3.1 Wide character case mapping functions      . . .    . . . 450</a>
-<a href="#7.29.3.2">                 7.29.3.2 Extensible wide character case mapping
-                           functions   . . . . . . . . . . . . . . .          .   .   .   450</a>
-<a href="#7.30">   7.30 Future library directions    . . . . . . . . . . . . . . . .          .   .   .   452</a>
-<a href="#7.30.1">        7.30.1 Complex arithmetic &lt;complex.h&gt; . . . . . . . .                 .   .   .   452</a>
-<a href="#7.30.2">        7.30.2 Character handling &lt;ctype.h&gt;            . . . . . . . . .      .   .   .   452</a>
-<a href="#7.30.3">        7.30.3 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .         .   .   .   452</a>
-<a href="#7.30.4">        7.30.4 Format conversion of integer types &lt;inttypes.h&gt;            .   .   .   .   452</a>
-<a href="#7.30.5">        7.30.5 Localization &lt;locale.h&gt;           . . . . . . . . . . .        .   .   .   452</a>
-<a href="#7.30.6">        7.30.6 Signal handling &lt;signal.h&gt;           . . . . . . . . . .       .   .   .   452</a>
-<a href="#7.30.7">        7.30.7 Boolean type and values &lt;stdbool.h&gt;            . . . . . .     .   .   .   452</a>
-<a href="#7.30.8">        7.30.8 Integer types &lt;stdint.h&gt;          . . . . . . . . . . .        .   .   .   452</a>
-<a href="#7.30.9">        7.30.9 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .        .   .   .   453</a>
-<a href="#7.30.10">        7.30.10 General utilities &lt;stdlib.h&gt;        . . . . . . . . . .       .   .   .   453</a>
-<a href="#7.30.11">        7.30.11 String handling &lt;string.h&gt;          . . . . . . . . . .       .   .   .   453</a>
-
-[page viii]
-
-<a href="#7.30.12">        7.30.12 Extended multibyte and wide character utilities
-                &lt;wchar.h&gt;        . . . . . . . . . . . . . . . . . . . . 453</a>
-<a href="#7.30.13">        7.30.13 Wide character classification and mapping utilities
-                &lt;wctype.h&gt; . . . . . . . . . . . . . . . . . . . . 453</a>
-<a href="#A">Annex A (informative) Language syntax summary   . .       .   .   .   .    .   .   .   .   .   .   454</a>
-<a href="#A.1">  A.1 Lexical grammar       . . . . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   454</a>
-<a href="#A.2">  A.2 Phrase structure grammar . . . . . . . . .          .   .   .   .    .   .   .   .   .   .   461</a>
-<a href="#A.3">  A.3 Preprocessing directives    . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   469</a>
-<a href="#B">Annex B (informative) Library summary     . . . . . . . . . . . . .                    .   .   .   471</a>
-<a href="#B.1">  B.1 Diagnostics &lt;assert.h&gt;          . . . . . . . . . . . . . . .                    .   .   .   471</a>
-<a href="#B.2">  B.2 Complex &lt;complex.h&gt; . . . . . . . . . . . . . . . .                              .   .   .   471</a>
-<a href="#B.3">  B.3 Character handling &lt;ctype.h&gt; . . . . . . . . . . . . .                           .   .   .   473</a>
-<a href="#B.4">  B.4 Errors &lt;errno.h&gt;         . . . . . . . . . . . . . . . . . .                     .   .   .   473</a>
-<a href="#B.5">  B.5 Floating-point environment &lt;fenv.h&gt;          . . . . . . . . . .                 .   .   .   473</a>
-<a href="#B.6">  B.6 Characteristics of floating types &lt;float.h&gt; . . . . . . . .                       .   .   .   474</a>
-<a href="#B.7">  B.7 Format conversion of integer types &lt;inttypes.h&gt; . . . . .                        .   .   .   474</a>
-<a href="#B.8">  B.8 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . . .                         .   .   .   475</a>
-<a href="#B.9">  B.9 Sizes of integer types &lt;limits.h&gt;          . . . . . . . . . . .                 .   .   .   475</a>
-<a href="#B.10">  B.10 Localization &lt;locale.h&gt; . . . . . . . . . . . . . . .                           .   .   .   475</a>
-<a href="#B.11">  B.11 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . . .                            .   .   .   475</a>
-<a href="#B.12">  B.12 Nonlocal jumps &lt;setjmp.h&gt;          . . . . . . . . . . . . .                    .   .   .   480</a>
-<a href="#B.13">  B.13 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . . .                          .   .   .   480</a>
-<a href="#B.14">  B.14 Alignment &lt;stdalign.h&gt;           . . . . . . . . . . . . . .                    .   .   .   481</a>
-<a href="#B.15">  B.15 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . . .                   .   .   .   481</a>
-<a href="#B.16">  B.16 Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . . .                             .   .   .   481</a>
-<a href="#B.17">  B.17 Boolean type and values &lt;stdbool.h&gt;           . . . . . . . . .                 .   .   .   483</a>
-<a href="#B.18">  B.18 Common definitions &lt;stddef.h&gt; . . . . . . . . . . . .                            .   .   .   483</a>
-<a href="#B.19">  B.19 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . . .                          .   .   .   483</a>
-<a href="#B.20">  B.20 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   484</a>
-<a href="#B.21">  B.21 General utilities &lt;stdlib.h&gt;       . . . . . . . . . . . . .                    .   .   .   487</a>
-<a href="#B.22">  B.22 String handling &lt;string.h&gt; . . . . . . . . . . . . . .                          .   .   .   489</a>
-<a href="#B.23">  B.23 Type-generic math &lt;tgmath.h&gt;          . . . . . . . . . . . .                   .   .   .   491</a>
-<a href="#B.24">  B.24 Threads &lt;threads.h&gt;          . . . . . . . . . . . . . . . .                    .   .   .   491</a>
-<a href="#B.25">  B.25 Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   492</a>
-<a href="#B.26">  B.26 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .                         .   .   .   493</a>
-<a href="#B.27">  B.27 Extended multibyte/wide character utilities &lt;wchar.h&gt;     . . .                 .   .   .   493</a>
-<a href="#B.28">  B.28 Wide character classification and mapping utilities &lt;wctype.h&gt;                   .   .   .   498</a>
-<a href="#C">Annex C (informative) Sequence points     . . . . . . . . . . . . . . . . . 499</a>
-<a href="#D">Annex D (normative) Universal character names for identifiers . . . . . . . 500</a>
-<a href="#D.1">  D.1 Ranges of characters allowed       . . . . . . . . . . . . . . . . . 500</a>
-<a href="#D.2">  D.2 Ranges of characters disallowed initially . . . . . . . . . . . . . 500</a>
-<a href="#E">Annex E (informative) Implementation limits        . . . . . . . . . . . . . . 501</a>
-
-[page ix]
-
-<a href="#F">Annex F (normative) IEC 60559 floating-point arithmetic . . . . . .          . .     .   .   503</a>
-<a href="#F.1">  F.1 Introduction      . . . . . . . . . . . . . . . . . . . .             . .     .   .   503</a>
-<a href="#F.2">  F.2 Types . . . . . . . . . . . . . . . . . . . . . . .                   . .     .   .   503</a>
-<a href="#F.3">  F.3 Operators and functions       . . . . . . . . . . . . . . .           . .     .   .   504</a>
-<a href="#F.4">  F.4 Floating to integer conversion    . . . . . . . . . . . . .           . .     .   .   506</a>
-<a href="#F.5">  F.5 Binary-decimal conversion       . . . . . . . . . . . . . .           . .     .   .   506</a>
-<a href="#F.6">  F.6 The return statement . . . . . . . . . . . . . . . .                  . .     .   .   507</a>
-<a href="#F.7">  F.7 Contracted expressions . . . . . . . . . . . . . . . .                . .     .   .   507</a>
-<a href="#F.8">  F.8 Floating-point environment      . . . . . . . . . . . . . .           . .     .   .   507</a>
-<a href="#F.9">  F.9 Optimization . . . . . . . . . . . . . . . . . . . .                  . .     .   .   510</a>
-<a href="#F.10">  F.10 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                   . .     .   .   513</a>
-<a href="#F.10.1">        F.10.1 Trigonometric functions . . . . . . . . . . . .              . .     .   .   514</a>
-<a href="#F.10.2">        F.10.2 Hyperbolic functions     . . . . . . . . . . . . .           . .     .   .   516</a>
-<a href="#F.10.3">        F.10.3 Exponential and logarithmic functions    . . . . . .         . .     .   .   516</a>
-<a href="#F.10.4">        F.10.4 Power and absolute value functions     . . . . . . .         . .     .   .   520</a>
-<a href="#F.10.5">        F.10.5 Error and gamma functions . . . . . . . . . . .              . .     .   .   521</a>
-<a href="#F.10.6">        F.10.6 Nearest integer functions . . . . . . . . . . . .            . .     .   .   522</a>
-<a href="#F.10.7">        F.10.7 Remainder functions      . . . . . . . . . . . . .           . .     .   .   524</a>
-<a href="#F.10.8">        F.10.8 Manipulation functions     . . . . . . . . . . . .           . .     .   .   525</a>
-<a href="#F.10.9">        F.10.9 Maximum, minimum, and positive difference functions            .     .   .   526</a>
-<a href="#F.10.10">        F.10.10 Floating multiply-add . . . . . . . . . . . . .             . .     .   .   526</a>
-<a href="#F.10.11">        F.10.11 Comparison macros . . . . . . . . . . . . . .               . .     .   .   527</a>
-<a href="#G">Annex G (normative) IEC 60559-compatible complex arithmetic     .   .   .   .   .   .   .   528</a>
-<a href="#G.1">  G.1 Introduction     . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   528</a>
-<a href="#G.2">  G.2 Types . . . . . . . . . . . . . . . . . . . .             .   .   .   .   .   .   .   528</a>
-<a href="#G.3">  G.3 Conventions      . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   528</a>
-<a href="#G.4">  G.4 Conversions      . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   529</a>
-<a href="#G.4.1">       G.4.1 Imaginary types     . . . . . . . . . . . .        .   .   .   .   .   .   .   529</a>
-<a href="#G.4.2">       G.4.2 Real and imaginary . . . . . . . . . . .           .   .   .   .   .   .   .   529</a>
-<a href="#G.4.3">       G.4.3 Imaginary and complex       . . . . . . . . .      .   .   .   .   .   .   .   529</a>
-<a href="#G.5">  G.5 Binary operators     . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   529</a>
-<a href="#G.5.1">       G.5.1 Multiplicative operators    . . . . . . . . .      .   .   .   .   .   .   .   530</a>
-<a href="#G.5.2">       G.5.2 Additive operators     . . . . . . . . . . .       .   .   .   .   .   .   .   533</a>
-<a href="#G.6">  G.6 Complex arithmetic &lt;complex.h&gt;         . . . . . . .      .   .   .   .   .   .   .   533</a>
-<a href="#G.6.1">       G.6.1 Trigonometric functions . . . . . . . . .          .   .   .   .   .   .   .   535</a>
-<a href="#G.6.2">       G.6.2 Hyperbolic functions     . . . . . . . . . .       .   .   .   .   .   .   .   535</a>
-<a href="#G.6.3">       G.6.3 Exponential and logarithmic functions     . . .    .   .   .   .   .   .   .   539</a>
-<a href="#G.6.4">       G.6.4 Power and absolute-value functions      . . . .    .   .   .   .   .   .   .   540</a>
-<a href="#G.7">  G.7 Type-generic math &lt;tgmath.h&gt;         . . . . . . . .      .   .   .   .   .   .   .   541</a>
-<a href="#H">Annex H (informative) Language independent arithmetic . .   .   .   .   .   .   .   .   .   542</a>
-<a href="#H.1">  H.1 Introduction     . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   542</a>
-<a href="#H.2">  H.2 Types . . . . . . . . . . . . . . . . . . .           .   .   .   .   .   .   .   .   542</a>
-<a href="#H.3">  H.3 Notification      . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   546</a>
-
-[page x]
-
-<a href="#I">Annex I (informative) Common warnings         . . . . . . . . . . . . . . . . 548</a>
-<a href="#J">Annex J (informative) Portability issues    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   550</a>
-<a href="#J.1">  J.1 Unspecified behavior . . . .           . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   550</a>
-<a href="#J.2">  J.2 Undefined behavior          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   553</a>
-<a href="#J.3">  J.3 Implementation-defined behavior          . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   566</a>
-<a href="#J.4">  J.4 Locale-specific behavior         . .   . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   574</a>
-<a href="#J.5">  J.5 Common extensions          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   575</a>
-<a href="#K">Annex K (normative) Bounds-checking interfaces . . . . . . . . . .                             .   .   .   578</a>
-<a href="#K.1">  K.1 Background       . . . . . . . . . . . . . . . . . . . . .                               .   .   .   578</a>
-<a href="#K.2">  K.2 Scope . . . . . . . . . . . . . . . . . . . . . . . .                                    .   .   .   579</a>
-<a href="#K.3">  K.3 Library     . . . . . . . . . . . . . . . . . . . . . . .                                .   .   .   579</a>
-<a href="#K.3.1">       K.3.1 Introduction . . . . . . . . . . . . . . . . . .                                  .   .   .   579</a>
-<a href="#K.3.1.1">                K.3.1.1 Standard headers     . . . . . . . . . . . .                           .   .   .   579</a>
-<a href="#K.3.1.2">                K.3.1.2 Reserved identifiers     . . . . . . . . . . .                          .   .   .   580</a>
-<a href="#K.3.1.3">                K.3.1.3 Use of errno . . . . . . . . . . . . . .                               .   .   .   580</a>
-<a href="#K.3.1.4">                K.3.1.4 Runtime-constraint violations     . . . . . . .                        .   .   .   580</a>
-<a href="#K.3.2">       K.3.2 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .                            .   .   .   581</a>
-<a href="#K.3.3">       K.3.3 Common definitions &lt;stddef.h&gt;               . . . . . . . .                        .   .   .   581</a>
-<a href="#K.3.4">       K.3.4 Integer types &lt;stdint.h&gt;           . . . . . . . . . . .                          .   .   .   581</a>
-<a href="#K.3.5">       K.3.5 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .                           .   .   .   582</a>
-<a href="#K.3.5.1">                K.3.5.1 Operations on files      . . . . . . . . . . .                          .   .   .   582</a>
-<a href="#K.3.5.2">                K.3.5.2 File access functions . . . . . . . . . . .                            .   .   .   584</a>
-<a href="#K.3.5.3">                K.3.5.3 Formatted input/output functions . . . . . .                           .   .   .   587</a>
-<a href="#K.3.5.4">                K.3.5.4 Character input/output functions . . . . . .                           .   .   .   598</a>
-<a href="#K.3.6">       K.3.6 General utilities &lt;stdlib.h&gt;          . . . . . . . . . .                         .   .   .   600</a>
-<a href="#K.3.6.1">                K.3.6.1 Runtime-constraint handling       . . . . . . .                        .   .   .   600</a>
-<a href="#K.3.6.2">                K.3.6.2 Communication with the environment . . . .                             .   .   .   602</a>
-<a href="#K.3.6.3">                K.3.6.3 Searching and sorting utilities . . . . . . .                          .   .   .   603</a>
-<a href="#K.3.6.4">                K.3.6.4 Multibyte/wide character conversion functions                          .   .   .   606</a>
-<a href="#K.3.6.5">                K.3.6.5 Multibyte/wide string conversion functions . .                         .   .   .   607</a>
-<a href="#K.3.7">       K.3.7 String handling &lt;string.h&gt;            . . . . . . . . . .                         .   .   .   610</a>
-<a href="#K.3.7.1">                K.3.7.1 Copying functions       . . . . . . . . . . .                          .   .   .   610</a>
-<a href="#K.3.7.2">                K.3.7.2 Concatenation functions       . . . . . . . . .                        .   .   .   613</a>
-<a href="#K.3.7.3">                K.3.7.3 Search functions     . . . . . . . . . . . .                           .   .   .   616</a>
-<a href="#K.3.7.4">                K.3.7.4 Miscellaneous functions       . . . . . . . . .                        .   .   .   617</a>
-<a href="#K.3.8">       K.3.8 Date and time &lt;time.h&gt;          . . . . . . . . . . . .                           .   .   .   620</a>
-<a href="#K.3.8.1">                K.3.8.1 Components of time . . . . . . . . . . .                               .   .   .   620</a>
-<a href="#K.3.8.2">                K.3.8.2 Time conversion functions       . . . . . . . .                        .   .   .   620</a>
-<a href="#K.3.9">       K.3.9 Extended multibyte and wide character utilities
-                &lt;wchar.h&gt;        . . . . . . . . . . . . . . . . .                             . . . 623</a>
-<a href="#K.3.9.1">                K.3.9.1 Formatted wide character input/output functions                        . . . 624</a>
-<a href="#K.3.9.2">                K.3.9.2 General wide string utilities . . . . . . . .                          . . . 635</a>
-
-[page xi]
-
-<a href="#K.3.9.3">               K.3.9.3 Extended multibyte/wide character conversion
-                       utilities . . . . . . . . . . . . . . . . . . . 643</a>
-<a href="#L">Annex L (normative) Analyzability . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648</a>
-<a href="#L.1">  L.1 Scope . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648</a>
-<a href="#L.2">  L.2 Definitions . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648</a>
-<a href="#L.3">  L.3 Requirements . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   649</a>
-<a href="#Bibliography">Bibliography   . . . . . . . . . . . . . . . . . . . . . . . . . . . 650</a>
-<a href="#Index">Index    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653</a>
-
-[<a name="pxii" href="#pxii">page xii</a>] (<a href="#Contents">Contents</a>)
-
-<a name="Foreword" href="#Foreword"><b>    Foreword</b></a>
-1   ISO (the International Organization for Standardization) and IEC (the International
-    Electrotechnical Commission) form the specialized system for worldwide
-    standardization. National bodies that are member of ISO or IEC participate in the
-    development of International Standards through technical committees established by the
-    respective organization to deal with particular fields of technical activity. ISO and IEC
-    technical committees collaborate in fields of mutual interest. Other international
-    organizations, governmental and non-governmental, in liaison with ISO and IEC, also
-    take part in the work.
-2   International Standards are drafted in accordance with the rules given in the ISO/IEC
-    Directives, Part 2. This International Standard was drafted in accordance with the fifth
-    edition (2004).
-3   In the field of information technology, ISO and IEC have established a joint technical
-    committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
-    committee are circulated to national bodies for voting. Publication as an International
-    Standard requires approval by at least 75% of the national bodies casting a vote.
-4   Attention is drawn to the possibility that some of the elements of this document may be
-    the subject of patent rights. ISO and IEC shall not be held responsible for identifying any
-    or all such patent rights.
-5   This International Standard was prepared by Joint Technical Committee ISO/IEC JTC 1,
-    Information technology, Subcommittee SC 22, Programming languages, their
-    environments and system software interfaces. The Working Group responsible for this
-    standard (WG 14) maintains a site on the World Wide Web at http://www.open-
-    std.org/JTC1/SC22/WG14/ containing additional information relevant to this
-    standard such as a Rationale for many of the decisions made during its preparation and a
-    log of Defect Reports and Responses.
-6   This third edition cancels and replaces the second edition, ISO/IEC 9899:1999, as
-    corrected by ISO/IEC 9899:1999/Cor 1:2001, ISO/IEC 9899:1999/Cor 2:2004, and
-    ISO/IEC 9899:1999/Cor 3:2007. Major changes from the previous edition include:
-    -- conditional (optional) features (including some that were previously mandatory)
-    -- support for multiple threads of execution including an improved memory sequencing
-      model, atomic objects, and thread-local storage (<a href="#7.17">&lt;stdatomic.h&gt;</a> and
-      <a href="#7.25">&lt;threads.h&gt;</a>)
-    -- additional floating-point characteristic macros (<a href="#7.7">&lt;float.h&gt;</a>)
-    -- querying and specifying alignment of objects (<a href="#7.15">&lt;stdalign.h&gt;</a>, <a href="#7.22">&lt;stdlib.h&gt;</a>)
-    -- Unicode characters and           strings   (<a href="#7.27">&lt;uchar.h&gt;</a>)       (originally   specified    in
-      ISO/IEC TR 19769:2004)
-    -- type-generic expressions
-
-[<a name="pxiii" href="#pxiii">page xiii</a>] (<a href="#Contents">Contents</a>)
-
-    -- static assertions
-    -- anonymous structures and unions
-    -- no-return functions
-    -- macros to create complex numbers (<a href="#7.3">&lt;complex.h&gt;</a>)
-    -- support for opening files for exclusive access
-    -- removed the gets function (<a href="#7.21">&lt;stdio.h&gt;</a>)
-    -- added the aligned_alloc, at_quick_exit, and quick_exit functions
-      (<a href="#7.22">&lt;stdlib.h&gt;</a>)
-    -- (conditional) support for bounds-checking interfaces (originally specified in
-      ISO/IEC TR 24731-1:2007)
-    -- (conditional) support for analyzability
-7   Major changes in the second edition included:
-    -- restricted character set support via digraphs and <a href="#7.9">&lt;iso646.h&gt;</a> (originally specified
-      in AMD1)
-    -- wide character library support in <a href="#7.28">&lt;wchar.h&gt;</a> and <a href="#7.29">&lt;wctype.h&gt;</a> (originally
-      specified in AMD1)
-    -- more precise aliasing rules via effective type
-    -- restricted pointers
-    -- variable length arrays
-    -- flexible array members
-    -- static and type qualifiers in parameter array declarators
-    -- complex (and imaginary) support in <a href="#7.3">&lt;complex.h&gt;</a>
-    -- type-generic math macros in <a href="#7.24">&lt;tgmath.h&gt;</a>
-    -- the long long int type and library functions
-    -- increased minimum translation limits
-    -- additional floating-point characteristics in <a href="#7.7">&lt;float.h&gt;</a>
-    -- remove implicit int
-    -- reliable integer division
-    -- universal character names (\u and \U)
-    -- extended identifiers
-    -- hexadecimal floating-point constants and %a and %A printf/scanf conversion
-      specifiers
-
-[<a name="pxiv" href="#pxiv">page xiv</a>] (<a href="#Contents">Contents</a>)
-
--- compound literals
--- designated initializers
--- // comments
--- extended integer types and library functions in <a href="#7.8">&lt;inttypes.h&gt;</a> and <a href="#7.20">&lt;stdint.h&gt;</a>
--- remove implicit function declaration
--- preprocessor arithmetic done in intmax_t/uintmax_t
--- mixed declarations and code
--- new block scopes for selection and iteration statements
--- integer constant type rules
--- integer promotion rules
--- macros with a variable number of arguments
--- the vscanf family of functions in <a href="#7.21">&lt;stdio.h&gt;</a> and <a href="#7.28">&lt;wchar.h&gt;</a>
--- additional math library functions in <a href="#7.12">&lt;math.h&gt;</a>
--- treatment of error conditions by math library functions (math_errhandling)
--- floating-point environment access in <a href="#7.6">&lt;fenv.h&gt;</a>
--- IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
--- trailing comma allowed in enum declaration
--- %lf conversion specifier allowed in printf
--- inline functions
--- the snprintf family of functions in <a href="#7.21">&lt;stdio.h&gt;</a>
--- boolean type in <a href="#7.18">&lt;stdbool.h&gt;</a>
--- idempotent type qualifiers
--- empty macro arguments
--- new structure type compatibility rules (tag compatibility)
--- additional predefined macro names
--- _Pragma preprocessing operator
--- standard pragmas
--- __func__ predefined identifier
--- va_copy macro
--- additional strftime conversion specifiers
--- LIA compatibility annex
-
-[<a name="pxv" href="#pxv">page xv</a>] (<a href="#Contents">Contents</a>)
-
-    -- deprecate ungetc at the beginning of a binary file
-    -- remove deprecation of aliased array parameters
-    -- conversion of array to pointer not limited to lvalues
-    -- relaxed constraints on aggregate and union initialization
-    -- relaxed restrictions on portable header names
-    -- return without expression not permitted in function that returns a value (and vice
-      versa)
-8   Annexes D, F, G, K, and L form a normative part of this standard; annexes A, B, C, E, H, *
-    I, J, the bibliography, and the index are for information only. In accordance with Part 2 of
-    the ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples
-    are also for information only.
-
-[<a name="pxvi" href="#pxvi">page xvi</a>] (<a href="#Contents">Contents</a>)
-
-<a name="Introduction" href="#Introduction"><b>    Introduction</b></a>
-1   With the introduction of new devices and extended character sets, new features may be
-    added to this International Standard. Subclauses in the language and library clauses warn
-    implementors and programmers of usages which, though valid in themselves, may
-    conflict with future additions.
-2   Certain features are obsolescent, which means that they may be considered for
-    withdrawal in future revisions of this International Standard. They are retained because
-    of their widespread use, but their use in new implementations (for implementation
-    features) or new programs (for language [6.11] or library features [7.30]) is discouraged.
-3   This International Standard is divided into four major subdivisions:
-    -- preliminary elements (clauses 1-4);
-    -- the characteristics of environments that translate and execute C programs (clause 5);
-    -- the language syntax, constraints, and semantics (clause 6);
-    -- the library facilities (clause 7).
-4   Examples are provided to illustrate possible forms of the constructions described.
-    Footnotes are provided to emphasize consequences of the rules described in that
-    subclause or elsewhere in this International Standard. References are used to refer to
-    other related subclauses. Recommendations are provided to give advice or guidance to
-    implementors. Annexes provide additional information and summarize the information
-    contained in this International Standard. A bibliography lists documents that were
-    referred to during the preparation of the standard.
-5   The language clause (clause 6) is derived from ''The C Reference Manual''.
-6   The library clause (clause 7) is based on the 1984 /usr/group Standard.
-
-[<a name="pxvii" href="#pxvii">page xvii</a>] (<a href="#Contents">Contents</a>)
-
-
-[<a name="pxviii" href="#pxviii">page xviii</a>] (<a href="#Contents">Contents</a>)
-
-
-
-    Programming languages -- C
-
-
-
-<a name="1" href="#1"><b>    1. Scope</b></a>
-1   This International Standard specifies the form and establishes the interpretation of
-    programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
-    -- the representation of C programs;
-    -- the syntax and constraints of the C language;
-    -- the semantic rules for interpreting C programs;
-    -- the representation of input data to be processed by C programs;
-    -- the representation of output data produced by C programs;
-    -- the restrictions and limits imposed by a conforming implementation of C.
-2   This International Standard does not specify
-    -- the mechanism by which C programs are transformed for use by a data-processing
-      system;
-    -- the mechanism by which C programs are invoked for use by a data-processing
-      system;
-    -- the mechanism by which input data are transformed for use by a C program;
-    -- the mechanism by which output data are transformed after being produced by a C
-      program;
-    -- the size or complexity of a program and its data that will exceed the capacity of any
-      specific data-processing system or the capacity of a particular processor;
-    -- all minimal requirements of a data-processing system that is capable of supporting a
-      conforming implementation.
-
-
-    <sup><a name="note1" href="#note1"><b>1)</b></a></sup>   This International Standard is designed to promote the portability of C programs among a variety of
-         data-processing systems. It is intended for use by implementors and programmers.
-
-[<a name="p1" href="#p1">page 1</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="2" href="#2"><b>    2. Normative references</b></a>
-1   The following referenced documents are indispensable for the application of this
-    document. For dated references, only the edition cited applies. For undated references,
-    the latest edition of the referenced document (including any amendments) applies.
-2   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and symbols for
-    use in the physical sciences and technology.
-3   ISO/IEC 646, Information technology -- ISO 7-bit coded character set for information
-    interchange.
-4   ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1: Fundamental
-    terms.
-5   ISO 4217, Codes for the representation of currencies and funds.
-6   ISO 8601, Data elements and interchange formats -- Information interchange --
-    Representation of dates and times.
-7   ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
-    Character Set (UCS).
-8   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously
-    designated IEC 559:1989).
-
-[<a name="p2" href="#p2">page 2</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="3" href="#3"><b>    3. Terms, definitions, and symbols</b></a>
-1   For the purposes of this International Standard, the following definitions apply. Other
-    terms are defined where they appear in italic type or on the left side of a syntax rule.
-    Terms explicitly defined in this International Standard are not to be presumed to refer
-    implicitly to similar terms defined elsewhere. Terms not defined in this International
-    Standard are to be interpreted according to ISO/IEC 2382-1. Mathematical symbols not
-    defined in this International Standard are to be interpreted according to ISO 31-11.
-<a name="3.1" href="#3.1"><b>    3.1</b></a>
-1   access
-    &lt;execution-time action&gt; to read or modify the value of an object
-2   NOTE 1   Where only one of these two actions is meant, ''read'' or ''modify'' is used.
-
-3   NOTE 2   ''Modify'' includes the case where the new value being stored is the same as the previous value.
-
-4   NOTE 3   Expressions that are not evaluated do not access objects.
-
-<a name="3.2" href="#3.2"><b>    3.2</b></a>
-1   alignment
-    requirement that objects of a particular type be located on storage boundaries with
-    addresses that are particular multiples of a byte address
-<a name="3.3" href="#3.3"><b>    3.3</b></a>
-1   argument
-    actual argument
-    actual parameter (deprecated)
-    expression in the comma-separated list bounded by the parentheses in a function call
-    expression, or a sequence of preprocessing tokens in the comma-separated list bounded
-    by the parentheses in a function-like macro invocation
-<a name="3.4" href="#3.4"><b>    3.4</b></a>
-1   behavior
-    external appearance or action
-<a name="3.4.1" href="#3.4.1"><b>    3.4.1</b></a>
-1   implementation-defined behavior
-    unspecified behavior where each implementation documents how the choice is made
-2   EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
-    when a signed integer is shifted right.
-
-<a name="3.4.2" href="#3.4.2"><b>    3.4.2</b></a>
-1   locale-specific behavior
-    behavior that depends on local conventions of nationality, culture, and language that each
-    implementation documents
-
-[<a name="p3" href="#p3">page 3</a>] (<a href="#Contents">Contents</a>)
-
-2   EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
-    characters other than the 26 lowercase Latin letters.
-
-<a name="3.4.3" href="#3.4.3"><b>    3.4.3</b></a>
-1   undefined behavior
-    behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
-    for which this International Standard imposes no requirements
-2   NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
-    results, to behaving during translation or program execution in a documented manner characteristic of the
-    environment (with or without the issuance of a diagnostic message), to terminating a translation or
-    execution (with the issuance of a diagnostic message).
-
-3   EXAMPLE        An example of undefined behavior is the behavior on integer overflow.
-
-<a name="3.4.4" href="#3.4.4"><b>    3.4.4</b></a>
-1   unspecified behavior
-    use of an unspecified value, or other behavior where this International Standard provides
-    two or more possibilities and imposes no further requirements on which is chosen in any
-    instance
-2   EXAMPLE        An example of unspecified behavior is the order in which the arguments to a function are
-    evaluated.
-
-<a name="3.5" href="#3.5"><b>    3.5</b></a>
-1   bit
-    unit of data storage in the execution environment large enough to hold an object that may
-    have one of two values
-2   NOTE     It need not be possible to express the address of each individual bit of an object.
-
-<a name="3.6" href="#3.6"><b>    3.6</b></a>
-1   byte
-    addressable unit of data storage large enough to hold any member of the basic character
-    set of the execution environment
-2   NOTE 1     It is possible to express the address of each individual byte of an object uniquely.
-
-3   NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
-    defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
-    bit.
-
-<a name="3.7" href="#3.7"><b>    3.7</b></a>
-1   character
-    &lt;abstract&gt; member of a set of elements used for the organization, control, or
-    representation of data
-<a name="3.7.1" href="#3.7.1"><b>    3.7.1</b></a>
-1   character
-    single-byte character
-    &lt;C&gt; bit representation that fits in a byte
-
-[<a name="p4" href="#p4">page 4</a>] (<a href="#Contents">Contents</a>)
-
-<a name="3.7.2" href="#3.7.2"><b>    3.7.2</b></a>
-1   multibyte character
-    sequence of one or more bytes representing a member of the extended character set of
-    either the source or the execution environment
-2   NOTE    The extended character set is a superset of the basic character set.
-
-<a name="3.7.3" href="#3.7.3"><b>    3.7.3</b></a>
-1   wide character
-    bit representation that fits in an object of type wchar_t, capable of representing any
-    character in the current locale
-<a name="3.8" href="#3.8"><b>    3.8</b></a>
-1   constraint
-    restriction, either syntactic or semantic, by which the exposition of language elements is
-    to be interpreted
-<a name="3.9" href="#3.9"><b>    3.9</b></a>
-1   correctly rounded result
-    representation in the result format that is nearest in value, subject to the current rounding
-    mode, to what the result would be given unlimited range and precision
-<a name="3.10" href="#3.10"><b>    3.10</b></a>
-1   diagnostic message
-    message belonging to an implementation-defined subset of the implementation's message
-    output
-<a name="3.11" href="#3.11"><b>    3.11</b></a>
-1   forward reference
-    reference to a later subclause of this International Standard that contains additional
-    information relevant to this subclause
-<a name="3.12" href="#3.12"><b>    3.12</b></a>
-1   implementation
-    particular set of software, running in a particular translation environment under particular
-    control options, that performs translation of programs for, and supports execution of
-    functions in, a particular execution environment
-<a name="3.13" href="#3.13"><b>    3.13</b></a>
-1   implementation limit
-    restriction imposed upon programs by the implementation
-<a name="3.14" href="#3.14"><b>    3.14</b></a>
-1   memory location
-    either an object of scalar type, or a maximal sequence of adjacent bit-fields all having
-    nonzero width
-
-[<a name="p5" href="#p5">page 5</a>] (<a href="#Contents">Contents</a>)
-
-2   NOTE 1 Two threads of execution can update and access separate memory locations without interfering
-    with each other.
-
-3   NOTE 2 A bit-field and an adjacent non-bit-field member are in separate memory locations. The same
-    applies to two bit-fields, if one is declared inside a nested structure declaration and the other is not, or if the
-    two are separated by a zero-length bit-field declaration, or if they are separated by a non-bit-field member
-    declaration. It is not safe to concurrently update two non-atomic bit-fields in the same structure if all
-    members declared between them are also (non-zero-length) bit-fields, no matter what the sizes of those
-    intervening bit-fields happen to be.
-
-4   EXAMPLE        A structure declared as
-             struct {
-                   char a;
-                   int b:5, c:11, :0, d:8;
-                   struct { int ee:8; } e;
-             }
-    contains four separate memory locations: The member a, and bit-fields d and e.ee are each separate
-    memory locations, and can be modified concurrently without interfering with each other. The bit-fields b
-    and c together constitute the fourth memory location. The bit-fields b and c cannot be concurrently
-    modified, but b and a, for example, can be.
-
-<a name="3.15" href="#3.15"><b>    3.15</b></a>
-1   object
-    region of data storage in the execution environment, the contents of which can represent
-    values
-2   NOTE      When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
-
-<a name="3.16" href="#3.16"><b>    3.16</b></a>
-1   parameter
-    formal parameter
-    formal argument (deprecated)
-    object declared as part of a function declaration or definition that acquires a value on
-    entry to the function, or an identifier from the comma-separated list bounded by the
-    parentheses immediately following the macro name in a function-like macro definition
-<a name="3.17" href="#3.17"><b>    3.17</b></a>
-1   recommended practice
-    specification that is strongly recommended as being in keeping with the intent of the
-    standard, but that may be impractical for some implementations
-<a name="3.18" href="#3.18"><b>    3.18</b></a>
-1   runtime-constraint
-    requirement on a program when calling a library function
-2   NOTE 1 Despite the similar terms, a runtime-constraint is not a kind of constraint as defined by <a href="#3.8">3.8</a>, and
-    need not be diagnosed at translation time.
-
-3   NOTE 2 Implementations that support the extensions in <a href="#K">annex K</a> are required to verify that the runtime-
-    constraints for a library function are not violated by the program; see <a href="#K.3.1.4">K.3.1.4</a>.
-
-[<a name="p6" href="#p6">page 6</a>] (<a href="#Contents">Contents</a>)
-
-<a name="3.19" href="#3.19"><b>    3.19</b></a>
-1   value
-    precise meaning of the contents of an object when interpreted as having a specific type
-<a name="3.19.1" href="#3.19.1"><b>    3.19.1</b></a>
-1   implementation-defined value
-    unspecified value where each implementation documents how the choice is made
-<a name="3.19.2" href="#3.19.2"><b>    3.19.2</b></a>
-1   indeterminate value
-    either an unspecified value or a trap representation
-<a name="3.19.3" href="#3.19.3"><b>    3.19.3</b></a>
-1   unspecified value
-    valid value of the relevant type where this International Standard imposes no
-    requirements on which value is chosen in any instance
-2   NOTE     An unspecified value cannot be a trap representation.
-
-<a name="3.19.4" href="#3.19.4"><b>    3.19.4</b></a>
-1   trap representation
-    an object representation that need not represent a value of the object type
-<a name="3.19.5" href="#3.19.5"><b>    3.19.5</b></a>
-1   perform a trap
-    interrupt execution of the program such that no further operations are performed
-2   NOTE In this International Standard, when the word ''trap'' is not immediately followed by
-    ''representation'', this is the intended usage.<sup><a href="#note2"><b>2)</b></a></sup>
-
-<a name="3.20" href="#3.20"><b>    3.20</b></a>
-1   [^ x^]
-    ceiling of x: the least integer greater than or equal to x
-2   EXAMPLE       [^2.4^] is 3, [^-2.4^] is -2.
-
-<a name="3.21" href="#3.21"><b>    3.21</b></a>
-1   [_ x_]
-    floor of x: the greatest integer less than or equal to x
-2   EXAMPLE       [_2.4_] is 2, [_-2.4_] is -3.
-
-
-
-
-    <sup><a name="note2" href="#note2"><b>2)</b></a></sup>   For example, ''Trapping or stopping (if supported) is disabled...'' (<a href="#F.8.2">F.8.2</a>). Note that fetching a trap
-         representation might perform a trap but is not required to (see <a href="#6.2.6.1">6.2.6.1</a>).
-
-[<a name="p7" href="#p7">page 7</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="4" href="#4"><b>    4. Conformance</b></a>
-1   In this International Standard, ''shall'' is to be interpreted as a requirement on an
-    implementation or on a program; conversely, ''shall not'' is to be interpreted as a
-    prohibition.
-2   If a ''shall'' or ''shall not'' requirement that appears outside of a constraint or runtime-
-    constraint is violated, the behavior is undefined. Undefined behavior is otherwise
-    indicated in this International Standard by the words ''undefined behavior'' or by the
-    omission of any explicit definition of behavior. There is no difference in emphasis among
-    these three; they all describe ''behavior that is undefined''.
-3   A program that is correct in all other aspects, operating on correct data, containing
-    unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
-4   The implementation shall not successfully translate a preprocessing translation unit
-    containing a #error preprocessing directive unless it is part of a group skipped by
-    conditional inclusion.
-5   A strictly conforming program shall use only those features of the language and library
-    specified in this International Standard.<sup><a href="#note3"><b>3)</b></a></sup> It shall not produce output dependent on any
-    unspecified, undefined, or implementation-defined behavior, and shall not exceed any
-    minimum implementation limit.
-6   The two forms of conforming implementation are hosted and freestanding. A conforming
-    hosted implementation shall accept any strictly conforming program. A conforming
-    freestanding implementation shall accept any strictly conforming program that does not
-    use complex types and in which the use of the features specified in the library clause
-    (clause 7) is confined to the contents of the standard headers <a href="#7.7">&lt;float.h&gt;</a>,
-    <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#7.15">&lt;stdalign.h&gt;</a>, <a href="#7.16">&lt;stdarg.h&gt;</a>, <a href="#7.18">&lt;stdbool.h&gt;</a>,
-    <a href="#7.19">&lt;stddef.h&gt;</a>, and <a href="#7.20">&lt;stdint.h&gt;</a>. A conforming implementation may have extensions
-    (including additional library functions), provided they do not alter the behavior of any
-    strictly conforming program.<sup><a href="#note4"><b>4)</b></a></sup>
-
-
-
-    <sup><a name="note3" href="#note3"><b>3)</b></a></sup>   A strictly conforming program can use conditional features (see <a href="#6.10.8.3">6.10.8.3</a>) provided the use is guarded
-         by an appropriate conditional inclusion preprocessing directive using the related macro. For example:
-                 #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
-                    /* ... */
-                    fesetround(FE_UPWARD);
-                    /* ... */
-                 #endif
-
-    <sup><a name="note4" href="#note4"><b>4)</b></a></sup>   This implies that a conforming implementation reserves no identifiers other than those explicitly
-         reserved in this International Standard.
-
-[<a name="p8" href="#p8">page 8</a>] (<a href="#Contents">Contents</a>)
-
-7   A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note5"><b>5)</b></a></sup>
-8   An implementation shall be accompanied by a document that defines all implementation-
-    defined and locale-specific characteristics and all extensions.
-    Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
-    characteristics of floating types <a href="#7.7">&lt;float.h&gt;</a> (<a href="#7.7">7.7</a>), alternative spellings <a href="#7.9">&lt;iso646.h&gt;</a>
-    (<a href="#7.9">7.9</a>), sizes of integer types <a href="#7.10">&lt;limits.h&gt;</a> (<a href="#7.10">7.10</a>), alignment <a href="#7.15">&lt;stdalign.h&gt;</a> (<a href="#7.15">7.15</a>),
-    variable arguments <a href="#7.16">&lt;stdarg.h&gt;</a> (<a href="#7.16">7.16</a>), boolean type and values <a href="#7.18">&lt;stdbool.h&gt;</a>
-    (<a href="#7.18">7.18</a>), common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), integer types <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#7.20">7.20</a>).
-
-
-
-
-    <sup><a name="note5" href="#note5"><b>5)</b></a></sup>   Strictly conforming programs are intended to be maximally portable among conforming
-         implementations. Conforming programs may depend upon nonportable features of a conforming
-         implementation.
-
-[<a name="p9" href="#p9">page 9</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="5" href="#5"><b>    5. Environment</b></a>
-1   An implementation translates C source files and executes C programs in two data-
-    processing-system environments, which will be called the translation environment and
-    the execution environment in this International Standard. Their characteristics define and
-    constrain the results of executing conforming C programs constructed according to the
-    syntactic and semantic rules for conforming implementations.
-    Forward references: In this clause, only a few of many possible forward references
-    have been noted.
-<a name="5.1" href="#5.1"><b>    5.1 Conceptual models</b></a>
-<a name="5.1.1" href="#5.1.1"><b>    5.1.1 Translation environment</b></a>
-<a name="5.1.1.1" href="#5.1.1.1"><b>    5.1.1.1 Program structure</b></a>
-1   A C program need not all be translated at the same time. The text of the program is kept
-    in units called source files, (or preprocessing files) in this International Standard. A
-    source file together with all the headers and source files included via the preprocessing
-    directive #include is known as a preprocessing translation unit. After preprocessing, a
-    preprocessing translation unit is called a translation unit. Previously translated translation
-    units may be preserved individually or in libraries. The separate translation units of a
-    program communicate by (for example) calls to functions whose identifiers have external
-    linkage, manipulation of objects whose identifiers have external linkage, or manipulation
-    of data files. Translation units may be separately translated and then later linked to
-    produce an executable program.
-    Forward references: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
-    preprocessing directives (<a href="#6.10">6.10</a>).
-<a name="5.1.1.2" href="#5.1.1.2"><b>    5.1.1.2 Translation phases</b></a>
-1   The precedence among the syntax rules of translation is specified by the following
-    phases.<sup><a href="#note6"><b>6)</b></a></sup>
-         1.   Physical source file multibyte characters are mapped, in an implementation-
-              defined manner, to the source character set (introducing new-line characters for
-              end-of-line indicators) if necessary. Trigraph sequences are replaced by
-              corresponding single-character internal representations.
-
-
-
-    <sup><a name="note6" href="#note6"><b>6)</b></a></sup>    Implementations shall behave as if these separate phases occur, even though many are typically folded
-          together in practice. Source files, translation units, and translated translation units need not
-          necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
-          and any external representation. The description is conceptual only, and does not specify any
-          particular implementation.
-
-[<a name="p10" href="#p10">page 10</a>] (<a href="#Contents">Contents</a>)
-
-     2.   Each instance of a backslash character (\) immediately followed by a new-line
-          character is deleted, splicing physical source lines to form logical source lines.
-          Only the last backslash on any physical source line shall be eligible for being part
-          of such a splice. A source file that is not empty shall end in a new-line character,
-          which shall not be immediately preceded by a backslash character before any such
-          splicing takes place.
-     3.   The source file is decomposed into preprocessing tokens<sup><a href="#note7"><b>7)</b></a></sup> and sequences of
-          white-space characters (including comments). A source file shall not end in a
-          partial preprocessing token or in a partial comment. Each comment is replaced by
-          one space character. New-line characters are retained. Whether each nonempty
-          sequence of white-space characters other than new-line is retained or replaced by
-          one space character is implementation-defined.
-     4. Preprocessing directives are executed, macro invocations are expanded, and
-        _Pragma unary operator expressions are executed. If a character sequence that
-        matches the syntax of a universal character name is produced by token
-        concatenation (<a href="#6.10.3.3">6.10.3.3</a>), the behavior is undefined. A #include preprocessing
-        directive causes the named header or source file to be processed from phase 1
-        through phase 4, recursively. All preprocessing directives are then deleted.
-     5. Each source character set member and escape sequence in character constants and
-        string literals is converted to the corresponding member of the execution character
-        set; if there is no corresponding member, it is converted to an implementation-
-        defined member other than the null (wide) character.<sup><a href="#note8"><b>8)</b></a></sup>
-     6.   Adjacent string literal tokens are concatenated.
-     7. White-space characters separating tokens are no longer significant. Each
-        preprocessing token is converted into a token. The resulting tokens are
-        syntactically and semantically analyzed and translated as a translation unit.
-     8.   All external object and function references are resolved. Library components are
-          linked to satisfy external references to functions and objects not defined in the
-          current translation. All such translator output is collected into a program image
-          which contains information needed for execution in its execution environment.
-Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
-preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href="#5.2.1.1">5.2.1.1</a>), external definitions (<a href="#6.9">6.9</a>).
-
-
-
-<sup><a name="note7" href="#note7"><b>7)</b></a></sup>    As described in <a href="#6.4">6.4</a>, the process of dividing a source file's characters into preprocessing tokens is
-      context-dependent. For example, see the handling of &lt; within a #include preprocessing directive.
-<sup><a name="note8" href="#note8"><b>8)</b></a></sup>    An implementation need not convert all non-corresponding source characters to the same execution
-      character.
-
-[<a name="p11" href="#p11">page 11</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.1.1.3" href="#5.1.1.3"><b>    5.1.1.3 Diagnostics</b></a>
-1   A conforming implementation shall produce at least one diagnostic message (identified in
-    an implementation-defined manner) if a preprocessing translation unit or translation unit
-    contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
-    specified as undefined or implementation-defined. Diagnostic messages need not be
-    produced in other circumstances.<sup><a href="#note9"><b>9)</b></a></sup>
-2   EXAMPLE        An implementation shall issue a diagnostic for the translation unit:
-             char i;
-             int i;
-    because in those cases where wording in this International Standard describes the behavior for a construct
-    as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
-
-<a name="5.1.2" href="#5.1.2"><b>    5.1.2 Execution environments</b></a>
-1   Two execution environments are defined: freestanding and hosted. In both cases,
-    program startup occurs when a designated C function is called by the execution
-    environment. All objects with static storage duration shall be initialized (set to their
-    initial values) before program startup. The manner and timing of such initialization are
-    otherwise unspecified. Program termination returns control to the execution
-    environment.
-    Forward references: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.9">6.7.9</a>).
-<a name="5.1.2.1" href="#5.1.2.1"><b>    5.1.2.1 Freestanding environment</b></a>
-1   In a freestanding environment (in which C program execution may take place without any
-    benefit of an operating system), the name and type of the function called at program
-    startup are implementation-defined. Any library facilities available to a freestanding
-    program, other than the minimal set required by clause 4, are implementation-defined.
-2   The effect of program termination in a freestanding environment is implementation-
-    defined.
-<a name="5.1.2.2" href="#5.1.2.2"><b>    5.1.2.2 Hosted environment</b></a>
-1   A hosted environment need not be provided, but shall conform to the following
-    specifications if present.
-
-
-
-
-    <sup><a name="note9" href="#note9"><b>9)</b></a></sup>   The intent is that an implementation should identify the nature of, and where possible localize, each
-         violation. Of course, an implementation is free to produce any number of diagnostics as long as a
-         valid program is still correctly translated. It may also successfully translate an invalid program.
-
-[<a name="p12" href="#p12">page 12</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.1.2.2.1" href="#5.1.2.2.1"><b>    5.1.2.2.1 Program startup</b></a>
-1   The function called at program startup is named main. The implementation declares no
-    prototype for this function. It shall be defined with a return type of int and with no
-    parameters:
-            int main(void) { /* ... */ }
-    or with two parameters (referred to here as argc and argv, though any names may be
-    used, as they are local to the function in which they are declared):
-            int main(int argc, char *argv[]) { /* ... */ }
-    or equivalent;<sup><a href="#note10"><b>10)</b></a></sup> or in some other implementation-defined manner.
-2   If they are declared, the parameters to the main function shall obey the following
-    constraints:
-    -- The value of argc shall be nonnegative.
-    -- argv[argc] shall be a null pointer.
-    -- If the value of argc is greater than zero, the array members argv[0] through
-      argv[argc-1] inclusive shall contain pointers to strings, which are given
-      implementation-defined values by the host environment prior to program startup. The
-      intent is to supply to the program information determined prior to program startup
-      from elsewhere in the hosted environment. If the host environment is not capable of
-      supplying strings with letters in both uppercase and lowercase, the implementation
-      shall ensure that the strings are received in lowercase.
-    -- If the value of argc is greater than zero, the string pointed to by argv[0]
-      represents the program name; argv[0][0] shall be the null character if the
-      program name is not available from the host environment. If the value of argc is
-      greater than one, the strings pointed to by argv[1] through argv[argc-1]
-      represent the program parameters.
-    -- The parameters argc and argv and the strings pointed to by the argv array shall
-      be modifiable by the program, and retain their last-stored values between program
-      startup and program termination.
-<a name="5.1.2.2.2" href="#5.1.2.2.2"><b>    5.1.2.2.2 Program execution</b></a>
-1   In a hosted environment, a program may use all the functions, macros, type definitions,
-    and objects described in the library clause (clause 7).
-
-
-
-
-    <sup><a name="note10" href="#note10"><b>10)</b></a></sup> Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
-        char ** argv, and so on.
-
-[<a name="p13" href="#p13">page 13</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.1.2.2.3" href="#5.1.2.2.3"><b>    5.1.2.2.3 Program termination</b></a>
-1   If the return type of the main function is a type compatible with int, a return from the
-    initial call to the main function is equivalent to calling the exit function with the value
-    returned by the main function as its argument;<sup><a href="#note11"><b>11)</b></a></sup> reaching the } that terminates the
-    main function returns a value of 0. If the return type is not compatible with int, the
-    termination status returned to the host environment is unspecified.
-    Forward references: definition of terms (<a href="#7.1.1">7.1.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>).
-<a name="5.1.2.3" href="#5.1.2.3"><b>    5.1.2.3 Program execution</b></a>
-1   The semantic descriptions in this International Standard describe the behavior of an
-    abstract machine in which issues of optimization are irrelevant.
-2   Accessing a volatile object, modifying an object, modifying a file, or calling a function
-    that does any of those operations are all side effects,<sup><a href="#note12"><b>12)</b></a></sup> which are changes in the state of
-    the execution environment. Evaluation of an expression in general includes both value
-    computations and initiation of side effects. Value computation for an lvalue expression
-    includes determining the identity of the designated object.
-3   Sequenced before is an asymmetric, transitive, pair-wise relation between evaluations
-    executed by a single thread, which induces a partial order among those evaluations.
-    Given any two evaluations A and B, if A is sequenced before B, then the execution of A
-    shall precede the execution of B. (Conversely, if A is sequenced before B, then B is
-    sequenced after A.) If A is not sequenced before or after B, then A and B are
-    unsequenced. Evaluations A and B are indeterminately sequenced when A is sequenced
-    either before or after B, but it is unspecified which.<sup><a href="#note13"><b>13)</b></a></sup> The presence of a sequence point
-    between the evaluation of expressions A and B implies that every value computation and
-    side effect associated with A is sequenced before every value computation and side effect
-    associated with B. (A summary of the sequence points is given in <a href="#C">annex C</a>.)
-4   In the abstract machine, all expressions are evaluated as specified by the semantics. An
-    actual implementation need not evaluate part of an expression if it can deduce that its
-    value is not used and that no needed side effects are produced (including any caused by
-
-    <sup><a name="note11" href="#note11"><b>11)</b></a></sup> In accordance with <a href="#6.2.4">6.2.4</a>, the lifetimes of objects with automatic storage duration declared in main
-        will have ended in the former case, even where they would not have in the latter.
-    <sup><a name="note12" href="#note12"><b>12)</b></a></sup> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
-        flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
-        values of floating-point operations. Implementations that support such floating-point state are
-        required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
-        environment library <a href="#7.6">&lt;fenv.h&gt;</a> provides a programming facility for indicating when these side
-        effects matter, freeing the implementations in other cases.
-    <sup><a name="note13" href="#note13"><b>13)</b></a></sup> The executions of unsequenced evaluations can interleave. Indeterminately sequenced evaluations
-        cannot interleave, but can be executed in any order.
-
-[<a name="p14" href="#p14">page 14</a>] (<a href="#Contents">Contents</a>)
-
-     calling a function or accessing a volatile object).
-5    When the processing of the abstract machine is interrupted by receipt of a signal, the
-     values of objects that are neither lock-free atomic objects nor of type volatile
-     sig_atomic_t are unspecified, and the value of any object that is modified by the
-     handler that is neither a lock-free atomic object nor of type volatile
-     sig_atomic_t becomes undefined.
-6    The least requirements on a conforming implementation are:
-     -- Accesses to volatile objects are evaluated strictly according to the rules of the abstract
-       machine.
-     -- At program termination, all data written into files shall be identical to the result that
-       execution of the program according to the abstract semantics would have produced.
-     -- The input and output dynamics of interactive devices shall take place as specified in
-<a name="7.21.3" href="#7.21.3"><b>       7.21.3. The intent of these requirements is that unbuffered or line-buffered output</b></a>
-       appear as soon as possible, to ensure that prompting messages actually appear prior to
-       a program waiting for input.
-     This is the observable behavior of the program.
-7    What constitutes an interactive device is implementation-defined.
-8    More stringent correspondences between abstract and actual semantics may be defined by
-     each implementation.
-9    EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
-     semantics: at every sequence point, the values of the actual objects would agree with those specified by the
-     abstract semantics. The keyword volatile would then be redundant.
-10   Alternatively, an implementation might perform various optimizations within each translation unit, such
-     that the actual semantics would agree with the abstract semantics only when making function calls across
-     translation unit boundaries. In such an implementation, at the time of each function entry and function
-     return where the calling function and the called function are in different translation units, the values of all
-     externally linked objects and of all objects accessible via pointers therein would agree with the abstract
-     semantics. Furthermore, at the time of each such function entry the values of the parameters of the called
-     function and of all objects accessible via pointers therein would agree with the abstract semantics. In this
-     type of implementation, objects referred to by interrupt service routines activated by the signal function
-     would require explicit specification of volatile storage, as well as other implementation-defined
-     restrictions.
-
-11   EXAMPLE 2       In executing the fragment
-              char c1, c2;
-              /* ... */
-              c1 = c1 + c2;
-     the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
-     and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
-     overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
-     produce the same result, possibly omitting the promotions.
-
-[<a name="p15" href="#p15">page 15</a>] (<a href="#Contents">Contents</a>)
-
-12   EXAMPLE 3       Similarly, in the fragment
-              float f1, f2;
-              double d;
-              /* ... */
-              f1 = f2 * d;
-     the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
-     that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
-     were replaced by the constant 2.0, which has type double).
-
-13   EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
-     semantics. Values are independent of whether they are represented in a register or in memory. For
-     example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
-     is required to round to the precision of the storage type. In particular, casts and assignments are required to
-     perform their specified conversion. For the fragment
-              double d1, d2;
-              float f;
-              d1 = f = expression;
-              d2 = (float) expression;
-     the values assigned to d1 and d2 are required to have been converted to float.
-
-14   EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
-     precision as well as range. The implementation cannot generally apply the mathematical associative rules
-     for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
-     overflow and underflow. Likewise, implementations cannot generally replace decimal constants in order to
-     rearrange expressions. In the following fragment, rearrangements suggested by mathematical rules for real
-     numbers are often not valid (see <a href="#F.9">F.9</a>).
-              double x, y, z;
-              /* ... */
-              x = (x * y) * z;            //   not equivalent to x   *= y * z;
-              z = (x - y) + y ;           //   not equivalent to z   = x;
-              z = x + x * y;              //   not equivalent to z   = x * (1.0 + y);
-              y = x / 5.0;                //   not equivalent to y   = x * 0.2;
-
-15   EXAMPLE 6       To illustrate the grouping behavior of expressions, in the following fragment
-              int a, b;
-              /* ... */
-              a = a + 32760 + b + 5;
-     the expression statement behaves exactly the same as
-              a = (((a + 32760) + b) + 5);
-     due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
-     next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
-     which overflows produce an explicit trap and in which the range of values representable by an int is
-     [-32768, +32767], the implementation cannot rewrite this expression as
-              a = ((a + b) + 32765);
-     since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
-     while the original expression would not; nor can the expression be rewritten either as
-
-[<a name="p16" href="#p16">page 16</a>] (<a href="#Contents">Contents</a>)
-
-              a = ((a + 32765) + b);
-     or
-              a = (a + (b + 32765));
-     since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
-     in which overflow silently generates some value and where positive and negative overflows cancel, the
-     above expression statement can be rewritten by the implementation in any of the above ways because the
-     same result will occur.
-
-16   EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
-     following fragment
-              #include <a href="#7.21">&lt;stdio.h&gt;</a>
-              int sum;
-              char *p;
-              /* ... */
-              sum = sum * 10 - '0' + (*p++ = getchar());
-     the expression statement is grouped as if it were written as
-              sum = (((sum * 10) - '0') + ((*(p++)) = (getchar())));
-     but the actual increment of p can occur at any time between the previous sequence point and the next
-     sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
-     value.
-
-     Forward references: expressions (<a href="#6.5">6.5</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>), statements (<a href="#6.8">6.8</a>), the
-     signal function (<a href="#7.14">7.14</a>), files (<a href="#7.21.3">7.21.3</a>).
-<a name="5.1.2.4" href="#5.1.2.4"><b>     5.1.2.4 Multi-threaded executions and data races</b></a>
-1    Under a hosted implementation, a program can have more than one thread of execution
-     (or thread) running concurrently. The execution of each thread proceeds as defined by
-     the remainder of this standard. The execution of the entire program consists of an
-     execution of all of its threads.<sup><a href="#note14"><b>14)</b></a></sup> Under a freestanding implementation, it is
-     implementation-defined whether a program can have more than one thread of execution.
-2    The value of an object visible to a thread T at a particular point is the initial value of the
-     object, a value stored in the object by T , or a value stored in the object by another thread,
-     according to the rules below.
-3    NOTE 1 In some cases, there may instead be undefined behavior. Much of this section is motivated by
-     the desire to support atomic operations with explicit and detailed visibility constraints. However, it also
-     implicitly supports a simpler view for more restricted programs.
-
-4    Two expression evaluations conflict if one of them modifies a memory location and the
-     other one reads or modifies the same memory location.
-
-
-
-
-     <sup><a name="note14" href="#note14"><b>14)</b></a></sup> The execution can usually be viewed as an interleaving of all of the threads. However, some kinds of
-         atomic operations, for example, allow executions inconsistent with a simple interleaving as described
-         below.
-
-[<a name="p17" href="#p17">page 17</a>] (<a href="#Contents">Contents</a>)
-
-5    The library defines a number of atomic operations (<a href="#7.17">7.17</a>) and operations on mutexes
-     (<a href="#7.25.4">7.25.4</a>) that are specially identified as synchronization operations. These operations play
-     a special role in making assignments in one thread visible to another. A synchronization
-     operation on one or more memory locations is either an acquire operation, a release
-     operation, both an acquire and release operation, or a consume operation. A
-     synchronization operation without an associated memory location is a fence and can be
-     either an acquire fence, a release fence, or both an acquire and release fence. In addition,
-     there are relaxed atomic operations, which are not synchronization operations, and
-     atomic read-modify-write operations, which have special characteristics.
-6    NOTE 2 For example, a call that acquires a mutex will perform an acquire operation on the locations
-     composing the mutex. Correspondingly, a call that releases the same mutex will perform a release
-     operation on those same locations. Informally, performing a release operation on A forces prior side effects
-     on other memory locations to become visible to other threads that later perform an acquire or consume
-     operation on A. We do not include relaxed atomic operations as synchronization operations although, like
-     synchronization operations, they cannot contribute to data races.
-
-7    All modifications to a particular atomic object M occur in some particular total order,
-     called the modification order of M. If A and B are modifications of an atomic object M,
-     and A happens before B, then A shall precede B in the modification order of M, which is
-     defined below.
-8    NOTE 3     This states that the modification orders must respect the ''happens before'' relation.
-
-9    NOTE 4 There is a separate order for each atomic object. There is no requirement that these can be
-     combined into a single total order for all objects. In general this will be impossible since different threads
-     may observe modifications to different variables in inconsistent orders.
-
-10   A release sequence on an atomic object M is a maximal contiguous sub-sequence of side
-     effects in the modification order of M, where the first operation is a release and every
-     subsequent operation either is performed by the same thread that performed the release or
-     is an atomic read-modify-write operation.
-11   Certain library calls synchronize with other library calls performed by another thread. In
-     particular, an atomic operation A that performs a release operation on an object M
-     synchronizes with an atomic operation B that performs an acquire operation on M and
-     reads a value written by any side effect in the release sequence headed by A.
-12   NOTE 5 Except in the specified cases, reading a later value does not necessarily ensure visibility as
-     described below. Such a requirement would sometimes interfere with efficient implementation.
-
-13   NOTE 6 The specifications of the synchronization operations define when one reads the value written by
-     another. For atomic variables, the definition is clear. All operations on a given mutex occur in a single total
-     order. Each mutex acquisition ''reads the value written'' by the last mutex release.
-
-14   An evaluation A carries a dependency <sup><a href="#note15"><b>15)</b></a></sup> to an evaluation B if:
-
-
-     <sup><a name="note15" href="#note15"><b>15)</b></a></sup> The ''carries a dependency'' relation is a subset of the ''sequenced before'' relation, and is similarly
-         strictly intra-thread.
-
-[<a name="p18" href="#p18">page 18</a>] (<a href="#Contents">Contents</a>)
-
-     -- the value of A is used as an operand of B, unless:
-           o B is an invocation of the kill_dependency macro,
-
-           o A is the left operand of a &amp;&amp; or || operator,
-
-           o A is the left operand of a ? : operator, or
-
-           o A is the left operand of a , operator;
-         or
-     -- A writes a scalar object or bit-field M, B reads from M the value written by A, and A
-       is sequenced before B, or
-     -- for some evaluation X, A carries a dependency to X and X carries a dependency to B.
-15   An evaluation A is dependency-ordered before<sup><a href="#note16"><b>16)</b></a></sup> an evaluation B if:
-     -- A performs a release operation on an atomic object M, and B performs a consume
-       operation on M and reads a value written by any side effect in the release sequence
-       headed by A, or
-     -- for some evaluation X, A is dependency-ordered before X and X carries a
-       dependency to B.
-16   An evaluation A inter-thread happens before an evaluation B if A synchronizes with B, A
-     is dependency-ordered before B, or, for some evaluation X:
-     -- A synchronizes with X and X is sequenced before B,
-     -- A is sequenced before X and X inter-thread happens before B, or
-     -- A inter-thread happens before X and X inter-thread happens before B.
-17   NOTE 7 The ''inter-thread happens before'' relation describes arbitrary concatenations of ''sequenced
-     before'', ''synchronizes with'', and ''dependency-ordered before'' relationships, with two exceptions. The
-     first exception is that a concatenation is not permitted to end with ''dependency-ordered before'' followed
-     by ''sequenced before''. The reason for this limitation is that a consume operation participating in a
-     ''dependency-ordered before'' relationship provides ordering only with respect to operations to which this
-     consume operation actually carries a dependency. The reason that this limitation applies only to the end of
-     such a concatenation is that any subsequent release operation will provide the required ordering for a prior
-     consume operation. The second exception is that a concatenation is not permitted to consist entirely of
-     ''sequenced before''. The reasons for this limitation are (1) to permit ''inter-thread happens before'' to be
-     transitively closed and (2) the ''happens before'' relation, defined below, provides for relationships
-     consisting entirely of ''sequenced before''.
-
-18   An evaluation A happens before an evaluation B if A is sequenced before B or A inter-
-     thread happens before B.
-
-
-
-     <sup><a name="note16" href="#note16"><b>16)</b></a></sup> The ''dependency-ordered before'' relation is analogous to the ''synchronizes with'' relation, but uses
-         release/consume in place of release/acquire.
-
-[<a name="p19" href="#p19">page 19</a>] (<a href="#Contents">Contents</a>)
-
-19   A visible side effect A on an object M with respect to a value computation B of M
-     satisfies the conditions:
-     -- A happens before B, and
-     -- there is no other side effect X to M such that A happens before X and X happens
-         before B.
-     The value of a non-atomic scalar object M, as determined by evaluation B, shall be the
-     value stored by the visible side effect A.
-20   NOTE 8 If there is ambiguity about which side effect to a non-atomic object is visible, then there is a data
-     race and the behavior is undefined.
-
-21   NOTE 9 This states that operations on ordinary variables are not visibly reordered. This is not actually
-     detectable without data races, but it is necessary to ensure that data races, as defined here, and with suitable
-     restrictions on the use of atomics, correspond to data races in a simple interleaved (sequentially consistent)
-     execution.
-
-22   The visible sequence of side effects on an atomic object M, with respect to a value
-     computation B of M, is a maximal contiguous sub-sequence of side effects in the
-     modification order of M, where the first side effect is visible with respect to B, and for
-     every subsequent side effect, it is not the case that B happens before it. The value of an
-     atomic object M, as determined by evaluation B, shall be the value stored by some
-     operation in the visible sequence of M with respect to B. Furthermore, if a value
-     computation A of an atomic object M happens before a value computation B of M, and
-     the value computed by A corresponds to the value stored by side effect X, then the value
-     computed by B shall either equal the value computed by A, or be the value stored by side
-     effect Y , where Y follows X in the modification order of M.
-23   NOTE 10 This effectively disallows compiler reordering of atomic operations to a single object, even if
-     both operations are ''relaxed'' loads. By doing so, we effectively make the ''cache coherence'' guarantee
-     provided by most hardware available to C atomic operations.
-
-24   NOTE 11 The visible sequence depends on the ''happens before'' relation, which in turn depends on the
-     values observed by loads of atomics, which we are restricting here. The intended reading is that there must
-     exist an association of atomic loads with modifications they observe that, together with suitably chosen
-     modification orders and the ''happens before'' relation derived as described above, satisfy the resulting
-     constraints as imposed here.
-
-25   The execution of a program contains a data race if it contains two conflicting actions in
-     different threads, at least one of which is not atomic, and neither happens before the
-     other. Any such data race results in undefined behavior.
-26   NOTE 12 It can be shown that programs that correctly use simple mutexes and
-     memory_order_seq_cst operations to prevent all data races, and use no other synchronization
-     operations, behave as though the operations executed by their constituent threads were simply interleaved,
-     with each value computation of an object being the last value stored in that interleaving. This is normally
-     referred to as ''sequential consistency''. However, this applies only to data-race-free programs, and data-
-     race-free programs cannot observe most program transformations that do not change single-threaded
-     program semantics. In fact, most single-threaded program transformations continue to be allowed, since
-     any program that behaves differently as a result must contain undefined behavior.
-
-[<a name="p20" href="#p20">page 20</a>] (<a href="#Contents">Contents</a>)
-
-27   NOTE 13 Compiler transformations that introduce assignments to a potentially shared memory location
-     that would not be modified by the abstract machine are generally precluded by this standard, since such an
-     assignment might overwrite another assignment by a different thread in cases in which an abstract machine
-     execution would not have encountered a data race. This includes implementations of data member
-     assignment that overwrite adjacent members in separate memory locations. We also generally preclude
-     reordering of atomic loads in cases in which the atomics in question may alias, since this may violate the
-     "visible sequence" rules.
-
-28   NOTE 14 Transformations that introduce a speculative read of a potentially shared memory location may
-     not preserve the semantics of the program as defined in this standard, since they potentially introduce a data
-     race. However, they are typically valid in the context of an optimizing compiler that targets a specific
-     machine with well-defined semantics for data races. They would be invalid for a hypothetical machine that
-     is not tolerant of races or provides hardware race detection.
-
-[<a name="p21" href="#p21">page 21</a>] (<a href="#Contents">Contents</a>)
-
-<a name="5.2" href="#5.2"><b>    5.2 Environmental considerations</b></a>
-<a name="5.2.1" href="#5.2.1"><b>    5.2.1 Character sets</b></a>
-1   Two sets of characters and their associated collating sequences shall be defined: the set in
-    which source files are written (the source character set), and the set interpreted in the
-    execution environment (the execution character set). Each set is further divided into a
-    basic character set, whose contents are given by this subclause, and a set of zero or more
-    locale-specific members (which are not members of the basic character set) called
-    extended characters. The combined set is also called the extended character set. The
-    values of the members of the execution character set are implementation-defined.
-2   In a character constant or string literal, members of the execution character set shall be
-    represented by corresponding members of the source character set or by escape
-    sequences consisting of the backslash \ followed by one or more characters. A byte with
-    all bits set to 0, called the null character, shall exist in the basic execution character set; it
-    is used to terminate a character string.
-3   Both the basic source and basic execution character sets shall have the following
-    members: the 26 uppercase letters of the Latin alphabet
-            A    B   C      D   E   F    G    H    I    J    K    L   M
-            N    O   P      Q   R   S    T    U    V    W    X    Y   Z
-    the 26 lowercase letters of the Latin alphabet
-            a    b   c      d   e   f    g    h    i    j    k    l   m
-            n    o   p      q   r   s    t    u    v    w    x    y   z
-    the 10 decimal digits
-            0    1   2      3   4   5    6    7    8    9
-    the following 29 graphic characters
-            !    "   #      %   &amp;   '    (    )    *    +    ,    -   .    /    :
-            ;    &lt;   =      &gt;   ?   [    \    ]    ^    _    {    |   }    ~
-    the space character, and control characters representing horizontal tab, vertical tab, and
-    form feed. The representation of each member of the source and execution basic
-    character sets shall fit in a byte. In both the source and execution basic character sets, the
-    value of each character after 0 in the above list of decimal digits shall be one greater than
-    the value of the previous. In source files, there shall be some way of indicating the end of
-    each line of text; this International Standard treats such an end-of-line indicator as if it
-    were a single new-line character. In the basic execution character set, there shall be
-    control characters representing alert, backspace, carriage return, and new line. If any
-    other characters are encountered in a source file (except in an identifier, a character
-    constant, a string literal, a header name, a comment, or a preprocessing token that is never
-
-[<a name="p22" href="#p22">page 22</a>] (<a href="#Contents">Contents</a>)
-
-    converted to a token), the behavior is undefined.
-4   A letter is an uppercase letter or a lowercase letter as defined above; in this International
-    Standard the term does not include other characters that are letters in other alphabets.
-5   The universal character name construct provides a way to name other characters.
-    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
-    preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
-<a name="5.2.1.1" href="#5.2.1.1"><b>    5.2.1.1 Trigraph sequences</b></a>
-1   Before any other processing takes place, each occurrence of one of the following
-    sequences of three characters (called trigraph sequences<sup><a href="#note17"><b>17)</b></a></sup>) is replaced with the
-    corresponding single character.
-           ??=      #                       ??)      ]                       ??!     |
-           ??(      [                       ??'      ^                       ??&gt;     }
-           ??/      \                       ??&lt;      {                       ??-     ~
-    No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
-    above is not changed.
-2   EXAMPLE 1
-              ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)
-    becomes
-              #define arraycheck(a, b) a[b] || b[a]
-
-3   EXAMPLE 2      The following source line
-              printf("Eh???/n");
-    becomes (after replacement of the trigraph sequence ??/)
-              printf("Eh?\n");
-
-<a name="5.2.1.2" href="#5.2.1.2"><b>    5.2.1.2 Multibyte characters</b></a>
-1   The source character set may contain multibyte characters, used to represent members of
-    the extended character set. The execution character set may also contain multibyte
-    characters, which need not have the same encoding as for the source character set. For
-    both character sets, the following shall hold:
-    -- The basic character set shall be present and each character shall be encoded as a
-      single byte.
-    -- The presence, meaning, and representation of any additional members is locale-
-      specific.
-
-    <sup><a name="note17" href="#note17"><b>17)</b></a></sup> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
-        described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
-
-[<a name="p23" href="#p23">page 23</a>] (<a href="#Contents">Contents</a>)
-
-    -- A multibyte character set may have a state-dependent encoding, wherein each
-      sequence of multibyte characters begins in an initial shift state and enters other
-      locale-specific shift states when specific multibyte characters are encountered in the
-      sequence. While in the initial shift state, all single-byte characters retain their usual
-      interpretation and do not alter the shift state. The interpretation for subsequent bytes
-      in the sequence is a function of the current shift state.
-    -- A byte with all bits zero shall be interpreted as a null character independent of shift
-      state. Such a byte shall not occur as part of any other multibyte character.
-2   For source files, the following shall hold:
-    -- An identifier, comment, string literal, character constant, or header name shall begin
-      and end in the initial shift state.
-    -- An identifier, comment, string literal, character constant, or header name shall consist
-      of a sequence of valid multibyte characters.
-<a name="5.2.2" href="#5.2.2"><b>    5.2.2 Character display semantics</b></a>
-1   The active position is that location on a display device where the next character output by
-    the fputc function would appear. The intent of writing a printing character (as defined
-    by the isprint function) to a display device is to display a graphic representation of
-    that character at the active position and then advance the active position to the next
-    position on the current line. The direction of writing is locale-specific. If the active
-    position is at the final position of a line (if there is one), the behavior of the display device
-    is unspecified.
-2   Alphabetic escape sequences representing nongraphic characters in the execution
-    character set are intended to produce actions on display devices as follows:
-    \a (alert) Produces an audible or visible alert without changing the active position.
-    \b (backspace) Moves the active position to the previous position on the current line. If
-       the active position is at the initial position of a line, the behavior of the display
-       device is unspecified.
-    \f ( form feed) Moves the active position to the initial position at the start of the next
-       logical page.
-    \n (new line) Moves the active position to the initial position of the next line.
-    \r (carriage return) Moves the active position to the initial position of the current line.
-    \t (horizontal tab) Moves the active position to the next horizontal tabulation position
-       on the current line. If the active position is at or past the last defined horizontal
-       tabulation position, the behavior of the display device is unspecified.
-    \v (vertical tab) Moves the active position to the initial position of the next vertical
-       tabulation position. If the active position is at or past the last defined vertical
-
-[<a name="p24" href="#p24">page 24</a>] (<a href="#Contents">Contents</a>)
-
-         tabulation position, the behavior of the display device is unspecified.
-3   Each of these escape sequences shall produce a unique implementation-defined value
-    which can be stored in a single char object. The external representations in a text file
-    need not be identical to the internal representations, and are outside the scope of this
-    International Standard.
-    Forward references: the isprint function (<a href="#7.4.1.8">7.4.1.8</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>).
-<a name="5.2.3" href="#5.2.3"><b>    5.2.3 Signals and interrupts</b></a>
-1   Functions shall be implemented such that they may be interrupted at any time by a signal,
-    or may be called by a signal handler, or both, with no alteration to earlier, but still active,
-    invocations' control flow (after the interruption), function return values, or objects with
-    automatic storage duration. All such objects shall be maintained outside the function
-    image (the instructions that compose the executable representation of a function) on a
-    per-invocation basis.
-<a name="5.2.4" href="#5.2.4"><b>    5.2.4 Environmental limits</b></a>
-1   Both the translation and execution environments constrain the implementation of
-    language translators and libraries. The following summarizes the language-related
-    environmental limits on a conforming implementation; the library-related limits are
-    discussed in clause 7.
-<a name="5.2.4.1" href="#5.2.4.1"><b>    5.2.4.1 Translation limits</b></a>
-1   The implementation shall be able to translate and execute at least one program that
-    contains at least one instance of every one of the following limits:<sup><a href="#note18"><b>18)</b></a></sup>
-    -- 127 nesting levels of blocks
-    -- 63 nesting levels of conditional inclusion
-    -- 12 pointer, array, and function declarators (in any combinations) modifying an
-      arithmetic, structure, union, or void type in a declaration
-    -- 63 nesting levels of parenthesized declarators within a full declarator
-    -- 63 nesting levels of parenthesized expressions within a full expression
-    -- 63 significant initial characters in an internal identifier or a macro name (each
-      universal character name or extended source character is considered a single
-      character)
-    -- 31 significant initial characters in an external identifier (each universal character name
-      specifying a short identifier of 0000FFFF or less is considered 6 characters, each
-
-
-    <sup><a name="note18" href="#note18"><b>18)</b></a></sup> Implementations should avoid imposing fixed translation limits whenever possible.
-
-[<a name="p25" href="#p25">page 25</a>] (<a href="#Contents">Contents</a>)
-
-         universal character name specifying a short identifier of 00010000 or more is
-         considered 10 characters, and each extended source character is considered the same
-         number of characters as the corresponding universal character name, if any)<sup><a href="#note19"><b>19)</b></a></sup>
-    -- 4095 external identifiers in one translation unit
-    -- 511 identifiers with block scope declared in one block
-    -- 4095 macro identifiers simultaneously defined in one preprocessing translation unit
-    -- 127 parameters in one function definition
-    -- 127 arguments in one function call
-    -- 127 parameters in one macro definition
-    -- 127 arguments in one macro invocation
-    -- 4095 characters in a logical source line
-    -- 4095 characters in a string literal (after concatenation)
-    -- 65535 bytes in an object (in a hosted environment only)
-    -- 15 nesting levels for #included files
-    -- 1023 case labels for a switch statement (excluding those for any nested switch
-      statements)
-    -- 1023 members in a single structure or union
-    -- 1023 enumeration constants in a single enumeration
-    -- 63 levels of nested structure or union definitions in a single struct-declaration-list
-<a name="5.2.4.2" href="#5.2.4.2"><b>    5.2.4.2 Numerical limits</b></a>
-1   An implementation is required to document all the limits specified in this subclause,
-    which are specified in the headers <a href="#7.10">&lt;limits.h&gt;</a> and <a href="#7.7">&lt;float.h&gt;</a>. Additional limits are
-    specified in <a href="#7.20">&lt;stdint.h&gt;</a>.
-    Forward references: integer types <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#7.20">7.20</a>).
-<a name="5.2.4.2.1" href="#5.2.4.2.1"><b>    5.2.4.2.1 Sizes of integer types &lt;limits.h&gt;</b></a>
-1   The values given below shall be replaced by constant expressions suitable for use in #if
-    preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
-    following shall be replaced by expressions that have the same type as would an
-    expression that is an object of the corresponding type converted according to the integer
-    promotions. Their implementation-defined values shall be equal or greater in magnitude
-
-
-    <sup><a name="note19" href="#note19"><b>19)</b></a></sup> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
-
-[<a name="p26" href="#p26">page 26</a>] (<a href="#Contents">Contents</a>)
-
-(absolute value) to those shown, with the same sign.
--- number of bits for smallest object that is not a bit-field (byte)
-  CHAR_BIT                                            8
--- minimum value for an object of type signed char
-  SCHAR_MIN                                -127 // -(27 - 1)
--- maximum value for an object of type signed char
-  SCHAR_MAX                                +127 // 27 - 1
--- maximum value for an object of type unsigned char
-  UCHAR_MAX                                 255 // 28 - 1
--- minimum value for an object of type char
-  CHAR_MIN                               see below
--- maximum value for an object of type char
-  CHAR_MAX                              see below
--- maximum number of bytes in a multibyte character, for any supported locale
-  MB_LEN_MAX                                    1
--- minimum value for an object of type short int
-  SHRT_MIN                               -32767 // -(215 - 1)
--- maximum value for an object of type short int
-  SHRT_MAX                               +32767 // 215 - 1
--- maximum value for an object of type unsigned short int
-  USHRT_MAX                               65535 // 216 - 1
--- minimum value for an object of type int
-  INT_MIN                                 -32767 // -(215 - 1)
--- maximum value for an object of type int
-  INT_MAX                                +32767 // 215 - 1
--- maximum value for an object of type unsigned int
-  UINT_MAX                                65535 // 216 - 1
--- minimum value for an object of type long int
-  LONG_MIN                         -2147483647 // -(231 - 1)
--- maximum value for an object of type long int
-  LONG_MAX                         +2147483647 // 231 - 1
--- maximum value for an object of type unsigned long int
-  ULONG_MAX                         4294967295 // 232 - 1
-
-[<a name="p27" href="#p27">page 27</a>] (<a href="#Contents">Contents</a>)
-
-    -- minimum value for an object of type long long int
-      LLONG_MIN          -9223372036854775807 // -(263 - 1)
-    -- maximum value for an object of type long long int
-      LLONG_MAX          +9223372036854775807 // 263 - 1
-    -- maximum value for an object of type unsigned long long int
-      ULLONG_MAX         18446744073709551615 // 264 - 1
-2   If the value of an object of type char is treated as a signed integer when used in an
-    expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
-    value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
-    CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
-    UCHAR_MAX.<sup><a href="#note20"><b>20)</b></a></sup> The value UCHAR_MAX shall equal 2CHAR_BIT - 1.
-    Forward references: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
-<a name="5.2.4.2.2" href="#5.2.4.2.2"><b>    5.2.4.2.2 Characteristics of floating types &lt;float.h&gt;</b></a>
-1   The characteristics of floating types are defined in terms of a model that describes a
-    representation of floating-point numbers and values that provide information about an
-    implementation's floating-point arithmetic.<sup><a href="#note21"><b>21)</b></a></sup> The following parameters are used to
-    define the model for each floating-point type:
-           s          sign ((+-)1)
-           b          base or radix of exponent representation (an integer &gt; 1)
-           e          exponent (an integer between a minimum emin and a maximum emax )
-           p          precision (the number of base-b digits in the significand)
-            fk        nonnegative integers less than b (the significand digits)
-2   A floating-point number (x) is defined by the following model:
-                       p
-           x = sb e   (Sum) f k b-k ,
-                      k=1
-                                    emin &lt;= e &lt;= emax
-
-3   In addition to normalized floating-point numbers ( f 1 &gt; 0 if x != 0), floating types may be
-    able to contain other kinds of floating-point numbers, such as subnormal floating-point
-    numbers (x != 0, e = emin , f 1 = 0) and unnormalized floating-point numbers (x != 0,
-    e &gt; emin , f 1 = 0), and values that are not floating-point numbers, such as infinities and
-    NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates
-    through almost every arithmetic operation without raising a floating-point exception; a
-    signaling NaN generally raises a floating-point exception when occurring as an
-
-
-    <sup><a name="note20" href="#note20"><b>20)</b></a></sup> See <a href="#6.2.5">6.2.5</a>.
-    <sup><a name="note21" href="#note21"><b>21)</b></a></sup> The floating-point model is intended to clarify the description of each floating-point characteristic and
-        does not require the floating-point arithmetic of the implementation to be identical.
-
-[<a name="p28" href="#p28">page 28</a>] (<a href="#Contents">Contents</a>)
-
-    arithmetic operand.<sup><a href="#note22"><b>22)</b></a></sup>
-4   An implementation may give zero and values that are not floating-point numbers (such as
-    infinities and NaNs) a sign or may leave them unsigned. Wherever such values are
-    unsigned, any requirement in this International Standard to retrieve the sign shall produce
-    an unspecified sign, and any requirement to set the sign shall be ignored.
-5   The minimum range of representable values for a floating type is the most negative finite
-    floating-point number representable in that type through the most positive finite floating-
-    point number representable in that type. In addition, if negative infinity is representable
-    in a type, the range of that type is extended to all negative real numbers; likewise, if
-    positive infinity is representable in a type, the range of that type is extended to all positive
-    real numbers.
-6   The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
-    <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results is implementation-
-    defined, as is the accuracy of the conversion between floating-point internal
-    representations and string representations performed by the library functions in
-    <a href="#7.21">&lt;stdio.h&gt;</a>, <a href="#7.22">&lt;stdlib.h&gt;</a>, and <a href="#7.28">&lt;wchar.h&gt;</a>. The implementation may state that the
-    accuracy is unknown.
-7   All integer values in the <a href="#7.7">&lt;float.h&gt;</a> header, except FLT_ROUNDS, shall be constant
-    expressions suitable for use in #if preprocessing directives; all floating values shall be
-    constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
-    and FLT_ROUNDS have separate names for all three floating-point types. The floating-
-    point model representation is provided for all values except FLT_EVAL_METHOD and
-    FLT_ROUNDS.
-8   The rounding mode for floating-point addition is characterized by the implementation-
-    defined value of FLT_ROUNDS:<sup><a href="#note23"><b>23)</b></a></sup>
-          -1      indeterminable
-           0      toward zero
-           1      to nearest
-           2      toward positive infinity
-           3      toward negative infinity
-    All other values for FLT_ROUNDS characterize implementation-defined rounding
-    behavior.
-
-
-    <sup><a name="note22" href="#note22"><b>22)</b></a></sup> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
-        IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
-        similar behavior.
-    <sup><a name="note23" href="#note23"><b>23)</b></a></sup> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
-        the function fesetround in <a href="#7.6">&lt;fenv.h&gt;</a>.
-
-[<a name="p29" href="#p29">page 29</a>] (<a href="#Contents">Contents</a>)
-
-9    Except for assignment and cast (which remove all extra range and precision), the values
-     yielded by operators with floating operands and values subject to the usual arithmetic
-     conversions and of floating constants are evaluated to a format whose range and precision
-     may be greater than required by the type. The use of evaluation formats is characterized
-     by the implementation-defined value of FLT_EVAL_METHOD:<sup><a href="#note24"><b>24)</b></a></sup>
-            -1         indeterminable;
-              0        evaluate all operations and constants just to the range and precision of the
-                       type;
-              1        evaluate operations and constants of type float and double to the
-                       range and precision of the double type, evaluate long double
-                       operations and constants to the range and precision of the long double
-                       type;
-              2        evaluate all operations and constants to the range and precision of the
-                       long double type.
-     All other negative values for FLT_EVAL_METHOD characterize implementation-defined
-     behavior.
-10   The presence or absence of subnormal numbers is characterized by the implementation-
-     defined     values     of    FLT_HAS_SUBNORM,          DBL_HAS_SUBNORM,           and
-     LDBL_HAS_SUBNORM:
-            -1       indeterminable<sup><a href="#note25"><b>25)</b></a></sup>
-             0       absent<sup><a href="#note26"><b>26)</b></a></sup> (type does not support subnormal numbers)
-             1       present (type does support subnormal numbers)
-11   The values given in the following list shall be replaced by constant expressions with
-     implementation-defined values that are greater or equal in magnitude (absolute value) to
-     those shown, with the same sign:
-     -- radix of exponent representation, b
-       FLT_RADIX                                                    2
-
-
-
-
-     <sup><a name="note24" href="#note24"><b>24)</b></a></sup> The evaluation method determines evaluation formats of expressions involving all floating types, not
-         just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
-         _Complex operands is represented in the double _Complex format, and its parts are evaluated to
-         double.
-     <sup><a name="note25" href="#note25"><b>25)</b></a></sup> Characterization as indeterminable is intended if floating-point operations do not consistently interpret
-         subnormal representations as zero, nor as nonzero.
-     <sup><a name="note26" href="#note26"><b>26)</b></a></sup> Characterization as absent is intended if no floating-point operations produce subnormal results from
-         non-subnormal inputs, even if the type format includes representations of subnormal numbers.
-
-[<a name="p30" href="#p30">page 30</a>] (<a href="#Contents">Contents</a>)
-
--- number of base-FLT_RADIX digits in the floating-point significand, p
-   FLT_MANT_DIG
-   DBL_MANT_DIG
-   LDBL_MANT_DIG
--- number of decimal digits, n, such that any floating-point number with p radix b digits
-  can be rounded to a floating-point number with n decimal digits and back again
-  without change to the value,
-       { p log10 b        if b is a power of 10
-       {
-       { [^1 + p log10 b^] otherwise
-   FLT_DECIMAL_DIG                                   6
-   DBL_DECIMAL_DIG                                  10
-   LDBL_DECIMAL_DIG                                 10
--- number of decimal digits, n, such that any floating-point number in the widest
-  supported floating type with pmax radix b digits can be rounded to a floating-point
-  number with n decimal digits and back again without change to the value,
-       { pmax log10 b       if b is a power of 10
-       {
-       { [^1 + pmax log10 b^] otherwise
-   DECIMAL_DIG                                     10
--- number of decimal digits, q, such that any floating-point number with q decimal digits
-  can be rounded into a floating-point number with p radix b digits and back again
-  without change to the q decimal digits,
-       { p log10 b          if b is a power of 10
-       {
-       { [_( p - 1) log10 b_] otherwise
-   FLT_DIG                                          6
-   DBL_DIG                                         10
-   LDBL_DIG                                        10
--- minimum negative integer such that FLT_RADIX raised to one less than that power is
-  a normalized floating-point number, emin
-   FLT_MIN_EXP
-   DBL_MIN_EXP
-   LDBL_MIN_EXP
-
-[<a name="p31" href="#p31">page 31</a>] (<a href="#Contents">Contents</a>)
-
-     -- minimum negative integer such that 10 raised to that power is in the range of
-       normalized floating-point numbers, [^log10 b emin -1 ^]
-                                         [                  ]
-       FLT_MIN_10_EXP                                 -37
-       DBL_MIN_10_EXP                                 -37
-       LDBL_MIN_10_EXP                                -37
-     -- maximum integer such that FLT_RADIX raised to one less than that power is a
-       representable finite floating-point number, emax
-          FLT_MAX_EXP
-          DBL_MAX_EXP
-          LDBL_MAX_EXP
-     -- maximum integer such that 10 raised to that power is in the range of representable
-       finite floating-point numbers, [_log10 ((1 - b- p )b emax )_]
-          FLT_MAX_10_EXP                               +37
-          DBL_MAX_10_EXP                               +37
-          LDBL_MAX_10_EXP                              +37
-12   The values given in the following list shall be replaced by constant expressions with
-     implementation-defined values that are greater than or equal to those shown:
-     -- maximum representable finite floating-point number, (1 - b- p )b emax
-          FLT_MAX                                   1E+37
-          DBL_MAX                                   1E+37
-          LDBL_MAX                                  1E+37
-13   The values given in the following list shall be replaced by constant expressions with
-     implementation-defined (positive) values that are less than or equal to those shown:
-     -- the difference between 1 and the least value greater than 1 that is representable in the
-       given floating point type, b1- p
-          FLT_EPSILON                                1E-5
-          DBL_EPSILON                                1E-9
-          LDBL_EPSILON                               1E-9
-     -- minimum normalized positive floating-point number, b emin -1
-          FLT_MIN                                   1E-37
-          DBL_MIN                                   1E-37
-          LDBL_MIN                                  1E-37
-
-[<a name="p32" href="#p32">page 32</a>] (<a href="#Contents">Contents</a>)
-
-     -- minimum positive floating-point number<sup><a href="#note27"><b>27)</b></a></sup>
-         FLT_TRUE_MIN                                       1E-37
-         DBL_TRUE_MIN                                       1E-37
-         LDBL_TRUE_MIN                                      1E-37
-     Recommended practice
-14   Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
-     should be the identity function.
-15   EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
-     requirements of this International Standard, and the appropriate values in a <a href="#7.7">&lt;float.h&gt;</a> header for type
-     float:
-                        6
-           x = s16e    (Sum) f k 16-k ,
-                       k=1
-                                       -31 &lt;= e &lt;= +32
-
-             FLT_RADIX                                    16
-             FLT_MANT_DIG                                  6
-             FLT_EPSILON                     9.53674316E-07F
-             FLT_DECIMAL_DIG                               9
-             FLT_DIG                                       6
-             FLT_MIN_EXP                                 -31
-             FLT_MIN                         2.93873588E-39F
-             FLT_MIN_10_EXP                              -38
-             FLT_MAX_EXP                                 +32
-             FLT_MAX                         3.40282347E+38F
-             FLT_MAX_10_EXP                              +38
-
-16   EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
-     single-precision and double-precision numbers in IEC 60559,<sup><a href="#note28"><b>28)</b></a></sup> and the appropriate values in a
-     <a href="#7.7">&lt;float.h&gt;</a> header for types float and double:
-                       24
-           x f = s2e   (Sum) f k 2-k ,
-                       k=1
-                                      -125 &lt;= e &lt;= +128
-
-                       53
-           x d = s2e   (Sum) f k 2-k ,
-                       k=1
-                                      -1021 &lt;= e &lt;= +1024
-
-             FLT_RADIX                                     2
-             DECIMAL_DIG                                  17
-             FLT_MANT_DIG                                 24
-             FLT_EPSILON                     1.19209290E-07F // decimal constant
-             FLT_EPSILON                            0X1P-23F // hex constant
-             FLT_DECIMAL_DIG                               9
-
-
-     <sup><a name="note27" href="#note27"><b>27)</b></a></sup> If the presence or absence of subnormal numbers is indeterminable, then the value is intended to be a
-         positive number no greater than the minimum normalized positive number for the type.
-     <sup><a name="note28" href="#note28"><b>28)</b></a></sup> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
-         limits are one less than shown here.
-
-[<a name="p33" href="#p33">page 33</a>] (<a href="#Contents">Contents</a>)
-
-        FLT_DIG                             6
-        FLT_MIN_EXP                      -125
-        FLT_MIN               1.17549435E-38F               //   decimal constant
-        FLT_MIN                     0X1P-126F               //   hex constant
-        FLT_TRUE_MIN          1.40129846E-45F               //   decimal constant
-        FLT_TRUE_MIN                0X1P-149F               //   hex constant
-        FLT_HAS_SUBNORM                     1
-        FLT_MIN_10_EXP                    -37
-        FLT_MAX_EXP                      +128
-        FLT_MAX               3.40282347E+38F               // decimal constant
-        FLT_MAX               0X1.fffffeP127F               // hex constant
-        FLT_MAX_10_EXP                    +38
-        DBL_MANT_DIG                       53
-        DBL_EPSILON    2.2204460492503131E-16               // decimal constant
-        DBL_EPSILON                   0X1P-52               // hex constant
-        DBL_DECIMAL_DIG                    17
-        DBL_DIG                            15
-        DBL_MIN_EXP                     -1021
-        DBL_MIN      2.2250738585072014E-308                //   decimal constant
-        DBL_MIN                     0X1P-1022               //   hex constant
-        DBL_TRUE_MIN 4.9406564584124654E-324                //   decimal constant
-        DBL_TRUE_MIN                0X1P-1074               //   hex constant
-        DBL_HAS_SUBNORM                     1
-        DBL_MIN_10_EXP                   -307
-        DBL_MAX_EXP                     +1024
-        DBL_MAX      1.7976931348623157E+308                // decimal constant
-        DBL_MAX        0X1.fffffffffffffP1023               // hex constant
-        DBL_MAX_10_EXP                   +308
-If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
-example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
-precision), then DECIMAL_DIG would be 21.
-
-Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
-<a href="#7.3">&lt;complex.h&gt;</a> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <a href="#7.28">&lt;wchar.h&gt;</a>
-(<a href="#7.28">7.28</a>), floating-point environment <a href="#7.6">&lt;fenv.h&gt;</a> (<a href="#7.6">7.6</a>), general utilities <a href="#7.22">&lt;stdlib.h&gt;</a>
-(<a href="#7.22">7.22</a>), input/output <a href="#7.21">&lt;stdio.h&gt;</a> (<a href="#7.21">7.21</a>), mathematics <a href="#7.12">&lt;math.h&gt;</a> (<a href="#7.12">7.12</a>).
-
-[<a name="p34" href="#p34">page 34</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="6" href="#6"><b>    6. Language</b></a>
-<a name="6.1" href="#6.1"><b>    6.1 Notation</b></a>
-1   In the syntax notation used in this clause, syntactic categories (nonterminals) are
-    indicated by italic type, and literal words and character set members (terminals) by bold
-    type. A colon (:) following a nonterminal introduces its definition. Alternative
-    definitions are listed on separate lines, except when prefaced by the words ''one of''. An
-    optional symbol is indicated by the subscript ''opt'', so that
-             { expressionopt }
-    indicates an optional expression enclosed in braces.
-2   When syntactic categories are referred to in the main text, they are not italicized and
-    words are separated by spaces instead of hyphens.
-3   A summary of the language syntax is given in <a href="#A">annex A</a>.
-<a name="6.2" href="#6.2"><b>    6.2 Concepts</b></a>
-<a name="6.2.1" href="#6.2.1"><b>    6.2.1 Scopes of identifiers</b></a>
-1   An identifier can denote an object; a function; a tag or a member of a structure, union, or
-    enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
-    same identifier can denote different entities at different points in the program. A member
-    of an enumeration is called an enumeration constant. Macro names and macro
-    parameters are not considered further here, because prior to the semantic phase of
-    program translation any occurrences of macro names in the source file are replaced by the
-    preprocessing token sequences that constitute their macro definitions.
-2   For each different entity that an identifier designates, the identifier is visible (i.e., can be
-    used) only within a region of program text called its scope. Different entities designated
-    by the same identifier either have different scopes, or are in different name spaces. There
-    are four kinds of scopes: function, file, block, and function prototype. (A function
-    prototype is a declaration of a function that declares the types of its parameters.)
-3   A label name is the only kind of identifier that has function scope. It can be used (in a
-    goto statement) anywhere in the function in which it appears, and is declared implicitly
-    by its syntactic appearance (followed by a : and a statement).
-4   Every other identifier has scope determined by the placement of its declaration (in a
-    declarator or type specifier). If the declarator or type specifier that declares the identifier
-    appears outside of any block or list of parameters, the identifier has file scope, which
-    terminates at the end of the translation unit. If the declarator or type specifier that
-    declares the identifier appears inside a block or within the list of parameter declarations in
-    a function definition, the identifier has block scope, which terminates at the end of the
-    associated block. If the declarator or type specifier that declares the identifier appears
-
-[<a name="p35" href="#p35">page 35</a>] (<a href="#Contents">Contents</a>)
-
-    within the list of parameter declarations in a function prototype (not part of a function
-    definition), the identifier has function prototype scope, which terminates at the end of the
-    function declarator. If an identifier designates two different entities in the same name
-    space, the scopes might overlap. If so, the scope of one entity (the inner scope) will end
-    strictly before the scope of the other entity (the outer scope). Within the inner scope, the
-    identifier designates the entity declared in the inner scope; the entity declared in the outer
-    scope is hidden (and not visible) within the inner scope.
-5   Unless explicitly stated otherwise, where this International Standard uses the term
-    ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
-    entity in the relevant name space whose declaration is visible at the point the identifier
-    occurs.
-6   Two identifiers have the same scope if and only if their scopes terminate at the same
-    point.
-7   Structure, union, and enumeration tags have scope that begins just after the appearance of
-    the tag in a type specifier that declares the tag. Each enumeration constant has scope that
-    begins just after the appearance of its defining enumerator in an enumerator list. Any
-    other identifier has scope that begins just after the completion of its declarator.
-8   As a special case, a type name (which is not a declaration of an identifier) is considered to
-    have a scope that begins just after the place within the type name where the omitted
-    identifier would appear were it not omitted.
-    Forward references: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
-    (<a href="#6.9.1">6.9.1</a>), identifiers (<a href="#6.4.2">6.4.2</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), name spaces of identifiers (<a href="#6.2.3">6.2.3</a>),
-    source file inclusion (<a href="#6.10.2">6.10.2</a>), statements (<a href="#6.8">6.8</a>).
-<a name="6.2.2" href="#6.2.2"><b>    6.2.2 Linkages of identifiers</b></a>
-1   An identifier declared in different scopes or in the same scope more than once can be
-    made to refer to the same object or function by a process called linkage.<sup><a href="#note29"><b>29)</b></a></sup> There are
-    three kinds of linkage: external, internal, and none.
-2   In the set of translation units and libraries that constitutes an entire program, each
-    declaration of a particular identifier with external linkage denotes the same object or
-    function. Within one translation unit, each declaration of an identifier with internal
-    linkage denotes the same object or function. Each declaration of an identifier with no
-    linkage denotes a unique entity.
-3   If the declaration of a file scope identifier for an object or a function contains the storage-
-    class specifier static, the identifier has internal linkage.<sup><a href="#note30"><b>30)</b></a></sup>
-
-
-
-    <sup><a name="note29" href="#note29"><b>29)</b></a></sup> There is no linkage between different identifiers.
-
-[<a name="p36" href="#p36">page 36</a>] (<a href="#Contents">Contents</a>)
-
-4   For an identifier declared with the storage-class specifier extern in a scope in which a
-    prior declaration of that identifier is visible,<sup><a href="#note31"><b>31)</b></a></sup> if the prior declaration specifies internal or
-    external linkage, the linkage of the identifier at the later declaration is the same as the
-    linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
-    declaration specifies no linkage, then the identifier has external linkage.
-5   If the declaration of an identifier for a function has no storage-class specifier, its linkage
-    is determined exactly as if it were declared with the storage-class specifier extern. If
-    the declaration of an identifier for an object has file scope and no storage-class specifier,
-    its linkage is external.
-6   The following identifiers have no linkage: an identifier declared to be anything other than
-    an object or a function; an identifier declared to be a function parameter; a block scope
-    identifier for an object declared without the storage-class specifier extern.
-7   If, within a translation unit, the same identifier appears with both internal and external
-    linkage, the behavior is undefined.
-    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
-    statements (<a href="#6.8">6.8</a>).
-<a name="6.2.3" href="#6.2.3"><b>    6.2.3 Name spaces of identifiers</b></a>
-1   If more than one declaration of a particular identifier is visible at any point in a
-    translation unit, the syntactic context disambiguates uses that refer to different entities.
-    Thus, there are separate name spaces for various categories of identifiers, as follows:
-    -- label names (disambiguated by the syntax of the label declaration and use);
-    -- the tags of structures, unions, and enumerations (disambiguated by following any<sup><a href="#note32"><b>32)</b></a></sup>
-      of the keywords struct, union, or enum);
-    -- the members of structures or unions; each structure or union has a separate name
-      space for its members (disambiguated by the type of the expression used to access the
-      member via the . or -&gt; operator);
-    -- all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
-      enumeration constants).
-    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
-    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>), tags
-    (<a href="#6.7.2.3">6.7.2.3</a>), the goto statement (<a href="#6.8.6.1">6.8.6.1</a>).
-
-    <sup><a name="note30" href="#note30"><b>30)</b></a></sup> A function declaration can contain the storage-class specifier static only if it is at file scope; see
-        <a href="#6.7.1">6.7.1</a>.
-    <sup><a name="note31" href="#note31"><b>31)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
-    <sup><a name="note32" href="#note32"><b>32)</b></a></sup> There is only one name space for tags even though three are possible.
-
-[<a name="p37" href="#p37">page 37</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.2.4" href="#6.2.4"><b>    6.2.4 Storage durations of objects</b></a>
-1   An object has a storage duration that determines its lifetime. There are four storage
-    durations: static, thread, automatic, and allocated. Allocated storage is described in
-    <a href="#7.22.3">7.22.3</a>.
-2   The lifetime of an object is the portion of program execution during which storage is
-    guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note33"><b>33)</b></a></sup> and retains
-    its last-stored value throughout its lifetime.<sup><a href="#note34"><b>34)</b></a></sup> If an object is referred to outside of its
-    lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
-    the object it points to (or just past) reaches the end of its lifetime.
-3   An object whose identifier is declared without the storage-class specifier
-    _Thread_local, and either with external or internal linkage or with the storage-class
-    specifier static, has static storage duration. Its lifetime is the entire execution of the
-    program and its stored value is initialized only once, prior to program startup.
-4   An object whose identifier is declared with the storage-class specifier _Thread_local
-    has thread storage duration. Its lifetime is the entire execution of the thread for which it
-    is created, and its stored value is initialized when the thread is started. There is a distinct
-    object per thread, and use of the declared name in an expression refers to the object
-    associated with the thread evaluating the expression. The result of attempting to
-    indirectly access an object with thread storage duration from a thread other than the one
-    with which the object is associated is implementation-defined.
-5   An object whose identifier is declared with no linkage and without the storage-class
-    specifier static has automatic storage duration, as do some compound literals. The
-    result of attempting to indirectly access an object with automatic storage duration from a
-    thread other than the one with which the object is associated is implementation-defined.
-6   For such an object that does not have a variable length array type, its lifetime extends
-    from entry into the block with which it is associated until execution of that block ends in
-    any way. (Entering an enclosed block or calling a function suspends, but does not end,
-    execution of the current block.) If the block is entered recursively, a new instance of the
-    object is created each time. The initial value of the object is indeterminate. If an
-    initialization is specified for the object, it is performed each time the declaration or
-    compound literal is reached in the execution of the block; otherwise, the value becomes
-    indeterminate each time the declaration is reached.
-
-
-
-    <sup><a name="note33" href="#note33"><b>33)</b></a></sup> The term ''constant address'' means that two pointers to the object constructed at possibly different
-        times will compare equal. The address may be different during two different executions of the same
-        program.
-    <sup><a name="note34" href="#note34"><b>34)</b></a></sup> In the case of a volatile object, the last store need not be explicit in the program.
-
-[<a name="p38" href="#p38">page 38</a>] (<a href="#Contents">Contents</a>)
-
-7   For such an object that does have a variable length array type, its lifetime extends from
-    the declaration of the object until execution of the program leaves the scope of the
-    declaration.<sup><a href="#note35"><b>35)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
-    each time. The initial value of the object is indeterminate.
-8   A non-lvalue expression with structure or union type, where the structure or union
-    contains a member with array type (including, recursively, members of all contained
-    structures and unions) refers to an object with automatic storage duration and temporary
-    lifetime.<sup><a href="#note36"><b>36)</b></a></sup> Its lifetime begins when the expression is evaluated and its initial value is the
-    value of the expression. Its lifetime ends when the evaluation of the containing full
-    expression or full declarator ends. Any attempt to modify an object with temporary
-    lifetime results in undefined behavior.
-    Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), compound literals (<a href="#6.5.2.5">6.5.2.5</a>), declarators
-    (<a href="#6.7.6">6.7.6</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), initialization (<a href="#6.7.9">6.7.9</a>), statements (<a href="#6.8">6.8</a>).
-<a name="6.2.5" href="#6.2.5"><b>    6.2.5 Types</b></a>
-1   The meaning of a value stored in an object or returned by a function is determined by the
-    type of the expression used to access it. (An identifier declared to be an object is the
-    simplest such expression; the type is specified in the declaration of the identifier.) Types
-    are partitioned into object types (types that describe objects) and function types (types
-    that describe functions). At various points within a translation unit an object type may be
-    incomplete (lacking sufficient information to determine the size of objects of that type) or
-    complete (having sufficient information).<sup><a href="#note37"><b>37)</b></a></sup>
-2   An object declared as type _Bool is large enough to store the values 0 and 1.
-3   An object declared as type char is large enough to store any member of the basic
-    execution character set. If a member of the basic execution character set is stored in a
-    char object, its value is guaranteed to be nonnegative. If any other character is stored in
-    a char object, the resulting value is implementation-defined but shall be within the range
-    of values that can be represented in that type.
-4   There are five standard signed integer types, designated as signed char, short
-    int, int, long int, and long long int. (These and other types may be
-    designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
-    implementation-defined extended signed integer types.<sup><a href="#note38"><b>38)</b></a></sup> The standard and extended
-    signed integer types are collectively called signed integer types.<sup><a href="#note39"><b>39)</b></a></sup>
-
-    <sup><a name="note35" href="#note35"><b>35)</b></a></sup> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
-        embedded block prior to the declaration, leaves the scope of the declaration.
-    <sup><a name="note36" href="#note36"><b>36)</b></a></sup> The address of such an object is taken implicitly when an array member is accessed.
-    <sup><a name="note37" href="#note37"><b>37)</b></a></sup> A type may be incomplete or complete throughout an entire translation unit, or it may change states at
-        different points within a translation unit.
-
-[<a name="p39" href="#p39">page 39</a>] (<a href="#Contents">Contents</a>)
-
-5    An object declared as type signed char occupies the same amount of storage as a
-     ''plain'' char object. A ''plain'' int object has the natural size suggested by the
-     architecture of the execution environment (large enough to contain any value in the range
-     INT_MIN to INT_MAX as defined in the header <a href="#7.10">&lt;limits.h&gt;</a>).
-6    For each of the signed integer types, there is a corresponding (but different) unsigned
-     integer type (designated with the keyword unsigned) that uses the same amount of
-     storage (including sign information) and has the same alignment requirements. The type
-     _Bool and the unsigned integer types that correspond to the standard signed integer
-     types are the standard unsigned integer types. The unsigned integer types that
-     correspond to the extended signed integer types are the extended unsigned integer types.
-     The standard and extended unsigned integer types are collectively called unsigned integer
-     types.<sup><a href="#note40"><b>40)</b></a></sup>
-7    The standard signed integer types and standard unsigned integer types are collectively
-     called the standard integer types, the extended signed integer types and extended
-     unsigned integer types are collectively called the extended integer types.
-8    For any two integer types with the same signedness and different integer conversion rank
-     (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
-     subrange of the values of the other type.
-9    The range of nonnegative values of a signed integer type is a subrange of the
-     corresponding unsigned integer type, and the representation of the same value in each
-     type is the same.<sup><a href="#note41"><b>41)</b></a></sup> A computation involving unsigned operands can never overflow,
-     because a result that cannot be represented by the resulting unsigned integer type is
-     reduced modulo the number that is one greater than the largest value that can be
-     represented by the resulting type.
-10   There are three real floating types, designated as float, double, and long
-     double.<sup><a href="#note42"><b>42)</b></a></sup> The set of values of the type float is a subset of the set of values of the
-     type double; the set of values of the type double is a subset of the set of values of the
-     type long double.
-
-
-     <sup><a name="note38" href="#note38"><b>38)</b></a></sup> Implementation-defined keywords shall have the form of an identifier reserved for any use as
-         described in <a href="#7.1.3">7.1.3</a>.
-     <sup><a name="note39" href="#note39"><b>39)</b></a></sup> Therefore, any statement in this Standard about signed integer types also applies to the extended
-         signed integer types.
-     <sup><a name="note40" href="#note40"><b>40)</b></a></sup> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
-         unsigned integer types.
-     <sup><a name="note41" href="#note41"><b>41)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
-         arguments to functions, return values from functions, and members of unions.
-     <sup><a name="note42" href="#note42"><b>42)</b></a></sup> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
-
-[<a name="p40" href="#p40">page 40</a>] (<a href="#Contents">Contents</a>)
-
-11   There are three complex types, designated as float _Complex, double
-     _Complex, and long double _Complex.<sup><a href="#note43"><b>43)</b></a></sup> (Complex types are a conditional
-     feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.) The real floating and
-     complex types are collectively called the floating types.
-12   For each floating type there is a corresponding real type, which is always a real floating
-     type. For real floating types, it is the same type. For complex types, it is the type given
-     by deleting the keyword _Complex from the type name.
-13   Each complex type has the same representation and alignment requirements as an array
-     type containing exactly two elements of the corresponding real type; the first element is
-     equal to the real part, and the second element to the imaginary part, of the complex
-     number.
-14   The type char, the signed and unsigned integer types, and the floating types are
-     collectively called the basic types. The basic types are complete object types. Even if the
-     implementation defines two or more basic types to have the same representation, they are
-     nevertheless different types.<sup><a href="#note44"><b>44)</b></a></sup>
-15   The three types char, signed char, and unsigned char are collectively called
-     the character types. The implementation shall define char to have the same range,
-     representation, and behavior as either signed char or unsigned char.<sup><a href="#note45"><b>45)</b></a></sup>
-16   An enumeration comprises a set of named integer constant values. Each distinct
-     enumeration constitutes a different enumerated type.
-17   The type char, the signed and unsigned integer types, and the enumerated types are
-     collectively called integer types. The integer and real floating types are collectively called
-     real types.
-18   Integer and floating types are collectively called arithmetic types. Each arithmetic type
-     belongs to one type domain: the real type domain comprises the real types, the complex
-     type domain comprises the complex types.
-19   The void type comprises an empty set of values; it is an incomplete object type that
-     cannot be completed.
-
-
-
-     <sup><a name="note43" href="#note43"><b>43)</b></a></sup> A specification for imaginary types is in <a href="#G">annex G</a>.
-     <sup><a name="note44" href="#note44"><b>44)</b></a></sup> An implementation may define new keywords that provide alternative ways to designate a basic (or
-         any other) type; this does not violate the requirement that all basic types be different.
-         Implementation-defined keywords shall have the form of an identifier reserved for any use as
-         described in <a href="#7.1.3">7.1.3</a>.
-     <sup><a name="note45" href="#note45"><b>45)</b></a></sup> CHAR_MIN, defined in <a href="#7.10">&lt;limits.h&gt;</a>, will have one of the values 0 or SCHAR_MIN, and this can be
-         used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
-         other two and is not compatible with either.
-
-[<a name="p41" href="#p41">page 41</a>] (<a href="#Contents">Contents</a>)
-
-20   Any number of derived types can be constructed from the object and function types, as
-     follows:
-     -- An array type describes a contiguously allocated nonempty set of objects with a
-       particular member object type, called the element type. The element type shall be
-       complete whenever the array type is specified. Array types are characterized by their
-       element type and by the number of elements in the array. An array type is said to be
-       derived from its element type, and if its element type is T , the array type is sometimes
-       called ''array of T ''. The construction of an array type from an element type is called
-       ''array type derivation''.
-     -- A structure type describes a sequentially allocated nonempty set of member objects
-       (and, in certain circumstances, an incomplete array), each of which has an optionally
-       specified name and possibly distinct type.
-     -- A union type describes an overlapping nonempty set of member objects, each of
-       which has an optionally specified name and possibly distinct type.
-     -- A function type describes a function with specified return type. A function type is
-       characterized by its return type and the number and types of its parameters. A
-       function type is said to be derived from its return type, and if its return type is T , the
-       function type is sometimes called ''function returning T ''. The construction of a
-       function type from a return type is called ''function type derivation''.
-     -- A pointer type may be derived from a function type or an object type, called the
-       referenced type. A pointer type describes an object whose value provides a reference
-       to an entity of the referenced type. A pointer type derived from the referenced type T
-       is sometimes called ''pointer to T ''. The construction of a pointer type from a
-       referenced type is called ''pointer type derivation''. A pointer type is a complete
-       object type.
-     -- An atomic type describes the type designated by the construct _Atomic ( type-
-       name ). (Atomic types are a conditional feature that implementations need not
-       support; see <a href="#6.10.8.3">6.10.8.3</a>.)
-     These methods of constructing derived types can be applied recursively.
-21   Arithmetic types and pointer types are collectively called scalar types. Array and
-     structure types are collectively called aggregate types.<sup><a href="#note46"><b>46)</b></a></sup>
-22   An array type of unknown size is an incomplete type. It is completed, for an identifier of
-     that type, by specifying the size in a later declaration (with internal or external linkage).
-     A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
-
-
-     <sup><a name="note46" href="#note46"><b>46)</b></a></sup> Note that aggregate type does not include union type because an object with union type can only
-         contain one member at a time.
-
-[<a name="p42" href="#p42">page 42</a>] (<a href="#Contents">Contents</a>)
-
-     type. It is completed, for all declarations of that type, by declaring the same structure or
-     union tag with its defining content later in the same scope.
-23   A type has known constant size if the type is not incomplete and is not a variable length
-     array type.
-24   Array, function, and pointer types are collectively called derived declarator types. A
-     declarator type derivation from a type T is the construction of a derived declarator type
-     from T by the application of an array-type, a function-type, or a pointer-type derivation to
-     T.
-25   A type is characterized by its type category, which is either the outermost derivation of a
-     derived type (as noted above in the construction of derived types), or the type itself if the
-     type consists of no derived types.
-26   Any type so far mentioned is an unqualified type. Each unqualified type has several
-     qualified versions of its type,<sup><a href="#note47"><b>47)</b></a></sup> corresponding to the combinations of one, two, or all
-     three of the const, volatile, and restrict qualifiers. The qualified or unqualified
-     versions of a type are distinct types that belong to the same type category and have the
-     same representation and alignment requirements.<sup><a href="#note48"><b>48)</b></a></sup> A derived type is not qualified by the
-     qualifiers (if any) of the type from which it is derived.
-27   Further, there is the _Atomic qualifier. The presence of the _Atomic qualifier
-     designates an atomic type. The size, representation, and alignment of an atomic type
-     need not be the same as those of the corresponding unqualified type. Therefore, this
-     Standard explicitly uses the phrase ''atomic, qualified or unqualified type'' whenever the
-     atomic version of a type is permitted along with the other qualified versions of a type.
-     The phrase ''qualified or unqualified type'', without specific mention of atomic, does not
-     include the atomic types.
-28   A pointer to void shall have the same representation and alignment requirements as a
-     pointer to a character type.48) Similarly, pointers to qualified or unqualified versions of
-     compatible types shall have the same representation and alignment requirements. All
-     pointers to structure types shall have the same representation and alignment requirements
-     as each other. All pointers to union types shall have the same representation and
-     alignment requirements as each other. Pointers to other types need not have the same
-     representation or alignment requirements.
-29   EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
-     pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
-     whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
-
-
-     <sup><a name="note47" href="#note47"><b>47)</b></a></sup> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
-     <sup><a name="note48" href="#note48"><b>48)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
-         arguments to functions, return values from functions, and members of unions.
-
-[<a name="p43" href="#p43">page 43</a>] (<a href="#Contents">Contents</a>)
-
-     qualified float'' and is a pointer to a qualified type.
-
-30   EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
-     function returning struct tag''. The array has length five and the function has a single parameter of type
-     float. Its type category is array.
-
-     Forward references: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
-<a name="6.2.6" href="#6.2.6"><b>     6.2.6 Representations of types</b></a>
-<a name="6.2.6.1" href="#6.2.6.1"><b>     6.2.6.1 General</b></a>
-1    The representations of all types are unspecified except as stated in this subclause.
-2    Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
-     the number, order, and encoding of which are either explicitly specified or
-     implementation-defined.
-3    Values stored in unsigned bit-fields and objects of type unsigned char shall be
-     represented using a pure binary notation.<sup><a href="#note49"><b>49)</b></a></sup>
-4    Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
-     bits, where n is the size of an object of that type, in bytes. The value may be copied into
-     an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
-     called the object representation of the value. Values stored in bit-fields consist of m bits,
-     where m is the size specified for the bit-field. The object representation is the set of m
-     bits the bit-field comprises in the addressable storage unit holding it. Two values (other
-     than NaNs) with the same object representation compare equal, but values that compare
-     equal may have different object representations.
-5    Certain object representations need not represent a value of the object type. If the stored
-     value of an object has such a representation and is read by an lvalue expression that does
-     not have character type, the behavior is undefined. If such a representation is produced
-     by a side effect that modifies all or any part of the object by an lvalue expression that
-     does not have character type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup> Such a representation is called
-     a trap representation.
-6    When a value is stored in an object of structure or union type, including in a member
-     object, the bytes of the object representation that correspond to any padding bytes take
-     unspecified values.<sup><a href="#note51"><b>51)</b></a></sup> The value of a structure or union object is never a trap
-
-
-     <sup><a name="note49" href="#note49"><b>49)</b></a></sup> A positional representation for integers that uses the binary digits 0 and 1, in which the values
-         represented by successive bits are additive, begin with 1, and are multiplied by successive integral
-         powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
-         Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
-         type unsigned char range from 0 to 2
-                                                   CHAR_BIT
-                                                             - 1.
-     <sup><a name="note50" href="#note50"><b>50)</b></a></sup> Thus, an automatic variable can be initialized to a trap representation without causing undefined
-         behavior, but the value of the variable cannot be used until a proper value is stored in it.
-
-[<a name="p44" href="#p44">page 44</a>] (<a href="#Contents">Contents</a>)
-
-    representation, even though the value of a member of the structure or union object may be
-    a trap representation.
-7   When a value is stored in a member of an object of union type, the bytes of the object
-    representation that do not correspond to that member but do correspond to other members
-    take unspecified values.
-8   Where an operator is applied to a value that has more than one object representation,
-    which object representation is used shall not affect the value of the result.<sup><a href="#note52"><b>52)</b></a></sup> Where a
-    value is stored in an object using a type that has more than one object representation for
-    that value, it is unspecified which representation is used, but a trap representation shall
-    not be generated.
-9   Loads and stores of objects with                            atomic       types     are     done      with
-    memory_order_seq_cst semantics.
-    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
-    designators (<a href="#6.3.2.1">6.3.2.1</a>), order and consistency (<a href="#7.17.3">7.17.3</a>).
-<a name="6.2.6.2" href="#6.2.6.2"><b>    6.2.6.2 Integer types</b></a>
-1   For unsigned integer types other than unsigned char, the bits of the object
-    representation shall be divided into two groups: value bits and padding bits (there need
-    not be any of the latter). If there are N value bits, each bit shall represent a different
-    power of 2 between 1 and 2 N -1 , so that objects of that type shall be capable of
-    representing values from 0 to 2 N - 1 using a pure binary representation; this shall be
-    known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note53"><b>53)</b></a></sup>
-2   For signed integer types, the bits of the object representation shall be divided into three
-    groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
-    signed char shall not have any padding bits. There shall be exactly one sign bit.
-    Each bit that is a value bit shall have the same value as the same bit in the object
-    representation of the corresponding unsigned type (if there are M value bits in the signed
-    type and N in the unsigned type, then M &lt;= N ). If the sign bit is zero, it shall not affect
-
-    <sup><a name="note51" href="#note51"><b>51)</b></a></sup> Thus, for example, structure assignment need not copy any padding bits.
-    <sup><a name="note52" href="#note52"><b>52)</b></a></sup> It is possible for objects x and y with the same effective type T to have the same value when they are
-        accessed as objects of type T, but to have different values in other contexts. In particular, if == is
-        defined for type T, then x == y does not imply that memcmp(&amp;x, &amp;y, sizeof (T)) == 0.
-        Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
-        on values of type T may distinguish between them.
-    <sup><a name="note53" href="#note53"><b>53)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
-        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
-        representation other than as part of an exceptional condition such as an overflow, and this cannot occur
-        with unsigned types. All other combinations of padding bits are alternative object representations of
-        the value specified by the value bits.
-
-[<a name="p45" href="#p45">page 45</a>] (<a href="#Contents">Contents</a>)
-
-    the resulting value. If the sign bit is one, the value shall be modified in one of the
-    following ways:
-    -- the corresponding value with sign bit 0 is negated (sign and magnitude);
-    -- the sign bit has the value -(2 M ) (two's complement);
-    -- the sign bit has the value -(2 M - 1) (ones' complement).
-    Which of these applies is implementation-defined, as is whether the value with sign bit 1
-    and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones'
-    complement), is a trap representation or a normal value. In the case of sign and
-    magnitude and ones' complement, if this representation is a normal value it is called a
-    negative zero.
-3   If the implementation supports negative zeros, they shall be generated only by:
-    -- the &amp;, |, ^, ~, &lt;&lt;, and &gt;&gt; operators with operands that produce such a value;
-    -- the +, -, *, /, and % operators where one operand is a negative zero and the result is
-      zero;
-    -- compound assignment operators based on the above cases.
-    It is unspecified whether these cases actually generate a negative zero or a normal zero,
-    and whether a negative zero becomes a normal zero when stored in an object.
-4   If the implementation does not support negative zeros, the behavior of the &amp;, |, ^, ~, &lt;&lt;,
-    and &gt;&gt; operators with operands that would produce such a value is undefined.
-5   The values of any padding bits are unspecified.<sup><a href="#note54"><b>54)</b></a></sup> A valid (non-trap) object representation
-    of a signed integer type where the sign bit is zero is a valid object representation of the
-    corresponding unsigned type, and shall represent the same value. For any integer type,
-    the object representation where all the bits are zero shall be a representation of the value
-    zero in that type.
-6   The precision of an integer type is the number of bits it uses to represent values,
-    excluding any sign and padding bits. The width of an integer type is the same but
-    including any sign bit; thus for unsigned integer types the two values are the same, while
-    for signed integer types the width is one greater than the precision.
-
-
-
-
-    <sup><a name="note54" href="#note54"><b>54)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
-        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
-        representation other than as part of an exceptional condition such as an overflow. All other
-        combinations of padding bits are alternative object representations of the value specified by the value
-        bits.
-
-[<a name="p46" href="#p46">page 46</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.2.7" href="#6.2.7"><b>    6.2.7 Compatible type and composite type</b></a>
-1   Two types have compatible type if their types are the same. Additional rules for
-    determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
-    in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.6">6.7.6</a> for declarators.<sup><a href="#note55"><b>55)</b></a></sup> Moreover, two structure,
-    union, or enumerated types declared in separate translation units are compatible if their
-    tags and members satisfy the following requirements: If one is declared with a tag, the
-    other shall be declared with the same tag. If both are completed anywhere within their
-    respective translation units, then the following additional requirements apply: there shall
-    be a one-to-one correspondence between their members such that each pair of
-    corresponding members are declared with compatible types; if one member of the pair is
-    declared with an alignment specifier, the other is declared with an equivalent alignment
-    specifier; and if one member of the pair is declared with a name, the other is declared
-    with the same name. For two structures, corresponding members shall be declared in the
-    same order. For two structures or unions, corresponding bit-fields shall have the same
-    widths. For two enumerations, corresponding members shall have the same values.
-2   All declarations that refer to the same object or function shall have compatible type;
-    otherwise, the behavior is undefined.
-3   A composite type can be constructed from two types that are compatible; it is a type that
-    is compatible with both of the two types and satisfies the following conditions:
-    -- If both types are array types, the following rules are applied:
-          o If one type is an array of known constant size, the composite type is an array of
-             that size.
-          o Otherwise, if one type is a variable length array whose size is specified by an
-             expression that is not evaluated, the behavior is undefined.
-          o Otherwise, if one type is a variable length array whose size is specified, the
-             composite type is a variable length array of that size.
-          o Otherwise, if one type is a variable length array of unspecified size, the composite
-             type is a variable length array of unspecified size.
-          o Otherwise, both types are arrays of unknown size and the composite type is an
-             array of unknown size.
-        The element type of the composite type is the composite type of the two element
-        types.
-    -- If only one type is a function type with a parameter type list (a function prototype),
-      the composite type is a function prototype with the parameter type list.
-
-
-    <sup><a name="note55" href="#note55"><b>55)</b></a></sup> Two types need not be identical to be compatible.
-
-[<a name="p47" href="#p47">page 47</a>] (<a href="#Contents">Contents</a>)
-
-    -- If both types are function types with parameter type lists, the type of each parameter
-      in the composite parameter type list is the composite type of the corresponding
-      parameters.
-    These rules apply recursively to the types from which the two types are derived.
-4   For an identifier with internal or external linkage declared in a scope in which a prior
-    declaration of that identifier is visible,<sup><a href="#note56"><b>56)</b></a></sup> if the prior declaration specifies internal or
-    external linkage, the type of the identifier at the later declaration becomes the composite
-    type.
-    Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
-5   EXAMPLE        Given the following two file scope declarations:
-             int f(int (*)(), double (*)[3]);
-             int f(int (*)(char *), double (*)[]);
-    The resulting composite type for the function is:
-             int f(int (*)(char *), double (*)[3]);
-
-<a name="6.2.8" href="#6.2.8"><b>    6.2.8 Alignment of objects</b></a>
-1   Complete object types have alignment requirements which place restrictions on the
-    addresses at which objects of that type may be allocated. An alignment is an
-    implementation-defined integer value representing the number of bytes between
-    successive addresses at which a given object can be allocated. An object type imposes an
-    alignment requirement on every object of that type: stricter alignment can be requested
-    using the _Alignas keyword.
-2   A fundamental alignment is represented by an alignment less than or equal to the greatest
-    alignment supported by the implementation in all contexts, which is equal to
-    alignof(max_align_t).
-3   An extended alignment is represented by an alignment greater than
-    alignof(max_align_t). It is implementation-defined whether any extended
-    alignments are supported and the contexts in which they are supported. A type having an
-    extended alignment requirement is an over-aligned type.<sup><a href="#note57"><b>57)</b></a></sup>
-4   Alignments are represented as values of the type size_t. Valid alignments include only
-    those values returned by an alignof expression for fundamental types, plus an
-    additional implementation-defined set of values, which may be empty. Every valid
-    alignment value shall be a nonnegative integral power of two.
-
-
-    <sup><a name="note56" href="#note56"><b>56)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
-    <sup><a name="note57" href="#note57"><b>57)</b></a></sup> Every over-aligned type is, or contains, a structure or union type with a member to which an extended
-        alignment has been applied.
-
-[<a name="p48" href="#p48">page 48</a>] (<a href="#Contents">Contents</a>)
-
-5   Alignments have an order from weaker to stronger or stricter alignments. Stricter
-    alignments have larger alignment values. An address that satisfies an alignment
-    requirement also satisfies any weaker valid alignment requirement.
-6   The alignment requirement of a complete type can be queried using an alignof
-    expression. The types char, signed char, and unsigned char shall have the
-    weakest alignment requirement.
-7   Comparing alignments is meaningful and provides the obvious results:
-    -- Two alignments are equal when their numeric values are equal.
-    -- Two alignments are different when their numeric values are not equal.
-    -- When an alignment is larger than another it represents a stricter alignment.
-
-[<a name="p49" href="#p49">page 49</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.3" href="#6.3"><b>    6.3 Conversions</b></a>
-1   Several operators convert operand values from one type to another automatically. This
-    subclause specifies the result required from such an implicit conversion, as well as those
-    that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
-    the conversions performed by most ordinary operators; it is supplemented as required by
-    the discussion of each operator in <a href="#6.5">6.5</a>.
-2   Conversion of an operand value to a compatible type causes no change to the value or the
-    representation.
-    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>).
-<a name="6.3.1" href="#6.3.1"><b>    6.3.1 Arithmetic operands</b></a>
-<a name="6.3.1.1" href="#6.3.1.1"><b>    6.3.1.1 Boolean, characters, and integers</b></a>
-1   Every integer type has an integer conversion rank defined as follows:
-    -- No two signed integer types shall have the same rank, even if they have the same
-      representation.
-    -- The rank of a signed integer type shall be greater than the rank of any signed integer
-      type with less precision.
-    -- The rank of long long int shall be greater than the rank of long int, which
-      shall be greater than the rank of int, which shall be greater than the rank of short
-      int, which shall be greater than the rank of signed char.
-    -- The rank of any unsigned integer type shall equal the rank of the corresponding
-      signed integer type, if any.
-    -- The rank of any standard integer type shall be greater than the rank of any extended
-      integer type with the same width.
-    -- The rank of char shall equal the rank of signed char and unsigned char.
-    -- The rank of _Bool shall be less than the rank of all other standard integer types.
-    -- The rank of any enumerated type shall equal the rank of the compatible integer type
-      (see <a href="#6.7.2.2">6.7.2.2</a>).
-    -- The rank of any extended signed integer type relative to another extended signed
-      integer type with the same precision is implementation-defined, but still subject to the
-      other rules for determining the integer conversion rank.
-    -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
-      greater rank than T3, then T1 has greater rank than T3.
-2   The following may be used in an expression wherever an int or unsigned int may
-    be used:
-
-[<a name="p50" href="#p50">page 50</a>] (<a href="#Contents">Contents</a>)
-
-    -- An object or expression with an integer type (other than int or unsigned int)
-      whose integer conversion rank is less than or equal to the rank of int and
-      unsigned int.
-    -- A bit-field of type _Bool, int, signed int, or unsigned int.
-    If an int can represent all values of the original type (as restricted by the width, for a
-    bit-field), the value is converted to an int; otherwise, it is converted to an unsigned
-    int. These are called the integer promotions.<sup><a href="#note58"><b>58)</b></a></sup> All other types are unchanged by the
-    integer promotions.
-3   The integer promotions preserve value including sign. As discussed earlier, whether a
-    ''plain'' char is treated as signed is implementation-defined.
-    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
-    (<a href="#6.7.2.1">6.7.2.1</a>).
-<a name="6.3.1.2" href="#6.3.1.2"><b>    6.3.1.2 Boolean type</b></a>
-1   When any scalar value is converted to _Bool, the result is 0 if the value compares equal
-    to 0; otherwise, the result is 1.<sup><a href="#note59"><b>59)</b></a></sup>
-<a name="6.3.1.3" href="#6.3.1.3"><b>    6.3.1.3 Signed and unsigned integers</b></a>
-1   When a value with integer type is converted to another integer type other than _Bool, if
-    the value can be represented by the new type, it is unchanged.
-2   Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
-    subtracting one more than the maximum value that can be represented in the new type
-    until the value is in the range of the new type.<sup><a href="#note60"><b>60)</b></a></sup>
-3   Otherwise, the new type is signed and the value cannot be represented in it; either the
-    result is implementation-defined or an implementation-defined signal is raised.
-<a name="6.3.1.4" href="#6.3.1.4"><b>    6.3.1.4 Real floating and integer</b></a>
-1   When a finite value of real floating type is converted to an integer type other than _Bool,
-    the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
-    the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note61"><b>61)</b></a></sup>
-
-
-    <sup><a name="note58" href="#note58"><b>58)</b></a></sup> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
-        argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
-        shift operators, as specified by their respective subclauses.
-    <sup><a name="note59" href="#note59"><b>59)</b></a></sup> NaNs do not compare equal to 0 and thus convert to 1.
-    <sup><a name="note60" href="#note60"><b>60)</b></a></sup> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
-    <sup><a name="note61" href="#note61"><b>61)</b></a></sup> The remaindering operation performed when a value of integer type is converted to unsigned type
-        need not be performed when a value of real floating type is converted to unsigned type. Thus, the
-        range of portable real floating values is (-1, Utype_MAX+1).
-
-[<a name="p51" href="#p51">page 51</a>] (<a href="#Contents">Contents</a>)
-
-2   When a value of integer type is converted to a real floating type, if the value being
-    converted can be represented exactly in the new type, it is unchanged. If the value being
-    converted is in the range of values that can be represented but cannot be represented
-    exactly, the result is either the nearest higher or nearest lower representable value, chosen
-    in an implementation-defined manner. If the value being converted is outside the range of
-    values that can be represented, the behavior is undefined. Results of some implicit
-    conversions (<a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>) may be represented in greater precision and range than that
-    required by the new type.
-<a name="6.3.1.5" href="#6.3.1.5"><b>    6.3.1.5 Real floating types</b></a>
-1   When a value of real floating type is converted to a real floating type, if the value being
-    converted can be represented exactly in the new type, it is unchanged. If the value being
-    converted is in the range of values that can be represented but cannot be represented
-    exactly, the result is either the nearest higher or nearest lower representable value, chosen
-    in an implementation-defined manner. If the value being converted is outside the range of
-    values that can be represented, the behavior is undefined. Results of some implicit
-    conversions (<a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>) may be represented in greater precision and range than that
-    required by the new type.
-<a name="6.3.1.6" href="#6.3.1.6"><b>    6.3.1.6 Complex types</b></a>
-1   When a value of complex type is converted to another complex type, both the real and
-    imaginary parts follow the conversion rules for the corresponding real types.
-<a name="6.3.1.7" href="#6.3.1.7"><b>    6.3.1.7 Real and complex</b></a>
-1   When a value of real type is converted to a complex type, the real part of the complex
-    result value is determined by the rules of conversion to the corresponding real type and
-    the imaginary part of the complex result value is a positive zero or an unsigned zero.
-2   When a value of complex type is converted to a real type, the imaginary part of the
-    complex value is discarded and the value of the real part is converted according to the
-    conversion rules for the corresponding real type.
-<a name="6.3.1.8" href="#6.3.1.8"><b>    6.3.1.8 Usual arithmetic conversions</b></a>
-1   Many operators that expect operands of arithmetic type cause conversions and yield result
-    types in a similar way. The purpose is to determine a common real type for the operands
-    and result. For the specified operands, each operand is converted, without change of type
-    domain, to a type whose corresponding real type is the common real type. Unless
-    explicitly stated otherwise, the common real type is also the corresponding real type of
-    the result, whose type domain is the type domain of the operands if they are the same,
-    and complex otherwise. This pattern is called the usual arithmetic conversions:
-          First, if the corresponding real type of either operand is long double, the other
-          operand is converted, without change of type domain, to a type whose
-
-[<a name="p52" href="#p52">page 52</a>] (<a href="#Contents">Contents</a>)
-
-           corresponding real type is long double.
-           Otherwise, if the corresponding real type of either operand is double, the other
-           operand is converted, without change of type domain, to a type whose
-           corresponding real type is double.
-           Otherwise, if the corresponding real type of either operand is float, the other
-           operand is converted, without change of type domain, to a type whose
-           corresponding real type is float.<sup><a href="#note62"><b>62)</b></a></sup>
-           Otherwise, the integer promotions are performed on both operands. Then the
-           following rules are applied to the promoted operands:
-                  If both operands have the same type, then no further conversion is needed.
-                  Otherwise, if both operands have signed integer types or both have unsigned
-                  integer types, the operand with the type of lesser integer conversion rank is
-                  converted to the type of the operand with greater rank.
-                  Otherwise, if the operand that has unsigned integer type has rank greater or
-                  equal to the rank of the type of the other operand, then the operand with
-                  signed integer type is converted to the type of the operand with unsigned
-                  integer type.
-                  Otherwise, if the type of the operand with signed integer type can represent
-                  all of the values of the type of the operand with unsigned integer type, then
-                  the operand with unsigned integer type is converted to the type of the
-                  operand with signed integer type.
-                  Otherwise, both operands are converted to the unsigned integer type
-                  corresponding to the type of the operand with signed integer type.
-2   The values of floating operands and of the results of floating expressions may be
-    represented in greater precision and range than that required by the type; the types are not
-    changed thereby.<sup><a href="#note63"><b>63)</b></a></sup>
-
-
-
-
-    <sup><a name="note62" href="#note62"><b>62)</b></a></sup> For example, addition of a double _Complex and a float entails just the conversion of the
-        float operand to double (and yields a double _Complex result).
-    <sup><a name="note63" href="#note63"><b>63)</b></a></sup> The cast and assignment operators are still required to remove extra range and precision.
-
-[<a name="p53" href="#p53">page 53</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.3.2" href="#6.3.2"><b>    6.3.2 Other operands</b></a>
-<a name="6.3.2.1" href="#6.3.2.1"><b>    6.3.2.1 Lvalues, arrays, and function designators</b></a>
-1   An lvalue is an expression (with an object type other than void) that potentially
-    designates an object;<sup><a href="#note64"><b>64)</b></a></sup> if an lvalue does not designate an object when it is evaluated, the
-    behavior is undefined. When an object is said to have a particular type, the type is
-    specified by the lvalue used to designate the object. A modifiable lvalue is an lvalue that
-    does not have array type, does not have an incomplete type, does not have a const-
-    qualified type, and if it is a structure or union, does not have any member (including,
-    recursively, any member or element of all contained aggregates or unions) with a const-
-    qualified type.
-2   Except when it is the operand of the sizeof operator, the unary &amp; operator, the ++
-    operator, the -- operator, or the left operand of the . operator or an assignment operator,
-    an lvalue that does not have array type is converted to the value stored in the designated
-    object (and is no longer an lvalue); this is called lvalue conversion. If the lvalue has
-    qualified type, the value has the unqualified version of the type of the lvalue; additionally,
-    if the lvalue has atomic type, the value has the non-atomic version of the type of the
-    lvalue; otherwise, the value has the type of the lvalue. If the lvalue has an incomplete
-    type and does not have array type, the behavior is undefined. If the lvalue designates an
-    object of automatic storage duration that could have been declared with the register
-    storage class (never had its address taken), and that object is uninitialized (not declared
-    with an initializer and no assignment to it has been performed prior to use), the behavior
-    is undefined.
-3   Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a
-    string literal used to initialize an array, an expression that has type ''array of type'' is
-    converted to an expression with type ''pointer to type'' that points to the initial element of
-    the array object and is not an lvalue. If the array object has register storage class, the
-    behavior is undefined.
-4   A function designator is an expression that has function type. Except when it is the
-    operand of the sizeof operator<sup><a href="#note65"><b>65)</b></a></sup> or the unary &amp; operator, a function designator with
-    type ''function returning type'' is converted to an expression that has type ''pointer to
-
-
-    <sup><a name="note64" href="#note64"><b>64)</b></a></sup> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
-        operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
-        object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
-        as the ''value of an expression''.
-         An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
-         expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
-    <sup><a name="note65" href="#note65"><b>65)</b></a></sup> Because this conversion does not occur, the operand of the sizeof operator remains a function
-        designator and violates the constraint in <a href="#6.5.3.4">6.5.3.4</a>.
-
-[<a name="p54" href="#p54">page 54</a>] (<a href="#Contents">Contents</a>)
-
-    function returning type''.
-    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
-    (<a href="#6.5.16">6.5.16</a>), common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), initialization (<a href="#6.7.9">6.7.9</a>), postfix
-    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
-    (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>).
-    <a href="#6.3.2.2">6.3.2.2</a> void
-1   The (nonexistent) value of a void expression (an expression that has type void) shall not
-    be used in any way, and implicit or explicit conversions (except to void) shall not be
-    applied to such an expression. If an expression of any other type is evaluated as a void
-    expression, its value or designator is discarded. (A void expression is evaluated for its
-    side effects.)
-<a name="6.3.2.3" href="#6.3.2.3"><b>    6.3.2.3 Pointers</b></a>
-1   A pointer to void may be converted to or from a pointer to any object type. A pointer to
-    any object type may be converted to a pointer to void and back again; the result shall
-    compare equal to the original pointer.
-2   For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
-    the q-qualified version of the type; the values stored in the original and converted pointers
-    shall compare equal.
-3   An integer constant expression with the value 0, or such an expression cast to type
-    void *, is called a null pointer constant.<sup><a href="#note66"><b>66)</b></a></sup> If a null pointer constant is converted to a
-    pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
-    to a pointer to any object or function.
-4   Conversion of a null pointer to another pointer type yields a null pointer of that type.
-    Any two null pointers shall compare equal.
-5   An integer may be converted to any pointer type. Except as previously specified, the
-    result is implementation-defined, might not be correctly aligned, might not point to an
-    entity of the referenced type, and might be a trap representation.<sup><a href="#note67"><b>67)</b></a></sup>
-6   Any pointer type may be converted to an integer type. Except as previously specified, the
-    result is implementation-defined. If the result cannot be represented in the integer type,
-    the behavior is undefined. The result need not be in the range of values of any integer
-    type.
-
-
-
-
-    <sup><a name="note66" href="#note66"><b>66)</b></a></sup> The macro NULL is defined in <a href="#7.19">&lt;stddef.h&gt;</a> (and other headers) as a null pointer constant; see <a href="#7.19">7.19</a>.
-    <sup><a name="note67" href="#note67"><b>67)</b></a></sup> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
-        be consistent with the addressing structure of the execution environment.
-
-[<a name="p55" href="#p55">page 55</a>] (<a href="#Contents">Contents</a>)
-
-7   A pointer to an object type may be converted to a pointer to a different object type. If the
-    resulting pointer is not correctly aligned<sup><a href="#note68"><b>68)</b></a></sup> for the referenced type, the behavior is
-    undefined. Otherwise, when converted back again, the result shall compare equal to the
-    original pointer. When a pointer to an object is converted to a pointer to a character type,
-    the result points to the lowest addressed byte of the object. Successive increments of the
-    result, up to the size of the object, yield pointers to the remaining bytes of the object.
-8   A pointer to a function of one type may be converted to a pointer to a function of another
-    type and back again; the result shall compare equal to the original pointer. If a converted
-    pointer is used to call a function whose type is not compatible with the referenced type,
-    the behavior is undefined.
-    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
-    capable of holding object pointers (<a href="#7.20.1.4">7.20.1.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
-
-
-
-
-    <sup><a name="note68" href="#note68"><b>68)</b></a></sup> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
-        pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
-        correctly aligned for a pointer to type C.
-
-[<a name="p56" href="#p56">page 56</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4" href="#6.4"><b>    6.4 Lexical elements</b></a>
-<b>    Syntax</b>
-1            token:
-                      keyword
-                      identifier
-                      constant
-                      string-literal
-                      punctuator
-             preprocessing-token:
-                    header-name
-                    identifier
-                    pp-number
-                    character-constant
-                    string-literal
-                    punctuator
-                    each non-white-space character that cannot be one of the above
-<b>    Constraints</b>
-2   Each preprocessing token that is converted to a token shall have the lexical form of a
-    keyword, an identifier, a constant, a string literal, or a punctuator.
-<b>    Semantics</b>
-3   A token is the minimal lexical element of the language in translation phases 7 and 8. The
-    categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
-    A preprocessing token is the minimal lexical element of the language in translation
-    phases 3 through 6. The categories of preprocessing tokens are: header names,
-    identifiers, preprocessing numbers, character constants, string literals, punctuators, and
-    single non-white-space characters that do not lexically match the other preprocessing
-    token categories.<sup><a href="#note69"><b>69)</b></a></sup> If a ' or a " character matches the last category, the behavior is
-    undefined. Preprocessing tokens can be separated by white space; this consists of
-    comments (described later), or white-space characters (space, horizontal tab, new-line,
-    vertical tab, and form-feed), or both. As described in <a href="#6.10">6.10</a>, in certain circumstances
-    during translation phase 4, white space (or the absence thereof) serves as more than
-    preprocessing token separation. White space may appear within a preprocessing token
-    only as part of a header name or between the quotation characters in a character constant
-    or string literal.
-
-
-
-    <sup><a name="note69" href="#note69"><b>69)</b></a></sup> An additional category, placemarkers, is used internally in translation phase 4 (see <a href="#6.10.3.3">6.10.3.3</a>); it cannot
-        occur in source files.
-
-[<a name="p57" href="#p57">page 57</a>] (<a href="#Contents">Contents</a>)
-
-4   If the input stream has been parsed into preprocessing tokens up to a given character, the
-    next preprocessing token is the longest sequence of characters that could constitute a
-    preprocessing token. There is one exception to this rule: header name preprocessing
-    tokens are recognized only within #include preprocessing directives and in
-    implementation-defined locations within #pragma directives. In such contexts, a
-    sequence of characters that could be either a header name or a string literal is recognized
-    as the former.
-5   EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
-    valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
-    might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
-    fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
-    not E is a macro name.
-
-6   EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
-    increment operators, even though the parse x ++ + ++ y might yield a correct expression.
-
-    Forward references: character constants (<a href="#6.4.4.4">6.4.4.4</a>), comments (<a href="#6.4.9">6.4.9</a>), expressions (<a href="#6.5">6.5</a>),
-    floating constants (<a href="#6.4.4.2">6.4.4.2</a>), header names (<a href="#6.4.7">6.4.7</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), postfix
-    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
-    (<a href="#6.5.3.1">6.5.3.1</a>), preprocessing directives (<a href="#6.10">6.10</a>), preprocessing numbers (<a href="#6.4.8">6.4.8</a>), string literals
-    (<a href="#6.4.5">6.4.5</a>).
-<a name="6.4.1" href="#6.4.1"><b>    6.4.1 Keywords</b></a>
-<b>    Syntax</b>
-1            keyword: one of
-                   alignof                         goto                         union
-                   auto                            if                           unsigned
-                   break                           inline                       void
-                   case                            int                          volatile
-                   char                            long                         while
-                   const                           register                     _Alignas
-                   continue                        restrict                     _Atomic
-                   default                         return                       _Bool
-                   do                              short                        _Complex
-                   double                          signed                       _Generic
-                   else                            sizeof                       _Imaginary
-                   enum                            static                       _Noreturn
-                   extern                          struct                       _Static_assert
-                   float                           switch                       _Thread_local
-                   for                             typedef
-<b>    Semantics</b>
-2   The above tokens (case sensitive) are reserved (in translation phases 7 and 8) for use as
-    keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
-
-[<a name="p58" href="#p58">page 58</a>] (<a href="#Contents">Contents</a>)
-
-    specifying imaginary types.<sup><a href="#note70"><b>70)</b></a></sup>
-<a name="6.4.2" href="#6.4.2"><b>    6.4.2 Identifiers</b></a>
-<a name="6.4.2.1" href="#6.4.2.1"><b>    6.4.2.1 General</b></a>
-<b>    Syntax</b>
-1            identifier:
-                    identifier-nondigit
-                    identifier identifier-nondigit
-                    identifier digit
-             identifier-nondigit:
-                    nondigit
-                    universal-character-name
-                    other implementation-defined characters
-             nondigit: one of
-                    _ a b            c    d    e    f     g    h    i    j     k    l    m
-                        n o          p    q    r    s     t    u    v    w     x    y    z
-                        A B          C    D    E    F     G    H    I    J     K    L    M
-                        N O          P    Q    R    S     T    U    V    W     X    Y    Z
-             digit: one of
-                    0 1        2     3    4    5    6     7    8    9
-<b>    Semantics</b>
-2   An identifier is a sequence of nondigit characters (including the underscore _, the
-    lowercase and uppercase Latin letters, and other characters) and digits, which designates
-    one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
-    There is no specific limit on the maximum length of an identifier.
-3   Each universal character name in an identifier shall designate a character whose encoding
-    in ISO/IEC 10646 falls into one of the ranges specified in D.1.<sup><a href="#note71"><b>71)</b></a></sup> The initial character
-    shall not be a universal character name designating a character whose encoding falls into
-    one of the ranges specified in <a href="#D.2">D.2</a>. An implementation may allow multibyte characters
-    that are not part of the basic source character set to appear in identifiers; which characters
-    and their correspondence to universal character names is implementation-defined.
-
-
-
-    <sup><a name="note70" href="#note70"><b>70)</b></a></sup> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
-    <sup><a name="note71" href="#note71"><b>71)</b></a></sup> On systems in which linkers cannot accept extended characters, an encoding of the universal character
-        name may be used in forming valid external identifiers. For example, some otherwise unused
-        character or sequence of characters may be used to encode the \u in a universal character name.
-        Extended characters may produce a long external identifier.
-
-[<a name="p59" href="#p59">page 59</a>] (<a href="#Contents">Contents</a>)
-
-4   When preprocessing tokens are converted to tokens during translation phase 7, if a
-    preprocessing token could be converted to either a keyword or an identifier, it is converted
-    to a keyword.
-    Implementation limits
-5   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
-    characters in an identifier; the limit for an external name (an identifier that has external
-    linkage) may be more restrictive than that for an internal name (a macro name or an
-    identifier that does not have external linkage). The number of significant characters in an
-    identifier is implementation-defined.
-6   Any identifiers that differ in a significant character are different identifiers. If two
-    identifiers differ only in nonsignificant characters, the behavior is undefined.
-    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
-<a name="6.4.2.2" href="#6.4.2.2"><b>    6.4.2.2 Predefined identifiers</b></a>
-<b>    Semantics</b>
-1   The identifier __func__ shall be implicitly declared by the translator as if,
-    immediately following the opening brace of each function definition, the declaration
-             static const char __func__[] = "function-name";
-    appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note72"><b>72)</b></a></sup>
-2   This name is encoded as if the implicit declaration had been written in the source
-    character set and then translated into the execution character set as indicated in translation
-    phase 5.
-3   EXAMPLE        Consider the code fragment:
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             void myfunc(void)
-             {
-                   printf("%s\n", __func__);
-                   /* ... */
-             }
-    Each time the function is called, it will print to the standard output stream:
-             myfunc
-
-    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
-
-
-
-
-    <sup><a name="note72" href="#note72"><b>72)</b></a></sup> Since the name __func__ is reserved for any use by the implementation (<a href="#7.1.3">7.1.3</a>), if any other
-        identifier is explicitly declared using the name __func__, the behavior is undefined.
-
-[<a name="p60" href="#p60">page 60</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.3" href="#6.4.3"><b>    6.4.3 Universal character names</b></a>
-<b>    Syntax</b>
-1            universal-character-name:
-                    \u hex-quad
-                    \U hex-quad hex-quad
-             hex-quad:
-                    hexadecimal-digit hexadecimal-digit
-                                 hexadecimal-digit hexadecimal-digit
-<b>    Constraints</b>
-2   A universal character name shall not specify a character whose short identifier is less than
-    00A0 other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through
-    DFFF inclusive.<sup><a href="#note73"><b>73)</b></a></sup>
-<b>    Description</b>
-3   Universal character names may be used in identifiers, character constants, and string
-    literals to designate characters that are not in the basic character set.
-<b>    Semantics</b>
-4   The universal character name \Unnnnnnnn designates the character whose eight-digit
-    short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note74"><b>74)</b></a></sup> Similarly, the universal
-    character name \unnnn designates the character whose four-digit short identifier is nnnn
-    (and whose eight-digit short identifier is 0000nnnn).
-
-
-
-
-    <sup><a name="note73" href="#note73"><b>73)</b></a></sup> The disallowed characters are the characters in the basic character set and the code positions reserved
-        by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
-        UTF-16).
-
-    <sup><a name="note74" href="#note74"><b>74)</b></a></sup> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
-
-[<a name="p61" href="#p61">page 61</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.4" href="#6.4.4"><b>    6.4.4 Constants</b></a>
-<b>    Syntax</b>
-1            constant:
-                    integer-constant
-                    floating-constant
-                    enumeration-constant
-                    character-constant
-<b>    Constraints</b>
-2   Each constant shall have a type and the value of a constant shall be in the range of
-    representable values for its type.
-<b>    Semantics</b>
-3   Each constant has a type, determined by its form and value, as detailed later.
-<a name="6.4.4.1" href="#6.4.4.1"><b>    6.4.4.1 Integer constants</b></a>
-<b>    Syntax</b>
-1            integer-constant:
-                     decimal-constant integer-suffixopt
-                     octal-constant integer-suffixopt
-                     hexadecimal-constant integer-suffixopt
-             decimal-constant:
-                   nonzero-digit
-                   decimal-constant digit
-             octal-constant:
-                    0
-                    octal-constant octal-digit
-             hexadecimal-constant:
-                   hexadecimal-prefix hexadecimal-digit
-                   hexadecimal-constant hexadecimal-digit
-             hexadecimal-prefix: one of
-                   0x 0X
-             nonzero-digit: one of
-                    1 2 3 4          5     6     7   8    9
-             octal-digit: one of
-                     0 1 2 3         4     5     6   7
-
-[<a name="p62" href="#p62">page 62</a>] (<a href="#Contents">Contents</a>)
-
-            hexadecimal-digit:   one of
-                  0 1 2           3 4     5    6   7     8   9
-                  a b c           d e     f
-                  A B C           D E     F
-            integer-suffix:
-                    unsigned-suffix long-suffixopt
-                    unsigned-suffix long-long-suffix
-                    long-suffix unsigned-suffixopt
-                    long-long-suffix unsigned-suffixopt
-            unsigned-suffix: one of
-                   u U
-            long-suffix: one of
-                   l L
-            long-long-suffix: one of
-                   ll LL
-<b>    Description</b>
-2   An integer constant begins with a digit, but has no period or exponent part. It may have a
-    prefix that specifies its base and a suffix that specifies its type.
-3   A decimal constant begins with a nonzero digit and consists of a sequence of decimal
-    digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
-    digits 0 through 7 only. A hexadecimal constant consists of the prefix 0x or 0X followed
-    by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
-    10 through 15 respectively.
-<b>    Semantics</b>
-4   The value of a decimal constant is computed base 10; that of an octal constant, base 8;
-    that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
-5   The type of an integer constant is the first of the corresponding list in which its value can
-    be represented.
-
-[<a name="p63" href="#p63">page 63</a>] (<a href="#Contents">Contents</a>)
-
-                                                                     Octal or Hexadecimal
-    Suffix                       Decimal Constant                           Constant
-
-    none                int                                    int
-                        long int                               unsigned int
-                        long long int                          long int
-                                                               unsigned long int
-                                                               long long int
-                                                               unsigned long long int
-
-    u or U              unsigned int                           unsigned int
-                        unsigned long int                      unsigned long int
-                        unsigned long long int                 unsigned long long int
-
-    l or L              long int                               long int
-                        long long int                          unsigned long int
-                                                               long long int
-                                                               unsigned long long int
-
-    Both u or U         unsigned long int                      unsigned long int
-    and l or L          unsigned long long int                 unsigned long long int
-
-    ll or LL            long long int                          long long int
-                                                               unsigned long long int
-
-    Both u or U         unsigned long long int                 unsigned long long int
-    and ll or LL
-6   If an integer constant cannot be represented by any type in its list, it may have an
-    extended integer type, if the extended integer type can represent its value. If all of the
-    types in the list for the constant are signed, the extended integer type shall be signed. If
-    all of the types in the list for the constant are unsigned, the extended integer type shall be
-    unsigned. If the list contains both signed and unsigned types, the extended integer type
-    may be signed or unsigned. If an integer constant cannot be represented by any type in
-    its list and has no extended integer type, then the integer constant has no type.
-
-[<a name="p64" href="#p64">page 64</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.4.2" href="#6.4.4.2"><b>    6.4.4.2 Floating constants</b></a>
-<b>    Syntax</b>
-1            floating-constant:
-                    decimal-floating-constant
-                    hexadecimal-floating-constant
-             decimal-floating-constant:
-                   fractional-constant exponent-partopt floating-suffixopt
-                   digit-sequence exponent-part floating-suffixopt
-             hexadecimal-floating-constant:
-                   hexadecimal-prefix hexadecimal-fractional-constant
-                                  binary-exponent-part floating-suffixopt
-                   hexadecimal-prefix hexadecimal-digit-sequence
-                                  binary-exponent-part floating-suffixopt
-             fractional-constant:
-                     digit-sequenceopt . digit-sequence
-                     digit-sequence .
-             exponent-part:
-                   e signopt digit-sequence
-                   E signopt digit-sequence
-             sign: one of
-                    + -
-             digit-sequence:
-                     digit
-                     digit-sequence digit
-             hexadecimal-fractional-constant:
-                   hexadecimal-digit-sequenceopt .
-                                  hexadecimal-digit-sequence
-                   hexadecimal-digit-sequence .
-             binary-exponent-part:
-                    p signopt digit-sequence
-                    P signopt digit-sequence
-             hexadecimal-digit-sequence:
-                   hexadecimal-digit
-                   hexadecimal-digit-sequence hexadecimal-digit
-             floating-suffix: one of
-                    f l F L
-
-[<a name="p65" href="#p65">page 65</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   A floating constant has a significand part that may be followed by an exponent part and a
-    suffix that specifies its type. The components of the significand part may include a digit
-    sequence representing the whole-number part, followed by a period (.), followed by a
-    digit sequence representing the fraction part. The components of the exponent part are an
-    e, E, p, or P followed by an exponent consisting of an optionally signed digit sequence.
-    Either the whole-number part or the fraction part has to be present; for decimal floating
-    constants, either the period or the exponent part has to be present.
-<b>    Semantics</b>
-3   The significand part is interpreted as a (decimal or hexadecimal) rational number; the
-    digit sequence in the exponent part is interpreted as a decimal integer. For decimal
-    floating constants, the exponent indicates the power of 10 by which the significand part is
-    to be scaled. For hexadecimal floating constants, the exponent indicates the power of 2
-    by which the significand part is to be scaled. For decimal floating constants, and also for
-    hexadecimal floating constants when FLT_RADIX is not a power of 2, the result is either
-    the nearest representable value, or the larger or smaller representable value immediately
-    adjacent to the nearest representable value, chosen in an implementation-defined manner.
-    For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
-    correctly rounded.
-4   An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
-    type float. If suffixed by the letter l or L, it has type long double.
-5   Floating constants are converted to internal format as if at translation-time. The
-    conversion of a floating constant shall not raise an exceptional condition or a floating-
-    point exception at execution time. All floating constants of the same source form<sup><a href="#note75"><b>75)</b></a></sup> shall
-    convert to the same internal format with the same value.
-    Recommended practice
-6   The implementation should produce a diagnostic message if a hexadecimal constant
-    cannot be represented exactly in its evaluation format; the implementation should then
-    proceed with the translation of the program.
-7   The translation-time conversion of floating constants should match the execution-time
-    conversion of character strings by library functions, such as strtod, given matching
-    inputs suitable for both conversions, the same result format, and default execution-time
-    rounding.<sup><a href="#note76"><b>76)</b></a></sup>
-
-    <sup><a name="note75" href="#note75"><b>75)</b></a></sup> <a href="#1.23">1.23</a>, 1.230, 123e-2, 123e-02, and 1.23L are all different source forms and thus need not
-        convert to the same internal format and value.
-    <sup><a name="note76" href="#note76"><b>76)</b></a></sup> The specification for the library functions recommends more accurate conversion than required for
-        floating constants (see <a href="#7.22.1.3">7.22.1.3</a>).
-
-[<a name="p66" href="#p66">page 66</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.4.3" href="#6.4.4.3"><b>    6.4.4.3 Enumeration constants</b></a>
-<b>    Syntax</b>
-1            enumeration-constant:
-                   identifier
-<b>    Semantics</b>
-2   An identifier declared as an enumeration constant has type int.
-    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
-<a name="6.4.4.4" href="#6.4.4.4"><b>    6.4.4.4 Character constants</b></a>
-<b>    Syntax</b>
-1            character-constant:
-                    ' c-char-sequence '
-                    L' c-char-sequence '
-                    u' c-char-sequence '
-                    U' c-char-sequence '
-             c-char-sequence:
-                    c-char
-                    c-char-sequence c-char
-             c-char:
-                       any member of the source character set except
-                                    the single-quote ', backslash \, or new-line character
-                       escape-sequence
-             escape-sequence:
-                    simple-escape-sequence
-                    octal-escape-sequence
-                    hexadecimal-escape-sequence
-                    universal-character-name
-             simple-escape-sequence: one of
-                    \' \" \? \\
-                    \a \b \f \n \r                  \t    \v
-             octal-escape-sequence:
-                     \ octal-digit
-                     \ octal-digit octal-digit
-                     \ octal-digit octal-digit octal-digit
-
-[<a name="p67" href="#p67">page 67</a>] (<a href="#Contents">Contents</a>)
-
-           hexadecimal-escape-sequence:
-                 \x hexadecimal-digit
-                 hexadecimal-escape-sequence hexadecimal-digit
-<b>    Description</b>
-2   An integer character constant is a sequence of one or more multibyte characters enclosed
-    in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
-    letter L, u, or U. With a few exceptions detailed later, the elements of the sequence are
-    any members of the source character set; they are mapped in an implementation-defined
-    manner to members of the execution character set.
-3   The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
-    arbitrary integer values are representable according to the following table of escape
-    sequences:
-          single quote '            \'
-          double quote "            \"
-          question mark ?           \?
-          backslash \               \\
-          octal character           \octal digits
-          hexadecimal character     \x hexadecimal digits
-4   The double-quote " and question-mark ? are representable either by themselves or by the
-    escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
-    shall be represented, respectively, by the escape sequences \' and \\.
-5   The octal digits that follow the backslash in an octal escape sequence are taken to be part
-    of the construction of a single character for an integer character constant or of a single
-    wide character for a wide character constant. The numerical value of the octal integer so
-    formed specifies the value of the desired character or wide character.
-6   The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
-    sequence are taken to be part of the construction of a single character for an integer
-    character constant or of a single wide character for a wide character constant. The
-    numerical value of the hexadecimal integer so formed specifies the value of the desired
-    character or wide character.
-7   Each octal or hexadecimal escape sequence is the longest sequence of characters that can
-    constitute the escape sequence.
-8   In addition, characters not in the basic character set are representable by universal
-    character names and certain nongraphic characters are representable by escape sequences
-    consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
-    and \v.<sup><a href="#note77"><b>77)</b></a></sup>
-
-[<a name="p68" href="#p68">page 68</a>] (<a href="#Contents">Contents</a>)
-
-<b>     Constraints</b>
-9    The value of an octal or hexadecimal escape sequence shall be in the range of
-     representable values for the corresponding type:
-            Prefix      Corresponding Type
-            none       unsigned char
-            L          the unsigned type corresponding to wchar_t
-            u          char16_t
-            U          char32_t
-<b>     Semantics</b>
-10   An integer character constant has type int. The value of an integer character constant
-     containing a single character that maps to a single-byte execution character is the
-     numerical value of the representation of the mapped character interpreted as an integer.
-     The value of an integer character constant containing more than one character (e.g.,
-     'ab'), or containing a character or escape sequence that does not map to a single-byte
-     execution character, is implementation-defined. If an integer character constant contains
-     a single character or escape sequence, its value is the one that results when an object with
-     type char whose value is that of the single character or escape sequence is converted to
-     type int.
-11   A wide character constant prefixed by the letter L has type wchar_t, an integer type
-     defined in the <a href="#7.19">&lt;stddef.h&gt;</a> header; a wide character constant prefixed by the letter u or
-     U has type char16_t or char32_t, respectively, unsigned integer types defined in the
-     <a href="#7.27">&lt;uchar.h&gt;</a> header. The value of a wide character constant containing a single
-     multibyte character that maps to a single member of the extended execution character set
-     is the wide character corresponding to that multibyte character, as defined by the
-     mbtowc, mbrtoc16, or mbrtoc32 function as appropriate for its type, with an
-     implementation-defined current locale. The value of a wide character constant containing
-     more than one multibyte character or a single multibyte character that maps to multiple
-     members of the extended execution character set, or containing a multibyte character or
-     escape sequence not represented in the extended execution character set, is
-     implementation-defined.
-12   EXAMPLE 1      The construction '\0' is commonly used to represent the null character.
-
-13   EXAMPLE 2 Consider implementations that use two's complement representation for integers and eight
-     bits for objects that have type char. In an implementation in which type char has the same range of
-     values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
-     same range of values as unsigned char, the character constant '\xFF' has the value +255.
-
-
-
-
-     <sup><a name="note77" href="#note77"><b>77)</b></a></sup> The semantics of these characters were discussed in <a href="#5.2.2">5.2.2</a>. If any other character follows a backslash,
-         the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
-
-[<a name="p69" href="#p69">page 69</a>] (<a href="#Contents">Contents</a>)
-
-14   EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
-     specifies an integer character constant containing only one character, since a hexadecimal escape sequence
-     is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
-     two characters whose values are '\x12' and '3', the construction '\0223' may be used, since an octal
-     escape sequence is terminated after three octal digits. (The value of this two-character integer character
-     constant is implementation-defined.)
-
-15   EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
-     L'\1234' specifies the implementation-defined value that results from the combination of the values
-     0123 and '4'.
-
-     Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), the mbtowc function
-     (<a href="#7.22.7.2">7.22.7.2</a>), Unicode utilities <a href="#7.27">&lt;uchar.h&gt;</a> (<a href="#7.27">7.27</a>).
-<a name="6.4.5" href="#6.4.5"><b>     6.4.5 String literals</b></a>
-<b>     Syntax</b>
-1             string-literal:
-                      encoding-prefixopt " s-char-sequenceopt "
-              encoding-prefix:
-                     u8
-                     u
-                     U
-                     L
-              s-char-sequence:
-                     s-char
-                     s-char-sequence s-char
-              s-char:
-                        any member of the source character set except
-                                     the double-quote ", backslash \, or new-line character
-                        escape-sequence
-<b>     Constraints</b>
-2    A sequence of adjacent string literal tokens shall not include both a wide string literal and
-     a UTF-8 string literal.
-<b>     Description</b>
-3    A character string literal is a sequence of zero or more multibyte characters enclosed in
-     double-quotes, as in "xyz". A UTF-8 string literal is the same, except prefixed by u8.
-     A wide string literal is the same, except prefixed by the letter L, u, or U.
-4    The same considerations apply to each element of the sequence in a string literal as if it
-     were in an integer character constant (for a character or UTF-8 string literal) or a wide
-     character constant (for a wide string literal), except that the single-quote ' is
-     representable either by itself or by the escape sequence \', but the double-quote " shall
-
-[<a name="p70" href="#p70">page 70</a>] (<a href="#Contents">Contents</a>)
-
-    be represented by the escape sequence \".
-<b>    Semantics</b>
-5   In translation phase 6, the multibyte character sequences specified by any sequence of
-    adjacent character and identically-prefixed string literal tokens are concatenated into a
-    single multibyte character sequence. If any of the tokens has an encoding prefix, the
-    resulting multibyte character sequence is treated as having the same prefix; otherwise, it
-    is treated as a character string literal. Whether differently-prefixed wide string literal
-    tokens can be concatenated and, if so, the treatment of the resulting multibyte character
-    sequence are implementation-defined.
-6   In translation phase 7, a byte or code of value zero is appended to each multibyte
-    character sequence that results from a string literal or literals.<sup><a href="#note78"><b>78)</b></a></sup> The multibyte character
-    sequence is then used to initialize an array of static storage duration and length just
-    sufficient to contain the sequence. For character string literals, the array elements have
-    type char, and are initialized with the individual bytes of the multibyte character
-    sequence. For UTF-8 string literals, the array elements have type char, and are
-    initialized with the characters of the multibyte character sequence, as encoded in UTF-8.
-    For wide string literals prefixed by the letter L, the array elements have type wchar_t
-    and are initialized with the sequence of wide characters corresponding to the multibyte
-    character sequence, as defined by the mbstowcs function with an implementation-
-    defined current locale. For wide string literals prefixed by the letter u or U, the array
-    elements have type char16_t or char32_t, respectively, and are initialized with the
-    sequence of wide characters corresponding to the multibyte character sequence, as
-    defined by successive calls to the mbrtoc16, or mbrtoc32 function as appropriate for
-    its type, with an implementation-defined current locale. The value of a string literal
-    containing a multibyte character or escape sequence not represented in the execution
-    character set is implementation-defined.
-7   It is unspecified whether these arrays are distinct provided their elements have the
-    appropriate values. If the program attempts to modify such an array, the behavior is
-    undefined.
-8   EXAMPLE 1      This pair of adjacent character string literals
-             "\x12" "3"
-    produces a single character string literal containing the two characters whose values are '\x12' and '3',
-    because escape sequences are converted into single members of the execution character set just prior to
-    adjacent string literal concatenation.
-
-9   EXAMPLE 2      Each of the sequences of adjacent string literal tokens
-
-
-
-    <sup><a name="note78" href="#note78"><b>78)</b></a></sup> A string literal need not be a string (see <a href="#7.1.1">7.1.1</a>), because a null character may be embedded in it by a
-        \0 escape sequence.
-
-[<a name="p71" href="#p71">page 71</a>] (<a href="#Contents">Contents</a>)
-
-             "a" "b" L"c"
-             "a" L"b" "c"
-             L"a" "b" L"c"
-             L"a" L"b" L"c"
-    is equivalent to the string literal
-             L"abc"
-    Likewise, each of the sequences
-             "a" "b" u"c"
-             "a" u"b" "c"
-             u"a" "b" u"c"
-             u"a" u"b" u"c"
-    is equivalent to
-             u"abc"
-
-    Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), the mbstowcs
-    function (<a href="#7.22.8.1">7.22.8.1</a>), Unicode utilities <a href="#7.27">&lt;uchar.h&gt;</a> (<a href="#7.27">7.27</a>).
-<a name="6.4.6" href="#6.4.6"><b>    6.4.6 Punctuators</b></a>
-<b>    Syntax</b>
-1            punctuator: one of
-                    [ ] ( ) { } . -&gt;
-                    ++ -- &amp; * + - ~ !
-                    / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                         ==    !=    ^    |   &amp;&amp;   ||
-                    ? : ; ...
-                    = *= /= %= += -= &lt;&lt;=                        &gt;&gt;=    &amp;=       ^=   |=
-                    , # ##
-                    &lt;: :&gt; &lt;% %&gt; %: %:%:
-<b>    Semantics</b>
-2   A punctuator is a symbol that has independent syntactic and semantic significance.
-    Depending on context, it may specify an operation to be performed (which in turn may
-    yield a value or a function designator, produce a side effect, or some combination thereof)
-    in which case it is known as an operator (other forms of operator also exist in some
-    contexts). An operand is an entity on which an operator acts.
-
-[<a name="p72" href="#p72">page 72</a>] (<a href="#Contents">Contents</a>)
-
-3   In all aspects of the language, the six tokens<sup><a href="#note79"><b>79)</b></a></sup>
-             &lt;:    :&gt;      &lt;%    %&gt;     %:     %:%:
-    behave, respectively, the same as the six tokens
-             [     ]       {     }      #      ##
-    except for their spelling.<sup><a href="#note80"><b>80)</b></a></sup>
-    Forward references: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
-    (<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
-<a name="6.4.7" href="#6.4.7"><b>    6.4.7 Header names</b></a>
-<b>    Syntax</b>
-1            header-name:
-                    &lt; h-char-sequence &gt;
-                    " q-char-sequence "
-             h-char-sequence:
-                    h-char
-                    h-char-sequence h-char
-             h-char:
-                       any member of the source character set except
-                                    the new-line character and &gt;
-             q-char-sequence:
-                    q-char
-                    q-char-sequence q-char
-             q-char:
-                       any member of the source character set except
-                                    the new-line character and "
-<b>    Semantics</b>
-2   The sequences in both forms of header names are mapped in an implementation-defined
-    manner to headers or external source file names as specified in <a href="#6.10.2">6.10.2</a>.
-3   If the characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt; delimiters,
-    the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
-
-
-
-
-    <sup><a name="note79" href="#note79"><b>79)</b></a></sup> These tokens are sometimes called ''digraphs''.
-    <sup><a name="note80" href="#note80"><b>80)</b></a></sup> Thus [ and &lt;: behave differently when ''stringized'' (see <a href="#6.10.3.2">6.10.3.2</a>), but can otherwise be freely
-        interchanged.
-
-[<a name="p73" href="#p73">page 73</a>] (<a href="#Contents">Contents</a>)
-
-    sequence between the " delimiters, the behavior is undefined.<sup><a href="#note81"><b>81)</b></a></sup> Header name
-    preprocessing tokens are recognized only within #include preprocessing directives and
-    in implementation-defined locations within #pragma directives.<sup><a href="#note82"><b>82)</b></a></sup>
-4   EXAMPLE       The following sequence of characters:
-             0x3&lt;1/a.h&gt;1e2
-             #include &lt;1/a.h&gt;
-             #define const.member@$
-    forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
-    by a { on the left and a } on the right).
-             {0x3}{&lt;}{1}{/}{a}{.}{h}{&gt;}{1e2}
-             {#}{include} {&lt;1/a.h&gt;}
-             {#}{define} {const}{.}{member}{@}{$}
-
-    Forward references: source file inclusion (<a href="#6.10.2">6.10.2</a>).
-<a name="6.4.8" href="#6.4.8"><b>    6.4.8 Preprocessing numbers</b></a>
-<b>    Syntax</b>
-1            pp-number:
-                   digit
-                   . digit
-                   pp-number       digit
-                   pp-number       identifier-nondigit
-                   pp-number       e sign
-                   pp-number       E sign
-                   pp-number       p sign
-                   pp-number       P sign
-                   pp-number       .
-<b>    Description</b>
-2   A preprocessing number begins with a digit optionally preceded by a period (.) and may
-    be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
-    p+, p-, P+, or P-.
-3   Preprocessing number tokens lexically include all floating and integer constant tokens.
-<b>    Semantics</b>
-4   A preprocessing number does not have type or a value; it acquires both after a successful
-    conversion (as part of translation phase 7) to a floating constant token or an integer
-    constant token.
-
-
-    <sup><a name="note81" href="#note81"><b>81)</b></a></sup> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
-    <sup><a name="note82" href="#note82"><b>82)</b></a></sup> For an example of a header name preprocessing token used in a #pragma directive, see <a href="#6.10.9">6.10.9</a>.
-
-[<a name="p74" href="#p74">page 74</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.4.9" href="#6.4.9"><b>    6.4.9 Comments</b></a>
-1   Except within a character constant, a string literal, or a comment, the characters /*
-    introduce a comment. The contents of such a comment are examined only to identify
-    multibyte characters and to find the characters */ that terminate it.<sup><a href="#note83"><b>83)</b></a></sup>
-2   Except within a character constant, a string literal, or a comment, the characters //
-    introduce a comment that includes all multibyte characters up to, but not including, the
-    next new-line character. The contents of such a comment are examined only to identify
-    multibyte characters and to find the terminating new-line character.
-3   EXAMPLE
-             "a//b"                             //   four-character string literal
-             #include "//e"                     //   undefined behavior
-             // */                              //   comment, not syntax error
-             f = g/**//h;                       //   equivalent to f = g / h;
-             //\
-             i();                               // part of a two-line comment
-             /\
-             / j();                             // part of a two-line comment
-             #define glue(x,y) x##y
-             glue(/,/) k();                     // syntax error, not comment
-             /*//*/ l();                        // equivalent to l();
-             m = n//**/o
-                + p;                            // equivalent to m = n + p;
-
-
-
-
-    <sup><a name="note83" href="#note83"><b>83)</b></a></sup> Thus, /* ... */ comments do not nest.
-
-[<a name="p75" href="#p75">page 75</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5" href="#6.5"><b>    6.5 Expressions</b></a>
-1   An expression is a sequence of operators and operands that specifies computation of a
-    value, or that designates an object or a function, or that generates side effects, or that
-    performs a combination thereof. The value computations of the operands of an operator
-    are sequenced before the value computation of the result of the operator.
-2   If a side effect on a scalar object is unsequenced relative to either a different side effect
-    on the same scalar object or a value computation using the value of the same scalar
-    object, the behavior is undefined. If there are multiple allowable orderings of the
-    subexpressions of an expression, the behavior is undefined if such an unsequenced side
-    effect occurs in any of the orderings.<sup><a href="#note84"><b>84)</b></a></sup>
-3   The grouping of operators and operands is indicated by the syntax.<sup><a href="#note85"><b>85)</b></a></sup> Except as specified
-    later, side effects and value computations of subexpressions are unsequenced.<sup><a href="#note86"><b>86)</b></a></sup>         *
-4   Some operators (the unary operator ~, and the binary operators &lt;&lt;, &gt;&gt;, &amp;, ^, and |,
-    collectively described as bitwise operators) are required to have operands that have
-    integer type. These operators yield values that depend on the internal representations of
-    integers, and have implementation-defined and undefined aspects for signed types.
-5   If an exceptional condition occurs during the evaluation of an expression (that is, if the
-    result is not mathematically defined or not in the range of representable values for its
-    type), the behavior is undefined.
-
-
-
-    <sup><a name="note84" href="#note84"><b>84)</b></a></sup> This paragraph renders undefined statement expressions such as
-                  i = ++i + 1;
-                  a[i++] = i;
-         while allowing
-                  i = i + 1;
-                  a[i] = i;
-
-    <sup><a name="note85" href="#note85"><b>85)</b></a></sup> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
-        as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
-        expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
-        <a href="#6.5.1">6.5.1</a> through <a href="#6.5.6">6.5.6</a>. The exceptions are cast expressions (<a href="#6.5.4">6.5.4</a>) as operands of unary operators
-        (<a href="#6.5.3">6.5.3</a>), and an operand contained between any of the following pairs of operators: grouping
-        parentheses () (<a href="#6.5.1">6.5.1</a>), subscripting brackets [] (<a href="#6.5.2.1">6.5.2.1</a>), function-call parentheses () (<a href="#6.5.2.2">6.5.2.2</a>), and
-        the conditional operator ? : (<a href="#6.5.15">6.5.15</a>).
-         Within each major subclause, the operators have the same precedence. Left- or right-associativity is
-         indicated in each subclause by the syntax for the expressions discussed therein.
-    <sup><a name="note86" href="#note86"><b>86)</b></a></sup> In an expression that is evaluated more than once during the execution of a program, unsequenced and
-        indeterminately sequenced evaluations of its subexpressions need not be performed consistently in
-        different evaluations.
-
-[<a name="p76" href="#p76">page 76</a>] (<a href="#Contents">Contents</a>)
-
-6   The effective type of an object for an access to its stored value is the declared type of the
-    object, if any.<sup><a href="#note87"><b>87)</b></a></sup> If a value is stored into an object having no declared type through an
-    lvalue having a type that is not a character type, then the type of the lvalue becomes the
-    effective type of the object for that access and for subsequent accesses that do not modify
-    the stored value. If a value is copied into an object having no declared type using
-    memcpy or memmove, or is copied as an array of character type, then the effective type
-    of the modified object for that access and for subsequent accesses that do not modify the
-    value is the effective type of the object from which the value is copied, if it has one. For
-    all other accesses to an object having no declared type, the effective type of the object is
-    simply the type of the lvalue used for the access.
-7   An object shall have its stored value accessed only by an lvalue expression that has one of
-    the following types:<sup><a href="#note88"><b>88)</b></a></sup>
-    -- a type compatible with the effective type of the object,
-    -- a qualified version of a type compatible with the effective type of the object,
-    -- a type that is the signed or unsigned type corresponding to the effective type of the
-      object,
-    -- a type that is the signed or unsigned type corresponding to a qualified version of the
-      effective type of the object,
-    -- an aggregate or union type that includes one of the aforementioned types among its
-      members (including, recursively, a member of a subaggregate or contained union), or
-    -- a character type.
-8   A floating expression may be contracted, that is, evaluated as though it were a single
-    operation, thereby omitting rounding errors implied by the source code and the
-    expression evaluation method.<sup><a href="#note89"><b>89)</b></a></sup> The FP_CONTRACT pragma in <a href="#7.12">&lt;math.h&gt;</a> provides a
-    way to disallow contracted expressions. Otherwise, whether and how expressions are
-    contracted is implementation-defined.<sup><a href="#note90"><b>90)</b></a></sup>
-    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.23.2">7.23.2</a>).
-
-
-    <sup><a name="note87" href="#note87"><b>87)</b></a></sup> Allocated objects have no declared type.
-    <sup><a name="note88" href="#note88"><b>88)</b></a></sup> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
-    <sup><a name="note89" href="#note89"><b>89)</b></a></sup> The intermediate operations in the contracted expression are evaluated as if to infinite precision and
-        range, while the final operation is rounded to the format determined by the expression evaluation
-        method. A contracted expression might also omit the raising of floating-point exceptions.
-    <sup><a name="note90" href="#note90"><b>90)</b></a></sup> This license is specifically intended to allow implementations to exploit fast machine instructions that
-        combine multiple C operators. As contractions potentially undermine predictability, and can even
-        decrease accuracy for containing expressions, their use needs to be well-defined and clearly
-        documented.
-
-[<a name="p77" href="#p77">page 77</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.1" href="#6.5.1"><b>    6.5.1 Primary expressions</b></a>
-<b>    Syntax</b>
-1            primary-expression:
-                    identifier
-                    constant
-                    string-literal
-                    ( expression )
-                    generic-selection
-<b>    Semantics</b>
-2   An identifier is a primary expression, provided it has been declared as designating an
-    object (in which case it is an lvalue) or a function (in which case it is a function
-    designator).<sup><a href="#note91"><b>91)</b></a></sup>
-3   A constant is a primary expression. Its type depends on its form and value, as detailed in
-    <a href="#6.4.4">6.4.4</a>.
-4   A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
-5   A parenthesized expression is a primary expression. Its type and value are identical to
-    those of the unparenthesized expression. It is an lvalue, a function designator, or a void
-    expression if the unparenthesized expression is, respectively, an lvalue, a function
-    designator, or a void expression.
-    Forward references: declarations (<a href="#6.7">6.7</a>).
-<a name="6.5.1.1" href="#6.5.1.1"><b>    6.5.1.1 Generic selection</b></a>
-<b>    Syntax</b>
-1            generic-selection:
-                    _Generic ( assignment-expression , generic-assoc-list )
-             generic-assoc-list:
-                    generic-association
-                    generic-assoc-list , generic-association
-             generic-association:
-                    type-name : assignment-expression
-                    default : assignment-expression
-<b>    Constraints</b>
-2   A generic selection shall have no more than one default generic association. The type
-    name in a generic association shall specify a complete object type other than a variably
-
-    <sup><a name="note91" href="#note91"><b>91)</b></a></sup> Thus, an undeclared identifier is a violation of the syntax.
-
-[<a name="p78" href="#p78">page 78</a>] (<a href="#Contents">Contents</a>)
-
-    modified type. No two generic associations in the same generic selection shall specify
-    compatible types. The controlling expression of a generic selection shall have type
-    compatible with at most one of the types named in its generic association list. If a
-    generic selection has no default generic association, its controlling expression shall
-    have type compatible with exactly one of the types named in its generic association list.
-<b>    Semantics</b>
-3   The controlling expression of a generic selection is not evaluated. If a generic selection
-    has a generic association with a type name that is compatible with the type of the
-    controlling expression, then the result expression of the generic selection is the
-    expression in that generic association. Otherwise, the result expression of the generic
-    selection is the expression in the default generic association. None of the expressions
-    from any other generic association of the generic selection is evaluated.
-4   The type and value of a generic selection are identical to those of its result expression. It
-    is an lvalue, a function designator, or a void expression if its result expression is,
-    respectively, an lvalue, a function designator, or a void expression.
-5   EXAMPLE      The cbrt type-generic macro could be implemented as follows:
-             #define cbrt(X) _Generic((X),                                      \
-                                     long double: cbrtl,                        \
-                                     default: cbrt,                             \
-                                     float: cbrtf                               \
-                                     )(X)
-
-<a name="6.5.2" href="#6.5.2"><b>    6.5.2 Postfix operators</b></a>
-<b>    Syntax</b>
-1            postfix-expression:
-                    primary-expression
-                    postfix-expression [ expression ]
-                    postfix-expression ( argument-expression-listopt )
-                    postfix-expression . identifier
-                    postfix-expression -&gt; identifier
-                    postfix-expression ++
-                    postfix-expression --
-                    ( type-name ) { initializer-list }
-                    ( type-name ) { initializer-list , }
-             argument-expression-list:
-                   assignment-expression
-                   argument-expression-list , assignment-expression
-
-[<a name="p79" href="#p79">page 79</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.2.1" href="#6.5.2.1"><b>    6.5.2.1 Array subscripting</b></a>
-<b>    Constraints</b>
-1   One of the expressions shall have type ''pointer to complete object type'', the other
-    expression shall have integer type, and the result has type ''type''.
-<b>    Semantics</b>
-2   A postfix expression followed by an expression in square brackets [] is a subscripted
-    designation of an element of an array object. The definition of the subscript operator []
-    is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
-    apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
-    initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
-    element of E1 (counting from zero).
-3   Successive subscript operators designate an element of a multidimensional array object.
-    If E is an n-dimensional array (n &gt;= 2) with dimensions i x j x . . . x k, then E (used as
-    other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
-    dimensions j x . . . x k. If the unary * operator is applied to this pointer explicitly, or
-    implicitly as a result of subscripting, the result is the referenced (n - 1)-dimensional
-    array, which itself is converted into a pointer if used as other than an lvalue. It follows
-    from this that arrays are stored in row-major order (last subscript varies fastest).
-4   EXAMPLE        Consider the array object defined by the declaration
-             int x[3][5];
-    Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
-    array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
-    a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
-    entails multiplying i by the size of the object to which the pointer points, namely an array of five int
-    objects. The results are added and indirection is applied to yield an array of five ints. When used in the
-    expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
-    yields an int.
-
-    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
-    (<a href="#6.5.3.2">6.5.3.2</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
-<a name="6.5.2.2" href="#6.5.2.2"><b>    6.5.2.2 Function calls</b></a>
-<b>    Constraints</b>
-1   The expression that denotes the called function<sup><a href="#note92"><b>92)</b></a></sup> shall have type pointer to function
-    returning void or returning a complete object type other than an array type.
-2   If the expression that denotes the called function has a type that includes a prototype, the
-    number of arguments shall agree with the number of parameters. Each argument shall
-
-
-    <sup><a name="note92" href="#note92"><b>92)</b></a></sup> Most often, this is the result of converting an identifier that is a function designator.
-
-[<a name="p80" href="#p80">page 80</a>] (<a href="#Contents">Contents</a>)
-
-    have a type such that its value may be assigned to an object with the unqualified version
-    of the type of its corresponding parameter.
-<b>    Semantics</b>
-3   A postfix expression followed by parentheses () containing a possibly empty, comma-
-    separated list of expressions is a function call. The postfix expression denotes the called
-    function. The list of expressions specifies the arguments to the function.
-4   An argument may be an expression of any complete object type. In preparing for the call
-    to a function, the arguments are evaluated, and each parameter is assigned the value of the
-    corresponding argument.<sup><a href="#note93"><b>93)</b></a></sup>
-5   If the expression that denotes the called function has type pointer to function returning an
-    object type, the function call expression has the same type as that object type, and has the
-    value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void.         *
-6   If the expression that denotes the called function has a type that does not include a
-    prototype, the integer promotions are performed on each argument, and arguments that
-    have type float are promoted to double. These are called the default argument
-    promotions. If the number of arguments does not equal the number of parameters, the
-    behavior is undefined. If the function is defined with a type that includes a prototype, and
-    either the prototype ends with an ellipsis (, ...) or the types of the arguments after
-    promotion are not compatible with the types of the parameters, the behavior is undefined.
-    If the function is defined with a type that does not include a prototype, and the types of
-    the arguments after promotion are not compatible with those of the parameters after
-    promotion, the behavior is undefined, except for the following cases:
-    -- one promoted type is a signed integer type, the other promoted type is the
-      corresponding unsigned integer type, and the value is representable in both types;
-    -- both types are pointers to qualified or unqualified versions of a character type or
-      void.
-7   If the expression that denotes the called function has a type that does include a prototype,
-    the arguments are implicitly converted, as if by assignment, to the types of the
-    corresponding parameters, taking the type of each parameter to be the unqualified version
-    of its declared type. The ellipsis notation in a function prototype declarator causes
-    argument type conversion to stop after the last declared parameter. The default argument
-    promotions are performed on trailing arguments.
-
-
-
-    <sup><a name="note93" href="#note93"><b>93)</b></a></sup> A function may change the values of its parameters, but these changes cannot affect the values of the
-        arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
-        change the value of the object pointed to. A parameter declared to have array or function type is
-        adjusted to have a pointer type as described in <a href="#6.9.1">6.9.1</a>.
-
-[<a name="p81" href="#p81">page 81</a>] (<a href="#Contents">Contents</a>)
-
-8    No other conversions are performed implicitly; in particular, the number and types of
-     arguments are not compared with those of the parameters in a function definition that
-     does not include a function prototype declarator.
-9    If the function is defined with a type that is not compatible with the type (of the
-     expression) pointed to by the expression that denotes the called function, the behavior is
-     undefined.
-10   There is a sequence point after the evaluations of the function designator and the actual
-     arguments but before the actual call. Every evaluation in the calling function (including
-     other function calls) that is not otherwise specifically sequenced before or after the
-     execution of the body of the called function is indeterminately sequenced with respect to
-     the execution of the called function.<sup><a href="#note94"><b>94)</b></a></sup>
-11   Recursive function calls shall be permitted, both directly and indirectly through any chain
-     of other functions.
-12   EXAMPLE        In the function call
-              (*pf[f1()]) (f2(), f3() + f4())
-     the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
-     the function pointed to by pf[f1()] is called.
-
-     Forward references: function declarators (including prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), function
-     definitions (<a href="#6.9.1">6.9.1</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
-<a name="6.5.2.3" href="#6.5.2.3"><b>     6.5.2.3 Structure and union members</b></a>
-<b>     Constraints</b>
-1    The first operand of the . operator shall have an atomic, qualified, or unqualified
-     structure or union type, and the second operand shall name a member of that type.
-2    The first operand of the -&gt; operator shall have type ''pointer to atomic, qualified, or
-     unqualified structure'' or ''pointer to atomic, qualified, or unqualified union'', and the
-     second operand shall name a member of the type pointed to.
-<b>     Semantics</b>
-3    A postfix expression followed by the . operator and an identifier designates a member of
-     a structure or union object. The value is that of the named member,<sup><a href="#note95"><b>95)</b></a></sup> and is an lvalue if
-     the first expression is an lvalue. If the first expression has qualified type, the result has
-     the so-qualified version of the type of the designated member.
-
-     <sup><a name="note94" href="#note94"><b>94)</b></a></sup> In other words, function executions do not ''interleave'' with each other.
-     <sup><a name="note95" href="#note95"><b>95)</b></a></sup> If the member used to read the contents of a union object is not the same as the member last used to
-         store a value in the object, the appropriate part of the object representation of the value is reinterpreted
-         as an object representation in the new type as described in <a href="#6.2.6">6.2.6</a> (a process sometimes called ''type
-         punning''). This might be a trap representation.
-
-[<a name="p82" href="#p82">page 82</a>] (<a href="#Contents">Contents</a>)
-
-4   A postfix expression followed by the -&gt; operator and an identifier designates a member
-    of a structure or union object. The value is that of the named member of the object to
-    which the first expression points, and is an lvalue.<sup><a href="#note96"><b>96)</b></a></sup> If the first expression is a pointer to
-    a qualified type, the result has the so-qualified version of the type of the designated
-    member.
-5   Accessing a member of an atomic structure or union object results in undefined
-    behavior.<sup><a href="#note97"><b>97)</b></a></sup>
-6   One special guarantee is made in order to simplify the use of unions: if a union contains
-    several structures that share a common initial sequence (see below), and if the union
-    object currently contains one of these structures, it is permitted to inspect the common
-    initial part of any of them anywhere that a declaration of the completed type of the union
-    is visible. Two structures share a common initial sequence if corresponding members
-    have compatible types (and, for bit-fields, the same widths) for a sequence of one or more
-    initial members.
-7   EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
-    union, f().x is a valid postfix expression but is not an lvalue.
-
-8   EXAMPLE 2       In:
-             struct s { int i; const int ci; };
-             struct s s;
-             const struct s cs;
-             volatile struct s vs;
-    the various members have the types:
-             s.i          int
-             s.ci         const int
-             cs.i         const int
-             cs.ci        const int
-             vs.i         volatile int
-             vs.ci        volatile const int
-
-
-
-
-    <sup><a name="note96" href="#note96"><b>96)</b></a></sup> If &amp;E is a valid pointer expression (where &amp; is the ''address-of '' operator, which generates a pointer to
-        its operand), the expression (&amp;E)-&gt;MOS is the same as E.MOS.
-    <sup><a name="note97" href="#note97"><b>97)</b></a></sup> For example, a data race would occur if access to the entire structure or union in one thread conflicts
-        with access to a member from another thread, where at least one access is a modification. Members
-        can be safely accessed using a non-atomic object which is assigned to or from the atomic object.
-
-[<a name="p83" href="#p83">page 83</a>] (<a href="#Contents">Contents</a>)
-
-9   EXAMPLE 3       The following is a valid fragment:
-             union {
-                     struct {
-                           int      alltypes;
-                     } n;
-                     struct {
-                           int      type;
-                           int      intnode;
-                     } ni;
-                     struct {
-                           int      type;
-                           double doublenode;
-                     } nf;
-             } u;
-             u.nf.type = 1;
-             u.nf.doublenode = <a href="#3.14">3.14</a>;
-             /* ... */
-             if (u.n.alltypes == 1)
-                     if (sin(u.nf.doublenode) == 0.0)
-                           /* ... */
-    The following is not a valid fragment (because the union type is not visible within function f):
-             struct t1 { int m; };
-             struct t2 { int m; };
-             int f(struct t1 *p1, struct t2 *p2)
-             {
-                   if (p1-&gt;m &lt; 0)
-                           p2-&gt;m = -p2-&gt;m;
-                   return p1-&gt;m;
-             }
-             int g()
-             {
-                   union {
-                           struct t1 s1;
-                           struct t2 s2;
-                   } u;
-                   /* ... */
-                   return f(&amp;u.s1, &amp;u.s2);
-             }
-
-    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
-    specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
-
-[<a name="p84" href="#p84">page 84</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.2.4" href="#6.5.2.4"><b>    6.5.2.4 Postfix increment and decrement operators</b></a>
-<b>    Constraints</b>
-1   The operand of the postfix increment or decrement operator shall have atomic, qualified,
-    or unqualified real or pointer type, and shall be a modifiable lvalue.
-<b>    Semantics</b>
-2   The result of the postfix ++ operator is the value of the operand. As a side effect, the
-    value of the operand object is incremented (that is, the value 1 of the appropriate type is
-    added to it). See the discussions of additive operators and compound assignment for
-    information on constraints, types, and conversions and the effects of operations on
-    pointers. The value computation of the result is sequenced before the side effect of
-    updating the stored value of the operand. With respect to an indeterminately-sequenced
-    function call, the operation of postfix ++ is a single evaluation. Postfix ++ on an object
-    with atomic type is a read-modify-write operation with memory_order_seq_cst
-    memory order semantics.<sup><a href="#note98"><b>98)</b></a></sup>
-3   The postfix -- operator is analogous to the postfix ++ operator, except that the value of
-    the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
-    it).
-    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
-<a name="6.5.2.5" href="#6.5.2.5"><b>    6.5.2.5 Compound literals</b></a>
-<b>    Constraints</b>
-1   The type name shall specify a complete object type or an array of unknown size, but not a
-    variable length array type.
-2   All the constraints for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.
-<b>    Semantics</b>
-3   A postfix expression that consists of a parenthesized type name followed by a brace-
-    enclosed list of initializers is a compound literal. It provides an unnamed object whose
-    value is given by the initializer list.<sup><a href="#note99"><b>99)</b></a></sup>
-
-
-    <sup><a name="note98" href="#note98"><b>98)</b></a></sup> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
-        where T is the type of E:
-                 T tmp;
-                 T result = E;
-                 do {
-                        tmp = result + 1;
-                 } while (!atomic_compare_exchange_strong(&amp;E, &amp;result, tmp));
-         with result being the result of the operation.
-
-[<a name="p85" href="#p85">page 85</a>] (<a href="#Contents">Contents</a>)
-
-4    If the type name specifies an array of unknown size, the size is determined by the
-     initializer list as specified in <a href="#6.7.9">6.7.9</a>, and the type of the compound literal is that of the
-     completed array type. Otherwise (when the type name specifies an object type), the type
-     of the compound literal is that specified by the type name. In either case, the result is an
-     lvalue.
-5    The value of the compound literal is that of an unnamed object initialized by the
-     initializer list. If the compound literal occurs outside the body of a function, the object
-     has static storage duration; otherwise, it has automatic storage duration associated with
-     the enclosing block.
-6    All the semantic rules for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.<sup><a href="#note100"><b>100)</b></a></sup>
-7    String literals, and compound literals with const-qualified types, need not designate
-     distinct objects.<sup><a href="#note101"><b>101)</b></a></sup>
-8    EXAMPLE 1       The file scope definition
-              int *p = (int []){2, 4};
-     initializes p to point to the first element of an array of two ints, the first having the value two and the
-     second, four. The expressions in this compound literal are required to be constant. The unnamed object
-     has static storage duration.
-
-9    EXAMPLE 2       In contrast, in
-              void f(void)
-              {
-                    int *p;
-                    /*...*/
-                    p = (int [2]){*p};
-                    /*...*/
-              }
-     p is assigned the address of the first element of an array of two ints, the first having the value previously
-     pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
-     unnamed object has automatic storage duration.
-
-10   EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
-     created using compound literals can be passed to functions without depending on member order:
-              drawline((struct point){.x=1, .y=1},
-                    (struct point){.x=3, .y=4});
-     Or, if drawline instead expected pointers to struct point:
-
-
-
-     <sup><a name="note99" href="#note99"><b>99)</b></a></sup> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
-         or void only, and the result of a cast expression is not an lvalue.
-     <sup><a name="note100" href="#note100"><b>100)</b></a></sup> For example, subobjects without explicit initializers are initialized to zero.
-     <sup><a name="note101" href="#note101"><b>101)</b></a></sup> This allows implementations to share storage for string literals and constant compound literals with
-          the same or overlapping representations.
-
-[<a name="p86" href="#p86">page 86</a>] (<a href="#Contents">Contents</a>)
-
-              drawline(&amp;(struct point){.x=1, .y=1},
-                    &amp;(struct point){.x=3, .y=4});
-
-11   EXAMPLE 4        A read-only compound literal can be specified through constructions like:
-              (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}
-
-12   EXAMPLE 5        The following three expressions have different meanings:
-              "/tmp/fileXXXXXX"
-              (char []){"/tmp/fileXXXXXX"}
-              (const char []){"/tmp/fileXXXXXX"}
-     The first always has static storage duration and has type array of char, but need not be modifiable; the last
-     two have automatic storage duration when they occur within the body of a function, and the first of these
-     two is modifiable.
-
-13   EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
-     and can even be shared. For example,
-              (const char []){"abc"} == "abc"
-     might yield 1 if the literals' storage is shared.
-
-14   EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
-     linked object. For example, there is no way to write a self-referential compound literal that could be used
-     as the function argument in place of the named object endless_zeros below:
-              struct int_list { int car; struct int_list *cdr; };
-              struct int_list endless_zeros = {0, &amp;endless_zeros};
-              eval(endless_zeros);
-
-15   EXAMPLE 8        Each compound literal creates only a single object in a given scope:
-              struct s { int i; };
-              int f (void)
-              {
-                    struct s *p = 0, *q;
-                    int j = 0;
-              again:
-                        q = p, p = &amp;((struct s){ j++ });
-                        if (j &lt; 2) goto again;
-                        return p == q &amp;&amp; q-&gt;i == 1;
-              }
-     The function f() always returns the value 1.
-16   Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
-     lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
-     have an indeterminate value, which would result in undefined behavior.
-
-     Forward references: type names (<a href="#6.7.7">6.7.7</a>), initialization (<a href="#6.7.9">6.7.9</a>).
-
-[<a name="p87" href="#p87">page 87</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.3" href="#6.5.3"><b>    6.5.3 Unary operators</b></a>
-<b>    Syntax</b>
-1            unary-expression:
-                    postfix-expression
-                    ++ unary-expression
-                    -- unary-expression
-                    unary-operator cast-expression
-                    sizeof unary-expression
-                    sizeof ( type-name )
-                    alignof ( type-name )
-             unary-operator: one of
-                    &amp; * + - ~             !
-<a name="6.5.3.1" href="#6.5.3.1"><b>    6.5.3.1 Prefix increment and decrement operators</b></a>
-<b>    Constraints</b>
-1   The operand of the prefix increment or decrement operator shall have atomic, qualified,
-    or unqualified real or pointer type, and shall be a modifiable lvalue.
-<b>    Semantics</b>
-2   The value of the operand of the prefix ++ operator is incremented. The result is the new
-    value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
-    See the discussions of additive operators and compound assignment for information on
-    constraints, types, side effects, and conversions and the effects of operations on pointers.
-3   The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
-    operand is decremented.
-    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
-<a name="6.5.3.2" href="#6.5.3.2"><b>    6.5.3.2 Address and indirection operators</b></a>
-<b>    Constraints</b>
-1   The operand of the unary &amp; operator shall be either a function designator, the result of a
-    [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
-    not declared with the register storage-class specifier.
-2   The operand of the unary * operator shall have pointer type.
-<b>    Semantics</b>
-3   The unary &amp; operator yields the address of its operand. If the operand has type ''type'',
-    the result has type ''pointer to type''. If the operand is the result of a unary * operator,
-    neither that operator nor the &amp; operator is evaluated and the result is as if both were
-    omitted, except that the constraints on the operators still apply and the result is not an
-
-[<a name="p88" href="#p88">page 88</a>] (<a href="#Contents">Contents</a>)
-
-    lvalue. Similarly, if the operand is the result of a [] operator, neither the &amp; operator nor
-    the unary * that is implied by the [] is evaluated and the result is as if the &amp; operator
-    were removed and the [] operator were changed to a + operator. Otherwise, the result is
-    a pointer to the object or function designated by its operand.
-4   The unary * operator denotes indirection. If the operand points to a function, the result is
-    a function designator; if it points to an object, the result is an lvalue designating the
-    object. If the operand has type ''pointer to type'', the result has type ''type''. If an
-    invalid value has been assigned to the pointer, the behavior of the unary * operator is
-    undefined.<sup><a href="#note102"><b>102)</b></a></sup>
-    Forward references: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
-    (<a href="#6.7.2.1">6.7.2.1</a>).
-<a name="6.5.3.3" href="#6.5.3.3"><b>    6.5.3.3 Unary arithmetic operators</b></a>
-<b>    Constraints</b>
-1   The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
-    integer type; of the ! operator, scalar type.
-<b>    Semantics</b>
-2   The result of the unary + operator is the value of its (promoted) operand. The integer
-    promotions are performed on the operand, and the result has the promoted type.
-3   The result of the unary - operator is the negative of its (promoted) operand. The integer
-    promotions are performed on the operand, and the result has the promoted type.
-4   The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
-    each bit in the result is set if and only if the corresponding bit in the converted operand is
-    not set). The integer promotions are performed on the operand, and the result has the
-    promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
-    to the maximum value representable in that type minus E.
-5   The result of the logical negation operator ! is 0 if the value of its operand compares
-    unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int.
-    The expression !E is equivalent to (0==E).
-
-
-
-    <sup><a name="note102" href="#note102"><b>102)</b></a></sup> Thus, &amp;*E is equivalent to E (even if E is a null pointer), and &amp;(E1[E2]) to ((E1)+(E2)). It is
-         always true that if E is a function designator or an lvalue that is a valid operand of the unary &amp;
-         operator, *&amp;E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
-         an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
-         Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
-         address inappropriately aligned for the type of object pointed to, and the address of an object after the
-         end of its lifetime.
-
-[<a name="p89" href="#p89">page 89</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.3.4" href="#6.5.3.4"><b>    6.5.3.4 The sizeof and alignof operators</b></a>
-<b>    Constraints</b>
-1   The sizeof operator shall not be applied to an expression that has function type or an
-    incomplete type, to the parenthesized name of such a type, or to an expression that
-    designates a bit-field member. The alignof operator shall not be applied to a function
-    type or an incomplete type.
-<b>    Semantics</b>
-2   The sizeof operator yields the size (in bytes) of its operand, which may be an
-    expression or the parenthesized name of a type. The size is determined from the type of
-    the operand. The result is an integer. If the type of the operand is a variable length array
-    type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
-    integer constant.
-3   The alignof operator yields the alignment requirement of its operand type. The result
-    is an integer constant. When applied to an array type, the result is the alignment
-    requirement of the element type.
-4   When sizeof is applied to an operand that has type char, unsigned char, or
-    signed char, (or a qualified version thereof) the result is 1. When applied to an
-    operand that has array type, the result is the total number of bytes in the array.<sup><a href="#note103"><b>103)</b></a></sup> When
-    applied to an operand that has structure or union type, the result is the total number of
-    bytes in such an object, including internal and trailing padding.
-5   The value of the result of both operators is implementation-defined, and its type (an
-    unsigned integer type) is size_t, defined in <a href="#7.19">&lt;stddef.h&gt;</a> (and other headers).
-6   EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
-    allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
-    allocate and return a pointer to void. For example:
-            extern void *alloc(size_t);
-            double *dp = alloc(sizeof *dp);
-    The implementation of the alloc function should ensure that its return value is aligned suitably for
-    conversion to a pointer to double.
-
-7   EXAMPLE 2      Another use of the sizeof operator is to compute the number of elements in an array:
-            sizeof array / sizeof array[0]
-
-8   EXAMPLE 3      In this example, the size of a variable length array is computed and returned from a
-    function:
-            #include <a href="#7.19">&lt;stddef.h&gt;</a>
-
-
-
-    <sup><a name="note103" href="#note103"><b>103)</b></a></sup> When applied to a parameter declared to have array or function type, the sizeof operator yields the
-         size of the adjusted (pointer) type (see <a href="#6.9.1">6.9.1</a>).
-
-[<a name="p90" href="#p90">page 90</a>] (<a href="#Contents">Contents</a>)
-
-             size_t fsize3(int n)
-             {
-                   char b[n+3];                  // variable length array
-                   return sizeof b;              // execution time sizeof
-             }
-             int main()
-             {
-                   size_t size;
-                   size = fsize3(10); // fsize3 returns 13
-                   return 0;
-             }
-
-    Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), declarations (<a href="#6.7">6.7</a>),
-    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.7">6.7.7</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
-<a name="6.5.4" href="#6.5.4"><b>    6.5.4 Cast operators</b></a>
-<b>    Syntax</b>
-1            cast-expression:
-                    unary-expression
-                    ( type-name ) cast-expression
-<b>    Constraints</b>
-2   Unless the type name specifies a void type, the type name shall specify atomic, qualified,
-    or unqualified scalar type, and the operand shall have scalar type.
-3   Conversions that involve pointers, other than where permitted by the constraints of
-    <a href="#6.5.16.1">6.5.16.1</a>, shall be specified by means of an explicit cast.
-4   A pointer type shall not be converted to any floating type. A floating type shall not be
-    converted to any pointer type.
-<b>    Semantics</b>
-5   Preceding an expression by a parenthesized type name converts the value of the
-    expression to the named type. This construction is called a cast.<sup><a href="#note104"><b>104)</b></a></sup> A cast that specifies
-    no conversion has no effect on the type or value of an expression.
-6   If the value of the expression is represented with greater precision or range than required
-    by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
-    type of the expression is the same as the named type and removes any extra range and
-    precision.
-    Forward references: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
-    prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
-
-    <sup><a name="note104" href="#note104"><b>104)</b></a></sup> A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the
-         unqualified version of the type.
-
-[<a name="p91" href="#p91">page 91</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.5" href="#6.5.5"><b>    6.5.5 Multiplicative operators</b></a>
-<b>    Syntax</b>
-1            multiplicative-expression:
-                     cast-expression
-                     multiplicative-expression * cast-expression
-                     multiplicative-expression / cast-expression
-                     multiplicative-expression % cast-expression
-<b>    Constraints</b>
-2   Each of the operands shall have arithmetic type. The operands of the % operator shall
-    have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the binary * operator is the product of the operands.
-5   The result of the / operator is the quotient from the division of the first operand by the
-    second; the result of the % operator is the remainder. In both operations, if the value of
-    the second operand is zero, the behavior is undefined.
-6   When integers are divided, the result of the / operator is the algebraic quotient with any
-    fractional part discarded.<sup><a href="#note105"><b>105)</b></a></sup> If the quotient a/b is representable, the expression
-    (a/b)*b + a%b shall equal a; otherwise, the behavior of both a/b and a%b is
-    undefined.
-<a name="6.5.6" href="#6.5.6"><b>    6.5.6 Additive operators</b></a>
-<b>    Syntax</b>
-1            additive-expression:
-                    multiplicative-expression
-                    additive-expression + multiplicative-expression
-                    additive-expression - multiplicative-expression
-<b>    Constraints</b>
-2   For addition, either both operands shall have arithmetic type, or one operand shall be a
-    pointer to a complete object type and the other shall have integer type. (Incrementing is
-    equivalent to adding 1.)
-3   For subtraction, one of the following shall hold:
-
-
-
-
-    <sup><a name="note105" href="#note105"><b>105)</b></a></sup> This is often called ''truncation toward zero''.
-
-[<a name="p92" href="#p92">page 92</a>] (<a href="#Contents">Contents</a>)
-
-    -- both operands have arithmetic type;
-    -- both operands are pointers to qualified or unqualified versions of compatible complete
-      object types; or
-    -- the left operand is a pointer to a complete object type and the right operand has
-      integer type.
-    (Decrementing is equivalent to subtracting 1.)
-<b>    Semantics</b>
-4   If both operands have arithmetic type, the usual arithmetic conversions are performed on
-    them.
-5   The result of the binary + operator is the sum of the operands.
-6   The result of the binary - operator is the difference resulting from the subtraction of the
-    second operand from the first.
-7   For the purposes of these operators, a pointer to an object that is not an element of an
-    array behaves the same as a pointer to the first element of an array of length one with the
-    type of the object as its element type.
-8   When an expression that has integer type is added to or subtracted from a pointer, the
-    result has the type of the pointer operand. If the pointer operand points to an element of
-    an array object, and the array is large enough, the result points to an element offset from
-    the original element such that the difference of the subscripts of the resulting and original
-    array elements equals the integer expression. In other words, if the expression P points to
-    the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and
-    (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of
-    the array object, provided they exist. Moreover, if the expression P points to the last
-    element of an array object, the expression (P)+1 points one past the last element of the
-    array object, and if the expression Q points one past the last element of an array object,
-    the expression (Q)-1 points to the last element of the array object. If both the pointer
-    operand and the result point to elements of the same array object, or one past the last
-    element of the array object, the evaluation shall not produce an overflow; otherwise, the
-    behavior is undefined. If the result points one past the last element of the array object, it
-    shall not be used as the operand of a unary * operator that is evaluated.
-9   When two pointers are subtracted, both shall point to elements of the same array object,
-    or one past the last element of the array object; the result is the difference of the
-    subscripts of the two array elements. The size of the result is implementation-defined,
-    and its type (a signed integer type) is ptrdiff_t defined in the <a href="#7.19">&lt;stddef.h&gt;</a> header.
-    If the result is not representable in an object of that type, the behavior is undefined. In
-    other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
-    an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
-
-[<a name="p93" href="#p93">page 93</a>] (<a href="#Contents">Contents</a>)
-
-     object of type ptrdiff_t. Moreover, if the expression P points either to an element of
-     an array object or one past the last element of an array object, and the expression Q points
-     to the last element of the same array object, the expression ((Q)+1)-(P) has the same
-     value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the
-     expression P points one past the last element of the array object, even though the
-     expression (Q)+1 does not point to an element of the array object.<sup><a href="#note106"><b>106)</b></a></sup>
-10   EXAMPLE        Pointer arithmetic is well defined with pointers to variable length array types.
-              {
-                       int n = 4, m = 3;
-                       int a[n][m];
-                       int (*p)[m] = a;            //   p == &amp;a[0]
-                       p += 1;                     //   p == &amp;a[1]
-                       (*p)[2] = 99;               //   a[1][2] == 99
-                       n = p - a;                  //   n == 1
-              }
-11   If array a in the above example were declared to be an array of known constant size, and pointer p were
-     declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
-     the same.
-
-     Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), common definitions <a href="#7.19">&lt;stddef.h&gt;</a>
-     (<a href="#7.19">7.19</a>).
-<a name="6.5.7" href="#6.5.7"><b>     6.5.7 Bitwise shift operators</b></a>
-<b>     Syntax</b>
-1             shift-expression:
-                      additive-expression
-                      shift-expression &lt;&lt; additive-expression
-                      shift-expression &gt;&gt; additive-expression
-<b>     Constraints</b>
-2    Each of the operands shall have integer type.
-<b>     Semantics</b>
-3    The integer promotions are performed on each of the operands. The type of the result is
-     that of the promoted left operand. If the value of the right operand is negative or is
-
-     <sup><a name="note106" href="#note106"><b>106)</b></a></sup> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
-          this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
-          by the size of the object originally pointed to, and the resulting pointer is converted back to the
-          original type. For pointer subtraction, the result of the difference between the character pointers is
-          similarly divided by the size of the object originally pointed to.
-          When viewed in this way, an implementation need only provide one extra byte (which may overlap
-          another object in the program) just after the end of the object in order to satisfy the ''one past the last
-          element'' requirements.
-
-[<a name="p94" href="#p94">page 94</a>] (<a href="#Contents">Contents</a>)
-
-    greater than or equal to the width of the promoted left operand, the behavior is undefined.
-4   The result of E1 &lt;&lt; E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
-    zeros. If E1 has an unsigned type, the value of the result is E1 x 2E2 , reduced modulo
-    one more than the maximum value representable in the result type. If E1 has a signed
-    type and nonnegative value, and E1 x 2E2 is representable in the result type, then that is
-    the resulting value; otherwise, the behavior is undefined.
-5   The result of E1 &gt;&gt; E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
-    or if E1 has a signed type and a nonnegative value, the value of the result is the integral
-    part of the quotient of E1 / 2E2 . If E1 has a signed type and a negative value, the
-    resulting value is implementation-defined.
-<a name="6.5.8" href="#6.5.8"><b>    6.5.8 Relational operators</b></a>
-<b>    Syntax</b>
-1            relational-expression:
-                     shift-expression
-                     relational-expression   &lt;    shift-expression
-                     relational-expression   &gt;    shift-expression
-                     relational-expression   &lt;=   shift-expression
-                     relational-expression   &gt;=   shift-expression
-<b>    Constraints</b>
-2   One of the following shall hold:
-    -- both operands have real type; or                                                            *
-    -- both operands are pointers to qualified or unqualified versions of compatible object
-      types.
-<b>    Semantics</b>
-3   If both of the operands have arithmetic type, the usual arithmetic conversions are
-    performed.
-4   For the purposes of these operators, a pointer to an object that is not an element of an
-    array behaves the same as a pointer to the first element of an array of length one with the
-    type of the object as its element type.
-5   When two pointers are compared, the result depends on the relative locations in the
-    address space of the objects pointed to. If two pointers to object types both point to the
-    same object, or both point one past the last element of the same array object, they
-    compare equal. If the objects pointed to are members of the same aggregate object,
-    pointers to structure members declared later compare greater than pointers to members
-    declared earlier in the structure, and pointers to array elements with larger subscript
-    values compare greater than pointers to elements of the same array with lower subscript
-
-[<a name="p95" href="#p95">page 95</a>] (<a href="#Contents">Contents</a>)
-
-    values. All pointers to members of the same union object compare equal. If the
-    expression P points to an element of an array object and the expression Q points to the
-    last element of the same array object, the pointer expression Q+1 compares greater than
-    P. In all other cases, the behavior is undefined.
-6   Each of the operators &lt; (less than), &gt; (greater than), &lt;= (less than or equal to), and &gt;=
-    (greater than or equal to) shall yield 1 if the specified relation is true and 0 if it is
-    false.<sup><a href="#note107"><b>107)</b></a></sup> The result has type int.
-<a name="6.5.9" href="#6.5.9"><b>    6.5.9 Equality operators</b></a>
-<b>    Syntax</b>
-1            equality-expression:
-                    relational-expression
-                    equality-expression == relational-expression
-                    equality-expression != relational-expression
-<b>    Constraints</b>
-2   One of the following shall hold:
-    -- both operands have arithmetic type;
-    -- both operands are pointers to qualified or unqualified versions of compatible types;
-    -- one operand is a pointer to an object type and the other is a pointer to a qualified or
-      unqualified version of void; or
-    -- one operand is a pointer and the other is a null pointer constant.
-<b>    Semantics</b>
-3   The == (equal to) and != (not equal to) operators are analogous to the relational
-    operators except for their lower precedence.<sup><a href="#note108"><b>108)</b></a></sup> Each of the operators yields 1 if the
-    specified relation is true and 0 if it is false. The result has type int. For any pair of
-    operands, exactly one of the relations is true.
-4   If both of the operands have arithmetic type, the usual arithmetic conversions are
-    performed. Values of complex types are equal if and only if both their real parts are equal
-    and also their imaginary parts are equal. Any two values of arithmetic types from
-    different type domains are equal if and only if the results of their conversions to the
-    (complex) result type determined by the usual arithmetic conversions are equal.
-
-
-
-    <sup><a name="note107" href="#note107"><b>107)</b></a></sup> The expression a&lt;b&lt;c is not interpreted as in ordinary mathematics. As the syntax indicates, it
-         means (a&lt;b)&lt;c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
-    <sup><a name="note108" href="#note108"><b>108)</b></a></sup> Because of the precedences, a&lt;b == c&lt;d is 1 whenever a&lt;b and c&lt;d have the same truth-value.
-
-[<a name="p96" href="#p96">page 96</a>] (<a href="#Contents">Contents</a>)
-
-5   Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
-    null pointer constant, the null pointer constant is converted to the type of the pointer. If
-    one operand is a pointer to an object type and the other is a pointer to a qualified or
-    unqualified version of void, the former is converted to the type of the latter.
-6   Two pointers compare equal if and only if both are null pointers, both are pointers to the
-    same object (including a pointer to an object and a subobject at its beginning) or function,
-    both are pointers to one past the last element of the same array object, or one is a pointer
-    to one past the end of one array object and the other is a pointer to the start of a different
-    array object that happens to immediately follow the first array object in the address
-    space.<sup><a href="#note109"><b>109)</b></a></sup>
-7   For the purposes of these operators, a pointer to an object that is not an element of an
-    array behaves the same as a pointer to the first element of an array of length one with the
-    type of the object as its element type.
-<a name="6.5.10" href="#6.5.10"><b>    6.5.10 Bitwise AND operator</b></a>
-<b>    Syntax</b>
-1            AND-expression:
-                   equality-expression
-                   AND-expression &amp; equality-expression
-<b>    Constraints</b>
-2   Each of the operands shall have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the binary &amp; operator is the bitwise AND of the operands (that is, each bit in
-    the result is set if and only if each of the corresponding bits in the converted operands is
-    set).
-
-
-
-
-    <sup><a name="note109" href="#note109"><b>109)</b></a></sup> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
-         adjacent members of a structure with no padding between them, or because the implementation chose
-         to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
-         outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
-         behavior.
-
-[<a name="p97" href="#p97">page 97</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.11" href="#6.5.11"><b>    6.5.11 Bitwise exclusive OR operator</b></a>
-<b>    Syntax</b>
-1            exclusive-OR-expression:
-                     AND-expression
-                     exclusive-OR-expression ^ AND-expression
-<b>    Constraints</b>
-2   Each of the operands shall have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
-    in the result is set if and only if exactly one of the corresponding bits in the converted
-    operands is set).
-<a name="6.5.12" href="#6.5.12"><b>    6.5.12 Bitwise inclusive OR operator</b></a>
-<b>    Syntax</b>
-1            inclusive-OR-expression:
-                     exclusive-OR-expression
-                     inclusive-OR-expression | exclusive-OR-expression
-<b>    Constraints</b>
-2   Each of the operands shall have integer type.
-<b>    Semantics</b>
-3   The usual arithmetic conversions are performed on the operands.
-4   The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
-    the result is set if and only if at least one of the corresponding bits in the converted
-    operands is set).
-
-[<a name="p98" href="#p98">page 98</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.13" href="#6.5.13"><b>    6.5.13 Logical AND operator</b></a>
-<b>    Syntax</b>
-1            logical-AND-expression:
-                     inclusive-OR-expression
-                     logical-AND-expression &amp;&amp; inclusive-OR-expression
-<b>    Constraints</b>
-2   Each of the operands shall have scalar type.
-<b>    Semantics</b>
-3   The &amp;&amp; operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
-    yields 0. The result has type int.
-4   Unlike the bitwise binary &amp; operator, the &amp;&amp; operator guarantees left-to-right evaluation;
-    if the second operand is evaluated, there is a sequence point between the evaluations of
-    the first and second operands. If the first operand compares equal to 0, the second
-    operand is not evaluated.
-<a name="6.5.14" href="#6.5.14"><b>    6.5.14 Logical OR operator</b></a>
-<b>    Syntax</b>
-1            logical-OR-expression:
-                     logical-AND-expression
-                     logical-OR-expression || logical-AND-expression
-<b>    Constraints</b>
-2   Each of the operands shall have scalar type.
-<b>    Semantics</b>
-3   The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
-    yields 0. The result has type int.
-4   Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; if the
-    second operand is evaluated, there is a sequence point between the evaluations of the first
-    and second operands. If the first operand compares unequal to 0, the second operand is
-    not evaluated.
-
-[<a name="p99" href="#p99">page 99</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.15" href="#6.5.15"><b>    6.5.15 Conditional operator</b></a>
-<b>    Syntax</b>
-1            conditional-expression:
-                    logical-OR-expression
-                    logical-OR-expression ? expression : conditional-expression
-<b>    Constraints</b>
-2   The first operand shall have scalar type.
-3   One of the following shall hold for the second and third operands:
-    -- both operands have arithmetic type;
-    -- both operands have the same structure or union type;
-    -- both operands have void type;
-    -- both operands are pointers to qualified or unqualified versions of compatible types;
-    -- one operand is a pointer and the other is a null pointer constant; or
-    -- one operand is a pointer to an object type and the other is a pointer to a qualified or
-      unqualified version of void.
-<b>    Semantics</b>
-4   The first operand is evaluated; there is a sequence point between its evaluation and the
-    evaluation of the second or third operand (whichever is evaluated). The second operand
-    is evaluated only if the first compares unequal to 0; the third operand is evaluated only if
-    the first compares equal to 0; the result is the value of the second or third operand
-    (whichever is evaluated), converted to the type described below.<sup><a href="#note110"><b>110)</b></a></sup>                        *
-5   If both the second and third operands have arithmetic type, the result type that would be
-    determined by the usual arithmetic conversions, were they applied to those two operands,
-    is the type of the result. If both the operands have structure or union type, the result has
-    that type. If both operands have void type, the result has void type.
-6   If both the second and third operands are pointers or one is a null pointer constant and the
-    other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
-    of the types referenced by both operands. Furthermore, if both operands are pointers to
-    compatible types or to differently qualified versions of compatible types, the result type is
-    a pointer to an appropriately qualified version of the composite type; if one operand is a
-    null pointer constant, the result has the type of the other operand; otherwise, one operand
-    is a pointer to void or a qualified version of void, in which case the result type is a
-    pointer to an appropriately qualified version of void.
-
-    <sup><a name="note110" href="#note110"><b>110)</b></a></sup> A conditional expression does not yield an lvalue.
-
-[<a name="p100" href="#p100">page 100</a>] (<a href="#Contents">Contents</a>)
-
-7   EXAMPLE The common type that results when the second and third operands are pointers is determined
-    in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
-    pointers have compatible types.
-8   Given the declarations
-              const void *c_vp;
-              void *vp;
-              const int *c_ip;
-              volatile int *v_ip;
-              int *ip;
-              const char *c_cp;
-    the third column in the following table is the common type that is the result of a conditional expression in
-    which the first two columns are the second and third operands (in either order):
-              c_vp    c_ip      const void *
-              v_ip    0         volatile int *
-              c_ip    v_ip      const volatile int *
-              vp      c_cp      const void *
-              ip      c_ip      const int *
-              vp      ip        void *
-
-<a name="6.5.16" href="#6.5.16"><b>    6.5.16 Assignment operators</b></a>
-<b>    Syntax</b>
-1            assignment-expression:
-                    conditional-expression
-                    unary-expression assignment-operator assignment-expression
-             assignment-operator: one of
-                    = *= /= %= +=                       -=     &lt;&lt;=      &gt;&gt;=      &amp;=     ^=     |=
-<b>    Constraints</b>
-2   An assignment operator shall have a modifiable lvalue as its left operand.
-<b>    Semantics</b>
-3   An assignment operator stores a value in the object designated by the left operand. An
-    assignment expression has the value of the left operand after the assignment,<sup><a href="#note111"><b>111)</b></a></sup> but is not
-    an lvalue. The type of an assignment expression is the type the left operand would have
-    after lvalue conversion. The side effect of updating the stored value of the left operand is
-    sequenced after the value computations of the left and right operands. The evaluations of
-    the operands are unsequenced.
-
-
-
-
-    <sup><a name="note111" href="#note111"><b>111)</b></a></sup> The implementation is permitted to read the object to determine the value but is not required to, even
-         when the object has volatile-qualified type.
-
-[<a name="p101" href="#p101">page 101</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.5.16.1" href="#6.5.16.1"><b>    6.5.16.1 Simple assignment</b></a>
-<b>    Constraints</b>
-1   One of the following shall hold:<sup><a href="#note112"><b>112)</b></a></sup>
-    -- the left operand has atomic, qualified, or unqualified arithmetic type, and the right has
-      arithmetic type;
-    -- the left operand has an atomic, qualified, or unqualified version of a structure or union
-      type compatible with the type of the right;
-    -- the left operand has atomic, qualified, or unqualified pointer type, and (considering
-      the type the left operand would have after lvalue conversion) both operands are
-      pointers to qualified or unqualified versions of compatible types, and the type pointed
-      to by the left has all the qualifiers of the type pointed to by the right;
-    -- the left operand has atomic, qualified, or unqualified pointer type, and (considering
-      the type the left operand would have after lvalue conversion) one operand is a pointer
-      to an object type, and the other is a pointer to a qualified or unqualified version of
-      void, and the type pointed to by the left has all the qualifiers of the type pointed to
-      by the right;
-    -- the left operand is an atomic, qualified, or unqualified pointer, and the right is a null
-      pointer constant; or
-    -- the left operand has type atomic, qualified, or unqualified _Bool, and the right is a
-      pointer.
-<b>    Semantics</b>
-2   In simple assignment (=), the value of the right operand is converted to the type of the
-    assignment expression and replaces the value stored in the object designated by the left
-    operand.
-3   If the value being stored in an object is read from another object that overlaps in any way
-    the storage of the first object, then the overlap shall be exact and the two objects shall
-    have qualified or unqualified versions of a compatible type; otherwise, the behavior is
-    undefined.
-4   EXAMPLE 1       In the program fragment
-
-
-
-
-    <sup><a name="note112" href="#note112"><b>112)</b></a></sup> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
-         (specified in <a href="#6.3.2.1">6.3.2.1</a>) that changes lvalues to ''the value of the expression'' and thus removes any type
-         qualifiers that were applied to the type category of the expression (for example, it removes const but
-         not volatile from the type int volatile * const).
-
-[<a name="p102" href="#p102">page 102</a>] (<a href="#Contents">Contents</a>)
-
-            int f(void);
-            char c;
+<!--page 2 indent 0-->
+<!--page 3 indent 0-->
+</pre>
+
+<a name="Contents" href="#Contents"><h2>Contents</h2></a>
+<pre>
+Foreword       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                 xiii
+Introduction    . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii
+1. Scope       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                   1
+2. Normative references     . . . . . . . . . . . . . . . . . . . . . . .                                  2
+3. Terms, definitions, and symbols    . . . . . . . . . . . . . . . . . . .                                 3
+4. Conformance       . . . . . . . . . . . . . . . . . . . . . . . . . .                                   8
+5. Environment    . . . . . . . . . . .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10
+   5.1 Conceptual models       . . . . . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10
+        5.1.1  Translation environment .      . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10
+        5.1.2  Execution environments     .   . .   .   .   .   .   .   .   .    .   .   .   .   .   .    12
+   5.2 Environmental considerations    . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    22
+        5.2.1  Character sets    . . . . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    22
+        5.2.2  Character display semantics      .   .   .   .   .   .   .   .    .   .   .   .   .   .    24
+        5.2.3  Signals and interrupts . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .    25
+        5.2.4  Environmental limits    . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    25
+6. Language . . . . . . . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .    35
+   6.1 Notation . . . . . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .    35
+   6.2 Concepts       . . . . . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .    35
+        6.2.1   Scopes of identifiers     . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    35
+        6.2.2   Linkages of identifiers . . . . .        .   .   .   .   .   .    .   .   .   .   .   .    36
+        6.2.3   Name spaces of identifiers      . . .    .   .   .   .   .   .    .   .   .   .   .   .    37
+        6.2.4   Storage durations of objects     . .    .   .   .   .   .   .    .   .   .   .   .   .    38
+        6.2.5   Types       . . . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    39
+        6.2.6   Representations of types . . . .        .   .   .   .   .   .    .   .   .   .   .   .    44
+        6.2.7   Compatible type and composite type          .   .   .   .   .    .   .   .   .   .   .    47
+        6.2.8   Alignment of objects     . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    48
+   6.3 Conversions       . . . . . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .    50
+        6.3.1   Arithmetic operands      . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    50
+        6.3.2   Other operands       . . . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    54
+   6.4 Lexical elements       . . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    57
+        6.4.1   Keywords . . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .    58
+        6.4.2   Identifiers . . . . . . . . . .          .   .   .   .   .   .    .   .   .   .   .   .    59
+        6.4.3   Universal character names      . . .    .   .   .   .   .   .    .   .   .   .   .   .    61
+        6.4.4   Constants . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .    62
+        6.4.5   String literals   . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    70
+        6.4.6   Punctuators . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .    72
+        6.4.7   Header names      . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    73
+        6.4.8   Preprocessing numbers        . . . .    .   .   .   .   .   .    .   .   .   .   .   .    74
+        6.4.9   Comments        . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    75
+<!--page 4 indent -1-->
+     6.5  Expressions      . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    76
+          6.5.1   Primary expressions      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    78
+          6.5.2   Postfix operators . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    79
+          6.5.3   Unary operators      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    88
+          6.5.4   Cast operators . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    91
+          6.5.5   Multiplicative operators   . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    92
+          6.5.6   Additive operators     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    92
+          6.5.7   Bitwise shift operators . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .    94
+          6.5.8   Relational operators . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    95
+          6.5.9   Equality operators     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    96
+          6.5.10 Bitwise AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    97
+          6.5.11 Bitwise exclusive OR operator         .   .   .   .   .   .   .   .   .   .   .   .   .    98
+          6.5.12 Bitwise inclusive OR operator     .   .   .   .   .   .   .   .   .   .   .   .   .   .    98
+          6.5.13 Logical AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    99
+          6.5.14 Logical OR operator       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    99
+          6.5.15 Conditional operator      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   100
+          6.5.16 Assignment operators . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   101
+          6.5.17 Comma operator . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .   104
+     6.6 Constant expressions . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   105
+     6.7 Declarations      . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   107
+          6.7.1   Storage-class specifiers    . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   108
+          6.7.2   Type specifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   109
+          6.7.3   Type qualifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   120
+          6.7.4   Function specifiers     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   124
+          6.7.5   Alignment specifier . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   126
+          6.7.6   Declarators     . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   127
+          6.7.7   Type names . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   135
+          6.7.8   Type definitions      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   136
+          6.7.9   Initialization    . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   138
+          6.7.10 Static assertions     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   144
+     6.8 Statements and blocks      . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   145
+          6.8.1   Labeled statements     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   145
+          6.8.2   Compound statement       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   146
+          6.8.3   Expression and null statements       .   .   .   .   .   .   .   .   .   .   .   .   .   146
+          6.8.4   Selection statements     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147
+          6.8.5   Iteration statements . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   149
+          6.8.6   Jump statements      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   150
+     6.9 External definitions      . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   154
+          6.9.1   Function definitions . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   155
+          6.9.2   External object definitions   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   157
+     6.10 Preprocessing directives     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   159
+          6.10.1 Conditional inclusion     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   161
+          6.10.2 Source file inclusion      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   163
+          6.10.3 Macro replacement . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   165
+<!--page 5 indent 0-->
+       6.10.4 Line control . . . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   172
+       6.10.5 Error directive . . . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   173
+       6.10.6 Pragma directive . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   173
+       6.10.7 Null directive      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174
+       6.10.8 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174
+       6.10.9 Pragma operator       . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   176
+  6.11 Future language directions     . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.1 Floating types      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.2 Linkages of identifiers . .      .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.3 External names        . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.4 Character escape sequences          .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.5 Storage-class specifiers     .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.6 Function declarators      . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.7 Function definitions . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.8 Pragma directives       . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+       6.11.9 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178
+7. Library . . . . . . . . . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   179
+   7.1 Introduction     . . . . . . . . . . . . .             .   .   .   .   .    .   .   .   .   .   .   179
+         7.1.1 Definitions of terms . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   179
+         7.1.2 Standard headers . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   180
+         7.1.3 Reserved identifiers . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   181
+         7.1.4 Use of library functions    . . . . .          .   .   .   .   .    .   .   .   .   .   .   182
+   7.2 Diagnostics &lt;assert.h&gt;          . . . . . . .          .   .   .   .   .    .   .   .   .   .   .   185
+         7.2.1 Program diagnostics       . . . . . .          .   .   .   .   .    .   .   .   .   .   .   185
+   7.3 Complex arithmetic &lt;complex.h&gt;           . . .         .   .   .   .   .    .   .   .   .   .   .   187
+         7.3.1 Introduction . . . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   187
+         7.3.2 Conventions . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   188
+         7.3.3 Branch cuts . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   188
+         7.3.4 The CX_LIMITED_RANGE pragma                    .   .   .   .   .    .   .   .   .   .   .   188
+         7.3.5 Trigonometric functions . . . . .              .   .   .   .   .    .   .   .   .   .   .   189
+         7.3.6 Hyperbolic functions      . . . . . .          .   .   .   .   .    .   .   .   .   .   .   191
+         7.3.7 Exponential and logarithmic functions              .   .   .   .    .   .   .   .   .   .   193
+         7.3.8 Power and absolute-value functions             .   .   .   .   .    .   .   .   .   .   .   194
+         7.3.9 Manipulation functions      . . . . .          .   .   .   .   .    .   .   .   .   .   .   195
+   7.4 Character handling &lt;ctype.h&gt; . . . . .                 .   .   .   .   .    .   .   .   .   .   .   199
+         7.4.1 Character classification functions    .         .   .   .   .   .    .   .   .   .   .   .   199
+         7.4.2 Character case mapping functions     .         .   .   .   .   .    .   .   .   .   .   .   202
+   7.5 Errors &lt;errno.h&gt;         . . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   204
+   7.6 Floating-point environment &lt;fenv.h&gt;        . .         .   .   .   .   .    .   .   .   .   .   .   205
+         7.6.1 The FENV_ACCESS pragma           . . .         .   .   .   .   .    .   .   .   .   .   .   207
+         7.6.2 Floating-point exceptions      . . . .         .   .   .   .   .    .   .   .   .   .   .   208
+         7.6.3 Rounding . . . . . . . . . . .                 .   .   .   .   .    .   .   .   .   .   .   211
+         7.6.4 Environment        . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   212
+   7.7 Characteristics of floating types &lt;float.h&gt;             .   .   .   .   .    .   .   .   .   .   .   215
+<!--page 6 indent -1-->
+     7.8    Format conversion of integer types &lt;inttypes.h&gt; . . . .           .   .   .   .   216
+            7.8.1    Macros for format specifiers      . . . . . . . . . .     .   .   .   .   216
+            7.8.2    Functions for greatest-width integer types   . . . . .   .   .   .   .   217
+     7.9    Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . .            .   .   .   .   220
+     7.10   Sizes of integer types &lt;limits.h&gt;         . . . . . . . . . .     .   .   .   .   221
+     7.11   Localization &lt;locale.h&gt; . . . . . . . . . . . . . .               .   .   .   .   222
+            7.11.1 Locale control . . . . . . . . . . . . . . . .             .   .   .   .   223
+            7.11.2 Numeric formatting convention inquiry . . . . . .          .   .   .   .   224
+     7.12   Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                .   .   .   .   230
+            7.12.1 Treatment of error conditions . . . . . . . . . .          .   .   .   .   232
+            7.12.2 The FP_CONTRACT pragma             . . . . . . . . . .     .   .   .   .   234
+            7.12.3 Classification macros       . . . . . . . . . . . . .       .   .   .   .   234
+            7.12.4 Trigonometric functions . . . . . . . . . . . .            .   .   .   .   237
+            7.12.5 Hyperbolic functions       . . . . . . . . . . . . .       .   .   .   .   239
+            7.12.6 Exponential and logarithmic functions        . . . . . .   .   .   .   .   241
+            7.12.7 Power and absolute-value functions         . . . . . . .   .   .   .   .   246
+            7.12.8 Error and gamma functions . . . . . . . . . . .            .   .   .   .   248
+            7.12.9 Nearest integer functions . . . . . . . . . . . .          .   .   .   .   250
+            7.12.10 Remainder functions       . . . . . . . . . . . . .       .   .   .   .   253
+            7.12.11 Manipulation functions       . . . . . . . . . . . .      .   .   .   .   254
+            7.12.12 Maximum, minimum, and positive difference functions           .   .   .   256
+            7.12.13 Floating multiply-add . . . . . . . . . . . . .           .   .   .   .   257
+            7.12.14 Comparison macros . . . . . . . . . . . . . .             .   .   .   .   258
+     7.13   Nonlocal jumps &lt;setjmp.h&gt;            . . . . . . . . . . . .      .   .   .   .   261
+            7.13.1 Save calling environment         . . . . . . . . . . .     .   .   .   .   261
+            7.13.2 Restore calling environment        . . . . . . . . . .     .   .   .   .   262
+     7.14   Signal handling &lt;signal.h&gt; . . . . . . . . . . . . .              .   .   .   .   264
+            7.14.1 Specify signal handling       . . . . . . . . . . . .      .   .   .   .   265
+            7.14.2 Send signal      . . . . . . . . . . . . . . . . .         .   .   .   .   266
+     7.15   Alignment &lt;stdalign.h&gt;            . . . . . . . . . . . . .       .   .   .   .   267
+     7.16   Variable arguments &lt;stdarg.h&gt;           . . . . . . . . . . .     .   .   .   .   268
+            7.16.1 Variable argument list access macros . . . . . . .         .   .   .   .   268
+     7.17   Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . .                 .   .   .   .   272
+            7.17.1 Introduction . . . . . . . . . . . . . . . . .             .   .   .   .   272
+            7.17.2 Initialization      . . . . . . . . . . . . . . . .        .   .   .   .   273
+            7.17.3 Order and consistency . . . . . . . . . . . . .            .   .   .   .   274
+            7.17.4 Fences . . . . . . . . . . . . . . . . . . .               .   .   .   .   277
+            7.17.5 Lock-free property       . . . . . . . . . . . . . .       .   .   .   .   278
+            7.17.6 Atomic integer and address types         . . . . . . . .   .   .   .   .   279
+            7.17.7 Operations on atomic types . . . . . . . . . . .           .   .   .   .   281
+            7.17.8 Atomic flag type and operations . . . . . . . . .           .   .   .   .   284
+     7.18   Boolean type and values &lt;stdbool.h&gt;             . . . . . . . .   .   .   .   .   286
+     7.19   Common definitions &lt;stddef.h&gt; . . . . . . . . . . .                .   .   .   .   287
+     7.20   Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . .              .   .   .   .   289
+<!--page 7 indent -1-->
+         7.20.1 Integer types      . . . . . . . . . . . .      .   .    .   .   .   .   .   .   289
+         7.20.2 Limits of specified-width integer types    . .   .   .    .   .   .   .   .   .   291
+         7.20.3 Limits of other integer types    . . . . . .    .   .    .   .   .   .   .   .   293
+         7.20.4 Macros for integer constants     . . . . . .    .   .    .   .   .   .   .   .   294
+  7.21   Input/output &lt;stdio.h&gt;         . . . . . . . . . .     .   .    .   .   .   .   .   .   296
+         7.21.1 Introduction . . . . . . . . . . . . .          .   .    .   .   .   .   .   .   296
+         7.21.2 Streams       . . . . . . . . . . . . . .       .   .    .   .   .   .   .   .   298
+         7.21.3 Files . . . . . . . . . . . . . . . .           .   .    .   .   .   .   .   .   300
+         7.21.4 Operations on files      . . . . . . . . . .     .   .    .   .   .   .   .   .   302
+         7.21.5 File access functions     . . . . . . . . .     .   .    .   .   .   .   .   .   304
+         7.21.6 Formatted input/output functions     . . . .    .   .    .   .   .   .   .   .   309
+         7.21.7 Character input/output functions . . . . .      .   .    .   .   .   .   .   .   330
+         7.21.8 Direct input/output functions    . . . . . .    .   .    .   .   .   .   .   .   334
+         7.21.9 File positioning functions     . . . . . . .    .   .    .   .   .   .   .   .   335
+         7.21.10 Error-handling functions . . . . . . . .       .   .    .   .   .   .   .   .   338
+  7.22   General utilities &lt;stdlib.h&gt;        . . . . . . . .    .   .    .   .   .   .   .   .   340
+         7.22.1 Numeric conversion functions . . . . . .        .   .    .   .   .   .   .   .   341
+         7.22.2 Pseudo-random sequence generation functions         .    .   .   .   .   .   .   346
+         7.22.3 Memory management functions . . . . .           .   .    .   .   .   .   .   .   347
+         7.22.4 Communication with the environment        . .   .   .    .   .   .   .   .   .   349
+         7.22.5 Searching and sorting utilities . . . . . .     .   .    .   .   .   .   .   .   353
+         7.22.6 Integer arithmetic functions     . . . . . .    .   .    .   .   .   .   .   .   355
+         7.22.7 Multibyte/wide character conversion functions       .    .   .   .   .   .   .   356
+         7.22.8 Multibyte/wide string conversion functions      .   .    .   .   .   .   .   .   358
+  7.23   String handling &lt;string.h&gt; . . . . . . . . .           .   .    .   .   .   .   .   .   360
+         7.23.1 String function conventions . . . . . . .       .   .    .   .   .   .   .   .   360
+         7.23.2 Copying functions       . . . . . . . . . .     .   .    .   .   .   .   .   .   360
+         7.23.3 Concatenation functions . . . . . . . .         .   .    .   .   .   .   .   .   362
+         7.23.4 Comparison functions . . . . . . . . .          .   .    .   .   .   .   .   .   363
+         7.23.5 Search functions      . . . . . . . . . . .     .   .    .   .   .   .   .   .   365
+         7.23.6 Miscellaneous functions . . . . . . . .         .   .    .   .   .   .   .   .   368
+  7.24   Type-generic math &lt;tgmath.h&gt;          . . . . . . .    .   .    .   .   .   .   .   .   370
+  7.25   Threads &lt;threads.h&gt;          . . . . . . . . . . .     .   .    .   .   .   .   .   .   373
+         7.25.1 Introduction . . . . . . . . . . . . .          .   .    .   .   .   .   .   .   373
+         7.25.2 Initialization functions . . . . . . . . .      .   .    .   .   .   .   .   .   375
+         7.25.3 Condition variable functions     . . . . . .    .   .    .   .   .   .   .   .   375
+         7.25.4 Mutex functions       . . . . . . . . . . .     .   .    .   .   .   .   .   .   377
+         7.25.5 Thread functions . . . . . . . . . . .          .   .    .   .   .   .   .   .   380
+         7.25.6 Thread-specific storage functions     . . . .    .   .    .   .   .   .   .   .   382
+         7.25.7 Time functions . . . . . . . . . . . .          .   .    .   .   .   .   .   .   384
+  7.26   Date and time &lt;time.h&gt;         . . . . . . . . . .     .   .    .   .   .   .   .   .   385
+         7.26.1 Components of time        . . . . . . . . .     .   .    .   .   .   .   .   .   385
+         7.26.2 Time manipulation functions      . . . . . .    .   .    .   .   .   .   .   .   386
+         7.26.3 Time conversion functions      . . . . . . .    .   .    .   .   .   .   .   .   388
+<!--page 8 indent -1-->
+   7.27 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .               . .     .   395
+        7.27.1 Restartable multibyte/wide character conversion functions        .     .   395
+   7.28 Extended multibyte and wide character utilities &lt;wchar.h&gt; . .         . .     .   399
+        7.28.1 Introduction . . . . . . . . . . . . . . . . . .               . .     .   399
+        7.28.2 Formatted wide character input/output functions       . . .    . .     .   400
+        7.28.3 Wide character input/output functions        . . . . . . .     . .     .   418
+        7.28.4 General wide string utilities     . . . . . . . . . . .        . .     .   422
+                 7.28.4.1 Wide string numeric conversion functions     . .    . .     .   423
+                 7.28.4.2 Wide string copying functions . . . . . . .         . .     .   427
+                 7.28.4.3 Wide string concatenation functions      . . . .    . .     .   429
+                 7.28.4.4 Wide string comparison functions      . . . . .     . .     .   430
+                 7.28.4.5 Wide string search functions      . . . . . . .     . .     .   432
+                 7.28.4.6 Miscellaneous functions      . . . . . . . . .      . .     .   436
+        7.28.5 Wide character time conversion functions       . . . . . .     . .     .   436
+        7.28.6 Extended multibyte/wide character conversion utilities .       . .     .   437
+                 7.28.6.1 Single-byte/wide character conversion functions     . .     .   438
+                 7.28.6.2 Conversion state functions     . . . . . . . .      . .     .   438
+                 7.28.6.3 Restartable multibyte/wide character conversion
+                           functions   . . . . . . . . . . . . . . .          . . . 439
+                 7.28.6.4 Restartable multibyte/wide string conversion
+                           functions   . . . . . . . . . . . . . . .          .   .   .   441
+   7.29 Wide character classification and mapping utilities &lt;wctype.h&gt;         .   .   .   444
+        7.29.1 Introduction . . . . . . . . . . . . . . . . . .               .   .   .   444
+        7.29.2 Wide character classification utilities . . . . . . . .         .   .   .   445
+                 7.29.2.1 Wide character classification functions     . . .    .   .   .   445
+                 7.29.2.2 Extensible wide character classification
+                           functions   . . . . . . . . . . . . . . .          . . . 448
+        7.29.3 Wide character case mapping utilities . . . . . . . .          . . . 450
+                 7.29.3.1 Wide character case mapping functions      . . .    . . . 450
+                 7.29.3.2 Extensible wide character case mapping
+                           functions   . . . . . . . . . . . . . . .          .   .   .   450
+   7.30 Future library directions    . . . . . . . . . . . . . . . .          .   .   .   452
+        7.30.1 Complex arithmetic &lt;complex.h&gt; . . . . . . . .                 .   .   .   452
+        7.30.2 Character handling &lt;ctype.h&gt;            . . . . . . . . .      .   .   .   452
+        7.30.3 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .         .   .   .   452
+        7.30.4 Format conversion of integer types &lt;inttypes.h&gt;            .   .   .   .   452
+        7.30.5 Localization &lt;locale.h&gt;           . . . . . . . . . . .        .   .   .   452
+        7.30.6 Signal handling &lt;signal.h&gt;           . . . . . . . . . .       .   .   .   452
+        7.30.7 Boolean type and values &lt;stdbool.h&gt;            . . . . . .     .   .   .   452
+        7.30.8 Integer types &lt;stdint.h&gt;          . . . . . . . . . . .        .   .   .   452
+        7.30.9 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .        .   .   .   453
+        7.30.10 General utilities &lt;stdlib.h&gt;        . . . . . . . . . .       .   .   .   453
+        7.30.11 String handling &lt;string.h&gt;          . . . . . . . . . .       .   .   .   453
+<!--page 9 indent 0-->
+        7.30.12 Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;        . . . . . . . . . . . . . . . . . . . . 453
+        7.30.13 Wide character classification and mapping utilities
+                &lt;wctype.h&gt; . . . . . . . . . . . . . . . . . . . . 453
+Annex A (informative) Language syntax summary   . .       .   .   .   .    .   .   .   .   .   .   454
+  A.1 Lexical grammar       . . . . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   454
+  A.2 Phrase structure grammar . . . . . . . . .          .   .   .   .    .   .   .   .   .   .   461
+  A.3 Preprocessing directives    . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   469
+Annex B (informative) Library summary     . . . . . . . . . . . . .                    .   .   .   471
+  B.1 Diagnostics &lt;assert.h&gt;          . . . . . . . . . . . . . . .                    .   .   .   471
+  B.2 Complex &lt;complex.h&gt; . . . . . . . . . . . . . . . .                              .   .   .   471
+  B.3 Character handling &lt;ctype.h&gt; . . . . . . . . . . . . .                           .   .   .   473
+  B.4 Errors &lt;errno.h&gt;         . . . . . . . . . . . . . . . . . .                     .   .   .   473
+  B.5 Floating-point environment &lt;fenv.h&gt;          . . . . . . . . . .                 .   .   .   473
+  B.6 Characteristics of floating types &lt;float.h&gt; . . . . . . . .                       .   .   .   474
+  B.7 Format conversion of integer types &lt;inttypes.h&gt; . . . . .                        .   .   .   474
+  B.8 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . . .                         .   .   .   475
+  B.9 Sizes of integer types &lt;limits.h&gt;          . . . . . . . . . . .                 .   .   .   475
+  B.10 Localization &lt;locale.h&gt; . . . . . . . . . . . . . . .                           .   .   .   475
+  B.11 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . . .                            .   .   .   475
+  B.12 Nonlocal jumps &lt;setjmp.h&gt;          . . . . . . . . . . . . .                    .   .   .   480
+  B.13 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . . .                          .   .   .   480
+  B.14 Alignment &lt;stdalign.h&gt;           . . . . . . . . . . . . . .                    .   .   .   481
+  B.15 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . . .                   .   .   .   481
+  B.16 Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . . .                             .   .   .   481
+  B.17 Boolean type and values &lt;stdbool.h&gt;           . . . . . . . . .                 .   .   .   483
+  B.18 Common definitions &lt;stddef.h&gt; . . . . . . . . . . . .                            .   .   .   483
+  B.19 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . . .                          .   .   .   483
+  B.20 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   484
+  B.21 General utilities &lt;stdlib.h&gt;       . . . . . . . . . . . . .                    .   .   .   487
+  B.22 String handling &lt;string.h&gt; . . . . . . . . . . . . . .                          .   .   .   489
+  B.23 Type-generic math &lt;tgmath.h&gt;          . . . . . . . . . . . .                   .   .   .   491
+  B.24 Threads &lt;threads.h&gt;          . . . . . . . . . . . . . . . .                    .   .   .   491
+  B.25 Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   492
+  B.26 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .                         .   .   .   493
+  B.27 Extended multibyte/wide character utilities &lt;wchar.h&gt;     . . .                 .   .   .   493
+  B.28 Wide character classification and mapping utilities &lt;wctype.h&gt;                   .   .   .   498
+Annex C (informative) Sequence points     . . . . . . . . . . . . . . . . . 499
+Annex D (normative) Universal character names for identifiers . . . . . . . 500
+  D.1 Ranges of characters allowed       . . . . . . . . . . . . . . . . . 500
+  D.2 Ranges of characters disallowed initially . . . . . . . . . . . . . 500
+Annex E (informative) Implementation limits        . . . . . . . . . . . . . . 501
+<!--page 10 indent 0-->
+Annex F (normative) IEC 60559 floating-point arithmetic . . . . . .          . .     .   .   503
+  F.1 Introduction      . . . . . . . . . . . . . . . . . . . .             . .     .   .   503
+  F.2 Types . . . . . . . . . . . . . . . . . . . . . . .                   . .     .   .   503
+  F.3 Operators and functions       . . . . . . . . . . . . . . .           . .     .   .   504
+  F.4 Floating to integer conversion    . . . . . . . . . . . . .           . .     .   .   506
+  F.5 Binary-decimal conversion       . . . . . . . . . . . . . .           . .     .   .   506
+  F.6 The return statement . . . . . . . . . . . . . . . .                  . .     .   .   507
+  F.7 Contracted expressions . . . . . . . . . . . . . . . .                . .     .   .   507
+  F.8 Floating-point environment      . . . . . . . . . . . . . .           . .     .   .   507
+  F.9 Optimization . . . . . . . . . . . . . . . . . . . .                  . .     .   .   510
+  F.10 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                   . .     .   .   513
+        F.10.1 Trigonometric functions . . . . . . . . . . . .              . .     .   .   514
+        F.10.2 Hyperbolic functions     . . . . . . . . . . . . .           . .     .   .   516
+        F.10.3 Exponential and logarithmic functions    . . . . . .         . .     .   .   516
+        F.10.4 Power and absolute value functions     . . . . . . .         . .     .   .   520
+        F.10.5 Error and gamma functions . . . . . . . . . . .              . .     .   .   521
+        F.10.6 Nearest integer functions . . . . . . . . . . . .            . .     .   .   522
+        F.10.7 Remainder functions      . . . . . . . . . . . . .           . .     .   .   524
+        F.10.8 Manipulation functions     . . . . . . . . . . . .           . .     .   .   525
+        F.10.9 Maximum, minimum, and positive difference functions            .     .   .   526
+        F.10.10 Floating multiply-add . . . . . . . . . . . . .             . .     .   .   526
+        F.10.11 Comparison macros . . . . . . . . . . . . . .               . .     .   .   527
+Annex G (normative) IEC 60559-compatible complex arithmetic     .   .   .   .   .   .   .   528
+  G.1 Introduction     . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   528
+  G.2 Types . . . . . . . . . . . . . . . . . . . .             .   .   .   .   .   .   .   528
+  G.3 Conventions      . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   528
+  G.4 Conversions      . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   529
+       G.4.1 Imaginary types     . . . . . . . . . . . .        .   .   .   .   .   .   .   529
+       G.4.2 Real and imaginary . . . . . . . . . . .           .   .   .   .   .   .   .   529
+       G.4.3 Imaginary and complex       . . . . . . . . .      .   .   .   .   .   .   .   529
+  G.5 Binary operators     . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   529
+       G.5.1 Multiplicative operators    . . . . . . . . .      .   .   .   .   .   .   .   530
+       G.5.2 Additive operators     . . . . . . . . . . .       .   .   .   .   .   .   .   533
+  G.6 Complex arithmetic &lt;complex.h&gt;         . . . . . . .      .   .   .   .   .   .   .   533
+       G.6.1 Trigonometric functions . . . . . . . . .          .   .   .   .   .   .   .   535
+       G.6.2 Hyperbolic functions     . . . . . . . . . .       .   .   .   .   .   .   .   535
+       G.6.3 Exponential and logarithmic functions     . . .    .   .   .   .   .   .   .   539
+       G.6.4 Power and absolute-value functions      . . . .    .   .   .   .   .   .   .   540
+  G.7 Type-generic math &lt;tgmath.h&gt;         . . . . . . . .      .   .   .   .   .   .   .   541
+Annex H (informative) Language independent arithmetic . .   .   .   .   .   .   .   .   .   542
+  H.1 Introduction     . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   542
+  H.2 Types . . . . . . . . . . . . . . . . . . .           .   .   .   .   .   .   .   .   542
+  H.3 Notification      . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   546
+<!--page 11 indent 0-->
+Annex I (informative) Common warnings         . . . . . . . . . . . . . . . . 548
+Annex J (informative) Portability issues    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   550
+  J.1 Unspecified behavior . . . .           . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   550
+  J.2 Undefined behavior          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   553
+  J.3 Implementation-defined behavior          . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   566
+  J.4 Locale-specific behavior         . .   . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   574
+  J.5 Common extensions          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   575
+Annex K (normative) Bounds-checking interfaces . . . . . . . . . .                             .   .   .   578
+  K.1 Background       . . . . . . . . . . . . . . . . . . . . .                               .   .   .   578
+  K.2 Scope . . . . . . . . . . . . . . . . . . . . . . . .                                    .   .   .   579
+  K.3 Library     . . . . . . . . . . . . . . . . . . . . . . .                                .   .   .   579
+       K.3.1 Introduction . . . . . . . . . . . . . . . . . .                                  .   .   .   579
+                K.3.1.1 Standard headers     . . . . . . . . . . . .                           .   .   .   579
+                K.3.1.2 Reserved identifiers     . . . . . . . . . . .                          .   .   .   580
+                K.3.1.3 Use of errno . . . . . . . . . . . . . .                               .   .   .   580
+                K.3.1.4 Runtime-constraint violations     . . . . . . .                        .   .   .   580
+       K.3.2 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .                            .   .   .   581
+       K.3.3 Common definitions &lt;stddef.h&gt;               . . . . . . . .                        .   .   .   581
+       K.3.4 Integer types &lt;stdint.h&gt;           . . . . . . . . . . .                          .   .   .   581
+       K.3.5 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .                           .   .   .   582
+                K.3.5.1 Operations on files      . . . . . . . . . . .                          .   .   .   582
+                K.3.5.2 File access functions . . . . . . . . . . .                            .   .   .   584
+                K.3.5.3 Formatted input/output functions . . . . . .                           .   .   .   587
+                K.3.5.4 Character input/output functions . . . . . .                           .   .   .   598
+       K.3.6 General utilities &lt;stdlib.h&gt;          . . . . . . . . . .                         .   .   .   600
+                K.3.6.1 Runtime-constraint handling       . . . . . . .                        .   .   .   600
+                K.3.6.2 Communication with the environment . . . .                             .   .   .   602
+                K.3.6.3 Searching and sorting utilities . . . . . . .                          .   .   .   603
+                K.3.6.4 Multibyte/wide character conversion functions                          .   .   .   606
+                K.3.6.5 Multibyte/wide string conversion functions . .                         .   .   .   607
+       K.3.7 String handling &lt;string.h&gt;            . . . . . . . . . .                         .   .   .   610
+                K.3.7.1 Copying functions       . . . . . . . . . . .                          .   .   .   610
+                K.3.7.2 Concatenation functions       . . . . . . . . .                        .   .   .   613
+                K.3.7.3 Search functions     . . . . . . . . . . . .                           .   .   .   616
+                K.3.7.4 Miscellaneous functions       . . . . . . . . .                        .   .   .   617
+       K.3.8 Date and time &lt;time.h&gt;          . . . . . . . . . . . .                           .   .   .   620
+                K.3.8.1 Components of time . . . . . . . . . . .                               .   .   .   620
+                K.3.8.2 Time conversion functions       . . . . . . . .                        .   .   .   620
+       K.3.9 Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;        . . . . . . . . . . . . . . . . .                             . . . 623
+                K.3.9.1 Formatted wide character input/output functions                        . . . 624
+                K.3.9.2 General wide string utilities . . . . . . . .                          . . . 635
+<!--page 12 indent 0-->
+               K.3.9.3 Extended multibyte/wide character conversion
+                       utilities . . . . . . . . . . . . . . . . . . . 643
+Annex L (normative) Analyzability . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648
+  L.1 Scope . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648
+  L.2 Definitions . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648
+  L.3 Requirements . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   649
+Bibliography   . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
+Index    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
+<!--page 13 indent 4-->
+</pre>
+
+<a name="Foreword" href="#Foreword"><h2>Foreword</h2></a>
+<p><!--para 1-->
+ ISO (the International Organization for Standardization) and IEC (the International
+ Electrotechnical Commission) form the specialized system for worldwide
+ standardization. National bodies that are member of ISO or IEC participate in the
+ development of International Standards through technical committees established by the
+ respective organization to deal with particular fields of technical activity. ISO and IEC
+ technical committees collaborate in fields of mutual interest. Other international
+ organizations, governmental and non-governmental, in liaison with ISO and IEC, also
+ take part in the work.
+<p><!--para 2-->
+ International Standards are drafted in accordance with the rules given in the ISO/IEC
+ Directives, Part 2. This International Standard was drafted in accordance with the fifth
+ edition (2004).
+<p><!--para 3-->
+ In the field of information technology, ISO and IEC have established a joint technical
+ committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
+ committee are circulated to national bodies for voting. Publication as an International
+ Standard requires approval by at least 75% of the national bodies casting a vote.
+<p><!--para 4-->
+ Attention is drawn to the possibility that some of the elements of this document may be
+ the subject of patent rights. ISO and IEC shall not be held responsible for identifying any
+ or all such patent rights.
+<p><!--para 5-->
+ This International Standard was prepared by Joint Technical Committee ISO/IEC JTC 1,
+ Information technology, Subcommittee SC 22, Programming languages, their
+ environments and system software interfaces. The Working Group responsible for this
+ standard (WG 14) maintains a site on the World Wide Web at http://www.open-
+ std.org/JTC1/SC22/WG14/ containing additional information relevant to this
+ standard such as a Rationale for many of the decisions made during its preparation and a
+ log of Defect Reports and Responses.
+<p><!--para 6-->
+ This third edition cancels and replaces the second edition, ISO/IEC 9899:1999, as
+ corrected by ISO/IEC 9899:1999/Cor 1:2001, ISO/IEC 9899:1999/Cor 2:2004, and
+ ISO/IEC 9899:1999/Cor 3:2007. Major changes from the previous edition include:
+<ul>
+<li>  conditional (optional) features (including some that were previously mandatory)
+<li>  support for multiple threads of execution including an improved memory sequencing
+ model, atomic objects, and thread-local storage (&lt;stdatomic.h&gt; and
+ &lt;threads.h&gt;)
+<li>  additional floating-point characteristic macros (&lt;float.h&gt;)
+<li>  querying and specifying alignment of objects (&lt;stdalign.h&gt;, &lt;stdlib.h&gt;)
+<li>  Unicode characters and           strings   (&lt;uchar.h&gt;)       (originally   specified    in
+ ISO/IEC TR 19769:2004)
+<li>  type-generic expressions
+<!--page 14 indent 4-->
+<li>  static assertions
+<li>  anonymous structures and unions
+<li>  no-return functions
+<li>  macros to create complex numbers (&lt;complex.h&gt;)
+<li>  support for opening files for exclusive access
+<li>  removed the gets function (&lt;stdio.h&gt;)
+<li>  added the aligned_alloc, at_quick_exit, and quick_exit functions
+ (&lt;stdlib.h&gt;)
+<li>  (conditional) support for bounds-checking interfaces (originally specified in
+ ISO/IEC TR 24731-1:2007)
+<li>  (conditional) support for analyzability
+</ul>
+<p><!--para 7-->
+ Major changes in the second edition included:
+<ul>
+<li>  restricted character set support via digraphs and &lt;iso646.h&gt; (originally specified
+ in AMD1)
+<li>  wide character library support in &lt;wchar.h&gt; and &lt;wctype.h&gt; (originally
+ specified in AMD1)
+<li>  more precise aliasing rules via effective type
+<li>  restricted pointers
+<li>  variable length arrays
+<li>  flexible array members
+<li>  static and type qualifiers in parameter array declarators
+<li>  complex (and imaginary) support in &lt;complex.h&gt;
+<li>  type-generic math macros in &lt;tgmath.h&gt;
+<li>  the long long int type and library functions
+<li>  increased minimum translation limits
+<li>  additional floating-point characteristics in &lt;float.h&gt;
+<li>  remove implicit int
+<li>  reliable integer division
+<li>  universal character names (\u and \U)
+<li>  extended identifiers
+<li>  hexadecimal floating-point constants and %a and %A printf/scanf conversion
+ specifiers
+<!--page 15 indent 0-->
+<li>  compound literals
+<li>  designated initializers
+<li>  // comments
+<li>  extended integer types and library functions in &lt;inttypes.h&gt; and &lt;stdint.h&gt;
+<li>  remove implicit function declaration
+<li>  preprocessor arithmetic done in intmax_t/uintmax_t
+<li>  mixed declarations and code
+<li>  new block scopes for selection and iteration statements
+<li>  integer constant type rules
+<li>  integer promotion rules
+<li>  macros with a variable number of arguments
+<li>  the vscanf family of functions in &lt;stdio.h&gt; and &lt;wchar.h&gt;
+<li>  additional math library functions in &lt;math.h&gt;
+<li>  treatment of error conditions by math library functions (math_errhandling)
+<li>  floating-point environment access in &lt;fenv.h&gt;
+<li>  IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
+<li>  trailing comma allowed in enum declaration
+<li>  %lf conversion specifier allowed in printf
+<li>  inline functions
+<li>  the snprintf family of functions in &lt;stdio.h&gt;
+<li>  boolean type in &lt;stdbool.h&gt;
+<li>  idempotent type qualifiers
+<li>  empty macro arguments
+<li>  new structure type compatibility rules (tag compatibility)
+<li>  additional predefined macro names
+<li>  _Pragma preprocessing operator
+<li>  standard pragmas
+<li>  __func__ predefined identifier
+<li>  va_copy macro
+<li>  additional strftime conversion specifiers
+<li>  LIA compatibility annex
+<!--page 16 indent 4-->
+<li>  deprecate ungetc at the beginning of a binary file
+<li>  remove deprecation of aliased array parameters
+<li>  conversion of array to pointer not limited to lvalues
+<li>  relaxed constraints on aggregate and union initialization
+<li>  relaxed restrictions on portable header names
+<li>  return without expression not permitted in function that returns a value (and vice
+ versa)
+</ul>
+<p><!--para 8-->
+ Annexes D, F, G, K, and L form a normative part of this standard; annexes A, B, C, E, H, *
+ I, J, the bibliography, and the index are for information only. In accordance with Part 2 of
+ the ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples
+ are also for information only.
+<!--page 17 indent 4-->
+
+<a name="Introduction" href="#Introduction"><h2>Introduction</h2></a>
+<p><!--para 1-->
+ With the introduction of new devices and extended character sets, new features may be
+ added to this International Standard. Subclauses in the language and library clauses warn
+ implementors and programmers of usages which, though valid in themselves, may
+ conflict with future additions.
+<p><!--para 2-->
+ Certain features are obsolescent, which means that they may be considered for
+ withdrawal in future revisions of this International Standard. They are retained because
+ of their widespread use, but their use in new implementations (for implementation
+ features) or new programs (for language [<a href="#6.11">6.11</a>] or library features [<a href="#7.30">7.30</a>]) is discouraged.
+<p><!--para 3-->
+ This International Standard is divided into four major subdivisions:
+<ul>
+<li>  preliminary elements (clauses 1-4);
+<li>  the characteristics of environments that translate and execute C programs (clause 5);
+<li>  the language syntax, constraints, and semantics (clause 6);
+<li>  the library facilities (clause 7).
+</ul>
+<p><!--para 4-->
+ Examples are provided to illustrate possible forms of the constructions described.
+ Footnotes are provided to emphasize consequences of the rules described in that
+ subclause or elsewhere in this International Standard. References are used to refer to
+ other related subclauses. Recommendations are provided to give advice or guidance to
+ implementors. Annexes provide additional information and summarize the information
+ contained in this International Standard. A bibliography lists documents that were
+ referred to during the preparation of the standard.
+<p><!--para 5-->
+ The language clause (clause 6) is derived from ''The C Reference Manual''.
+<p><!--para 6-->
+ The library clause (clause 7) is based on the 1984 /usr/group Standard.
+<!--page 18 indent 0-->
+<!--page 19 indent 4-->
+
+<h1>Programming languages -- C</h1>
+ 
+ 
+ 
+
+<a name="1" href="#1"><h2>1. Scope</h2></a>
+<p><!--para 1-->
+ This International Standard specifies the form and establishes the interpretation of
+ programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
+<ul>
+<li>  the representation of C programs;
+<li>  the syntax and constraints of the C language;
+<li>  the semantic rules for interpreting C programs;
+<li>  the representation of input data to be processed by C programs;
+<li>  the representation of output data produced by C programs;
+<li>  the restrictions and limits imposed by a conforming implementation of C.
+</ul>
+<p><!--para 2-->
+ This International Standard does not specify
+<ul>
+<li>  the mechanism by which C programs are transformed for use by a data-processing
+ system;
+<li>  the mechanism by which C programs are invoked for use by a data-processing
+ system;
+<li>  the mechanism by which input data are transformed for use by a C program;
+<li>  the mechanism by which output data are transformed after being produced by a C
+ program;
+<li>  the size or complexity of a program and its data that will exceed the capacity of any
+ specific data-processing system or the capacity of a particular processor;
+<li>  all minimal requirements of a data-processing system that is capable of supporting a
+ conforming implementation.
+ 
+ 
+<!--page 20 indent 4-->
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note1">1)</a> This International Standard is designed to promote the portability of C programs among a variety of
+ data-processing systems. It is intended for use by implementors and programmers.
+
+
+<a name="2" href="#2"><h2>2. Normative references</h2></a>
+<p><!--para 1-->
+ The following referenced documents are indispensable for the application of this
+ document. For dated references, only the edition cited applies. For undated references,
+ the latest edition of the referenced document (including any amendments) applies.
+<p><!--para 2-->
+ ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and symbols for
+ use in the physical sciences and technology.
+<p><!--para 3-->
+ ISO/IEC 646, Information technology -- ISO 7-bit coded character set for information
+ interchange.
+<p><!--para 4-->
+ ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1: Fundamental
+ terms.
+<p><!--para 5-->
+ ISO 4217, Codes for the representation of currencies and funds.
+<p><!--para 6-->
+ ISO 8601, Data elements and interchange formats -- Information interchange --
+ Representation of dates and times.
+<p><!--para 7-->
+ ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
+ Character Set (UCS).
+<p><!--para 8-->
+ IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously
+ designated IEC 559:1989).
+<!--page 21 indent 4-->
+
+<a name="3" href="#3"><h2>3. Terms, definitions, and symbols</h2></a>
+<p><!--para 1-->
+ For the purposes of this International Standard, the following definitions apply. Other
+ terms are defined where they appear in italic type or on the left side of a syntax rule.
+ Terms explicitly defined in this International Standard are not to be presumed to refer
+ implicitly to similar terms defined elsewhere. Terms not defined in this International
+ Standard are to be interpreted according to ISO/IEC 2382-1. Mathematical symbols not
+ defined in this International Standard are to be interpreted according to ISO 31-11.
+
+<a name="3.1" href="#3.1"><h3>3.1</h3></a>
+<p><!--para 1-->
+ access
+ &lt;execution-time action&gt; to read or modify the value of an object
+<p><!--para 2-->
+ NOTE 1   Where only one of these two actions is meant, ''read'' or ''modify'' is used.
+ 
+<p><!--para 3-->
+ NOTE 2   ''Modify'' includes the case where the new value being stored is the same as the previous value.
+ 
+<p><!--para 4-->
+ NOTE 3   Expressions that are not evaluated do not access objects.
+ 
+
+<a name="3.2" href="#3.2"><h3>3.2</h3></a>
+<p><!--para 1-->
+ alignment
+ requirement that objects of a particular type be located on storage boundaries with
+ addresses that are particular multiples of a byte address
+
+<a name="3.3" href="#3.3"><h3>3.3</h3></a>
+<p><!--para 1-->
+ argument
+ actual argument
+ actual parameter (deprecated)
+ expression in the comma-separated list bounded by the parentheses in a function call
+ expression, or a sequence of preprocessing tokens in the comma-separated list bounded
+ by the parentheses in a function-like macro invocation
+
+<a name="3.4" href="#3.4"><h3>3.4</h3></a>
+<p><!--para 1-->
+ behavior
+ external appearance or action
+
+<a name="3.4.1" href="#3.4.1"><h4>3.4.1</h4></a>
+<p><!--para 1-->
+ implementation-defined behavior
+ unspecified behavior where each implementation documents how the choice is made
+<p><!--para 2-->
+ EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
+ when a signed integer is shifted right.
+ 
+
+<a name="3.4.2" href="#3.4.2"><h4>3.4.2</h4></a>
+<p><!--para 1-->
+ locale-specific behavior
+ behavior that depends on local conventions of nationality, culture, and language that each
+ implementation documents
+<!--page 22 indent 4-->
+<p><!--para 2-->
+ EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
+ characters other than the 26 lowercase Latin letters.
+ 
+
+<a name="3.4.3" href="#3.4.3"><h4>3.4.3</h4></a>
+<p><!--para 1-->
+ undefined behavior
+ behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
+ for which this International Standard imposes no requirements
+<p><!--para 2-->
+ NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
+ results, to behaving during translation or program execution in a documented manner characteristic of the
+ environment (with or without the issuance of a diagnostic message), to terminating a translation or
+ execution (with the issuance of a diagnostic message).
+ 
+<p><!--para 3-->
+ EXAMPLE        An example of undefined behavior is the behavior on integer overflow.
+ 
+
+<a name="3.4.4" href="#3.4.4"><h4>3.4.4</h4></a>
+<p><!--para 1-->
+ unspecified behavior
+ use of an unspecified value, or other behavior where this International Standard provides
+ two or more possibilities and imposes no further requirements on which is chosen in any
+ instance
+<p><!--para 2-->
+ EXAMPLE        An example of unspecified behavior is the order in which the arguments to a function are
+ evaluated.
+ 
+
+<a name="3.5" href="#3.5"><h3>3.5</h3></a>
+<p><!--para 1-->
+ bit
+ unit of data storage in the execution environment large enough to hold an object that may
+ have one of two values
+<p><!--para 2-->
+ NOTE     It need not be possible to express the address of each individual bit of an object.
+ 
+
+<a name="3.6" href="#3.6"><h3>3.6</h3></a>
+<p><!--para 1-->
+ byte
+ addressable unit of data storage large enough to hold any member of the basic character
+ set of the execution environment
+<p><!--para 2-->
+ NOTE 1     It is possible to express the address of each individual byte of an object uniquely.
+ 
+<p><!--para 3-->
+ NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
+ defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
+ bit.
+ 
+
+<a name="3.7" href="#3.7"><h3>3.7</h3></a>
+<p><!--para 1-->
+ character
+ &lt;abstract&gt; member of a set of elements used for the organization, control, or
+ representation of data
+
+<a name="3.7.1" href="#3.7.1"><h4>3.7.1</h4></a>
+<p><!--para 1-->
+ character
+ single-byte character
+ &lt;C&gt; bit representation that fits in a byte
+<!--page 23 indent 4-->
+
+<a name="3.7.2" href="#3.7.2"><h4>3.7.2</h4></a>
+<p><!--para 1-->
+ multibyte character
+ sequence of one or more bytes representing a member of the extended character set of
+ either the source or the execution environment
+<p><!--para 2-->
+ NOTE    The extended character set is a superset of the basic character set.
+ 
+
+<a name="3.7.3" href="#3.7.3"><h4>3.7.3</h4></a>
+<p><!--para 1-->
+ wide character
+ bit representation that fits in an object of type wchar_t, capable of representing any
+ character in the current locale
+
+<a name="3.8" href="#3.8"><h3>3.8</h3></a>
+<p><!--para 1-->
+ constraint
+ restriction, either syntactic or semantic, by which the exposition of language elements is
+ to be interpreted
+
+<a name="3.9" href="#3.9"><h3>3.9</h3></a>
+<p><!--para 1-->
+ correctly rounded result
+ representation in the result format that is nearest in value, subject to the current rounding
+ mode, to what the result would be given unlimited range and precision
+
+<a name="3.10" href="#3.10"><h3>3.10</h3></a>
+<p><!--para 1-->
+ diagnostic message
+ message belonging to an implementation-defined subset of the implementation's message
+ output
+
+<a name="3.11" href="#3.11"><h3>3.11</h3></a>
+<p><!--para 1-->
+ forward reference
+ reference to a later subclause of this International Standard that contains additional
+ information relevant to this subclause
+
+<a name="3.12" href="#3.12"><h3>3.12</h3></a>
+<p><!--para 1-->
+ implementation
+ particular set of software, running in a particular translation environment under particular
+ control options, that performs translation of programs for, and supports execution of
+ functions in, a particular execution environment
+
+<a name="3.13" href="#3.13"><h3>3.13</h3></a>
+<p><!--para 1-->
+ implementation limit
+ restriction imposed upon programs by the implementation
+
+<a name="3.14" href="#3.14"><h3>3.14</h3></a>
+<p><!--para 1-->
+ memory location
+ either an object of scalar type, or a maximal sequence of adjacent bit-fields all having
+ nonzero width
+<!--page 24 indent 4-->
+<p><!--para 2-->
+ NOTE 1 Two threads of execution can update and access separate memory locations without interfering
+ with each other.
+ 
+<p><!--para 3-->
+ NOTE 2 A bit-field and an adjacent non-bit-field member are in separate memory locations. The same
+ applies to two bit-fields, if one is declared inside a nested structure declaration and the other is not, or if the
+ two are separated by a zero-length bit-field declaration, or if they are separated by a non-bit-field member
+ declaration. It is not safe to concurrently update two non-atomic bit-fields in the same structure if all
+ members declared between them are also (non-zero-length) bit-fields, no matter what the sizes of those
+ intervening bit-fields happen to be.
+ 
+<p><!--para 4-->
+ EXAMPLE        A structure declared as
+<pre>
+          struct {
+                char a;
+                int b:5, c:11, :0, d:8;
+                struct { int ee:8; } e;
+          }</pre>
+ contains four separate memory locations: The member a, and bit-fields d and e.ee are each separate
+ memory locations, and can be modified concurrently without interfering with each other. The bit-fields b
+ and c together constitute the fourth memory location. The bit-fields b and c cannot be concurrently
+ modified, but b and a, for example, can be.
+ 
+
+<a name="3.15" href="#3.15"><h3>3.15</h3></a>
+<p><!--para 1-->
+ object
+ region of data storage in the execution environment, the contents of which can represent
+ values
+<p><!--para 2-->
+ NOTE      When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
+ 
+
+<a name="3.16" href="#3.16"><h3>3.16</h3></a>
+<p><!--para 1-->
+ parameter
+ formal parameter
+ formal argument (deprecated)
+ object declared as part of a function declaration or definition that acquires a value on
+ entry to the function, or an identifier from the comma-separated list bounded by the
+ parentheses immediately following the macro name in a function-like macro definition
+
+<a name="3.17" href="#3.17"><h3>3.17</h3></a>
+<p><!--para 1-->
+ recommended practice
+ specification that is strongly recommended as being in keeping with the intent of the
+ standard, but that may be impractical for some implementations
+
+<a name="3.18" href="#3.18"><h3>3.18</h3></a>
+<p><!--para 1-->
+ runtime-constraint
+ requirement on a program when calling a library function
+<p><!--para 2-->
+ NOTE 1 Despite the similar terms, a runtime-constraint is not a kind of constraint as defined by <a href="#3.8">3.8</a>, and
+ need not be diagnosed at translation time.
+ 
+<p><!--para 3-->
+ NOTE 2 Implementations that support the extensions in <a href="#K">annex K</a> are required to verify that the runtime-
+ constraints for a library function are not violated by the program; see <a href="#K.3.1.4">K.3.1.4</a>.
+<!--page 25 indent 4-->
+
+<a name="3.19" href="#3.19"><h3>3.19</h3></a>
+<p><!--para 1-->
+ value
+ precise meaning of the contents of an object when interpreted as having a specific type
+
+<a name="3.19.1" href="#3.19.1"><h4>3.19.1</h4></a>
+<p><!--para 1-->
+ implementation-defined value
+ unspecified value where each implementation documents how the choice is made
+
+<a name="3.19.2" href="#3.19.2"><h4>3.19.2</h4></a>
+<p><!--para 1-->
+ indeterminate value
+ either an unspecified value or a trap representation
+
+<a name="3.19.3" href="#3.19.3"><h4>3.19.3</h4></a>
+<p><!--para 1-->
+ unspecified value
+ valid value of the relevant type where this International Standard imposes no
+ requirements on which value is chosen in any instance
+<p><!--para 2-->
+ NOTE     An unspecified value cannot be a trap representation.
+ 
+
+<a name="3.19.4" href="#3.19.4"><h4>3.19.4</h4></a>
+<p><!--para 1-->
+ trap representation
+ an object representation that need not represent a value of the object type
+
+<a name="3.19.5" href="#3.19.5"><h4>3.19.5</h4></a>
+<p><!--para 1-->
+ perform a trap
+ interrupt execution of the program such that no further operations are performed
+<p><!--para 2-->
+ NOTE In this International Standard, when the word ''trap'' is not immediately followed by
+ ''representation'', this is the intended usage.<sup><a href="#note2"><b>2)</b></a></sup>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note2">2)</a> For example, ''Trapping or stopping (if supported) is disabled...'' (<a href="#F.8.2">F.8.2</a>). Note that fetching a trap
+ representation might perform a trap but is not required to (see <a href="#6.2.6.1">6.2.6.1</a>).
+
+
+<a name="3.20" href="#3.20"><h3>3.20</h3></a>
+<p><!--para 1-->
+ [^ x^]
+ ceiling of x: the least integer greater than or equal to x
+<p><!--para 2-->
+ EXAMPLE       [^2.4^] is 3, [^-2.4^] is -2.
+ 
+
+<a name="3.21" href="#3.21"><h3>3.21</h3></a>
+<p><!--para 1-->
+ [_ x_]
+ floor of x: the greatest integer less than or equal to x
+<p><!--para 2-->
+ EXAMPLE       [_2.4_] is 2, [_-2.4_] is -3.
+ 
+ 
+ 
+ 
+<!--page 26 indent 4-->
+
+<a name="4" href="#4"><h2>4. Conformance</h2></a>
+<p><!--para 1-->
+ In this International Standard, ''shall'' is to be interpreted as a requirement on an
+ implementation or on a program; conversely, ''shall not'' is to be interpreted as a
+ prohibition.
+<p><!--para 2-->
+ If a ''shall'' or ''shall not'' requirement that appears outside of a constraint or runtime-
+ constraint is violated, the behavior is undefined. Undefined behavior is otherwise
+ indicated in this International Standard by the words ''undefined behavior'' or by the
+ omission of any explicit definition of behavior. There is no difference in emphasis among
+ these three; they all describe ''behavior that is undefined''.
+<p><!--para 3-->
+ A program that is correct in all other aspects, operating on correct data, containing
+ unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
+<p><!--para 4-->
+ The implementation shall not successfully translate a preprocessing translation unit
+ containing a #error preprocessing directive unless it is part of a group skipped by
+ conditional inclusion.
+<p><!--para 5-->
+ A strictly conforming program shall use only those features of the language and library
+ specified in this International Standard.<sup><a href="#note3"><b>3)</b></a></sup> It shall not produce output dependent on any
+ unspecified, undefined, or implementation-defined behavior, and shall not exceed any
+ minimum implementation limit.
+<p><!--para 6-->
+ The two forms of conforming implementation are hosted and freestanding. A conforming
+ hosted implementation shall accept any strictly conforming program. A conforming
+ freestanding implementation shall accept any strictly conforming program that does not
+ use complex types and in which the use of the features specified in the library clause
+ (clause 7) is confined to the contents of the standard headers &lt;float.h&gt;,
+ &lt;iso646.h&gt;, &lt;limits.h&gt;, &lt;stdalign.h&gt;, &lt;stdarg.h&gt;, &lt;stdbool.h&gt;,
+ &lt;stddef.h&gt;, and &lt;stdint.h&gt;. A conforming implementation may have extensions
+ (including additional library functions), provided they do not alter the behavior of any
+ strictly conforming program.<sup><a href="#note4"><b>4)</b></a></sup>
+ 
+ 
+ 
+<!--page 27 indent 4-->
+<p><!--para 7-->
+ A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note5"><b>5)</b></a></sup>
+<p><!--para 8-->
+ An implementation shall be accompanied by a document that defines all implementation-
+ defined and locale-specific characteristics and all extensions.
+ Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
+ characteristics of floating types &lt;float.h&gt; (<a href="#7.7">7.7</a>), alternative spellings &lt;iso646.h&gt;
+ (<a href="#7.9">7.9</a>), sizes of integer types &lt;limits.h&gt; (<a href="#7.10">7.10</a>), alignment &lt;stdalign.h&gt; (<a href="#7.15">7.15</a>),
+ variable arguments &lt;stdarg.h&gt; (<a href="#7.16">7.16</a>), boolean type and values &lt;stdbool.h&gt;
+ (<a href="#7.18">7.18</a>), common definitions &lt;stddef.h&gt; (<a href="#7.19">7.19</a>), integer types &lt;stdint.h&gt; (<a href="#7.20">7.20</a>).
+ 
+ 
+ 
+ 
+<!--page 28 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note3">3)</a> A strictly conforming program can use conditional features (see <a href="#6.10.8.3">6.10.8.3</a>) provided the use is guarded
+ by an appropriate conditional inclusion preprocessing directive using the related macro. For example:
+
+<pre>
+         #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
             /* ... */
-            if ((c = f()) == -1)
-                    /* ... */
-    the int value returned by the function may be truncated when stored in the char, and then converted back
-    to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
-    values as unsigned char (and char is narrower than int), the result of the conversion cannot be
-    negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
-    variable c should be declared as int.
-
-5   EXAMPLE 2       In the fragment:
-            char c;
-            int i;
-            long l;
-            l = (c = i);
-    the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
-    of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
-    that is, long int type.
-
-6   EXAMPLE 3       Consider the fragment:
-            const char **cpp;
-            char *p;
-            const char c = 'A';
-            cpp = &amp;p;                  // constraint violation
-            *cpp = &amp;c;                 // valid
-            *p = 0;                    // valid
-    The first assignment is unsafe because it would allow the following valid code to attempt to change the
-    value of the const object c.
-
-<a name="6.5.16.2" href="#6.5.16.2"><b>    6.5.16.2 Compound assignment</b></a>
-<b>    Constraints</b>
-1   For the operators += and -= only, either the left operand shall be an atomic, qualified, or
-    unqualified pointer to a complete object type, and the right shall have integer type; or the
-    left operand shall have atomic, qualified, or unqualified arithmetic type, and the right
-    shall have arithmetic type.
-2   For the other operators, the left operand shall have atomic, qualified, or unqualified
-    arithmetic type, and (considering the type the left operand would have after lvalue
-    conversion) each operand shall have arithmetic type consistent with those allowed by the
-    corresponding binary operator.
-<b>    Semantics</b>
-3   A compound assignment of the form E1 op = E2 is equivalent to the simple assignment
-    expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once, and with
-    respect to an indeterminately-sequenced function call, the operation of a compound
-
-[<a name="p103" href="#p103">page 103</a>] (<a href="#Contents">Contents</a>)
-
-    assignment is a single evaluation. If E1 has an atomic type, compound assignment is a
-    read-modify-write operation with memory_order_seq_cst memory order
-    semantics.<sup><a href="#note113"><b>113)</b></a></sup>
-<a name="6.5.17" href="#6.5.17"><b>    6.5.17 Comma operator</b></a>
-<b>    Syntax</b>
-1            expression:
-                    assignment-expression
-                    expression , assignment-expression
-<b>    Semantics</b>
-2   The left operand of a comma operator is evaluated as a void expression; there is a
-    sequence point between its evaluation and that of the right operand. Then the right
-    operand is evaluated; the result has its type and value.<sup><a href="#note114"><b>114)</b></a></sup>                        *
-3   EXAMPLE As indicated by the syntax, the comma operator (as described in this subclause) cannot
-    appear in contexts where a comma is used to separate items in a list (such as arguments to functions or lists
-    of initializers). On the other hand, it can be used within a parenthesized expression or within the second
-    expression of a conditional operator in such contexts. In the function call
-             f(a, (t=3, t+2), c)
-    the function has three arguments, the second of which has the value 5.
-
-    Forward references: initialization (<a href="#6.7.9">6.7.9</a>).
-
-
-
-
-    <sup><a name="note113" href="#note113"><b>113)</b></a></sup> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
-         where T is the type of E1:
-                  T tmp = E1;
-                  T result;
-                  do {
-                        result = tmp op (E2);
-                  } while (!atomic_compare_exchange_strong(&amp;E1, &amp;tmp, result));
-          with result being the result of the operation.
-    <sup><a name="note114" href="#note114"><b>114)</b></a></sup> A comma operator does not yield an lvalue.
-
-[<a name="p104" href="#p104">page 104</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.6" href="#6.6"><b>    6.6 Constant expressions</b></a>
-<b>    Syntax</b>
-1            constant-expression:
-                    conditional-expression
-<b>    Description</b>
-2   A constant expression can be evaluated during translation rather than runtime, and
-    accordingly may be used in any place that a constant may be.
-<b>    Constraints</b>
-3   Constant expressions shall not contain assignment, increment, decrement, function-call,
-    or comma operators, except when they are contained within a subexpression that is not
-    evaluated.<sup><a href="#note115"><b>115)</b></a></sup>
-4   Each constant expression shall evaluate to a constant that is in the range of representable
-    values for its type.
-<b>    Semantics</b>
-5   An expression that evaluates to a constant is required in several contexts. If a floating
-    expression is evaluated in the translation environment, the arithmetic precision and range
-    shall be at least as great as if the expression were being evaluated in the execution
-    environment.<sup><a href="#note116"><b>116)</b></a></sup>
-6   An integer constant expression<sup><a href="#note117"><b>117)</b></a></sup> shall have integer type and shall only have operands
-    that are integer constants, enumeration constants, character constants, sizeof
-    expressions whose results are integer constants, and floating constants that are the
-    immediate operands of casts. Cast operators in an integer constant expression shall only
-    convert arithmetic types to integer types, except as part of an operand to the sizeof
-    operator.
-7   More latitude is permitted for constant expressions in initializers. Such a constant
-    expression shall be, or evaluate to, one of the following:
-    -- an arithmetic constant expression,
-
-
-
-    <sup><a name="note115" href="#note115"><b>115)</b></a></sup> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
-    <sup><a name="note116" href="#note116"><b>116)</b></a></sup> The use of evaluation formats as characterized by FLT_EVAL_METHOD also applies to evaluation in
-         the translation environment.
-    <sup><a name="note117" href="#note117"><b>117)</b></a></sup> An integer constant expression is required in a number of contexts such as the size of a bit-field
-         member of a structure, the value of an enumeration constant, and the size of a non-variable length
-         array. Further constraints that apply to the integer constant expressions used in conditional-inclusion
-         preprocessing directives are discussed in <a href="#6.10.1">6.10.1</a>.
-
-[<a name="p105" href="#p105">page 105</a>] (<a href="#Contents">Contents</a>)
-
-     -- a null pointer constant,
-     -- an address constant, or
-     -- an address constant for a complete object type plus or minus an integer constant
-       expression.
-8    An arithmetic constant expression shall have arithmetic type and shall only have
-     operands that are integer constants, floating constants, enumeration constants, character
-     constants, and sizeof expressions. Cast operators in an arithmetic constant expression
-     shall only convert arithmetic types to arithmetic types, except as part of an operand to a
-     sizeof operator whose result is an integer constant.
-9    An address constant is a null pointer, a pointer to an lvalue designating an object of static
-     storage duration, or a pointer to a function designator; it shall be created explicitly using
-     the unary &amp; operator or an integer constant cast to pointer type, or implicitly by the use of
-     an expression of array or function type. The array-subscript [] and member-access .
-     and -&gt; operators, the address &amp; and indirection * unary operators, and pointer casts may
-     be used in the creation of an address constant, but the value of an object shall not be
-     accessed by use of these operators.
-10   An implementation may accept other forms of constant expressions.
-11   The semantic rules for the evaluation of a constant expression are the same as for
-     nonconstant expressions.<sup><a href="#note118"><b>118)</b></a></sup>
-     Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), initialization (<a href="#6.7.9">6.7.9</a>).
-
-
-
-
-     <sup><a name="note118" href="#note118"><b>118)</b></a></sup> Thus, in the following initialization,
-                    static int i = 2 || 1 / 0;
-           the expression is a valid integer constant expression with value one.
-
-[<a name="p106" href="#p106">page 106</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7" href="#6.7"><b>    6.7 Declarations</b></a>
-<b>    Syntax</b>
-1            declaration:
-                    declaration-specifiers init-declarator-listopt ;
-                    static_assert-declaration
-             declaration-specifiers:
-                    storage-class-specifier declaration-specifiersopt
-                    type-specifier declaration-specifiersopt
-                    type-qualifier declaration-specifiersopt
-                    function-specifier declaration-specifiersopt
-                    alignment-specifier declaration-specifiersopt
-             init-declarator-list:
-                     init-declarator
-                     init-declarator-list , init-declarator
-             init-declarator:
-                     declarator
-                     declarator = initializer
-<b>    Constraints</b>
-2   A declaration other than a static_assert declaration shall declare at least a declarator
-    (other than the parameters of a function or the members of a structure or union), a tag, or
-    the members of an enumeration.
-3   If an identifier has no linkage, there shall be no more than one declaration of the identifier
-    (in a declarator or type specifier) with the same scope and in the same name space, except
-    that a typedef name can be redefined to denote the same type as it currently does and tags
-    may be redeclared as specified in <a href="#6.7.2.3">6.7.2.3</a>.
-4   All declarations in the same scope that refer to the same object or function shall specify
-    compatible types.
-<b>    Semantics</b>
-5   A declaration specifies the interpretation and attributes of a set of identifiers. A definition
-    of an identifier is a declaration for that identifier that:
-    -- for an object, causes storage to be reserved for that object;
-    -- for a function, includes the function body;<sup><a href="#note119"><b>119)</b></a></sup>
-
-
-
-    <sup><a name="note119" href="#note119"><b>119)</b></a></sup> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
-
-[<a name="p107" href="#p107">page 107</a>] (<a href="#Contents">Contents</a>)
-
-    -- for an enumeration constant or typedef name, is the (only) declaration of the
-      identifier.
-6   The declaration specifiers consist of a sequence of specifiers that indicate the linkage,
-    storage duration, and part of the type of the entities that the declarators denote. The init-
-    declarator-list is a comma-separated sequence of declarators, each of which may have
-    additional type information, or an initializer, or both. The declarators contain the
-    identifiers (if any) being declared.
-7   If an identifier for an object is declared with no linkage, the type for the object shall be
-    complete by the end of its declarator, or by the end of its init-declarator if it has an
-    initializer; in the case of function parameters (including in prototypes), it is the adjusted
-    type (see <a href="#6.7.6.3">6.7.6.3</a>) that is required to be complete.
-    Forward references: declarators (<a href="#6.7.6">6.7.6</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
-    (<a href="#6.7.9">6.7.9</a>), type names (<a href="#6.7.7">6.7.7</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>).
-<a name="6.7.1" href="#6.7.1"><b>    6.7.1 Storage-class specifiers</b></a>
-<b>    Syntax</b>
-1            storage-class-specifier:
-                    typedef
-                    extern
-                    static
-                    _Thread_local
-                    auto
-                    register
-<b>    Constraints</b>
-2   At most, one storage-class specifier may be given in the declaration specifiers in a
-    declaration, except that _Thread_local may appear with static or extern.<sup><a href="#note120"><b>120)</b></a></sup>
-3   In the declaration of an object with block scope, if the declaration specifiers include
-    _Thread_local, they shall also include either static or extern. If
-    _Thread_local appears in any declaration of an object, it shall be present in every
-    declaration of that object.
-<b>    Semantics</b>
-4   The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
-    only; it is discussed in <a href="#6.7.8">6.7.8</a>. The meanings of the various linkages and storage durations
-    were discussed in <a href="#6.2.2">6.2.2</a> and <a href="#6.2.4">6.2.4</a>.
-
-
-
-    <sup><a name="note120" href="#note120"><b>120)</b></a></sup> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
-
-[<a name="p108" href="#p108">page 108</a>] (<a href="#Contents">Contents</a>)
-
-5   A declaration of an identifier for an object with storage-class specifier register
-    suggests that access to the object be as fast as possible. The extent to which such
-    suggestions are effective is implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
-6   The declaration of an identifier for a function that has block scope shall have no explicit
-    storage-class specifier other than extern.
-7   If an aggregate or union object is declared with a storage-class specifier other than
-    typedef, the properties resulting from the storage-class specifier, except with respect to
-    linkage, also apply to the members of the object, and so on recursively for any aggregate
-    or union member objects.
-    Forward references: type definitions (<a href="#6.7.8">6.7.8</a>).
-<a name="6.7.2" href="#6.7.2"><b>    6.7.2 Type specifiers</b></a>
-<b>    Syntax</b>
-1            type-specifier:
-                    void
-                    char
-                    short
-                    int
-                    long
-                    float
-                    double
-                    signed
-                    unsigned
-                    _Bool
-                    _Complex
-                    atomic-type-specifier
-                    struct-or-union-specifier
-                    enum-specifier
-                    typedef-name
-<b>    Constraints</b>
-2   At least one type specifier shall be given in the declaration specifiers in each declaration,
-    and in the specifier-qualifier list in each struct declaration and type name. Each list of
-
-
-    <sup><a name="note121" href="#note121"><b>121)</b></a></sup> The implementation may treat any register declaration simply as an auto declaration. However,
-         whether or not addressable storage is actually used, the address of any part of an object declared with
-         storage-class specifier register cannot be computed, either explicitly (by use of the unary &amp;
-         operator as discussed in <a href="#6.5.3.2">6.5.3.2</a>) or implicitly (by converting an array name to a pointer as discussed in
-         <a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operator that can be applied to an array declared with storage-class specifier
-         register is sizeof.
-
-[<a name="p109" href="#p109">page 109</a>] (<a href="#Contents">Contents</a>)
-
-    type specifiers shall be one of the following multisets (delimited by commas, when there
-    is more than one multiset per item); the type specifiers may occur in any order, possibly
-    intermixed with the other declaration specifiers.
-    -- void
-    -- char
-    -- signed char
-    -- unsigned char
-    -- short, signed short, short int, or signed short int
-    -- unsigned short, or unsigned short int
-    -- int, signed, or signed int
-    -- unsigned, or unsigned int
-    -- long, signed long, long int, or signed long int
-    -- unsigned long, or unsigned long int
-    -- long long, signed long long, long long int, or
-      signed long long int
-    -- unsigned long long, or unsigned long long int
-    -- float
-    -- double
-    -- long double
-    -- _Bool
-    -- float _Complex
-    -- double _Complex
-    -- long double _Complex
-    -- atomic type specifier
-    -- struct or union specifier
-    -- enum specifier
-    -- typedef name
-3   The type specifier _Complex shall not be used if the implementation does not support
-    complex types (see <a href="#6.10.8.3">6.10.8.3</a>).
-
-[<a name="p110" href="#p110">page 110</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Semantics</b>
-4   Specifiers for structures, unions, enumerations, and atomic types are discussed in <a href="#6.7.2.1">6.7.2.1</a>
-    through <a href="#6.7.2.4">6.7.2.4</a>. Declarations of typedef names are discussed in <a href="#6.7.8">6.7.8</a>. The
-    characteristics of the other types are discussed in <a href="#6.2.5">6.2.5</a>.
-5   Each of the comma-separated multisets designates the same type, except that for bit-
-    fields, it is implementation-defined whether the specifier int designates the same type as
-    signed int or the same type as unsigned int.
-    Forward references: atomic type specifiers (<a href="#6.7.2.4">6.7.2.4</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>),
-    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
-<a name="6.7.2.1" href="#6.7.2.1"><b>    6.7.2.1 Structure and union specifiers</b></a>
-<b>    Syntax</b>
-1            struct-or-union-specifier:
-                     struct-or-union identifieropt { struct-declaration-list }
-                     struct-or-union identifier
-             struct-or-union:
-                     struct
-                     union
-             struct-declaration-list:
-                     struct-declaration
-                     struct-declaration-list struct-declaration
-             struct-declaration:
-                     specifier-qualifier-list struct-declarator-listopt ;
-                     static_assert-declaration
-             specifier-qualifier-list:
-                    type-specifier specifier-qualifier-listopt
-                    type-qualifier specifier-qualifier-listopt
-             struct-declarator-list:
-                     struct-declarator
-                     struct-declarator-list , struct-declarator
-             struct-declarator:
-                     declarator
-                     declaratoropt : constant-expression
-<b>    Constraints</b>
-2   A struct-declaration that does not declare an anonymous structure or anonymous union
-    shall contain a struct-declarator-list.
-
-[<a name="p111" href="#p111">page 111</a>] (<a href="#Contents">Contents</a>)
-
-3    A structure or union shall not contain a member with incomplete or function type (hence,
-     a structure shall not contain an instance of itself, but may contain a pointer to an instance
-     of itself), except that the last member of a structure with more than one named member
-     may have incomplete array type; such a structure (and any union containing, possibly
-     recursively, a member that is such a structure) shall not be a member of a structure or an
-     element of an array.
-4    The expression that specifies the width of a bit-field shall be an integer constant
-     expression with a nonnegative value that does not exceed the width of an object of the
-     type that would be specified were the colon and expression omitted.<sup><a href="#note122"><b>122)</b></a></sup> If the value is
-     zero, the declaration shall have no declarator.
-5    A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
-     int, unsigned int, or some other implementation-defined type. It is
-     implementation-defined whether atomic types are permitted.
-<b>     Semantics</b>
-6    As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
-     storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
-     of members whose storage overlap.
-7    Structure and union specifiers have the same form. The keywords struct and union
-     indicate that the type being specified is, respectively, a structure type or a union type.
-8    The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
-     within a translation unit. The struct-declaration-list is a sequence of declarations for the
-     members of the structure or union. If the struct-declaration-list contains no named
-     members, no anonymous structures, and no anonymous unions, the behavior is undefined.
-     The type is incomplete until immediately after the } that terminates the list, and complete
-     thereafter.
-9    A member of a structure or union may have any complete object type other than a
-     variably modified type.<sup><a href="#note123"><b>123)</b></a></sup> In addition, a member may be declared to consist of a
-     specified number of bits (including a sign bit, if any). Such a member is called a
-     bit-field;<sup><a href="#note124"><b>124)</b></a></sup> its width is preceded by a colon.
-10   A bit-field is interpreted as having a signed or unsigned integer type consisting of the
-     specified number of bits.<sup><a href="#note125"><b>125)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of
-
-     <sup><a name="note122" href="#note122"><b>122)</b></a></sup> While the number of bits in a _Bool object is at least CHAR_BIT, the width (number of sign and
-          value bits) of a _Bool may be just 1 bit.
-     <sup><a name="note123" href="#note123"><b>123)</b></a></sup> A structure or union cannot contain a member with a variably modified type because member names
-          are not ordinary identifiers as defined in <a href="#6.2.3">6.2.3</a>.
-     <sup><a name="note124" href="#note124"><b>124)</b></a></sup> The unary &amp; (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
-          or arrays of bit-field objects.
-
-[<a name="p112" href="#p112">page 112</a>] (<a href="#Contents">Contents</a>)
-
-     type _Bool, the value of the bit-field shall compare equal to the value stored; a _Bool
-     bit-field has the semantics of a _Bool.
-11   An implementation may allocate any addressable storage unit large enough to hold a bit-
-     field. If enough space remains, a bit-field that immediately follows another bit-field in a
-     structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
-     whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is
-     implementation-defined. The order of allocation of bit-fields within a unit (high-order to
-     low-order or low-order to high-order) is implementation-defined. The alignment of the
-     addressable storage unit is unspecified.
-12   A bit-field declaration with no declarator, but only a colon and a width, indicates an
-     unnamed bit-field.<sup><a href="#note126"><b>126)</b></a></sup> As a special case, a bit-field structure member with a width of 0
-     indicates that no further bit-field is to be packed into the unit in which the previous bit-
-     field, if any, was placed.
-13   An unnamed member of structure type with no tag is called an anonymous structure; an
-     unnamed member of union type with no tag is called an anonymous union. The members
-     of an anonymous structure or union are considered to be members of the containing
-     structure or union. This applies recursively if the containing structure or union is also
-     anonymous.
-14   Each non-bit-field member of a structure or union object is aligned in an implementation-
-     defined manner appropriate to its type.
-15   Within a structure object, the non-bit-field members and the units in which bit-fields
-     reside have addresses that increase in the order in which they are declared. A pointer to a
-     structure object, suitably converted, points to its initial member (or if that member is a
-     bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
-     padding within a structure object, but not at its beginning.
-16   The size of a union is sufficient to contain the largest of its members. The value of at
-     most one of the members can be stored in a union object at any time. A pointer to a
-     union object, suitably converted, points to each of its members (or if a member is a bit-
-     field, then to the unit in which it resides), and vice versa.
-17   There may be unnamed padding at the end of a structure or union.
-18   As a special case, the last element of a structure with more than one named member may
-     have an incomplete array type; this is called a flexible array member. In most situations,
-
-
-     <sup><a name="note125" href="#note125"><b>125)</b></a></sup> As specified in <a href="#6.7.2">6.7.2</a> above, if the actual type specifier used is int or a typedef-name defined as int,
-          then it is implementation-defined whether the bit-field is signed or unsigned.
-     <sup><a name="note126" href="#note126"><b>126)</b></a></sup> An unnamed bit-field structure member is useful for padding to conform to externally imposed
-          layouts.
-
-[<a name="p113" href="#p113">page 113</a>] (<a href="#Contents">Contents</a>)
-
-     the flexible array member is ignored. In particular, the size of the structure is as if the
-     flexible array member were omitted except that it may have more trailing padding than
-     the omission would imply. However, when a . (or -&gt;) operator has a left operand that is
-     (a pointer to) a structure with a flexible array member and the right operand names that
-     member, it behaves as if that member were replaced with the longest array (with the same
-     element type) that would not make the structure larger than the object being accessed; the
-     offset of the array shall remain that of the flexible array member, even if this would differ
-     from that of the replacement array. If this array would have no elements, it behaves as if
-     it had one element but the behavior is undefined if any attempt is made to access that
-     element or to generate a pointer one past it.
-19   EXAMPLE 1       The following illustrates anonymous structures and unions:
-              struct v {
-                    union {      // anonymous union
-                           struct { int i, j; };    // anonymous structure
-                           struct { long k, l; } w;
-                    };
-                    int m;
-              } v1;
-              v1.i = 2;   // valid
-              v1.k = 3;   // invalid: inner structure is not anonymous
-              v1.w.k = 5; // valid
-
-20   EXAMPLE 2       After the declaration:
-              struct s { int n; double d[]; };
-     the structure struct s has a flexible array member d. A typical way to use this is:
-              int m = /* some value */;
-              struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));
-     and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
-     p had been declared as:
-              struct { int n; double d[m]; } *p;
-     (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
-     not be the same).
-21   Following the above declaration:
-              struct s t1 = { 0 };                         //   valid
-              struct s t2 = { 1, { <a href="#4.2">4.2</a> }};                 //   invalid
-              t1.n = 4;                                    //   valid
-              t1.d[0] = <a href="#4.2">4.2</a>;                               //   might be undefined behavior
-     The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
-     contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
-              sizeof (struct s) &gt;= offsetof(struct s, d) + sizeof (double)
-     in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
-     code.
-
-[<a name="p114" href="#p114">page 114</a>] (<a href="#Contents">Contents</a>)
-
-22   After the further declaration:
-              struct ss { int n; };
-     the expressions:
-              sizeof (struct s) &gt;= sizeof (struct ss)
-              sizeof (struct s) &gt;= offsetof(struct s, d)
-     are always equal to 1.
-23   If sizeof (double) is 8, then after the following code is executed:
-              struct s *s1;
-              struct s *s2;
-              s1 = malloc(sizeof (struct s) + 64);
-              s2 = malloc(sizeof (struct s) + 46);
-     and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
-     purposes, as if the identifiers had been declared as:
-              struct { int n; double d[8]; } *s1;
-              struct { int n; double d[5]; } *s2;
-24   Following the further successful assignments:
-              s1 = malloc(sizeof (struct s) + 10);
-              s2 = malloc(sizeof (struct s) + 6);
-     they then behave as if the declarations were:
-              struct { int n; double d[1]; } *s1, *s2;
-     and:
-              double *dp;
-              dp = &amp;(s1-&gt;d[0]);          //   valid
-              *dp = 42;                  //   valid
-              dp = &amp;(s2-&gt;d[0]);          //   valid
-              *dp = 42;                  //   undefined behavior
-25   The assignment:
-              *s1 = *s2;
-     only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
-     of the structure, they might be copied or simply overwritten with indeterminate values.
-
-     Forward references: declarators (<a href="#6.7.6">6.7.6</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>).
-
-[<a name="p115" href="#p115">page 115</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.2.2" href="#6.7.2.2"><b>    6.7.2.2 Enumeration specifiers</b></a>
-<b>    Syntax</b>
-1            enum-specifier:
-                   enum identifieropt { enumerator-list }
-                   enum identifieropt { enumerator-list , }
-                   enum identifier
-             enumerator-list:
-                   enumerator
-                   enumerator-list , enumerator
-             enumerator:
-                   enumeration-constant
-                   enumeration-constant = constant-expression
-<b>    Constraints</b>
-2   The expression that defines the value of an enumeration constant shall be an integer
-    constant expression that has a value representable as an int.
-<b>    Semantics</b>
-3   The identifiers in an enumerator list are declared as constants that have type int and
-    may appear wherever such are permitted.<sup><a href="#note127"><b>127)</b></a></sup> An enumerator with = defines its
-    enumeration constant as the value of the constant expression. If the first enumerator has
-    no =, the value of its enumeration constant is 0. Each subsequent enumerator with no =
-    defines its enumeration constant as the value of the constant expression obtained by
-    adding 1 to the value of the previous enumeration constant. (The use of enumerators with
-    = may produce enumeration constants with values that duplicate other values in the same
-    enumeration.) The enumerators of an enumeration are also known as its members.
-4   Each enumerated type shall be compatible with char, a signed integer type, or an
-    unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note128"><b>128)</b></a></sup> but shall be
-    capable of representing the values of all the members of the enumeration. The
-    enumerated type is incomplete until immediately after the } that terminates the list of
-    enumerator declarations, and complete thereafter.
-
-
-
-
-    <sup><a name="note127" href="#note127"><b>127)</b></a></sup> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
-         each other and from other identifiers declared in ordinary declarators.
-    <sup><a name="note128" href="#note128"><b>128)</b></a></sup> An implementation may delay the choice of which integer type until all enumeration constants have
-         been seen.
-
-[<a name="p116" href="#p116">page 116</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE       The following fragment:
-             enum hue { chartreuse, burgundy, claret=20, winedark };
-             enum hue col, *cp;
-             col = claret;
-             cp = &amp;col;
-             if (*cp != burgundy)
-                   /* ... */
-    makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
-    pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
-
-    Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
-<a name="6.7.2.3" href="#6.7.2.3"><b>    6.7.2.3 Tags</b></a>
-<b>    Constraints</b>
-1   A specific type shall have its content defined at most once.
-2   Where two declarations that use the same tag declare the same type, they shall both use
-    the same choice of struct, union, or enum.
-3   A type specifier of the form
-            enum identifier
-    without an enumerator list shall only appear after the type it specifies is complete.
-<b>    Semantics</b>
-4   All declarations of structure, union, or enumerated types that have the same scope and
-    use the same tag declare the same type. Irrespective of whether there is a tag or what
-    other declarations of the type are in the same translation unit, the type is incomplete<sup><a href="#note129"><b>129)</b></a></sup>
-    until immediately after the closing brace of the list defining the content, and complete
-    thereafter.
-5   Two declarations of structure, union, or enumerated types which are in different scopes or
-    use different tags declare distinct types. Each declaration of a structure, union, or
-    enumerated type which does not include a tag declares a distinct type.
-6   A type specifier of the form
-
-
-
-
-    <sup><a name="note129" href="#note129"><b>129)</b></a></sup> An incomplete type may only by used when the size of an object of that type is not needed. It is not
-         needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
-         when a pointer to or a function returning a structure or union is being declared. (See incomplete types
-         in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
-
-[<a name="p117" href="#p117">page 117</a>] (<a href="#Contents">Contents</a>)
-
-              struct-or-union identifieropt { struct-declaration-list }
-     or
-              enum identifieropt { enumerator-list }
-     or
-              enum identifieropt { enumerator-list , }
-     declares a structure, union, or enumerated type. The list defines the structure content,
-     union content, or enumeration content. If an identifier is provided,<sup><a href="#note130"><b>130)</b></a></sup> the type specifier
-     also declares the identifier to be the tag of that type.
-7    A declaration of the form
-              struct-or-union identifier ;
-     specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note131"><b>131)</b></a></sup>
-8    If a type specifier of the form
-              struct-or-union identifier
-     occurs other than as part of one of the above forms, and no other declaration of the
-     identifier as a tag is visible, then it declares an incomplete structure or union type, and
-     declares the identifier as the tag of that type.131)
-9    If a type specifier of the form
-              struct-or-union identifier
-     or
-              enum identifier
-     occurs other than as part of one of the above forms, and a declaration of the identifier as a
-     tag is visible, then it specifies the same type as that other declaration, and does not
-     redeclare the tag.
-10   EXAMPLE 1       This mechanism allows declaration of a self-referential structure.
-              struct tnode {
-                    int count;
-                    struct tnode *left, *right;
-              };
-     specifies a structure that contains an integer and two pointers to objects of the same type. Once this
-     declaration has been given, the declaration
-
-
-
-
-     <sup><a name="note130" href="#note130"><b>130)</b></a></sup> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
-          of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
-          can make use of that typedef name to declare objects having the specified structure, union, or
-          enumerated type.
-     <sup><a name="note131" href="#note131"><b>131)</b></a></sup> A similar construction with enum does not exist.
-
-[<a name="p118" href="#p118">page 118</a>] (<a href="#Contents">Contents</a>)
-
-              struct tnode s, *sp;
-     declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
-     these declarations, the expression sp-&gt;left refers to the left struct tnode pointer of the object to
-     which sp points; the expression s.right-&gt;count designates the count member of the right struct
-     tnode pointed to from s.
-11   The following alternative formulation uses the typedef mechanism:
-              typedef struct tnode TNODE;
-              struct tnode {
-                    int count;
-                    TNODE *left, *right;
-              };
-              TNODE s, *sp;
-
-12   EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
-     structures, the declarations
-              struct s1 { struct s2 *s2p; /* ... */ }; // D1
-              struct s2 { struct s1 *s1p; /* ... */ }; // D2
-     specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
-     declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
-     D2. To eliminate this context sensitivity, the declaration
-              struct s2;
-     may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
-     completes the specification of the new type.
-
-     Forward references: declarators (<a href="#6.7.6">6.7.6</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
-<a name="6.7.2.4" href="#6.7.2.4"><b>     6.7.2.4 Atomic type specifiers</b></a>
-<b>     Syntax</b>
-1             atomic-type-specifier:
-                     _Atomic ( type-name )
-<b>     Constraints</b>
-2    Atomic type specifiers shall not be used if the implementation does not support atomic
-     types (see <a href="#6.10.8.3">6.10.8.3</a>).
-3    The type name in an atomic type specifier shall not refer to an array type, a function type,
-     an atomic type, or a qualified type.
-<b>     Semantics</b>
-4    The properties associated with atomic types are meaningful only for expressions that are
-     lvalues. If the _Atomic keyword is immediately followed by a left parenthesis, it is
-     interpreted as a type specifier (with a type name), not as a type qualifier.
-
-[<a name="p119" href="#p119">page 119</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.3" href="#6.7.3"><b>    6.7.3 Type qualifiers</b></a>
-<b>    Syntax</b>
-1            type-qualifier:
-                    const
-                    restrict
-                    volatile
-                    _Atomic
-<b>    Constraints</b>
-2   Types other than pointer types whose referenced type is an object type shall not be
-    restrict-qualified.
-3   The type modified by the _Atomic qualifier shall not be an array type or a function
-    type.
-<b>    Semantics</b>
-4   The properties associated with qualified types are meaningful only for expressions that
-    are lvalues.<sup><a href="#note132"><b>132)</b></a></sup>
-5   If the same qualifier appears more than once in the same specifier-qualifier-list, either
-    directly or via one or more typedefs, the behavior is the same as if it appeared only
-    once. If other qualifiers appear along with the _Atomic qualifier in a specifier-qualifier-
-    list, the resulting type is the so-qualified atomic type.
-6   If an attempt is made to modify an object defined with a const-qualified type through use
-    of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
-    made to refer to an object defined with a volatile-qualified type through use of an lvalue
-    with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note133"><b>133)</b></a></sup>
-7   An object that has volatile-qualified type may be modified in ways unknown to the
-    implementation or have other unknown side effects. Therefore any expression referring
-    to such an object shall be evaluated strictly according to the rules of the abstract machine,
-    as described in <a href="#5.1.2.3">5.1.2.3</a>. Furthermore, at every sequence point the value last stored in the
-    object shall agree with that prescribed by the abstract machine, except as modified by the
-
-
-
-
-    <sup><a name="note132" href="#note132"><b>132)</b></a></sup> The implementation may place a const object that is not volatile in a read-only region of
-         storage. Moreover, the implementation need not allocate storage for such an object if its address is
-         never used.
-    <sup><a name="note133" href="#note133"><b>133)</b></a></sup> This applies to those objects that behave as if they were defined with qualified types, even if they are
-         never actually defined as objects in the program (such as an object at a memory-mapped input/output
-         address).
-
-[<a name="p120" href="#p120">page 120</a>] (<a href="#Contents">Contents</a>)
-
-     unknown factors mentioned previously.<sup><a href="#note134"><b>134)</b></a></sup> What constitutes an access to an object that
-     has volatile-qualified type is implementation-defined.
-8    An object that is accessed through a restrict-qualified pointer has a special association
-     with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
-     that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note135"><b>135)</b></a></sup> The intended
-     use of the restrict qualifier (like the register storage class) is to promote
-     optimization, and deleting all instances of the qualifier from all preprocessing translation
-     units composing a conforming program does not change its meaning (i.e., observable
-     behavior).
-9    If the specification of an array type includes any type qualifiers, the element type is so-
-     qualified, not the array type. If the specification of a function type includes any type
-     qualifiers, the behavior is undefined.<sup><a href="#note136"><b>136)</b></a></sup>
-10   For two qualified types to be compatible, both shall have the identically qualified version
-     of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
-     does not affect the specified type.
-11   EXAMPLE 1      An object declared
-              extern const volatile int real_time_clock;
-     may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
-
-12   EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
-     modify an aggregate type:
-              const struct s { int mem; } cs = { 1 };
-              struct s ncs; // the object ncs is modifiable
-              typedef int A[2][3];
-              const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
-              int *pi;
-              const int *pci;
-              ncs = cs;            //    valid
-              cs = ncs;            //    violates modifiable lvalue constraint for =
-              pi = &amp;ncs.mem;       //    valid
-              pi = &amp;cs.mem;        //    violates type constraints for =
-              pci = &amp;cs.mem;       //    valid
-              pi = a[0];           //    invalid: a[0] has type ''const int *''
-
-
-
-     <sup><a name="note134" href="#note134"><b>134)</b></a></sup> A volatile declaration may be used to describe an object corresponding to a memory-mapped
-          input/output port or an object accessed by an asynchronously interrupting function. Actions on
-          objects so declared shall not be ''optimized out'' by an implementation or reordered except as
-          permitted by the rules for evaluating expressions.
-     <sup><a name="note135" href="#note135"><b>135)</b></a></sup> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
-          association between the allocated object and the pointer.
-     <sup><a name="note136" href="#note136"><b>136)</b></a></sup> Both of these can occur through the use of typedefs.
-
-[<a name="p121" href="#p121">page 121</a>] (<a href="#Contents">Contents</a>)
-
-13   EXAMPLE 3       The declaration
-              _Atomic volatile int *p;
-     specifies that p has the type ''pointer to volatile atomic int'', a pointer to a volatile-qualified atomic type.
-
-<a name="6.7.3.1" href="#6.7.3.1"><b>     6.7.3.1 Formal definition of restrict</b></a>
-1    Let D be a declaration of an ordinary identifier that provides a means of designating an
-     object P as a restrict-qualified pointer to type T.
-2    If D appears inside a block and does not have storage class extern, let B denote the
-     block. If D appears in the list of parameter declarations of a function definition, let B
-     denote the associated block. Otherwise, let B denote the block of main (or the block of
-     whatever function is called at program startup in a freestanding environment).
-3    In what follows, a pointer expression E is said to be based on object P if (at some
-     sequence point in the execution of B prior to the evaluation of E) modifying P to point to
-     a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note137"><b>137)</b></a></sup>
-     Note that ''based'' is defined only for expressions with pointer types.
-4    During each execution of B, let L be any lvalue that has &amp;L based on P. If L is used to
-     access the value of the object X that it designates, and X is also modified (by any means),
-     then the following requirements apply: T shall not be const-qualified. Every other lvalue
-     used to access the value of X shall also have its address based on P. Every access that
-     modifies X shall be considered also to modify P, for the purposes of this subclause. If P
-     is assigned the value of a pointer expression E that is based on another restricted pointer
-     object P2, associated with block B2, then either the execution of B2 shall begin before
-     the execution of B, or the execution of B2 shall end prior to the assignment. If these
-     requirements are not met, then the behavior is undefined.
-5    Here an execution of B means that portion of the execution of the program that would
-     correspond to the lifetime of an object with scalar type and automatic storage duration
-     associated with B.
-6    A translator is free to ignore any or all aliasing implications of uses of restrict.
-7    EXAMPLE 1       The file scope declarations
-              int * restrict a;
-              int * restrict b;
-              extern int c[];
-     assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
-     program, then it is never accessed using either of the other two.
-
-
-     <sup><a name="note137" href="#note137"><b>137)</b></a></sup> In other words, E depends on the value of P itself rather than on the value of an object referenced
-          indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
-          expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
-          expressions *p and p[1] are not.
-
-[<a name="p122" href="#p122">page 122</a>] (<a href="#Contents">Contents</a>)
-
-8    EXAMPLE 2       The function parameter declarations in the following example
-             void f(int n, int * restrict p, int * restrict q)
-             {
-                   while (n-- &gt; 0)
-                         *p++ = *q++;
-             }
-     assert that, during each execution of the function, if an object is accessed through one of the pointer
-     parameters, then it is not also accessed through the other.
-9    The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
-     analysis of function f without examining any of the calls of f in the program. The cost is that the
-     programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
-     second call of f in g has undefined behavior because each of d[1] through d[49] is accessed through
-     both p and q.
-              void g(void)
-              {
-                    extern int d[100];
-                    f(50, d + 50, d); // valid
-                    f(50, d + 1, d); // undefined behavior
-              }
-
-10   EXAMPLE 3       The function parameter declarations
-             void h(int n, int * restrict p, int * restrict q, int * restrict r)
-             {
-                   int i;
-                   for (i = 0; i &lt; n; i++)
-                          p[i] = q[i] + r[i];
-             }
-     illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
-     are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
-     modified within function h.
-
-11   EXAMPLE 4 The rule limiting assignments between restricted pointers does not distinguish between a
-     function call and an equivalent nested block. With one exception, only ''outer-to-inner'' assignments
-     between restricted pointers declared in nested blocks have defined behavior.
-             {
-                      int * restrict p1;
-                      int * restrict q1;
-                      p1 = q1; // undefined behavior
-                      {
-                            int * restrict p2 = p1; // valid
-                            int * restrict q2 = q1; // valid
-                            p1 = q2;                // undefined behavior
-                            p2 = q2;                // undefined behavior
-                      }
-             }
-
-[<a name="p123" href="#p123">page 123</a>] (<a href="#Contents">Contents</a>)
-
-12   The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
-     precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
-     example, this permits new_vector to return a vector.
-              typedef struct { int n; float * restrict v; } vector;
-              vector new_vector(int n)
-              {
-                    vector t;
-                    t.n = n;
-                    t.v = malloc(n * sizeof (float));
-                    return t;
-              }
-
-<a name="6.7.4" href="#6.7.4"><b>     6.7.4 Function specifiers</b></a>
-<b>     Syntax</b>
-1             function-specifier:
-                     inline
-                     _Noreturn
-<b>     Constraints</b>
-2    Function specifiers shall be used only in the declaration of an identifier for a function.
-3    An inline definition of a function with external linkage shall not contain a definition of a
-     modifiable object with static or thread storage duration, and shall not contain a reference
-     to an identifier with internal linkage.
-4    In a hosted environment, no function specifier(s) shall appear in a declaration of main.
-<b>     Semantics</b>
-5    A function specifier may appear more than once; the behavior is the same as if it
-     appeared only once.
-6    A function declared with an inline function specifier is an inline function. Making a *
-     function an inline function suggests that calls to the function be as fast as possible.<sup><a href="#note138"><b>138)</b></a></sup>
-     The extent to which such suggestions are effective is implementation-defined.<sup><a href="#note139"><b>139)</b></a></sup>
-
-
-
-
-     <sup><a name="note138" href="#note138"><b>138)</b></a></sup> By using, for example, an alternative to the usual function call mechanism, such as ''inline
-          substitution''. Inline substitution is not textual substitution, nor does it create a new function.
-          Therefore, for example, the expansion of a macro used within the body of the function uses the
-          definition it had at the point the function body appears, and not where the function is called; and
-          identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
-          single address, regardless of the number of inline definitions that occur in addition to the external
-          definition.
-     <sup><a name="note139" href="#note139"><b>139)</b></a></sup> For example, an implementation might never perform inline substitution, or might only perform inline
-          substitutions to calls in the scope of an inline declaration.
-
-[<a name="p124" href="#p124">page 124</a>] (<a href="#Contents">Contents</a>)
-
-7    Any function with internal linkage can be an inline function. For a function with external
-     linkage, the following restrictions apply: If a function is declared with an inline
-     function specifier, then it shall also be defined in the same translation unit. If all of the
-     file scope declarations for a function in a translation unit include the inline function
-     specifier without extern, then the definition in that translation unit is an inline
-     definition. An inline definition does not provide an external definition for the function,
-     and does not forbid an external definition in another translation unit. An inline definition
-     provides an alternative to an external definition, which a translator may use to implement
-     any call to the function in the same translation unit. It is unspecified whether a call to the
-     function uses the inline definition or the external definition.<sup><a href="#note140"><b>140)</b></a></sup>
-8    A function declared with a _Noreturn function specifier shall not return to its caller.
-     Recommended practice
-9    The implementation should produce a diagnostic message for a function declared with a
-     _Noreturn function specifier that appears to be capable of returning to its caller.
-10   EXAMPLE 1 The declaration of an inline function with external linkage can result in either an external
-     definition, or a definition available for use only within the translation unit. A file scope declaration with
-     extern creates an external definition. The following example shows an entire translation unit.
-              inline double fahr(double t)
-              {
-                    return (9.0 * t) / 5.0 + 32.0;
-              }
-              inline double cels(double t)
-              {
-                    return (5.0 * (t - 32.0)) / 9.0;
-              }
-              extern double fahr(double);                  // creates an external definition
-              double convert(int is_fahr, double temp)
-              {
-                    /* A translator may perform inline substitutions */
-                    return is_fahr ? cels(temp) : fahr(temp);
-              }
-11   Note that the definition of fahr is an external definition because fahr is also declared with extern, but
-     the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
-     external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
-     definition are distinct and either may be used for the call.
-
-12   EXAMPLE 2
-
-
-
-
-     <sup><a name="note140" href="#note140"><b>140)</b></a></sup> Since an inline definition is distinct from the corresponding external definition and from any other
-          corresponding inline definitions in other translation units, all corresponding objects with static storage
-          duration are also distinct in each of the definitions.
-
-[<a name="p125" href="#p125">page 125</a>] (<a href="#Contents">Contents</a>)
-
-             _Noreturn void f () {
-                   abort(); // ok
-             }
-             _Noreturn void g (int i) { // causes undefined behavior if i &lt;= 0
-                   if (i &gt; 0) abort();
-             }
-
-    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
-<a name="6.7.5" href="#6.7.5"><b>    6.7.5 Alignment specifier</b></a>
-<b>    Syntax</b>
-1            alignment-specifier:
-                   _Alignas ( type-name )
-                   _Alignas ( constant-expression )
-<b>    Constraints</b>
-2   An alignment attribute shall not be specified in a declaration of a typedef, or a bit-field, or
-    a function, or a parameter, or an object declared with the register storage-class
-    specifier.
-3   The constant expression shall be an integer constant expression. It shall evaluate to a
-    valid fundamental alignment, or to a valid extended alignment supported by the
-    implementation in the context in which it appears, or to zero.
-4   The combined effect of all alignment attributes in a declaration shall not specify an
-    alignment that is less strict than the alignment that would otherwise be required for the
-    type of the object or member being declared.
-<b>    Semantics</b>
-5   The first form is equivalent to _Alignas(alignof(type-name)).
-6   The alignment requirement of the declared object or member is taken to be the specified
-    alignment. An alignment specification of zero has no effect.<sup><a href="#note141"><b>141)</b></a></sup> When multiple
-    alignment specifiers occur in a declaration, the effective alignment requirement is the
-    strictest specified alignment.
-7   If the definition of an object has an alignment specifier, any other declaration of that
-    object shall either specify equivalent alignment or have no alignment specifier. If the
-    definition of an object does not have an alignment specifier, any other declaration of that
-    object shall also have no alignment specifier. If declarations of an object in different
-    translation units have different alignment specifiers, the behavior is undefined.
-
-
-
-    <sup><a name="note141" href="#note141"><b>141)</b></a></sup> An alignment specification of zero also does not affect other alignment specifications in the same
-         declaration.
-
-[<a name="p126" href="#p126">page 126</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.6" href="#6.7.6"><b>    6.7.6 Declarators</b></a>
-<b>    Syntax</b>
-1            declarator:
-                    pointeropt direct-declarator
-             direct-declarator:
-                     identifier
-                     ( declarator )
-                     direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
-                     direct-declarator [ static type-qualifier-listopt assignment-expression ]
-                     direct-declarator [ type-qualifier-list static assignment-expression ]
-                     direct-declarator [ type-qualifier-listopt * ]
-                     direct-declarator ( parameter-type-list )
-                     direct-declarator ( identifier-listopt )
-             pointer:
-                    * type-qualifier-listopt
-                    * type-qualifier-listopt pointer
-             type-qualifier-list:
-                    type-qualifier
-                    type-qualifier-list type-qualifier
-             parameter-type-list:
-                   parameter-list
-                   parameter-list , ...
-             parameter-list:
-                   parameter-declaration
-                   parameter-list , parameter-declaration
-             parameter-declaration:
-                   declaration-specifiers declarator
-                   declaration-specifiers abstract-declaratoropt
-             identifier-list:
-                    identifier
-                    identifier-list , identifier
-<b>    Semantics</b>
-2   Each declarator declares one identifier, and asserts that when an operand of the same
-    form as the declarator appears in an expression, it designates a function or object with the
-    scope, storage duration, and type indicated by the declaration specifiers.
-3   A full declarator is a declarator that is not part of another declarator. The end of a full
-    declarator is a sequence point. If, in the nested sequence of declarators in a full
-
-[<a name="p127" href="#p127">page 127</a>] (<a href="#Contents">Contents</a>)
-
-    declarator, there is a declarator specifying a variable length array type, the type specified
-    by the full declarator is said to be variably modified. Furthermore, any type derived by
-    declarator type derivation from a variably modified type is itself variably modified.
-4   In the following subclauses, consider a declaration
-            T D1
-    where T contains the declaration specifiers that specify a type T (such as int) and D1 is
-    a declarator that contains an identifier ident. The type specified for the identifier ident in
-    the various forms of declarator is described inductively using this notation.
-5   If, in the declaration ''T D1'', D1 has the form
-            identifier
-    then the type specified for ident is T .
-6   If, in the declaration ''T D1'', D1 has the form
-            ( D )
-    then ident has the type specified by the declaration ''T D''. Thus, a declarator in
-    parentheses is identical to the unparenthesized declarator, but the binding of complicated
-    declarators may be altered by parentheses.
-    Implementation limits
-7   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
-    function declarators that modify an arithmetic, structure, union, or void type, either
-    directly or via one or more typedefs.
-    Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
-<a name="6.7.6.1" href="#6.7.6.1"><b>    6.7.6.1 Pointer declarators</b></a>
-<b>    Semantics</b>
-1   If, in the declaration ''T D1'', D1 has the form
-            * type-qualifier-listopt D
-    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
-    T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
-    pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
-2   For two pointer types to be compatible, both shall be identically qualified and both shall
-    be pointers to compatible types.
-3   EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
-    to a constant value'' and a ''constant pointer to a variable value''.
-
-[<a name="p128" href="#p128">page 128</a>] (<a href="#Contents">Contents</a>)
-
-             const int *ptr_to_constant;
-             int *const constant_ptr;
-    The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
-    but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
-    int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
-    same location.
-4   The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
-    type ''pointer to int''.
-             typedef int *int_ptr;
-             const int_ptr constant_ptr;
-    declares constant_ptr as an object that has type ''const-qualified pointer to int''.
-
-<a name="6.7.6.2" href="#6.7.6.2"><b>    6.7.6.2 Array declarators</b></a>
-<b>    Constraints</b>
-1   In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
-    an expression or *. If they delimit an expression (which specifies the size of an array), the
-    expression shall have an integer type. If the expression is a constant expression, it shall
-    have a value greater than zero. The element type shall not be an incomplete or function
-    type. The optional type qualifiers and the keyword static shall appear only in a
-    declaration of a function parameter with an array type, and then only in the outermost
-    array type derivation.
-2   If an identifier is declared as having a variably modified type, it shall be an ordinary
-    identifier (as defined in <a href="#6.2.3">6.2.3</a>), have no linkage, and have either block scope or function
-    prototype scope. If an identifier is declared to be an object with static or thread storage
-    duration, it shall not have a variable length array type.
-<b>    Semantics</b>
-3   If, in the declaration ''T D1'', D1 has one of the forms:
-             D[ type-qualifier-listopt assignment-expressionopt ]
-             D[ static type-qualifier-listopt assignment-expression ]
-             D[ type-qualifier-list static assignment-expression ]
-             D[ type-qualifier-listopt * ]
-    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
-    T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note142"><b>142)</b></a></sup>
-    (See <a href="#6.7.6.3">6.7.6.3</a> for the meaning of the optional type qualifiers and the keyword static.)
-4   If the size is not present, the array type is an incomplete type. If the size is * instead of
-    being an expression, the array type is a variable length array type of unspecified size,
-    which can only be used in declarations or type names with function prototype scope;<sup><a href="#note143"><b>143)</b></a></sup>
-
-    <sup><a name="note142" href="#note142"><b>142)</b></a></sup> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
-
-[<a name="p129" href="#p129">page 129</a>] (<a href="#Contents">Contents</a>)
-
-    such arrays are nonetheless complete types. If the size is an integer constant expression
-    and the element type has a known constant size, the array type is not a variable length
-    array type; otherwise, the array type is a variable length array type. (Variable length
-    arrays are a conditional feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.)
-5   If the size is an expression that is not an integer constant expression: if it occurs in a
-    declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
-    each time it is evaluated it shall have a value greater than zero. The size of each instance
-    of a variable length array type does not change during its lifetime. Where a size
-    expression is part of the operand of a sizeof operator and changing the value of the
-    size expression would not affect the result of the operator, it is unspecified whether or not
-    the size expression is evaluated.
-6   For two array types to be compatible, both shall have compatible element types, and if
-    both size specifiers are present, and are integer constant expressions, then both size
-    specifiers shall have the same constant value. If the two array types are used in a context
-    which requires them to be compatible, it is undefined behavior if the two size specifiers
-    evaluate to unequal values.
-7   EXAMPLE 1
-             float fa[11], *afp[17];
-    declares an array of float numbers and an array of pointers to float numbers.
-
-8   EXAMPLE 2       Note the distinction between the declarations
-             extern int *x;
-             extern int y[];
-    The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
-    (an incomplete type), the storage for which is defined elsewhere.
-
-9   EXAMPLE 3       The following declarations demonstrate the compatibility rules for variably modified types.
-             extern int n;
-             extern int m;
-             void fcompat(void)
-             {
-                   int a[n][6][m];
-                   int (*p)[4][n+1];
-                   int c[n][n][6][m];
-                   int (*r)[n][n][n+1];
-                   p = a;       // invalid: not compatible because 4 != 6
-                   r = c;       // compatible, but defined behavior only if
-                                // n == 6 and m == n+1
-             }
-
-
-
-
-    <sup><a name="note143" href="#note143"><b>143)</b></a></sup> Thus, * can be used only in function declarations that are not definitions (see <a href="#6.7.6.3">6.7.6.3</a>).
-
-[<a name="p130" href="#p130">page 130</a>] (<a href="#Contents">Contents</a>)
-
-10   EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
-     function prototype scope. Array objects declared with the _Thread_local, static, or extern
-     storage-class specifier cannot have a variable length array (VLA) type. However, an object declared with
-     the static storage-class specifier can have a VM type (that is, a pointer to a VLA type). Finally, all
-     identifiers declared with a VM type have to be ordinary identifiers and cannot, therefore, be members of
-     structures or unions.
-             extern int n;
-             int A[n];                                           // invalid: file scope VLA
-             extern int (*p2)[n];                                // invalid: file scope VM
-             int B[100];                                         // valid: file scope but not VM
-             void fvla(int m, int C[m][m]);                      // valid: VLA with prototype scope
-             void fvla(int m, int C[m][m])                       // valid: adjusted to auto pointer to VLA
-             {
-                   typedef int VLA[m][m];                        // valid: block scope typedef VLA
-                      struct tag {
-                            int (*y)[n];                         // invalid: y not ordinary identifier
-                            int z[n];                            // invalid: z not ordinary identifier
-                      };
-                      int D[m];                                  //   valid: auto VLA
-                      static int E[m];                           //   invalid: static block scope VLA
-                      extern int F[m];                           //   invalid: F has linkage and is VLA
-                      int (*s)[m];                               //   valid: auto pointer to VLA
-                      extern int (*r)[m];                        //   invalid: r has linkage and points to VLA
-                      static int (*q)[m] = &amp;B;                   //   valid: q is a static block pointer to VLA
-             }
-
-     Forward references:          function declarators (<a href="#6.7.6.3">6.7.6.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
-     initialization (<a href="#6.7.9">6.7.9</a>).
-<a name="6.7.6.3" href="#6.7.6.3"><b>     6.7.6.3 Function declarators (including prototypes)</b></a>
-<b>     Constraints</b>
-1    A function declarator shall not specify a return type that is a function type or an array
-     type.
-2    The only storage-class specifier that shall occur in a parameter declaration is register.
-3    An identifier list in a function declarator that is not part of a definition of that function
-     shall be empty.
-4    After adjustment, the parameters in a parameter type list in a function declarator that is
-     part of a definition of that function shall not have incomplete type.
-<b>     Semantics</b>
-5    If, in the declaration ''T D1'', D1 has the form
-
-[<a name="p131" href="#p131">page 131</a>] (<a href="#Contents">Contents</a>)
-
-            D( parameter-type-list )
-     or
-            D( identifier-listopt )
-     and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
-     T '', then the type specified for ident is ''derived-declarator-type-list function returning
-     T ''.
-6    A parameter type list specifies the types of, and may declare identifiers for, the
-     parameters of the function.
-7    A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
-     type'', where the type qualifiers (if any) are those specified within the [ and ] of the
-     array type derivation. If the keyword static also appears within the [ and ] of the
-     array type derivation, then for each call to the function, the value of the corresponding
-     actual argument shall provide access to the first element of an array with at least as many
-     elements as specified by the size expression.
-8    A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
-     function returning type'', as in <a href="#6.3.2.1">6.3.2.1</a>.
-9    If the list terminates with an ellipsis (, ...), no information about the number or types
-     of the parameters after the comma is supplied.<sup><a href="#note144"><b>144)</b></a></sup>
-10   The special case of an unnamed parameter of type void as the only item in the list
-     specifies that the function has no parameters.
-11   If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
-     parameter name, it shall be taken as a typedef name.
-12   If the function declarator is not part of a definition of that function, parameters may have
-     incomplete type and may use the [*] notation in their sequences of declarator specifiers
-     to specify variable length array types.
-13   The storage-class specifier in the declaration specifiers for a parameter declaration, if
-     present, is ignored unless the declared parameter is one of the members of the parameter
-     type list for a function definition.
-14   An identifier list declares only the identifiers of the parameters of the function. An empty
-     list in a function declarator that is part of a definition of that function specifies that the
-     function has no parameters. The empty list in a function declarator that is not part of a
-     definition of that function specifies that no information about the number or types of the
-     parameters is supplied.<sup><a href="#note145"><b>145)</b></a></sup>
-
-
-
-     <sup><a name="note144" href="#note144"><b>144)</b></a></sup> The macros defined in the <a href="#7.16">&lt;stdarg.h&gt;</a> header (<a href="#7.16">7.16</a>) may be used to access arguments that
-          correspond to the ellipsis.
-
-[<a name="p132" href="#p132">page 132</a>] (<a href="#Contents">Contents</a>)
-
-15   For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note146"><b>146)</b></a></sup>
-     Moreover, the parameter type lists, if both are present, shall agree in the number of
-     parameters and in use of the ellipsis terminator; corresponding parameters shall have
-     compatible types. If one type has a parameter type list and the other type is specified by a
-     function declarator that is not part of a function definition and that contains an empty
-     identifier list, the parameter list shall not have an ellipsis terminator and the type of each
-     parameter shall be compatible with the type that results from the application of the
-     default argument promotions. If one type has a parameter type list and the other type is
-     specified by a function definition that contains a (possibly empty) identifier list, both shall
-     agree in the number of parameters, and the type of each prototype parameter shall be
-     compatible with the type that results from the application of the default argument
-     promotions to the type of the corresponding identifier. (In the determination of type
-     compatibility and of a composite type, each parameter declared with function or array
-     type is taken as having the adjusted type and each parameter declared with qualified type
-     is taken as having the unqualified version of its declared type.)
-16   EXAMPLE 1       The declaration
-              int f(void), *fip(), (*pfi)();
-     declares a function f with no parameters returning an int, a function fip with no parameter specification
-     returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
-     int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
-     declaration suggests, and the same construction in an expression requires, the calling of a function fip,
-     and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
-     extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
-     designator, which is then used to call the function; it returns an int.
-17   If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
-     declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
-     internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
-     the identifier of the pointer pfi has block scope and no linkage.
-
-18   EXAMPLE 2       The declaration
-              int (*apfi[3])(int *x, int *y);
-     declares an array apfi of three pointers to functions returning int. Each of these functions has two
-     parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
-     go out of scope at the end of the declaration of apfi.
-
-19   EXAMPLE 3       The declaration
-              int (*fpfi(int (*)(long), int))(int, ...);
-     declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
-     parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
-     The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
-
-
-     <sup><a name="note145" href="#note145"><b>145)</b></a></sup> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
-     <sup><a name="note146" href="#note146"><b>146)</b></a></sup> If both function types are ''old style'', parameter types are not compared.
-
-[<a name="p133" href="#p133">page 133</a>] (<a href="#Contents">Contents</a>)
-
-     additional arguments of any type.
-
-20   EXAMPLE 4        The following prototype has a variably modified parameter.
-               void addscalar(int n, int m,
-                     double a[n][n*m+300], double x);
-               int main()
-               {
-                     double b[4][308];
-                     addscalar(4, 2, b, <a href="#2.17">2.17</a>);
-                     return 0;
-               }
-               void addscalar(int n, int m,
-                     double a[n][n*m+300], double x)
-               {
-                     for (int i = 0; i &lt; n; i++)
-                           for (int j = 0, k = n*m+300; j &lt; k; j++)
-                                 // a is a pointer to a VLA with n*m+300 elements
-                                 a[i][j] += x;
-               }
-
-21   EXAMPLE 5        The following are all compatible function prototype declarators.
-               double    maximum(int       n,   int   m,   double   a[n][m]);
-               double    maximum(int       n,   int   m,   double   a[*][*]);
-               double    maximum(int       n,   int   m,   double   a[ ][*]);
-               double    maximum(int       n,   int   m,   double   a[ ][m]);
-     as are:
-               void   f(double     (* restrict a)[5]);
-               void   f(double     a[restrict][5]);
-               void   f(double     a[restrict 3][5]);
-               void   f(double     a[restrict static 3][5]);
-     (Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
-     non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
-
-     Forward references: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
-
-[<a name="p134" href="#p134">page 134</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.7" href="#6.7.7"><b>    6.7.7 Type names</b></a>
-<b>    Syntax</b>
-1            type-name:
-                    specifier-qualifier-list abstract-declaratoropt
-             abstract-declarator:
-                    pointer
-                    pointeropt direct-abstract-declarator
-             direct-abstract-declarator:
-                     ( abstract-declarator )
-                     direct-abstract-declaratoropt [ type-qualifier-listopt
-                                    assignment-expressionopt ]
-                     direct-abstract-declaratoropt [ static type-qualifier-listopt
-                                    assignment-expression ]
-                     direct-abstract-declaratoropt [ type-qualifier-list static
-                                    assignment-expression ]
-                     direct-abstract-declaratoropt [ * ]
-                     direct-abstract-declaratoropt ( parameter-type-listopt )
-<b>    Semantics</b>
-2   In several contexts, it is necessary to specify a type. This is accomplished using a type
-    name, which is syntactically a declaration for a function or an object of that type that
-    omits the identifier.<sup><a href="#note147"><b>147)</b></a></sup>
-3   EXAMPLE        The constructions
-             (a)      int
-             (b)      int   *
-             (c)      int   *[3]
-             (d)      int   (*)[3]
-             (e)      int   (*)[*]
-             (f)      int   *()
-             (g)      int   (*)(void)
-             (h)      int   (*const [])(unsigned int, ...)
-    name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
-    array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
-    with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
-    returning an int, and (h) array of an unspecified number of constant pointers to functions, each with one
-    parameter that has type unsigned int and an unspecified number of other parameters, returning an
-    int.
-
-
-
-
-    <sup><a name="note147" href="#note147"><b>147)</b></a></sup> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
-         parameter specification'', rather than redundant parentheses around the omitted identifier.
-
-[<a name="p135" href="#p135">page 135</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.8" href="#6.7.8"><b>    6.7.8 Type definitions</b></a>
-<b>    Syntax</b>
-1            typedef-name:
-                    identifier
-<b>    Constraints</b>
-2   If a typedef name specifies a variably modified type then it shall have block scope.
-<b>    Semantics</b>
-3   In a declaration whose storage-class specifier is typedef, each declarator defines an
-    identifier to be a typedef name that denotes the type specified for the identifier in the way
-    described in <a href="#6.7.6">6.7.6</a>. Any array size expressions associated with variable length array
-    declarators are evaluated each time the declaration of the typedef name is reached in the
-    order of execution. A typedef declaration does not introduce a new type, only a
-    synonym for the type so specified. That is, in the following declarations:
-             typedef T type_ident;
-             type_ident D;
-    type_ident is defined as a typedef name with the type specified by the declaration
-    specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
-    type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
-    typedef name shares the same name space as other identifiers declared in ordinary
-    declarators.
-4   EXAMPLE 1       After
-             typedef int MILES, KLICKSP();
-             typedef struct { double hi, lo; } range;
-    the constructions
-             MILES distance;
-             extern KLICKSP *metricp;
-             range x;
-             range z, *zp;
-    are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
-    parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
-    such a structure. The object distance has a type compatible with any other int object.
-
-5   EXAMPLE 2       After the declarations
-             typedef struct s1 { int x; } t1, *tp1;
-             typedef struct s2 { int x; } t2, *tp2;
-    type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
-    s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
-
-[<a name="p136" href="#p136">page 136</a>] (<a href="#Contents">Contents</a>)
-
-6   EXAMPLE 3       The following obscure constructions
-             typedef signed int t;
-             typedef int plain;
-             struct tag {
-                   unsigned t:4;
-                   const t:5;
-                   plain r:5;
-             };
-    declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
-    with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
-    qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
-    [-16, +15], and one named r that contains values in one of the ranges [0, 31], [-15, +15], or [-16, +15].
-    (The choice of range is implementation-defined.) The first two bit-field declarations differ in that
-    unsigned is a type specifier (which forces t to be the name of a structure member), while const is a
-    type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed
-    in an inner scope by
-             t f(t (t));
-             long t;
-    then a function f is declared with type ''function returning signed int with one unnamed parameter
-    with type pointer to function returning signed int with one unnamed parameter with type signed
-    int'', and an identifier t with type long int.
-
-7   EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
-    following declarations of the signal function specify exactly the same type, the first without making use
-    of any typedef names.
-             typedef void fv(int), (*pfv)(int);
-             void (*signal(int, void (*)(int)))(int);
-             fv *signal(int, fv *);
-             pfv signal(int, pfv);
-
-8   EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
-    time the typedef name is defined, not each time it is used:
-             void copyt(int n)
-             {
-                   typedef int B[n];   //               B is n ints, n evaluated now
-                   n += 1;
-                   B a;                //               a is n ints, n without += 1
-                   int b[n];           //               a and b are different sizes
-                   for (int i = 1; i &lt; n;               i++)
-                         a[i-1] = b[i];
-             }
-
-[<a name="p137" href="#p137">page 137</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.9" href="#6.7.9"><b>    6.7.9 Initialization</b></a>
-<b>    Syntax</b>
-1            initializer:
-                      assignment-expression
-                      { initializer-list }
-                      { initializer-list , }
-             initializer-list:
-                      designationopt initializer
-                      initializer-list , designationopt initializer
-             designation:
-                    designator-list =
-             designator-list:
-                    designator
-                    designator-list designator
-             designator:
-                    [ constant-expression ]
-                    . identifier
-<b>    Constraints</b>
-2   No initializer shall attempt to provide a value for an object not contained within the entity
-    being initialized.
-3   The type of the entity to be initialized shall be an array of unknown size or a complete
-    object type that is not a variable length array type.
-4   All the expressions in an initializer for an object that has static or thread storage duration
-    shall be constant expressions or string literals.
-5   If the declaration of an identifier has block scope, and the identifier has external or
-    internal linkage, the declaration shall have no initializer for the identifier.
-6   If a designator has the form
-             [ constant-expression ]
-    then the current object (defined below) shall have array type and the expression shall be
-    an integer constant expression. If the array is of unknown size, any nonnegative value is
-    valid.
-7   If a designator has the form
-             . identifier
-    then the current object (defined below) shall have structure or union type and the
-    identifier shall be the name of a member of that type.
-
-[<a name="p138" href="#p138">page 138</a>] (<a href="#Contents">Contents</a>)
-
-<b>     Semantics</b>
-8    An initializer specifies the initial value stored in an object.
-9    Except where explicitly stated otherwise, for the purposes of this subclause unnamed
-     members of objects of structure and union type do not participate in initialization.
-     Unnamed members of structure objects have indeterminate value even after initialization.
-10   If an object that has automatic storage duration is not initialized explicitly, its value is
-     indeterminate. If an object that has static or thread storage duration is not initialized
-     explicitly, then:
-     -- if it has pointer type, it is initialized to a null pointer;
-     -- if it has arithmetic type, it is initialized to (positive or unsigned) zero;
-     -- if it is an aggregate, every member is initialized (recursively) according to these rules,
-       and any padding is initialized to zero bits;
-     -- if it is a union, the first named member is initialized (recursively) according to these
-       rules, and any padding is initialized to zero bits;
-11   The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
-     initial value of the object is that of the expression (after conversion); the same type
-     constraints and conversions as for simple assignment apply, taking the type of the scalar
-     to be the unqualified version of its declared type.
-12   The rest of this subclause deals with initializers for objects that have aggregate or union
-     type.
-13   The initializer for a structure or union object that has automatic storage duration shall be
-     either an initializer list as described below, or a single expression that has compatible
-     structure or union type. In the latter case, the initial value of the object, including
-     unnamed members, is that of the expression.
-14   An array of character type may be initialized by a character string literal or UTF-8 string
-     literal, optionally enclosed in braces. Successive bytes of the string literal (including the
-     terminating null character if there is room or if the array is of unknown size) initialize the
-     elements of the array.
-15   An array with element type compatible with a qualified or unqualified version of
-     wchar_t may be initialized by a wide string literal, optionally enclosed in braces.
-     Successive wide characters of the wide string literal (including the terminating null wide
-     character if there is room or if the array is of unknown size) initialize the elements of the
-     array.
-16   Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
-     enclosed list of initializers for the elements or named members.
-
-[<a name="p139" href="#p139">page 139</a>] (<a href="#Contents">Contents</a>)
-
-17   Each brace-enclosed initializer list has an associated current object. When no
-     designations are present, subobjects of the current object are initialized in order according
-     to the type of the current object: array elements in increasing subscript order, structure
-     members in declaration order, and the first named member of a union.<sup><a href="#note148"><b>148)</b></a></sup> In contrast, a
-     designation causes the following initializer to begin initialization of the subobject
-     described by the designator. Initialization then continues forward in order, beginning
-     with the next subobject after that described by the designator.<sup><a href="#note149"><b>149)</b></a></sup>
-18   Each designator list begins its description with the current object associated with the
-     closest surrounding brace pair. Each item in the designator list (in order) specifies a
-     particular member of its current object and changes the current object for the next
-     designator (if any) to be that member.<sup><a href="#note150"><b>150)</b></a></sup> The current object that results at the end of the
-     designator list is the subobject to be initialized by the following initializer.
-19   The initialization shall occur in initializer list order, each initializer provided for a
-     particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note151"><b>151)</b></a></sup>
-     all subobjects that are not initialized explicitly shall be initialized implicitly the same as
-     objects that have static storage duration.
-20   If the aggregate or union contains elements or members that are aggregates or unions,
-     these rules apply recursively to the subaggregates or contained unions. If the initializer of
-     a subaggregate or contained union begins with a left brace, the initializers enclosed by
-     that brace and its matching right brace initialize the elements or members of the
-     subaggregate or the contained union. Otherwise, only enough initializers from the list are
-     taken to account for the elements or members of the subaggregate or the first member of
-     the contained union; any remaining initializers are left to initialize the next element or
-     member of the aggregate of which the current subaggregate or contained union is a part.
-21   If there are fewer initializers in a brace-enclosed list than there are elements or members
-     of an aggregate, or fewer characters in a string literal used to initialize an array of known
-     size than there are elements in the array, the remainder of the aggregate shall be
-     initialized implicitly the same as objects that have static storage duration.
-
-
-
-     <sup><a name="note148" href="#note148"><b>148)</b></a></sup> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
-          subobjects are initialized as usual, but the subaggregate or contained union does not become the
-          current object: current objects are associated only with brace-enclosed initializer lists.
-     <sup><a name="note149" href="#note149"><b>149)</b></a></sup> After a union member is initialized, the next object is not the next member of the union; instead, it is
-          the next subobject of an object containing the union.
-     <sup><a name="note150" href="#note150"><b>150)</b></a></sup> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
-          the surrounding brace pair. Note, too, that each separate designator list is independent.
-     <sup><a name="note151" href="#note151"><b>151)</b></a></sup> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
-          not be evaluated at all.
-
-[<a name="p140" href="#p140">page 140</a>] (<a href="#Contents">Contents</a>)
-
-22   If an array of unknown size is initialized, its size is determined by the largest indexed
-     element with an explicit initializer. The array type is completed at the end of its
-     initializer list.
-23   The evaluations of the initialization list expressions are indeterminately sequenced with
-     respect to one another and thus the order in which any side effects occur is
-     unspecified.<sup><a href="#note152"><b>152)</b></a></sup>
-24   EXAMPLE 1       Provided that <a href="#7.3">&lt;complex.h&gt;</a> has been #included, the declarations
-              int i = <a href="#3.5">3.5</a>;
-              double complex c = 5 + 3 * I;
-     define and initialize i with the value 3 and c with the value 5.0 + i3.0.
-
-25   EXAMPLE 2       The declaration
-              int x[] = { 1, 3, 5 };
-     defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
-     and there are three initializers.
-
-26   EXAMPLE 3       The declaration
-              int y[4][3] =         {
-                    { 1, 3,         5 },
-                    { 2, 4,         6 },
-                    { 3, 5,         7 },
-              };
-     is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
-     y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
-     y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
-     been achieved by
-              int y[4][3] = {
-                    1, 3, 5, 2, 4, 6, 3, 5, 7
-              };
-     The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
-     next three are taken successively for y[1] and y[2].
-
-27   EXAMPLE 4       The declaration
-              int z[4][3] = {
-                    { 1 }, { 2 }, { 3 }, { 4 }
-              };
-     initializes the first column of z as specified and initializes the rest with zeros.
-
-28   EXAMPLE 5       The declaration
-              struct { int a[3], b; } w[] = { { 1 }, 2 };
-     is a definition with an inconsistently bracketed initialization. It defines an array with two element
-
-
-
-     <sup><a name="note152" href="#note152"><b>152)</b></a></sup> In particular, the evaluation order need not be the same as the order of subobject initialization.
-
-[<a name="p141" href="#p141">page 141</a>] (<a href="#Contents">Contents</a>)
-
-     structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
-
-29   EXAMPLE 6         The declaration
-               short q[4][3][2] = {
-                     { 1 },
-                     { 2, 3 },
-                     { 4, 5, 6 }
-               };
-     contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
-     object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
-     q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
-     q[0][0] does not begin with a left brace, so up to six items from the current list may be used. There is
-     only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers
-     for q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their
-     respective two-dimensional subaggregates. If there had been more than six items in any of the lists, a
-     diagnostic message would have been issued. The same initialization result could have been achieved by:
-               short q[4][3][2] = {
-                     1, 0, 0, 0, 0, 0,
-                     2, 3, 0, 0, 0, 0,
-                     4, 5, 6
-               };
-     or by:
-               short q[4][3][2] = {
-                     {
-                           { 1 },
-                     },
-                     {
-                           { 2, 3 },
-                     },
-                     {
-                           { 4, 5 },
-                           { 6 },
-                     }
-               };
-     in a fully bracketed form.
-30   Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
-     cause confusion.
-
-31   EXAMPLE 7         One form of initialization that completes array types involves typedef names. Given the
-     declaration
-               typedef int A[];          // OK - declared with block scope
-     the declaration
-               A a = { 1, 2 }, b = { 3, 4, 5 };
-     is identical to
-               int a[] = { 1, 2 }, b[] = { 3, 4, 5 };
-     due to the rules for incomplete types.
-
-[<a name="p142" href="#p142">page 142</a>] (<a href="#Contents">Contents</a>)
-
-32   EXAMPLE 8       The declaration
-              char s[] = "abc", t[3] = "abc";
-     defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
-     This declaration is identical to
-              char s[] = { 'a', 'b', 'c', '\0' },
-                   t[] = { 'a', 'b', 'c' };
-     The contents of the arrays are modifiable. On the other hand, the declaration
-              char *p = "abc";
-     defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
-     with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
-     modify the contents of the array, the behavior is undefined.
-
-33   EXAMPLE 9       Arrays can be initialized to correspond to the elements of an enumeration by using
-     designators:
-              enum { member_one,           member_two };
-              const char *nm[] =           {
-                    [member_two]           = "member two",
-                    [member_one]           = "member one",
-              };
-
-34   EXAMPLE 10       Structure members can be initialized to nonzero values without depending on their order:
-              div_t answer = { .quot = 2, .rem = -1 };
-
-35   EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
-     might be misunderstood:
-              struct { int a[3], b; } w[] =
-                    { [0].a = {1}, [1].a[0] = 2 };
-
-36   EXAMPLE 12       Space can be ''allocated'' from both ends of an array by using a single designator:
-              int a[MAX] = {
-                    1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
-              };
-37   In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
-     than ten, some of the values provided by the first five initializers will be overridden by the second five.
-
-38   EXAMPLE 13       Any member of a union can be initialized:
-              union { /* ... */ } u = { .any_member = 42 };
-
-     Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>).
-
-[<a name="p143" href="#p143">page 143</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.7.10" href="#6.7.10"><b>    6.7.10 Static assertions</b></a>
-<b>    Syntax</b>
-1            static_assert-declaration:
-                     _Static_assert ( constant-expression , string-literal ) ;
-<b>    Constraints</b>
-2   The constant expression shall compare unequal to 0.
-<b>    Semantics</b>
-3   The constant expression shall be an integer constant expression. If the value of the
-    constant expression compares unequal to 0, the declaration has no effect. Otherwise, the
-    constraint is violated and the implementation shall produce a diagnostic message that
-    includes the text of the string literal, except that characters not in the basic source
-    character set are not required to appear in the message.
-    Forward references: diagnostics (<a href="#7.2">7.2</a>).
-
-[<a name="p144" href="#p144">page 144</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.8" href="#6.8"><b>    6.8 Statements and blocks</b></a>
-<b>    Syntax</b>
-1            statement:
-                    labeled-statement
-                    compound-statement
-                    expression-statement
-                    selection-statement
-                    iteration-statement
-                    jump-statement
-<b>    Semantics</b>
-2   A statement specifies an action to be performed. Except as indicated, statements are
-    executed in sequence.
-3   A block allows a set of declarations and statements to be grouped into one syntactic unit.
-    The initializers of objects that have automatic storage duration, and the variable length
-    array declarators of ordinary identifiers with block scope, are evaluated and the values are
-    stored in the objects (including storing an indeterminate value in objects without an
-    initializer) each time the declaration is reached in the order of execution, as if it were a
-    statement, and within each declaration in the order that declarators appear.
-4   A full expression is an expression that is not part of another expression or of a declarator.
-    Each of the following is a full expression: an initializer that is not part of a compound
-    literal; the expression in an expression statement; the controlling expression of a selection
-    statement (if or switch); the controlling expression of a while or do statement; each
-    of the (optional) expressions of a for statement; the (optional) expression in a return
-    statement. There is a sequence point between the evaluation of a full expression and the
-    evaluation of the next full expression to be evaluated.
-    Forward references: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
-    (<a href="#6.8.4">6.8.4</a>), iteration statements (<a href="#6.8.5">6.8.5</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>).
-<a name="6.8.1" href="#6.8.1"><b>    6.8.1 Labeled statements</b></a>
-<b>    Syntax</b>
-1            labeled-statement:
-                    identifier : statement
-                    case constant-expression : statement
-                    default : statement
-<b>    Constraints</b>
-2   A case or default label shall appear only in a switch statement. Further
-    constraints on such labels are discussed under the switch statement.
-
-[<a name="p145" href="#p145">page 145</a>] (<a href="#Contents">Contents</a>)
-
-3   Label names shall be unique within a function.
-<b>    Semantics</b>
-4   Any statement may be preceded by a prefix that declares an identifier as a label name.
-    Labels in themselves do not alter the flow of control, which continues unimpeded across
-    them.
-    Forward references: the goto statement (<a href="#6.8.6.1">6.8.6.1</a>), the switch statement (<a href="#6.8.4.2">6.8.4.2</a>).
-<a name="6.8.2" href="#6.8.2"><b>    6.8.2 Compound statement</b></a>
-<b>    Syntax</b>
-1            compound-statement:
-                   { block-item-listopt }
-             block-item-list:
-                     block-item
-                     block-item-list block-item
-             block-item:
-                     declaration
-                     statement
-<b>    Semantics</b>
-2   A compound statement is a block.
-<a name="6.8.3" href="#6.8.3"><b>    6.8.3 Expression and null statements</b></a>
-<b>    Syntax</b>
-1            expression-statement:
-                    expressionopt ;
-<b>    Semantics</b>
-2   The expression in an expression statement is evaluated as a void expression for its side
-    effects.<sup><a href="#note153"><b>153)</b></a></sup>
-3   A null statement (consisting of just a semicolon) performs no operations.
-4   EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
-    discarding of its value may be made explicit by converting the expression to a void expression by means of
-    a cast:
-             int p(int);
-             /* ... */
-             (void)p(0);
-
-
-
-    <sup><a name="note153" href="#note153"><b>153)</b></a></sup> Such as assignments, and function calls which have side effects.
-
-[<a name="p146" href="#p146">page 146</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE 2       In the program fragment
-             char *s;
-             /* ... */
-             while (*s++ != '\0')
-                     ;
-    a null statement is used to supply an empty loop body to the iteration statement.
-
-6   EXAMPLE 3       A null statement may also be used to carry a label just before the closing } of a compound
-    statement.
-             while (loop1) {
-                   /* ... */
-                   while (loop2) {
-                           /* ... */
-                           if (want_out)
-                                   goto end_loop1;
-                           /* ... */
-                   }
-                   /* ... */
-             end_loop1: ;
-             }
-
-    Forward references: iteration statements (<a href="#6.8.5">6.8.5</a>).
-<a name="6.8.4" href="#6.8.4"><b>    6.8.4 Selection statements</b></a>
-<b>    Syntax</b>
-1            selection-statement:
-                     if ( expression ) statement
-                     if ( expression ) statement else statement
-                     switch ( expression ) statement
-<b>    Semantics</b>
-2   A selection statement selects among a set of statements depending on the value of a
-    controlling expression.
-3   A selection statement is a block whose scope is a strict subset of the scope of its
-    enclosing block. Each associated substatement is also a block whose scope is a strict
-    subset of the scope of the selection statement.
-<a name="6.8.4.1" href="#6.8.4.1"><b>    6.8.4.1 The if statement</b></a>
-<b>    Constraints</b>
-1   The controlling expression of an if statement shall have scalar type.
-<b>    Semantics</b>
-2   In both forms, the first substatement is executed if the expression compares unequal to 0.
-    In the else form, the second substatement is executed if the expression compares equal
-
-[<a name="p147" href="#p147">page 147</a>] (<a href="#Contents">Contents</a>)
-
-    to 0. If the first substatement is reached via a label, the second substatement is not
-    executed.
-3   An else is associated with the lexically nearest preceding if that is allowed by the
-    syntax.
-<a name="6.8.4.2" href="#6.8.4.2"><b>    6.8.4.2 The switch statement</b></a>
-<b>    Constraints</b>
-1   The controlling expression of a switch statement shall have integer type.
-2   If a switch statement has an associated case or default label within the scope of an
-    identifier with a variably modified type, the entire switch statement shall be within the
-    scope of that identifier.<sup><a href="#note154"><b>154)</b></a></sup>
-3   The expression of each case label shall be an integer constant expression and no two of
-    the case constant expressions in the same switch statement shall have the same value
-    after conversion. There may be at most one default label in a switch statement.
-    (Any enclosed switch statement may have a default label or case constant
-    expressions with values that duplicate case constant expressions in the enclosing
-    switch statement.)
-<b>    Semantics</b>
-4   A switch statement causes control to jump to, into, or past the statement that is the
-    switch body, depending on the value of a controlling expression, and on the presence of a
-    default label and the values of any case labels on or in the switch body. A case or
-    default label is accessible only within the closest enclosing switch statement.
-5   The integer promotions are performed on the controlling expression. The constant
-    expression in each case label is converted to the promoted type of the controlling
-    expression. If a converted value matches that of the promoted controlling expression,
-    control jumps to the statement following the matched case label. Otherwise, if there is
-    a default label, control jumps to the labeled statement. If no converted case constant
-    expression matches and there is no default label, no part of the switch body is
-    executed.
-    Implementation limits
-6   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
-    switch statement.
-
-
-
-
-    <sup><a name="note154" href="#note154"><b>154)</b></a></sup> That is, the declaration either precedes the switch statement, or it follows the last case or
-         default label associated with the switch that is in the block containing the declaration.
-
-[<a name="p148" href="#p148">page 148</a>] (<a href="#Contents">Contents</a>)
-
-7   EXAMPLE        In the artificial program fragment
-             switch (expr)
-             {
-                   int i = 4;
-                   f(i);
-             case 0:
-                   i = 17;
-                   /* falls through into default code */
-             default:
-                   printf("%d\n", i);
-             }
-    the object whose identifier is i exists with automatic storage duration (within the block) but is never
-    initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
-    access an indeterminate value. Similarly, the call to the function f cannot be reached.
-
-<a name="6.8.5" href="#6.8.5"><b>    6.8.5 Iteration statements</b></a>
-<b>    Syntax</b>
-1            iteration-statement:
-                     while ( expression ) statement
-                     do statement while ( expression ) ;
-                     for ( expressionopt ; expressionopt ; expressionopt ) statement
-                     for ( declaration expressionopt ; expressionopt ) statement
-<b>    Constraints</b>
-2   The controlling expression of an iteration statement shall have scalar type.
-3   The declaration part of a for statement shall only declare identifiers for objects having
-    storage class auto or register.
-<b>    Semantics</b>
-4   An iteration statement causes a statement called the loop body to be executed repeatedly
-    until the controlling expression compares equal to 0. The repetition occurs regardless of
-    whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note155"><b>155)</b></a></sup>
-5   An iteration statement is a block whose scope is a strict subset of the scope of its
-    enclosing block. The loop body is also a block whose scope is a strict subset of the scope
-    of the iteration statement.
-6   An iteration statement whose controlling expression is not a constant expression,<sup><a href="#note156"><b>156)</b></a></sup> that
-    performs no input/output operations, does not access volatile objects, and performs no
-    synchronization or atomic operations in its body, controlling expression, or (in the case of
-
-    <sup><a name="note155" href="#note155"><b>155)</b></a></sup> Code jumped over is not executed. In particular, the controlling expression of a for or while
-         statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
-    <sup><a name="note156" href="#note156"><b>156)</b></a></sup> An omitted controlling expression is replaced by a nonzero constant, which is a constant expression.
-
-[<a name="p149" href="#p149">page 149</a>] (<a href="#Contents">Contents</a>)
-
-    a for statement) its expression-3, may be assumed by the implementation to
-    terminate.<sup><a href="#note157"><b>157)</b></a></sup>
-<a name="6.8.5.1" href="#6.8.5.1"><b>    6.8.5.1 The while statement</b></a>
-1   The evaluation of the controlling expression takes place before each execution of the loop
-    body.
-<a name="6.8.5.2" href="#6.8.5.2"><b>    6.8.5.2 The do statement</b></a>
-1   The evaluation of the controlling expression takes place after each execution of the loop
-    body.
-<a name="6.8.5.3" href="#6.8.5.3"><b>    6.8.5.3 The for statement</b></a>
-1   The statement
-             for ( clause-1 ; expression-2 ; expression-3 ) statement
-    behaves as follows: The expression expression-2 is the controlling expression that is
-    evaluated before each execution of the loop body. The expression expression-3 is
-    evaluated as a void expression after each execution of the loop body. If clause-1 is a
-    declaration, the scope of any identifiers it declares is the remainder of the declaration and
-    the entire loop, including the other two expressions; it is reached in the order of execution
-    before the first evaluation of the controlling expression. If clause-1 is an expression, it is
-    evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note158"><b>158)</b></a></sup>
-2   Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a
-    nonzero constant.
-<a name="6.8.6" href="#6.8.6"><b>    6.8.6 Jump statements</b></a>
-<b>    Syntax</b>
-1            jump-statement:
-                    goto identifier ;
-                    continue ;
-                    break ;
-                    return expressionopt ;
-
-
-
-
-    <sup><a name="note157" href="#note157"><b>157)</b></a></sup> This is intended to allow compiler transformations such as removal of empty loops even when
-         termination cannot be proven.
-    <sup><a name="note158" href="#note158"><b>158)</b></a></sup> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
-         the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
-         such that execution of the loop continues until the expression compares equal to 0; and expression-3
-         specifies an operation (such as incrementing) that is performed after each iteration.
-
-[<a name="p150" href="#p150">page 150</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Semantics</b>
-2   A jump statement causes an unconditional jump to another place.
-<a name="6.8.6.1" href="#6.8.6.1"><b>    6.8.6.1 The goto statement</b></a>
-<b>    Constraints</b>
-1   The identifier in a goto statement shall name a label located somewhere in the enclosing
-    function. A goto statement shall not jump from outside the scope of an identifier having
-    a variably modified type to inside the scope of that identifier.
-<b>    Semantics</b>
-2   A goto statement causes an unconditional jump to the statement prefixed by the named
-    label in the enclosing function.
-3   EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
-    following outline presents one possible approach to a problem based on these three assumptions:
-      1.   The general initialization code accesses objects only visible to the current function.
-      2.   The general initialization code is too large to warrant duplication.
-      3. The code to determine the next operation is at the head of the loop. (To allow it to be reached by
-         continue statements, for example.)
+            fesetround(FE_UPWARD);
             /* ... */
-            goto first_time;
-            for (;;) {
-                    // determine next operation
-                    /* ... */
-                    if (need to reinitialize) {
-                            // reinitialize-only code
-                            /* ... */
-                    first_time:
-                            // general initialization code
-                            /* ... */
-                            continue;
-                    }
-                    // handle other operations
-                    /* ... */
-            }
-
-[<a name="p151" href="#p151">page 151</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
-    modified types. A jump within the scope, however, is permitted.
-            goto lab3;                         // invalid: going INTO scope of VLA.
-            {
-                  double a[n];
-                  a[j] = <a href="#4.4">4.4</a>;
-            lab3:
-                  a[j] = <a href="#3.3">3.3</a>;
-                  goto lab4;                   // valid: going WITHIN scope of VLA.
-                  a[j] = <a href="#5.5">5.5</a>;
-            lab4:
-                  a[j] = <a href="#6.6">6.6</a>;
-            }
-            goto lab4;                         // invalid: going INTO scope of VLA.
-
-<a name="6.8.6.2" href="#6.8.6.2"><b>    6.8.6.2 The continue statement</b></a>
-<b>    Constraints</b>
-1   A continue statement shall appear only in or as a loop body.
-<b>    Semantics</b>
-2   A continue statement causes a jump to the loop-continuation portion of the smallest
-    enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
-    of the statements
-    while (/* ... */) {                  do {                                 for (/* ... */) {
-       /* ... */                            /* ... */                            /* ... */
-       continue;                            continue;                            continue;
-       /* ... */                            /* ... */                            /* ... */
-    contin: ;                            contin: ;                            contin: ;
-    }                                    } while (/* ... */);                 }
-    unless the continue statement shown is in an enclosed iteration statement (in which
-    case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note159"><b>159)</b></a></sup>
-<a name="6.8.6.3" href="#6.8.6.3"><b>    6.8.6.3 The break statement</b></a>
-<b>    Constraints</b>
-1   A break statement shall appear only in or as a switch body or loop body.
-<b>    Semantics</b>
-2   A break statement terminates execution of the smallest enclosing switch or iteration
-    statement.
-
-
-
-    <sup><a name="note159" href="#note159"><b>159)</b></a></sup> Following the contin: label is a null statement.
-
-[<a name="p152" href="#p152">page 152</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.8.6.4" href="#6.8.6.4"><b>    6.8.6.4 The return statement</b></a>
-<b>    Constraints</b>
-1   A return statement with an expression shall not appear in a function whose return type
-    is void. A return statement without an expression shall only appear in a function
-    whose return type is void.
-<b>    Semantics</b>
-2   A return statement terminates execution of the current function and returns control to
-    its caller. A function may have any number of return statements.
-3   If a return statement with an expression is executed, the value of the expression is
-    returned to the caller as the value of the function call expression. If the expression has a
-    type different from the return type of the function in which it appears, the value is
-    converted as if by assignment to an object having the return type of the function.<sup><a href="#note160"><b>160)</b></a></sup>
-4   EXAMPLE       In:
-            struct s { double i; } f(void);
-            union {
+         #endif</pre>
+ 
+
+<p><a name="note4">4)</a> This implies that a conforming implementation reserves no identifiers other than those explicitly
+ reserved in this International Standard.
+
+<p><a name="note5">5)</a> Strictly conforming programs are intended to be maximally portable among conforming
+ implementations. Conforming programs may depend upon nonportable features of a conforming
+ implementation.
+
+
+<a name="5" href="#5"><h2>5. Environment</h2></a>
+<p><!--para 1-->
+ An implementation translates C source files and executes C programs in two data-
+ processing-system environments, which will be called the translation environment and
+ the execution environment in this International Standard. Their characteristics define and
+ constrain the results of executing conforming C programs constructed according to the
+ syntactic and semantic rules for conforming implementations.
+ Forward references: In this clause, only a few of many possible forward references
+ have been noted.
+
+<a name="5.1" href="#5.1"><h3>5.1 Conceptual models</h3></a>
+
+<a name="5.1.1" href="#5.1.1"><h4>5.1.1 Translation environment</h4></a>
+
+<a name="5.1.1.1" href="#5.1.1.1"><h5>5.1.1.1 Program structure</h5></a>
+<p><!--para 1-->
+ A C program need not all be translated at the same time. The text of the program is kept
+ in units called source files, (or preprocessing files) in this International Standard. A
+ source file together with all the headers and source files included via the preprocessing
+ directive #include is known as a preprocessing translation unit. After preprocessing, a
+ preprocessing translation unit is called a translation unit. Previously translated translation
+ units may be preserved individually or in libraries. The separate translation units of a
+ program communicate by (for example) calls to functions whose identifiers have external
+ linkage, manipulation of objects whose identifiers have external linkage, or manipulation
+ of data files. Translation units may be separately translated and then later linked to
+ produce an executable program.
+ Forward references: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
+ preprocessing directives (<a href="#6.10">6.10</a>).
+
+<a name="5.1.1.2" href="#5.1.1.2"><h5>5.1.1.2 Translation phases</h5></a>
+<p><!--para 1-->
+ The precedence among the syntax rules of translation is specified by the following
+ phases.<sup><a href="#note6"><b>6)</b></a></sup>
+<ol>
+<li>  Physical source file multibyte characters are mapped, in an implementation-
+ defined manner, to the source character set (introducing new-line characters for
+ end-of-line indicators) if necessary. Trigraph sequences are replaced by
+ corresponding single-character internal representations.
+ 
+ 
+ 
+<!--page 29 indent 0-->
+<li>  Each instance of a backslash character (\) immediately followed by a new-line
+ character is deleted, splicing physical source lines to form logical source lines.
+ Only the last backslash on any physical source line shall be eligible for being part
+ of such a splice. A source file that is not empty shall end in a new-line character,
+ which shall not be immediately preceded by a backslash character before any such
+ splicing takes place.
+<li>  The source file is decomposed into preprocessing tokens<sup><a href="#note7"><b>7)</b></a></sup> and sequences of
+ white-space characters (including comments). A source file shall not end in a
+ partial preprocessing token or in a partial comment. Each comment is replaced by
+ one space character. New-line characters are retained. Whether each nonempty
+ sequence of white-space characters other than new-line is retained or replaced by
+ one space character is implementation-defined.
+<li>  Preprocessing directives are executed, macro invocations are expanded, and
+ _Pragma unary operator expressions are executed. If a character sequence that
+ matches the syntax of a universal character name is produced by token
+ concatenation (<a href="#6.10.3.3">6.10.3.3</a>), the behavior is undefined. A #include preprocessing
+ directive causes the named header or source file to be processed from phase 1
+ through phase 4, recursively. All preprocessing directives are then deleted.
+<li>  Each source character set member and escape sequence in character constants and
+ string literals is converted to the corresponding member of the execution character
+ set; if there is no corresponding member, it is converted to an implementation-
+ defined member other than the null (wide) character.<sup><a href="#note8"><b>8)</b></a></sup>
+<li>  Adjacent string literal tokens are concatenated.
+<li>  White-space characters separating tokens are no longer significant. Each
+ preprocessing token is converted into a token. The resulting tokens are
+ syntactically and semantically analyzed and translated as a translation unit.
+<li>  All external object and function references are resolved. Library components are
+ linked to satisfy external references to functions and objects not defined in the
+ current translation. All such translator output is collected into a program image
+ which contains information needed for execution in its execution environment.
+</ol>
+ Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
+ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href="#5.2.1.1">5.2.1.1</a>), external definitions (<a href="#6.9">6.9</a>).
+ 
+ 
+ 
+<!--page 30 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note6">6)</a> Implementations shall behave as if these separate phases occur, even though many are typically folded
+ together in practice. Source files, translation units, and translated translation units need not
+ necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
+ and any external representation. The description is conceptual only, and does not specify any
+ particular implementation.
+
+<p><a name="note7">7)</a> As described in <a href="#6.4">6.4</a>, the process of dividing a source file's characters into preprocessing tokens is
+ context-dependent. For example, see the handling of &lt; within a #include preprocessing directive.
+
+<p><a name="note8">8)</a> An implementation need not convert all non-corresponding source characters to the same execution
+ character.
+
+
+<a name="5.1.1.3" href="#5.1.1.3"><h5>5.1.1.3 Diagnostics</h5></a>
+<p><!--para 1-->
+ A conforming implementation shall produce at least one diagnostic message (identified in
+ an implementation-defined manner) if a preprocessing translation unit or translation unit
+ contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
+ specified as undefined or implementation-defined. Diagnostic messages need not be
+ produced in other circumstances.<sup><a href="#note9"><b>9)</b></a></sup>
+<p><!--para 2-->
+ EXAMPLE        An implementation shall issue a diagnostic for the translation unit:
+<pre>
+          char i;
+          int i;</pre>
+ because in those cases where wording in this International Standard describes the behavior for a construct
+ as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note9">9)</a> The intent is that an implementation should identify the nature of, and where possible localize, each
+ violation. Of course, an implementation is free to produce any number of diagnostics as long as a
+ valid program is still correctly translated. It may also successfully translate an invalid program.
+
+
+<a name="5.1.2" href="#5.1.2"><h4>5.1.2 Execution environments</h4></a>
+<p><!--para 1-->
+ Two execution environments are defined: freestanding and hosted. In both cases,
+ program startup occurs when a designated C function is called by the execution
+ environment. All objects with static storage duration shall be initialized (set to their
+ initial values) before program startup. The manner and timing of such initialization are
+ otherwise unspecified. Program termination returns control to the execution
+ environment.
+ Forward references: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+
+<a name="5.1.2.1" href="#5.1.2.1"><h5>5.1.2.1 Freestanding environment</h5></a>
+<p><!--para 1-->
+ In a freestanding environment (in which C program execution may take place without any
+ benefit of an operating system), the name and type of the function called at program
+ startup are implementation-defined. Any library facilities available to a freestanding
+ program, other than the minimal set required by clause 4, are implementation-defined.
+<p><!--para 2-->
+ The effect of program termination in a freestanding environment is implementation-
+ defined.
+
+<a name="5.1.2.2" href="#5.1.2.2"><h5>5.1.2.2 Hosted environment</h5></a>
+<p><!--para 1-->
+ A hosted environment need not be provided, but shall conform to the following
+ specifications if present.
+ 
+ 
+ 
+ 
+<!--page 31 indent 4-->
+
+<a name="5.1.2.2.1" href="#5.1.2.2.1"><h5>5.1.2.2.1 Program startup</h5></a>
+<p><!--para 1-->
+ The function called at program startup is named main. The implementation declares no
+ prototype for this function. It shall be defined with a return type of int and with no
+ parameters:
+<pre>
+         int main(void) { /* ... */ }</pre>
+ or with two parameters (referred to here as argc and argv, though any names may be
+ used, as they are local to the function in which they are declared):
+<pre>
+         int main(int argc, char *argv[]) { /* ... */ }</pre>
+ or equivalent;<sup><a href="#note10"><b>10)</b></a></sup> or in some other implementation-defined manner.
+<p><!--para 2-->
+ If they are declared, the parameters to the main function shall obey the following
+ constraints:
+<ul>
+<li>  The value of argc shall be nonnegative.
+<li>  argv[argc] shall be a null pointer.
+<li>  If the value of argc is greater than zero, the array members argv[0] through
+ argv[argc-1] inclusive shall contain pointers to strings, which are given
+ implementation-defined values by the host environment prior to program startup. The
+ intent is to supply to the program information determined prior to program startup
+ from elsewhere in the hosted environment. If the host environment is not capable of
+ supplying strings with letters in both uppercase and lowercase, the implementation
+ shall ensure that the strings are received in lowercase.
+<li>  If the value of argc is greater than zero, the string pointed to by argv[0]
+ represents the program name; argv[0][0] shall be the null character if the
+ program name is not available from the host environment. If the value of argc is
+ greater than one, the strings pointed to by argv[1] through argv[argc-1]
+ represent the program parameters.
+<li>  The parameters argc and argv and the strings pointed to by the argv array shall
+ be modifiable by the program, and retain their last-stored values between program
+ startup and program termination.
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note10">10)</a> Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
+ char ** argv, and so on.
+
+
+<a name="5.1.2.2.2" href="#5.1.2.2.2"><h5>5.1.2.2.2 Program execution</h5></a>
+<p><!--para 1-->
+ In a hosted environment, a program may use all the functions, macros, type definitions,
+ and objects described in the library clause (clause 7).
+ 
+ 
+ 
+ 
+<!--page 32 indent 4-->
+
+<a name="5.1.2.2.3" href="#5.1.2.2.3"><h5>5.1.2.2.3 Program termination</h5></a>
+<p><!--para 1-->
+ If the return type of the main function is a type compatible with int, a return from the
+ initial call to the main function is equivalent to calling the exit function with the value
+ returned by the main function as its argument;<sup><a href="#note11"><b>11)</b></a></sup> reaching the } that terminates the
+ main function returns a value of 0. If the return type is not compatible with int, the
+ termination status returned to the host environment is unspecified.
+ Forward references: definition of terms (<a href="#7.1.1">7.1.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>).
+
+<h6>footnotes</h6>
+<p><a name="note11">11)</a> In accordance with <a href="#6.2.4">6.2.4</a>, the lifetimes of objects with automatic storage duration declared in main
+ will have ended in the former case, even where they would not have in the latter.
+
+
+<a name="5.1.2.3" href="#5.1.2.3"><h5>5.1.2.3 Program execution</h5></a>
+<p><!--para 1-->
+ The semantic descriptions in this International Standard describe the behavior of an
+ abstract machine in which issues of optimization are irrelevant.
+<p><!--para 2-->
+ Accessing a volatile object, modifying an object, modifying a file, or calling a function
+ that does any of those operations are all side effects,<sup><a href="#note12"><b>12)</b></a></sup> which are changes in the state of
+ the execution environment. Evaluation of an expression in general includes both value
+ computations and initiation of side effects. Value computation for an lvalue expression
+ includes determining the identity of the designated object.
+<p><!--para 3-->
+ Sequenced before is an asymmetric, transitive, pair-wise relation between evaluations
+ executed by a single thread, which induces a partial order among those evaluations.
+ Given any two evaluations A and B, if A is sequenced before B, then the execution of A
+ shall precede the execution of B. (Conversely, if A is sequenced before B, then B is
+ sequenced after A.) If A is not sequenced before or after B, then A and B are
+ unsequenced. Evaluations A and B are indeterminately sequenced when A is sequenced
+ either before or after B, but it is unspecified which.<sup><a href="#note13"><b>13)</b></a></sup> The presence of a sequence point
+ between the evaluation of expressions A and B implies that every value computation and
+ side effect associated with A is sequenced before every value computation and side effect
+ associated with B. (A summary of the sequence points is given in <a href="#C">annex C</a>.)
+<p><!--para 4-->
+ In the abstract machine, all expressions are evaluated as specified by the semantics. An
+ actual implementation need not evaluate part of an expression if it can deduce that its
+ value is not used and that no needed side effects are produced (including any caused by
+ 
+<!--page 33 indent 5-->
+ calling a function or accessing a volatile object).
+<p><!--para 5-->
+ When the processing of the abstract machine is interrupted by receipt of a signal, the
+ values of objects that are neither lock-free atomic objects nor of type volatile
+ sig_atomic_t are unspecified, and the value of any object that is modified by the
+ handler that is neither a lock-free atomic object nor of type volatile
+ sig_atomic_t becomes undefined.
+<p><!--para 6-->
+ The least requirements on a conforming implementation are:
+<ul>
+<li>  Accesses to volatile objects are evaluated strictly according to the rules of the abstract
+ machine.
+<li>  At program termination, all data written into files shall be identical to the result that
+ execution of the program according to the abstract semantics would have produced.
+<li>  The input and output dynamics of interactive devices shall take place as specified in
+ <a href="#7.21.3">7.21.3</a>. The intent of these requirements is that unbuffered or line-buffered output
+ appear as soon as possible, to ensure that prompting messages actually appear prior to
+ a program waiting for input.
+</ul>
+ This is the observable behavior of the program.
+<p><!--para 7-->
+ What constitutes an interactive device is implementation-defined.
+<p><!--para 8-->
+ More stringent correspondences between abstract and actual semantics may be defined by
+ each implementation.
+<p><!--para 9-->
+ EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
+ semantics: at every sequence point, the values of the actual objects would agree with those specified by the
+ abstract semantics. The keyword volatile would then be redundant.
+<p><!--para 10-->
+ Alternatively, an implementation might perform various optimizations within each translation unit, such
+ that the actual semantics would agree with the abstract semantics only when making function calls across
+ translation unit boundaries. In such an implementation, at the time of each function entry and function
+ return where the calling function and the called function are in different translation units, the values of all
+ externally linked objects and of all objects accessible via pointers therein would agree with the abstract
+ semantics. Furthermore, at the time of each such function entry the values of the parameters of the called
+ function and of all objects accessible via pointers therein would agree with the abstract semantics. In this
+ type of implementation, objects referred to by interrupt service routines activated by the signal function
+ would require explicit specification of volatile storage, as well as other implementation-defined
+ restrictions.
+ 
+<p><!--para 11-->
+ EXAMPLE 2       In executing the fragment
+<pre>
+          char c1, c2;
+          /* ... */
+          c1 = c1 + c2;</pre>
+ the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
+ and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
+ overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
+ produce the same result, possibly omitting the promotions.
+<!--page 34 indent 5-->
+<p><!--para 12-->
+ EXAMPLE 3       Similarly, in the fragment
+<pre>
+          float f1, f2;
+          double d;
+          /* ... */
+          f1 = f2 * d;</pre>
+ the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
+ that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
+ were replaced by the constant 2.0, which has type double).
+ 
+<p><!--para 13-->
+ EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
+ semantics. Values are independent of whether they are represented in a register or in memory. For
+ example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
+ is required to round to the precision of the storage type. In particular, casts and assignments are required to
+ perform their specified conversion. For the fragment
+<pre>
+          double d1, d2;
+          float f;
+          d1 = f = expression;
+          d2 = (float) expression;</pre>
+ the values assigned to d1 and d2 are required to have been converted to float.
+ 
+<p><!--para 14-->
+ EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
+ precision as well as range. The implementation cannot generally apply the mathematical associative rules
+ for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
+ overflow and underflow. Likewise, implementations cannot generally replace decimal constants in order to
+ rearrange expressions. In the following fragment, rearrangements suggested by mathematical rules for real
+ numbers are often not valid (see <a href="#F.9">F.9</a>).
+<pre>
+          double x, y, z;
+          /* ... */
+          x = (x * y) * z;            //   not equivalent to x   *= y * z;
+          z = (x - y) + y ;           //   not equivalent to z   = x;
+          z = x + x * y;              //   not equivalent to z   = x * (1.0 + y);
+          y = x / 5.0;                //   not equivalent to y   = x * 0.2;</pre>
+ 
+<p><!--para 15-->
+ EXAMPLE 6       To illustrate the grouping behavior of expressions, in the following fragment
+<pre>
+          int a, b;
+          /* ... */
+          a = a + 32760 + b + 5;</pre>
+ the expression statement behaves exactly the same as
+<pre>
+          a = (((a + 32760) + b) + 5);</pre>
+ due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
+ next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
+ which overflows produce an explicit trap and in which the range of values representable by an int is
+ [-32768, +32767], the implementation cannot rewrite this expression as
+<pre>
+          a = ((a + b) + 32765);</pre>
+ since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
+ while the original expression would not; nor can the expression be rewritten either as
+<!--page 35 indent 5-->
+<pre>
+          a = ((a + 32765) + b);</pre>
+ or
+<pre>
+          a = (a + (b + 32765));</pre>
+ since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
+ in which overflow silently generates some value and where positive and negative overflows cancel, the
+ above expression statement can be rewritten by the implementation in any of the above ways because the
+ same result will occur.
+ 
+<p><!--para 16-->
+ EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
+ following fragment
+<pre>
+          #include &lt;stdio.h&gt;
+          int sum;
+          char *p;
+          /* ... */
+          sum = sum * 10 - '0' + (*p++ = getchar());</pre>
+ the expression statement is grouped as if it were written as
+<pre>
+          sum = (((sum * 10) - '0') + ((*(p++)) = (getchar())));</pre>
+ but the actual increment of p can occur at any time between the previous sequence point and the next
+ sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
+ value.
+ 
+ Forward references: expressions (<a href="#6.5">6.5</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>), statements (<a href="#6.8">6.8</a>), the
+ signal function (<a href="#7.14">7.14</a>), files (<a href="#7.21.3">7.21.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note12">12)</a> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
+ flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
+ values of floating-point operations. Implementations that support such floating-point state are
+ required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
+ environment library &lt;fenv.h&gt; provides a programming facility for indicating when these side
+ effects matter, freeing the implementations in other cases.
+
+<p><a name="note13">13)</a> The executions of unsequenced evaluations can interleave. Indeterminately sequenced evaluations
+ cannot interleave, but can be executed in any order.
+
+
+<a name="5.1.2.4" href="#5.1.2.4"><h5>5.1.2.4 Multi-threaded executions and data races</h5></a>
+<p><!--para 1-->
+ Under a hosted implementation, a program can have more than one thread of execution
+ (or thread) running concurrently. The execution of each thread proceeds as defined by
+ the remainder of this standard. The execution of the entire program consists of an
+ execution of all of its threads.<sup><a href="#note14"><b>14)</b></a></sup> Under a freestanding implementation, it is
+ implementation-defined whether a program can have more than one thread of execution.
+<p><!--para 2-->
+ The value of an object visible to a thread T at a particular point is the initial value of the
+ object, a value stored in the object by T , or a value stored in the object by another thread,
+ according to the rules below.
+<p><!--para 3-->
+ NOTE 1 In some cases, there may instead be undefined behavior. Much of this section is motivated by
+ the desire to support atomic operations with explicit and detailed visibility constraints. However, it also
+ implicitly supports a simpler view for more restricted programs.
+ 
+<p><!--para 4-->
+ Two expression evaluations conflict if one of them modifies a memory location and the
+ other one reads or modifies the same memory location.
+ 
+ 
+ 
+ 
+<!--page 36 indent 5-->
+<p><!--para 5-->
+ The library defines a number of atomic operations (<a href="#7.17">7.17</a>) and operations on mutexes
+ (<a href="#7.25.4">7.25.4</a>) that are specially identified as synchronization operations. These operations play
+ a special role in making assignments in one thread visible to another. A synchronization
+ operation on one or more memory locations is either an acquire operation, a release
+ operation, both an acquire and release operation, or a consume operation. A
+ synchronization operation without an associated memory location is a fence and can be
+ either an acquire fence, a release fence, or both an acquire and release fence. In addition,
+ there are relaxed atomic operations, which are not synchronization operations, and
+ atomic read-modify-write operations, which have special characteristics.
+<p><!--para 6-->
+ NOTE 2 For example, a call that acquires a mutex will perform an acquire operation on the locations
+ composing the mutex. Correspondingly, a call that releases the same mutex will perform a release
+ operation on those same locations. Informally, performing a release operation on A forces prior side effects
+ on other memory locations to become visible to other threads that later perform an acquire or consume
+ operation on A. We do not include relaxed atomic operations as synchronization operations although, like
+ synchronization operations, they cannot contribute to data races.
+ 
+<p><!--para 7-->
+ All modifications to a particular atomic object M occur in some particular total order,
+ called the modification order of M. If A and B are modifications of an atomic object M,
+ and A happens before B, then A shall precede B in the modification order of M, which is
+ defined below.
+<p><!--para 8-->
+ NOTE 3     This states that the modification orders must respect the ''happens before'' relation.
+ 
+<p><!--para 9-->
+ NOTE 4 There is a separate order for each atomic object. There is no requirement that these can be
+ combined into a single total order for all objects. In general this will be impossible since different threads
+ may observe modifications to different variables in inconsistent orders.
+ 
+<p><!--para 10-->
+ A release sequence on an atomic object M is a maximal contiguous sub-sequence of side
+ effects in the modification order of M, where the first operation is a release and every
+ subsequent operation either is performed by the same thread that performed the release or
+ is an atomic read-modify-write operation.
+<p><!--para 11-->
+ Certain library calls synchronize with other library calls performed by another thread. In
+ particular, an atomic operation A that performs a release operation on an object M
+ synchronizes with an atomic operation B that performs an acquire operation on M and
+ reads a value written by any side effect in the release sequence headed by A.
+<p><!--para 12-->
+ NOTE 5 Except in the specified cases, reading a later value does not necessarily ensure visibility as
+ described below. Such a requirement would sometimes interfere with efficient implementation.
+ 
+<p><!--para 13-->
+ NOTE 6 The specifications of the synchronization operations define when one reads the value written by
+ another. For atomic variables, the definition is clear. All operations on a given mutex occur in a single total
+ order. Each mutex acquisition ''reads the value written'' by the last mutex release.
+ 
+<p><!--para 14-->
+ An evaluation A carries a dependency <sup><a href="#note15"><b>15)</b></a></sup> to an evaluation B if:
+ 
+ 
+<!--page 37 indent 5-->
+<ul>
+<li>  the value of A is used as an operand of B, unless:
+<ul>
+<li> B is an invocation of the kill_dependency macro,
+ 
+<li> A is the left operand of a &amp;&amp; or || operator,
+ 
+<li> A is the left operand of a ? : operator, or
+ 
+<li> A is the left operand of a , operator;
+</ul>
+   or
+<li>  A writes a scalar object or bit-field M, B reads from M the value written by A, and A
+ is sequenced before B, or
+<li>  for some evaluation X, A carries a dependency to X and X carries a dependency to B.
+</ul>
+<p><!--para 15-->
+ An evaluation A is dependency-ordered before<sup><a href="#note16"><b>16)</b></a></sup> an evaluation B if:
+<ul>
+<li>  A performs a release operation on an atomic object M, and B performs a consume
+ operation on M and reads a value written by any side effect in the release sequence
+ headed by A, or
+<li>  for some evaluation X, A is dependency-ordered before X and X carries a
+ dependency to B.
+</ul>
+<p><!--para 16-->
+ An evaluation A inter-thread happens before an evaluation B if A synchronizes with B, A
+ is dependency-ordered before B, or, for some evaluation X:
+<ul>
+<li>  A synchronizes with X and X is sequenced before B,
+<li>  A is sequenced before X and X inter-thread happens before B, or
+<li>  A inter-thread happens before X and X inter-thread happens before B.
+</ul>
+<p><!--para 17-->
+ NOTE 7 The ''inter-thread happens before'' relation describes arbitrary concatenations of ''sequenced
+ before'', ''synchronizes with'', and ''dependency-ordered before'' relationships, with two exceptions. The
+ first exception is that a concatenation is not permitted to end with ''dependency-ordered before'' followed
+ by ''sequenced before''. The reason for this limitation is that a consume operation participating in a
+ ''dependency-ordered before'' relationship provides ordering only with respect to operations to which this
+ consume operation actually carries a dependency. The reason that this limitation applies only to the end of
+ such a concatenation is that any subsequent release operation will provide the required ordering for a prior
+ consume operation. The second exception is that a concatenation is not permitted to consist entirely of
+ ''sequenced before''. The reasons for this limitation are (1) to permit ''inter-thread happens before'' to be
+ transitively closed and (2) the ''happens before'' relation, defined below, provides for relationships
+ consisting entirely of ''sequenced before''.
+ 
+<p><!--para 18-->
+ An evaluation A happens before an evaluation B if A is sequenced before B or A inter-
+ thread happens before B.
+ 
+ 
+ 
+<!--page 38 indent 5-->
+<p><!--para 19-->
+ A visible side effect A on an object M with respect to a value computation B of M
+ satisfies the conditions:
+<ul>
+<li>  A happens before B, and
+<li>  there is no other side effect X to M such that A happens before X and X happens
+   before B.
+</ul>
+ The value of a non-atomic scalar object M, as determined by evaluation B, shall be the
+ value stored by the visible side effect A.
+<p><!--para 20-->
+ NOTE 8 If there is ambiguity about which side effect to a non-atomic object is visible, then there is a data
+ race and the behavior is undefined.
+ 
+<p><!--para 21-->
+ NOTE 9 This states that operations on ordinary variables are not visibly reordered. This is not actually
+ detectable without data races, but it is necessary to ensure that data races, as defined here, and with suitable
+ restrictions on the use of atomics, correspond to data races in a simple interleaved (sequentially consistent)
+ execution.
+ 
+<p><!--para 22-->
+ The visible sequence of side effects on an atomic object M, with respect to a value
+ computation B of M, is a maximal contiguous sub-sequence of side effects in the
+ modification order of M, where the first side effect is visible with respect to B, and for
+ every subsequent side effect, it is not the case that B happens before it. The value of an
+ atomic object M, as determined by evaluation B, shall be the value stored by some
+ operation in the visible sequence of M with respect to B. Furthermore, if a value
+ computation A of an atomic object M happens before a value computation B of M, and
+ the value computed by A corresponds to the value stored by side effect X, then the value
+ computed by B shall either equal the value computed by A, or be the value stored by side
+ effect Y , where Y follows X in the modification order of M.
+<p><!--para 23-->
+ NOTE 10 This effectively disallows compiler reordering of atomic operations to a single object, even if
+ both operations are ''relaxed'' loads. By doing so, we effectively make the ''cache coherence'' guarantee
+ provided by most hardware available to C atomic operations.
+ 
+<p><!--para 24-->
+ NOTE 11 The visible sequence depends on the ''happens before'' relation, which in turn depends on the
+ values observed by loads of atomics, which we are restricting here. The intended reading is that there must
+ exist an association of atomic loads with modifications they observe that, together with suitably chosen
+ modification orders and the ''happens before'' relation derived as described above, satisfy the resulting
+ constraints as imposed here.
+ 
+<p><!--para 25-->
+ The execution of a program contains a data race if it contains two conflicting actions in
+ different threads, at least one of which is not atomic, and neither happens before the
+ other. Any such data race results in undefined behavior.
+<p><!--para 26-->
+ NOTE 12 It can be shown that programs that correctly use simple mutexes and
+ memory_order_seq_cst operations to prevent all data races, and use no other synchronization
+ operations, behave as though the operations executed by their constituent threads were simply interleaved,
+ with each value computation of an object being the last value stored in that interleaving. This is normally
+ referred to as ''sequential consistency''. However, this applies only to data-race-free programs, and data-
+ race-free programs cannot observe most program transformations that do not change single-threaded
+ program semantics. In fact, most single-threaded program transformations continue to be allowed, since
+ any program that behaves differently as a result must contain undefined behavior.
+<!--page 39 indent 5-->
+<p><!--para 27-->
+ NOTE 13 Compiler transformations that introduce assignments to a potentially shared memory location
+ that would not be modified by the abstract machine are generally precluded by this standard, since such an
+ assignment might overwrite another assignment by a different thread in cases in which an abstract machine
+ execution would not have encountered a data race. This includes implementations of data member
+ assignment that overwrite adjacent members in separate memory locations. We also generally preclude
+ reordering of atomic loads in cases in which the atomics in question may alias, since this may violate the
+ "visible sequence" rules.
+ 
+<p><!--para 28-->
+ NOTE 14 Transformations that introduce a speculative read of a potentially shared memory location may
+ not preserve the semantics of the program as defined in this standard, since they potentially introduce a data
+ race. However, they are typically valid in the context of an optimizing compiler that targets a specific
+ machine with well-defined semantics for data races. They would be invalid for a hypothetical machine that
+ is not tolerant of races or provides hardware race detection.
+<!--page 40 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note14">14)</a> The execution can usually be viewed as an interleaving of all of the threads. However, some kinds of
+ atomic operations, for example, allow executions inconsistent with a simple interleaving as described
+ below.
+
+<p><a name="note15">15)</a> The ''carries a dependency'' relation is a subset of the ''sequenced before'' relation, and is similarly
+ strictly intra-thread.
+
+<p><a name="note16">16)</a> The ''dependency-ordered before'' relation is analogous to the ''synchronizes with'' relation, but uses
+ release/consume in place of release/acquire.
+
+
+<a name="5.2" href="#5.2"><h3>5.2 Environmental considerations</h3></a>
+
+<a name="5.2.1" href="#5.2.1"><h4>5.2.1 Character sets</h4></a>
+<p><!--para 1-->
+ Two sets of characters and their associated collating sequences shall be defined: the set in
+ which source files are written (the source character set), and the set interpreted in the
+ execution environment (the execution character set). Each set is further divided into a
+ basic character set, whose contents are given by this subclause, and a set of zero or more
+ locale-specific members (which are not members of the basic character set) called
+ extended characters. The combined set is also called the extended character set. The
+ values of the members of the execution character set are implementation-defined.
+<p><!--para 2-->
+ In a character constant or string literal, members of the execution character set shall be
+ represented by corresponding members of the source character set or by escape
+ sequences consisting of the backslash \ followed by one or more characters. A byte with
+ all bits set to 0, called the null character, shall exist in the basic execution character set; it
+ is used to terminate a character string.
+<p><!--para 3-->
+ Both the basic source and basic execution character sets shall have the following
+ members: the 26 uppercase letters of the Latin alphabet
+<pre>
+         A    B   C      D   E   F    G    H    I    J    K    L   M
+         N    O   P      Q   R   S    T    U    V    W    X    Y   Z</pre>
+ the 26 lowercase letters of the Latin alphabet
+<pre>
+         a    b   c      d   e   f    g    h    i    j    k    l   m
+         n    o   p      q   r   s    t    u    v    w    x    y   z</pre>
+ the 10 decimal digits
+<pre>
+         0    1   2      3   4   5    6    7    8    9</pre>
+ the following 29 graphic characters
+<pre>
+         !    "   #      %   &amp;   '    (    )    *    +    ,    -   .    /    :
+         ;    &lt;   =      &gt;   ?   [    \    ]    ^    _    {    |   }    ~</pre>
+ the space character, and control characters representing horizontal tab, vertical tab, and
+ form feed. The representation of each member of the source and execution basic
+ character sets shall fit in a byte. In both the source and execution basic character sets, the
+ value of each character after 0 in the above list of decimal digits shall be one greater than
+ the value of the previous. In source files, there shall be some way of indicating the end of
+ each line of text; this International Standard treats such an end-of-line indicator as if it
+ were a single new-line character. In the basic execution character set, there shall be
+ control characters representing alert, backspace, carriage return, and new line. If any
+ other characters are encountered in a source file (except in an identifier, a character
+ constant, a string literal, a header name, a comment, or a preprocessing token that is never
+<!--page 41 indent 4-->
+ converted to a token), the behavior is undefined.
+<p><!--para 4-->
+ A letter is an uppercase letter or a lowercase letter as defined above; in this International
+ Standard the term does not include other characters that are letters in other alphabets.
+<p><!--para 5-->
+ The universal character name construct provides a way to name other characters.
+ Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
+ preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
+
+<a name="5.2.1.1" href="#5.2.1.1"><h5>5.2.1.1 Trigraph sequences</h5></a>
+<p><!--para 1-->
+ Before any other processing takes place, each occurrence of one of the following
+ sequences of three characters (called trigraph sequences<sup><a href="#note17"><b>17)</b></a></sup>) is replaced with the
+ corresponding single character.
+<pre>
+        ??=      #                       ??)      ]                       ??!     |
+        ??(      [                       ??'      ^                       ??&gt;     }
+        ??/      \                       ??&lt;      {                       ??-     ~</pre>
+ No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
+ above is not changed.
+<p><!--para 2-->
+ EXAMPLE 1
+<pre>
+           ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)</pre>
+ becomes
+<pre>
+           #define arraycheck(a, b) a[b] || b[a]</pre>
+ 
+<p><!--para 3-->
+ EXAMPLE 2      The following source line
+<pre>
+           printf("Eh???/n");</pre>
+ becomes (after replacement of the trigraph sequence ??/)
+<pre>
+           printf("Eh?\n");</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note17">17)</a> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
+ described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
+
+
+<a name="5.2.1.2" href="#5.2.1.2"><h5>5.2.1.2 Multibyte characters</h5></a>
+<p><!--para 1-->
+ The source character set may contain multibyte characters, used to represent members of
+ the extended character set. The execution character set may also contain multibyte
+ characters, which need not have the same encoding as for the source character set. For
+ both character sets, the following shall hold:
+<ul>
+<li>  The basic character set shall be present and each character shall be encoded as a
+ single byte.
+<li>  The presence, meaning, and representation of any additional members is locale-
+ specific.
+ 
+<!--page 42 indent 4-->
+<li>  A multibyte character set may have a state-dependent encoding, wherein each
+ sequence of multibyte characters begins in an initial shift state and enters other
+ locale-specific shift states when specific multibyte characters are encountered in the
+ sequence. While in the initial shift state, all single-byte characters retain their usual
+ interpretation and do not alter the shift state. The interpretation for subsequent bytes
+ in the sequence is a function of the current shift state.
+<li>  A byte with all bits zero shall be interpreted as a null character independent of shift
+ state. Such a byte shall not occur as part of any other multibyte character.
+</ul>
+<p><!--para 2-->
+ For source files, the following shall hold:
+<ul>
+<li>  An identifier, comment, string literal, character constant, or header name shall begin
+ and end in the initial shift state.
+<li>  An identifier, comment, string literal, character constant, or header name shall consist
+ of a sequence of valid multibyte characters.
+</ul>
+
+<a name="5.2.2" href="#5.2.2"><h4>5.2.2 Character display semantics</h4></a>
+<p><!--para 1-->
+ The active position is that location on a display device where the next character output by
+ the fputc function would appear. The intent of writing a printing character (as defined
+ by the isprint function) to a display device is to display a graphic representation of
+ that character at the active position and then advance the active position to the next
+ position on the current line. The direction of writing is locale-specific. If the active
+ position is at the final position of a line (if there is one), the behavior of the display device
+ is unspecified.
+<p><!--para 2-->
+ Alphabetic escape sequences representing nongraphic characters in the execution
+ character set are intended to produce actions on display devices as follows:
+ \a (alert) Produces an audible or visible alert without changing the active position.
+ \b (backspace) Moves the active position to the previous position on the current line. If
+<pre>
+    the active position is at the initial position of a line, the behavior of the display
+    device is unspecified.</pre>
+ \f ( form feed) Moves the active position to the initial position at the start of the next
+<pre>
+    logical page.</pre>
+ \n (new line) Moves the active position to the initial position of the next line.
+ \r (carriage return) Moves the active position to the initial position of the current line.
+ \t (horizontal tab) Moves the active position to the next horizontal tabulation position
+<pre>
+    on the current line. If the active position is at or past the last defined horizontal
+    tabulation position, the behavior of the display device is unspecified.</pre>
+ \v (vertical tab) Moves the active position to the initial position of the next vertical
+<!--page 43 indent 4-->
+<p><!--para 3-->
+<pre>
+    tabulation position. If the active position is at or past the last defined vertical
+      tabulation position, the behavior of the display device is unspecified.</pre>
+ Each of these escape sequences shall produce a unique implementation-defined value
+ which can be stored in a single char object. The external representations in a text file
+ need not be identical to the internal representations, and are outside the scope of this
+ International Standard.
+ Forward references: the isprint function (<a href="#7.4.1.8">7.4.1.8</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>).
+
+<a name="5.2.3" href="#5.2.3"><h4>5.2.3 Signals and interrupts</h4></a>
+<p><!--para 1-->
+ Functions shall be implemented such that they may be interrupted at any time by a signal,
+ or may be called by a signal handler, or both, with no alteration to earlier, but still active,
+ invocations' control flow (after the interruption), function return values, or objects with
+ automatic storage duration. All such objects shall be maintained outside the function
+ image (the instructions that compose the executable representation of a function) on a
+ per-invocation basis.
+
+<a name="5.2.4" href="#5.2.4"><h4>5.2.4 Environmental limits</h4></a>
+<p><!--para 1-->
+ Both the translation and execution environments constrain the implementation of
+ language translators and libraries. The following summarizes the language-related
+ environmental limits on a conforming implementation; the library-related limits are
+ discussed in clause 7.
+
+<a name="5.2.4.1" href="#5.2.4.1"><h5>5.2.4.1 Translation limits</h5></a>
+<p><!--para 1-->
+ The implementation shall be able to translate and execute at least one program that
+ contains at least one instance of every one of the following limits:<sup><a href="#note18"><b>18)</b></a></sup>
+<ul>
+<li>  127 nesting levels of blocks
+<li>  63 nesting levels of conditional inclusion
+<li>  12 pointer, array, and function declarators (in any combinations) modifying an
+ arithmetic, structure, union, or void type in a declaration
+<li>  63 nesting levels of parenthesized declarators within a full declarator
+<li>  63 nesting levels of parenthesized expressions within a full expression
+<li>  63 significant initial characters in an internal identifier or a macro name (each
+ universal character name or extended source character is considered a single
+ character)
+<li>  31 significant initial characters in an external identifier (each universal character name
+ specifying a short identifier of 0000FFFF or less is considered 6 characters, each
+ 
+ 
+<!--page 44 indent 4-->
+<pre>
+    universal character name specifying a short identifier of 00010000 or more is
+    considered 10 characters, and each extended source character is considered the same
+    number of characters as the corresponding universal character name, if any)<sup><a href="#note19"><b>19)</b></a></sup></pre>
+<li>  4095 external identifiers in one translation unit
+<li>  511 identifiers with block scope declared in one block
+<li>  4095 macro identifiers simultaneously defined in one preprocessing translation unit
+<li>  127 parameters in one function definition
+<li>  127 arguments in one function call
+<li>  127 parameters in one macro definition
+<li>  127 arguments in one macro invocation
+<li>  4095 characters in a logical source line
+<li>  4095 characters in a string literal (after concatenation)
+<li>  65535 bytes in an object (in a hosted environment only)
+<li>  15 nesting levels for #included files
+<li>  1023 case labels for a switch statement (excluding those for any nested switch
+ statements)
+<li>  1023 members in a single structure or union
+<li>  1023 enumeration constants in a single enumeration
+<li>  63 levels of nested structure or union definitions in a single struct-declaration-list
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note18">18)</a> Implementations should avoid imposing fixed translation limits whenever possible.
+
+<p><a name="note19">19)</a> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
+
+
+<a name="5.2.4.2" href="#5.2.4.2"><h5>5.2.4.2 Numerical limits</h5></a>
+<p><!--para 1-->
+ An implementation is required to document all the limits specified in this subclause,
+ which are specified in the headers &lt;limits.h&gt; and &lt;float.h&gt;. Additional limits are
+ specified in &lt;stdint.h&gt;.
+ Forward references: integer types &lt;stdint.h&gt; (<a href="#7.20">7.20</a>).
+
+<a name="5.2.4.2.1" href="#5.2.4.2.1"><h5>5.2.4.2.1 Sizes of integer types <limits.h></h5></a>
+<p><!--para 1-->
+ The values given below shall be replaced by constant expressions suitable for use in #if
+ preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
+ following shall be replaced by expressions that have the same type as would an
+ expression that is an object of the corresponding type converted according to the integer
+ promotions. Their implementation-defined values shall be equal or greater in magnitude
+ 
+ 
+<!--page 45 indent 0-->
+ (absolute value) to those shown, with the same sign.
+<ul>
+<li>  number of bits for smallest object that is not a bit-field (byte)
+ CHAR_BIT                                            8
+<li>  minimum value for an object of type signed char
+ SCHAR_MIN                                -127 // -(27 - 1)
+<li>  maximum value for an object of type signed char
+ SCHAR_MAX                                +127 // 27 - 1
+<li>  maximum value for an object of type unsigned char
+ UCHAR_MAX                                 255 // 28 - 1
+<li>  minimum value for an object of type char
+ CHAR_MIN                               see below
+<li>  maximum value for an object of type char
+ CHAR_MAX                              see below
+<li>  maximum number of bytes in a multibyte character, for any supported locale
+ MB_LEN_MAX                                    1
+<li>  minimum value for an object of type short int
+ SHRT_MIN                               -32767 // -(215 - 1)
+<li>  maximum value for an object of type short int
+ SHRT_MAX                               +32767 // 215 - 1
+<li>  maximum value for an object of type unsigned short int
+ USHRT_MAX                               65535 // 216 - 1
+<li>  minimum value for an object of type int
+ INT_MIN                                 -32767 // -(215 - 1)
+<li>  maximum value for an object of type int
+ INT_MAX                                +32767 // 215 - 1
+<li>  maximum value for an object of type unsigned int
+ UINT_MAX                                65535 // 216 - 1
+<li>  minimum value for an object of type long int
+ LONG_MIN                         -2147483647 // -(231 - 1)
+<li>  maximum value for an object of type long int
+ LONG_MAX                         +2147483647 // 231 - 1
+<li>  maximum value for an object of type unsigned long int
+ ULONG_MAX                         4294967295 // 232 - 1
+<!--page 46 indent 4-->
+<li>  minimum value for an object of type long long int
+ LLONG_MIN          -9223372036854775807 // -(263 - 1)
+<li>  maximum value for an object of type long long int
+ LLONG_MAX          +9223372036854775807 // 263 - 1
+<li>  maximum value for an object of type unsigned long long int
+ ULLONG_MAX         18446744073709551615 // 264 - 1
+</ul>
+<p><!--para 2-->
+ If the value of an object of type char is treated as a signed integer when used in an
+ expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
+ value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
+ CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
+ UCHAR_MAX.<sup><a href="#note20"><b>20)</b></a></sup> The value UCHAR_MAX shall equal 2CHAR_BIT - 1.
+ Forward references: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note20">20)</a> See <a href="#6.2.5">6.2.5</a>.
+
+
+<a name="5.2.4.2.2" href="#5.2.4.2.2"><h5>5.2.4.2.2 Characteristics of floating types <float.h></h5></a>
+<p><!--para 1-->
+ The characteristics of floating types are defined in terms of a model that describes a
+ representation of floating-point numbers and values that provide information about an
+ implementation's floating-point arithmetic.<sup><a href="#note21"><b>21)</b></a></sup> The following parameters are used to
+ define the model for each floating-point type:
+<p><!--para 2-->
+<pre>
+        s          sign ((+-)1)
+        b          base or radix of exponent representation (an integer &gt; 1)
+        e          exponent (an integer between a minimum emin and a maximum emax )
+        p          precision (the number of base-b digits in the significand)
+         fk        nonnegative integers less than b (the significand digits)</pre>
+ A floating-point number (x) is defined by the following model:
+<pre>
+                    p
+        x = sb e   (Sum) f k b-k ,
+                   k=1
+                                 emin &lt;= e &lt;= emax</pre>
+ 
+<p><!--para 3-->
+ In addition to normalized floating-point numbers ( f 1 &gt; 0 if x != 0), floating types may be
+ able to contain other kinds of floating-point numbers, such as subnormal floating-point
+ numbers (x != 0, e = emin , f 1 = 0) and unnormalized floating-point numbers (x != 0,
+ e &gt; emin , f 1 = 0), and values that are not floating-point numbers, such as infinities and
+ NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates
+ through almost every arithmetic operation without raising a floating-point exception; a
+ signaling NaN generally raises a floating-point exception when occurring as an
+ 
+ 
+<!--page 47 indent 4-->
+ arithmetic operand.<sup><a href="#note22"><b>22)</b></a></sup>
+<p><!--para 4-->
+ An implementation may give zero and values that are not floating-point numbers (such as
+ infinities and NaNs) a sign or may leave them unsigned. Wherever such values are
+ unsigned, any requirement in this International Standard to retrieve the sign shall produce
+ an unspecified sign, and any requirement to set the sign shall be ignored.
+<p><!--para 5-->
+ The minimum range of representable values for a floating type is the most negative finite
+ floating-point number representable in that type through the most positive finite floating-
+ point number representable in that type. In addition, if negative infinity is representable
+ in a type, the range of that type is extended to all negative real numbers; likewise, if
+ positive infinity is representable in a type, the range of that type is extended to all positive
+ real numbers.
+<p><!--para 6-->
+ The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
+ &lt;math.h&gt; and &lt;complex.h&gt; that return floating-point results is implementation-
+ defined, as is the accuracy of the conversion between floating-point internal
+ representations and string representations performed by the library functions in
+ &lt;stdio.h&gt;, &lt;stdlib.h&gt;, and &lt;wchar.h&gt;. The implementation may state that the
+ accuracy is unknown.
+<p><!--para 7-->
+ All integer values in the &lt;float.h&gt; header, except FLT_ROUNDS, shall be constant
+ expressions suitable for use in #if preprocessing directives; all floating values shall be
+ constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
+ and FLT_ROUNDS have separate names for all three floating-point types. The floating-
+ point model representation is provided for all values except FLT_EVAL_METHOD and
+ FLT_ROUNDS.
+<p><!--para 8-->
+ The rounding mode for floating-point addition is characterized by the implementation-
+ defined value of FLT_ROUNDS:<sup><a href="#note23"><b>23)</b></a></sup>
+<pre>
+       -1      indeterminable
+        0      toward zero
+        1      to nearest
+        2      toward positive infinity
+        3      toward negative infinity</pre>
+ All other values for FLT_ROUNDS characterize implementation-defined rounding
+ behavior.
+ 
+ 
+<!--page 48 indent 5-->
+<p><!--para 9-->
+ Except for assignment and cast (which remove all extra range and precision), the values
+ yielded by operators with floating operands and values subject to the usual arithmetic
+ conversions and of floating constants are evaluated to a format whose range and precision
+ may be greater than required by the type. The use of evaluation formats is characterized
+ by the implementation-defined value of FLT_EVAL_METHOD:<sup><a href="#note24"><b>24)</b></a></sup>
+<pre>
+        -1         indeterminable;
+          0        evaluate all operations and constants just to the range and precision of the
+                   type;
+          1        evaluate operations and constants of type float and double to the
+                   range and precision of the double type, evaluate long double
+                   operations and constants to the range and precision of the long double
+                   type;
+          2        evaluate all operations and constants to the range and precision of the
+                   long double type.</pre>
+ All other negative values for FLT_EVAL_METHOD characterize implementation-defined
+ behavior.
+<p><!--para 10-->
+ The presence or absence of subnormal numbers is characterized by the implementation-
+ defined     values     of    FLT_HAS_SUBNORM,          DBL_HAS_SUBNORM,           and
+ LDBL_HAS_SUBNORM:
+<p><!--para 11-->
+<pre>
+        -1       indeterminable<sup><a href="#note25"><b>25)</b></a></sup>
+         0       absent<sup><a href="#note26"><b>26)</b></a></sup> (type does not support subnormal numbers)
+         1       present (type does support subnormal numbers)</pre>
+ The values given in the following list shall be replaced by constant expressions with
+ implementation-defined values that are greater or equal in magnitude (absolute value) to
+ those shown, with the same sign:
+<ul>
+<li>  radix of exponent representation, b
+ FLT_RADIX                                                    2
+ 
+ 
+ 
+ 
+<!--page 49 indent 0-->
+<li>  number of base-FLT_RADIX digits in the floating-point significand, p
+  FLT_MANT_DIG
+  DBL_MANT_DIG
+  LDBL_MANT_DIG
+<li>  number of decimal digits, n, such that any floating-point number with p radix b digits
+ can be rounded to a floating-point number with n decimal digits and back again
+ without change to the value,
+<pre>
+      { p log10 b        if b is a power of 10
+      {
+      { [^1 + p log10 b^] otherwise</pre>
+  FLT_DECIMAL_DIG                                   6
+  DBL_DECIMAL_DIG                                  10
+  LDBL_DECIMAL_DIG                                 10
+<li>  number of decimal digits, n, such that any floating-point number in the widest
+ supported floating type with pmax radix b digits can be rounded to a floating-point
+ number with n decimal digits and back again without change to the value,
+<pre>
+      { pmax log10 b       if b is a power of 10
+      {
+      { [^1 + pmax log10 b^] otherwise</pre>
+  DECIMAL_DIG                                     10
+<li>  number of decimal digits, q, such that any floating-point number with q decimal digits
+ can be rounded into a floating-point number with p radix b digits and back again
+ without change to the q decimal digits,
+<pre>
+      { p log10 b          if b is a power of 10
+      {
+      { [_( p - 1) log10 b_] otherwise</pre>
+  FLT_DIG                                          6
+  DBL_DIG                                         10
+  LDBL_DIG                                        10
+<li>  minimum negative integer such that FLT_RADIX raised to one less than that power is
+ a normalized floating-point number, emin
+  FLT_MIN_EXP
+  DBL_MIN_EXP
+  LDBL_MIN_EXP
+<!--page 50 indent 5-->
+<li>  minimum negative integer such that 10 raised to that power is in the range of
+ normalized floating-point numbers, [^log10 b emin -1 ^]
+<pre>
+                                   [                  ]</pre>
+ FLT_MIN_10_EXP                                 -37
+ DBL_MIN_10_EXP                                 -37
+ LDBL_MIN_10_EXP                                -37
+<li>  maximum integer such that FLT_RADIX raised to one less than that power is a
+ representable finite floating-point number, emax
+<pre>
+    FLT_MAX_EXP
+    DBL_MAX_EXP
+    LDBL_MAX_EXP</pre>
+<li>  maximum integer such that 10 raised to that power is in the range of representable
+ finite floating-point numbers, [_log10 ((1 - b- p )b emax )_]
+</ul>
+<p><!--para 12-->
+<pre>
+    FLT_MAX_10_EXP                               +37
+    DBL_MAX_10_EXP                               +37
+    LDBL_MAX_10_EXP                              +37</pre>
+ The values given in the following list shall be replaced by constant expressions with
+ implementation-defined values that are greater than or equal to those shown:
+<ul>
+<li>  maximum representable finite floating-point number, (1 - b- p )b emax
+</ul>
+<p><!--para 13-->
+<pre>
+    FLT_MAX                                   1E+37
+    DBL_MAX                                   1E+37
+    LDBL_MAX                                  1E+37</pre>
+ The values given in the following list shall be replaced by constant expressions with
+ implementation-defined (positive) values that are less than or equal to those shown:
+<ul>
+<li>  the difference between 1 and the least value greater than 1 that is representable in the
+ given floating point type, b1- p
+<pre>
+    FLT_EPSILON                                1E-5
+    DBL_EPSILON                                1E-9
+    LDBL_EPSILON                               1E-9</pre>
+<li>  minimum normalized positive floating-point number, b emin -1
+<!--page 51 indent 5-->
+<pre>
+    FLT_MIN                                   1E-37
+    DBL_MIN                                   1E-37
+    LDBL_MIN                                  1E-37</pre>
+<li>  minimum positive floating-point number<sup><a href="#note27"><b>27)</b></a></sup>
+   FLT_TRUE_MIN                                       1E-37
+   DBL_TRUE_MIN                                       1E-37
+   LDBL_TRUE_MIN                                      1E-37
+</ul>
+ Recommended practice
+<p><!--para 14-->
+ Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
+ should be the identity function.
+<p><!--para 15-->
+ EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
+ requirements of this International Standard, and the appropriate values in a &lt;float.h&gt; header for type
+ float:
+<pre>
+                    6
+       x = s16e    (Sum) f k 16-k ,
+                   k=1
+                                   -31 &lt;= e &lt;= +32</pre>
+ 
+<pre>
+         FLT_RADIX                                    16
+         FLT_MANT_DIG                                  6
+         FLT_EPSILON                     9.53674316E-07F
+         FLT_DECIMAL_DIG                               9
+         FLT_DIG                                       6
+         FLT_MIN_EXP                                 -31
+         FLT_MIN                         2.93873588E-39F
+         FLT_MIN_10_EXP                              -38
+         FLT_MAX_EXP                                 +32
+         FLT_MAX                         3.40282347E+38F
+         FLT_MAX_10_EXP                              +38</pre>
+ 
+<p><!--para 16-->
+ EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
+ single-precision and double-precision numbers in IEC 60559,<sup><a href="#note28"><b>28)</b></a></sup> and the appropriate values in a
+ &lt;float.h&gt; header for types float and double:
+<pre>
+                   24
+       x f = s2e   (Sum) f k 2-k ,
+                   k=1
+                                  -125 &lt;= e &lt;= +128</pre>
+ 
+<pre>
+                   53
+       x d = s2e   (Sum) f k 2-k ,
+                   k=1
+                                  -1021 &lt;= e &lt;= +1024</pre>
+ 
+<pre>
+         FLT_RADIX                                     2
+         DECIMAL_DIG                                  17
+         FLT_MANT_DIG                                 24
+         FLT_EPSILON                     1.19209290E-07F // decimal constant
+         FLT_EPSILON                            0X1P-23F // hex constant
+         FLT_DECIMAL_DIG                               9</pre>
+ 
+ 
+<!--page 52 indent 0-->
+<pre>
+         FLT_DIG                             6
+         FLT_MIN_EXP                      -125
+         FLT_MIN               1.17549435E-38F               //   decimal constant
+         FLT_MIN                     0X1P-126F               //   hex constant
+         FLT_TRUE_MIN          1.40129846E-45F               //   decimal constant
+         FLT_TRUE_MIN                0X1P-149F               //   hex constant
+         FLT_HAS_SUBNORM                     1
+         FLT_MIN_10_EXP                    -37
+         FLT_MAX_EXP                      +128
+         FLT_MAX               3.40282347E+38F               // decimal constant
+         FLT_MAX               0X1.fffffeP127F               // hex constant
+         FLT_MAX_10_EXP                    +38
+         DBL_MANT_DIG                       53
+         DBL_EPSILON    2.2204460492503131E-16               // decimal constant
+         DBL_EPSILON                   0X1P-52               // hex constant
+         DBL_DECIMAL_DIG                    17
+         DBL_DIG                            15
+         DBL_MIN_EXP                     -1021
+         DBL_MIN      2.2250738585072014E-308                //   decimal constant
+         DBL_MIN                     0X1P-1022               //   hex constant
+         DBL_TRUE_MIN 4.9406564584124654E-324                //   decimal constant
+         DBL_TRUE_MIN                0X1P-1074               //   hex constant
+         DBL_HAS_SUBNORM                     1
+         DBL_MIN_10_EXP                   -307
+         DBL_MAX_EXP                     +1024
+         DBL_MAX      1.7976931348623157E+308                // decimal constant
+         DBL_MAX        0X1.fffffffffffffP1023               // hex constant
+         DBL_MAX_10_EXP                   +308</pre>
+ If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
+ example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
+ precision), then DECIMAL_DIG would be 21.
+ 
+ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
+ &lt;complex.h&gt; (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities &lt;wchar.h&gt;
+ (<a href="#7.28">7.28</a>), floating-point environment &lt;fenv.h&gt; (<a href="#7.6">7.6</a>), general utilities &lt;stdlib.h&gt;
+ (<a href="#7.22">7.22</a>), input/output &lt;stdio.h&gt; (<a href="#7.21">7.21</a>), mathematics &lt;math.h&gt; (<a href="#7.12">7.12</a>).
+<!--page 53 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note21">21)</a> The floating-point model is intended to clarify the description of each floating-point characteristic and
+ does not require the floating-point arithmetic of the implementation to be identical.
+
+<p><a name="note22">22)</a> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
+ IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
+ similar behavior.
+
+<p><a name="note23">23)</a> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
+ the function fesetround in &lt;fenv.h&gt;.
+
+<p><a name="note24">24)</a> The evaluation method determines evaluation formats of expressions involving all floating types, not
+ just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
+ _Complex operands is represented in the double _Complex format, and its parts are evaluated to
+ double.
+
+<p><a name="note25">25)</a> Characterization as indeterminable is intended if floating-point operations do not consistently interpret
+ subnormal representations as zero, nor as nonzero.
+
+<p><a name="note26">26)</a> Characterization as absent is intended if no floating-point operations produce subnormal results from
+ non-subnormal inputs, even if the type format includes representations of subnormal numbers.
+
+<p><a name="note27">27)</a> If the presence or absence of subnormal numbers is indeterminable, then the value is intended to be a
+ positive number no greater than the minimum normalized positive number for the type.
+
+<p><a name="note28">28)</a> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
+ limits are one less than shown here.
+
+
+<a name="6" href="#6"><h2>6. Language</h2></a>
+
+<a name="6.1" href="#6.1"><h3>6.1 Notation</h3></a>
+<p><!--para 1-->
+ In the syntax notation used in this clause, syntactic categories (nonterminals) are
+ indicated by italic type, and literal words and character set members (terminals) by bold
+ type. A colon (:) following a nonterminal introduces its definition. Alternative
+ definitions are listed on separate lines, except when prefaced by the words ''one of''. An
+ optional symbol is indicated by the subscript ''opt'', so that
+<pre>
+          { expressionopt }</pre>
+ indicates an optional expression enclosed in braces.
+<p><!--para 2-->
+ When syntactic categories are referred to in the main text, they are not italicized and
+ words are separated by spaces instead of hyphens.
+<p><!--para 3-->
+ A summary of the language syntax is given in <a href="#A">annex A</a>.
+
+<a name="6.2" href="#6.2"><h3>6.2 Concepts</h3></a>
+
+<a name="6.2.1" href="#6.2.1"><h4>6.2.1 Scopes of identifiers</h4></a>
+<p><!--para 1-->
+ An identifier can denote an object; a function; a tag or a member of a structure, union, or
+ enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
+ same identifier can denote different entities at different points in the program. A member
+ of an enumeration is called an enumeration constant. Macro names and macro
+ parameters are not considered further here, because prior to the semantic phase of
+ program translation any occurrences of macro names in the source file are replaced by the
+ preprocessing token sequences that constitute their macro definitions.
+<p><!--para 2-->
+ For each different entity that an identifier designates, the identifier is visible (i.e., can be
+ used) only within a region of program text called its scope. Different entities designated
+ by the same identifier either have different scopes, or are in different name spaces. There
+ are four kinds of scopes: function, file, block, and function prototype. (A function
+ prototype is a declaration of a function that declares the types of its parameters.)
+<p><!--para 3-->
+ A label name is the only kind of identifier that has function scope. It can be used (in a
+ goto statement) anywhere in the function in which it appears, and is declared implicitly
+ by its syntactic appearance (followed by a : and a statement).
+<p><!--para 4-->
+ Every other identifier has scope determined by the placement of its declaration (in a
+ declarator or type specifier). If the declarator or type specifier that declares the identifier
+ appears outside of any block or list of parameters, the identifier has file scope, which
+ terminates at the end of the translation unit. If the declarator or type specifier that
+ declares the identifier appears inside a block or within the list of parameter declarations in
+ a function definition, the identifier has block scope, which terminates at the end of the
+ associated block. If the declarator or type specifier that declares the identifier appears
+<!--page 54 indent 4-->
+ within the list of parameter declarations in a function prototype (not part of a function
+ definition), the identifier has function prototype scope, which terminates at the end of the
+ function declarator. If an identifier designates two different entities in the same name
+ space, the scopes might overlap. If so, the scope of one entity (the inner scope) will end
+ strictly before the scope of the other entity (the outer scope). Within the inner scope, the
+ identifier designates the entity declared in the inner scope; the entity declared in the outer
+ scope is hidden (and not visible) within the inner scope.
+<p><!--para 5-->
+ Unless explicitly stated otherwise, where this International Standard uses the term
+ ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
+ entity in the relevant name space whose declaration is visible at the point the identifier
+ occurs.
+<p><!--para 6-->
+ Two identifiers have the same scope if and only if their scopes terminate at the same
+ point.
+<p><!--para 7-->
+ Structure, union, and enumeration tags have scope that begins just after the appearance of
+ the tag in a type specifier that declares the tag. Each enumeration constant has scope that
+ begins just after the appearance of its defining enumerator in an enumerator list. Any
+ other identifier has scope that begins just after the completion of its declarator.
+<p><!--para 8-->
+ As a special case, a type name (which is not a declaration of an identifier) is considered to
+ have a scope that begins just after the place within the type name where the omitted
+ identifier would appear were it not omitted.
+ Forward references: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
+ (<a href="#6.9.1">6.9.1</a>), identifiers (<a href="#6.4.2">6.4.2</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), name spaces of identifiers (<a href="#6.2.3">6.2.3</a>),
+ source file inclusion (<a href="#6.10.2">6.10.2</a>), statements (<a href="#6.8">6.8</a>).
+
+<a name="6.2.2" href="#6.2.2"><h4>6.2.2 Linkages of identifiers</h4></a>
+<p><!--para 1-->
+ An identifier declared in different scopes or in the same scope more than once can be
+ made to refer to the same object or function by a process called linkage.<sup><a href="#note29"><b>29)</b></a></sup> There are
+ three kinds of linkage: external, internal, and none.
+<p><!--para 2-->
+ In the set of translation units and libraries that constitutes an entire program, each
+ declaration of a particular identifier with external linkage denotes the same object or
+ function. Within one translation unit, each declaration of an identifier with internal
+ linkage denotes the same object or function. Each declaration of an identifier with no
+ linkage denotes a unique entity.
+<p><!--para 3-->
+ If the declaration of a file scope identifier for an object or a function contains the storage-
+ class specifier static, the identifier has internal linkage.<sup><a href="#note30"><b>30)</b></a></sup>
+ 
+ 
+ 
+<!--page 55 indent 4-->
+<p><!--para 4-->
+ For an identifier declared with the storage-class specifier extern in a scope in which a
+ prior declaration of that identifier is visible,<sup><a href="#note31"><b>31)</b></a></sup> if the prior declaration specifies internal or
+ external linkage, the linkage of the identifier at the later declaration is the same as the
+ linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
+ declaration specifies no linkage, then the identifier has external linkage.
+<p><!--para 5-->
+ If the declaration of an identifier for a function has no storage-class specifier, its linkage
+ is determined exactly as if it were declared with the storage-class specifier extern. If
+ the declaration of an identifier for an object has file scope and no storage-class specifier,
+ its linkage is external.
+<p><!--para 6-->
+ The following identifiers have no linkage: an identifier declared to be anything other than
+ an object or a function; an identifier declared to be a function parameter; a block scope
+ identifier for an object declared without the storage-class specifier extern.
+<p><!--para 7-->
+ If, within a translation unit, the same identifier appears with both internal and external
+ linkage, the behavior is undefined.
+ Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
+ statements (<a href="#6.8">6.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note29">29)</a> There is no linkage between different identifiers.
+
+<p><a name="note30">30)</a> A function declaration can contain the storage-class specifier static only if it is at file scope; see
+ <a href="#6.7.1">6.7.1</a>.
+
+<p><a name="note31">31)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+
+
+<a name="6.2.3" href="#6.2.3"><h4>6.2.3 Name spaces of identifiers</h4></a>
+<p><!--para 1-->
+ If more than one declaration of a particular identifier is visible at any point in a
+ translation unit, the syntactic context disambiguates uses that refer to different entities.
+ Thus, there are separate name spaces for various categories of identifiers, as follows:
+<ul>
+<li>  label names (disambiguated by the syntax of the label declaration and use);
+<li>  the tags of structures, unions, and enumerations (disambiguated by following any<sup><a href="#note32"><b>32)</b></a></sup>
+ of the keywords struct, union, or enum);
+<li>  the members of structures or unions; each structure or union has a separate name
+ space for its members (disambiguated by the type of the expression used to access the
+ member via the . or -&gt; operator);
+<li>  all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
+ enumeration constants).
+</ul>
+ Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
+ structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>), tags
+ (<a href="#6.7.2.3">6.7.2.3</a>), the goto statement (<a href="#6.8.6.1">6.8.6.1</a>).
+ 
+<!--page 56 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note32">32)</a> There is only one name space for tags even though three are possible.
+
+
+<a name="6.2.4" href="#6.2.4"><h4>6.2.4 Storage durations of objects</h4></a>
+<p><!--para 1-->
+ An object has a storage duration that determines its lifetime. There are four storage
+ durations: static, thread, automatic, and allocated. Allocated storage is described in
+ <a href="#7.22.3">7.22.3</a>.
+<p><!--para 2-->
+ The lifetime of an object is the portion of program execution during which storage is
+ guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note33"><b>33)</b></a></sup> and retains
+ its last-stored value throughout its lifetime.<sup><a href="#note34"><b>34)</b></a></sup> If an object is referred to outside of its
+ lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
+ the object it points to (or just past) reaches the end of its lifetime.
+<p><!--para 3-->
+ An object whose identifier is declared without the storage-class specifier
+ _Thread_local, and either with external or internal linkage or with the storage-class
+ specifier static, has static storage duration. Its lifetime is the entire execution of the
+ program and its stored value is initialized only once, prior to program startup.
+<p><!--para 4-->
+ An object whose identifier is declared with the storage-class specifier _Thread_local
+ has thread storage duration. Its lifetime is the entire execution of the thread for which it
+ is created, and its stored value is initialized when the thread is started. There is a distinct
+ object per thread, and use of the declared name in an expression refers to the object
+ associated with the thread evaluating the expression. The result of attempting to
+ indirectly access an object with thread storage duration from a thread other than the one
+ with which the object is associated is implementation-defined.
+<p><!--para 5-->
+ An object whose identifier is declared with no linkage and without the storage-class
+ specifier static has automatic storage duration, as do some compound literals. The
+ result of attempting to indirectly access an object with automatic storage duration from a
+ thread other than the one with which the object is associated is implementation-defined.
+<p><!--para 6-->
+ For such an object that does not have a variable length array type, its lifetime extends
+ from entry into the block with which it is associated until execution of that block ends in
+ any way. (Entering an enclosed block or calling a function suspends, but does not end,
+ execution of the current block.) If the block is entered recursively, a new instance of the
+ object is created each time. The initial value of the object is indeterminate. If an
+ initialization is specified for the object, it is performed each time the declaration or
+ compound literal is reached in the execution of the block; otherwise, the value becomes
+ indeterminate each time the declaration is reached.
+ 
+ 
+ 
+<!--page 57 indent 4-->
+<p><!--para 7-->
+ For such an object that does have a variable length array type, its lifetime extends from
+ the declaration of the object until execution of the program leaves the scope of the
+ declaration.<sup><a href="#note35"><b>35)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
+ each time. The initial value of the object is indeterminate.
+<p><!--para 8-->
+ A non-lvalue expression with structure or union type, where the structure or union
+ contains a member with array type (including, recursively, members of all contained
+ structures and unions) refers to an object with automatic storage duration and temporary
+ lifetime.<sup><a href="#note36"><b>36)</b></a></sup> Its lifetime begins when the expression is evaluated and its initial value is the
+ value of the expression. Its lifetime ends when the evaluation of the containing full
+ expression or full declarator ends. Any attempt to modify an object with temporary
+ lifetime results in undefined behavior.
+ Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), compound literals (<a href="#6.5.2.5">6.5.2.5</a>), declarators
+ (<a href="#6.7.6">6.7.6</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), initialization (<a href="#6.7.9">6.7.9</a>), statements (<a href="#6.8">6.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note33">33)</a> The term ''constant address'' means that two pointers to the object constructed at possibly different
+ times will compare equal. The address may be different during two different executions of the same
+ program.
+
+<p><a name="note34">34)</a> In the case of a volatile object, the last store need not be explicit in the program.
+
+<p><a name="note35">35)</a> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
+ embedded block prior to the declaration, leaves the scope of the declaration.
+
+<p><a name="note36">36)</a> The address of such an object is taken implicitly when an array member is accessed.
+
+
+<a name="6.2.5" href="#6.2.5"><h4>6.2.5 Types</h4></a>
+<p><!--para 1-->
+ The meaning of a value stored in an object or returned by a function is determined by the
+ type of the expression used to access it. (An identifier declared to be an object is the
+ simplest such expression; the type is specified in the declaration of the identifier.) Types
+ are partitioned into object types (types that describe objects) and function types (types
+ that describe functions). At various points within a translation unit an object type may be
+ incomplete (lacking sufficient information to determine the size of objects of that type) or
+ complete (having sufficient information).<sup><a href="#note37"><b>37)</b></a></sup>
+<p><!--para 2-->
+ An object declared as type _Bool is large enough to store the values 0 and 1.
+<p><!--para 3-->
+ An object declared as type char is large enough to store any member of the basic
+ execution character set. If a member of the basic execution character set is stored in a
+ char object, its value is guaranteed to be nonnegative. If any other character is stored in
+ a char object, the resulting value is implementation-defined but shall be within the range
+ of values that can be represented in that type.
+<p><!--para 4-->
+ There are five standard signed integer types, designated as signed char, short
+ int, int, long int, and long long int. (These and other types may be
+ designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
+ implementation-defined extended signed integer types.<sup><a href="#note38"><b>38)</b></a></sup> The standard and extended
+ signed integer types are collectively called signed integer types.<sup><a href="#note39"><b>39)</b></a></sup>
+ 
+<!--page 58 indent 5-->
+<p><!--para 5-->
+ An object declared as type signed char occupies the same amount of storage as a
+ ''plain'' char object. A ''plain'' int object has the natural size suggested by the
+ architecture of the execution environment (large enough to contain any value in the range
+ INT_MIN to INT_MAX as defined in the header &lt;limits.h&gt;).
+<p><!--para 6-->
+ For each of the signed integer types, there is a corresponding (but different) unsigned
+ integer type (designated with the keyword unsigned) that uses the same amount of
+ storage (including sign information) and has the same alignment requirements. The type
+ _Bool and the unsigned integer types that correspond to the standard signed integer
+ types are the standard unsigned integer types. The unsigned integer types that
+ correspond to the extended signed integer types are the extended unsigned integer types.
+ The standard and extended unsigned integer types are collectively called unsigned integer
+ types.<sup><a href="#note40"><b>40)</b></a></sup>
+<p><!--para 7-->
+ The standard signed integer types and standard unsigned integer types are collectively
+ called the standard integer types, the extended signed integer types and extended
+ unsigned integer types are collectively called the extended integer types.
+<p><!--para 8-->
+ For any two integer types with the same signedness and different integer conversion rank
+ (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
+ subrange of the values of the other type.
+<p><!--para 9-->
+ The range of nonnegative values of a signed integer type is a subrange of the
+ corresponding unsigned integer type, and the representation of the same value in each
+ type is the same.<sup><a href="#note41"><b>41)</b></a></sup> A computation involving unsigned operands can never overflow,
+ because a result that cannot be represented by the resulting unsigned integer type is
+ reduced modulo the number that is one greater than the largest value that can be
+ represented by the resulting type.
+<p><!--para 10-->
+ There are three real floating types, designated as float, double, and long
+ double.<sup><a href="#note42"><b>42)</b></a></sup> The set of values of the type float is a subset of the set of values of the
+ type double; the set of values of the type double is a subset of the set of values of the
+ type long double.
+ 
+ 
+<!--page 59 indent 5-->
+<p><!--para 11-->
+ There are three complex types, designated as float _Complex, double
+ _Complex, and long double _Complex.<sup><a href="#note43"><b>43)</b></a></sup> (Complex types are a conditional
+ feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.) The real floating and
+ complex types are collectively called the floating types.
+<p><!--para 12-->
+ For each floating type there is a corresponding real type, which is always a real floating
+ type. For real floating types, it is the same type. For complex types, it is the type given
+ by deleting the keyword _Complex from the type name.
+<p><!--para 13-->
+ Each complex type has the same representation and alignment requirements as an array
+ type containing exactly two elements of the corresponding real type; the first element is
+ equal to the real part, and the second element to the imaginary part, of the complex
+ number.
+<p><!--para 14-->
+ The type char, the signed and unsigned integer types, and the floating types are
+ collectively called the basic types. The basic types are complete object types. Even if the
+ implementation defines two or more basic types to have the same representation, they are
+ nevertheless different types.<sup><a href="#note44"><b>44)</b></a></sup>
+<p><!--para 15-->
+ The three types char, signed char, and unsigned char are collectively called
+ the character types. The implementation shall define char to have the same range,
+ representation, and behavior as either signed char or unsigned char.<sup><a href="#note45"><b>45)</b></a></sup>
+<p><!--para 16-->
+ An enumeration comprises a set of named integer constant values. Each distinct
+ enumeration constitutes a different enumerated type.
+<p><!--para 17-->
+ The type char, the signed and unsigned integer types, and the enumerated types are
+ collectively called integer types. The integer and real floating types are collectively called
+ real types.
+<p><!--para 18-->
+ Integer and floating types are collectively called arithmetic types. Each arithmetic type
+ belongs to one type domain: the real type domain comprises the real types, the complex
+ type domain comprises the complex types.
+<p><!--para 19-->
+ The void type comprises an empty set of values; it is an incomplete object type that
+ cannot be completed.
+ 
+ 
+ 
+<!--page 60 indent 5-->
+<p><!--para 20-->
+ Any number of derived types can be constructed from the object and function types, as
+ follows:
+<ul>
+<li>  An array type describes a contiguously allocated nonempty set of objects with a
+ particular member object type, called the element type. The element type shall be
+ complete whenever the array type is specified. Array types are characterized by their
+ element type and by the number of elements in the array. An array type is said to be
+ derived from its element type, and if its element type is T , the array type is sometimes
+ called ''array of T ''. The construction of an array type from an element type is called
+ ''array type derivation''.
+<li>  A structure type describes a sequentially allocated nonempty set of member objects
+ (and, in certain circumstances, an incomplete array), each of which has an optionally
+ specified name and possibly distinct type.
+<li>  A union type describes an overlapping nonempty set of member objects, each of
+ which has an optionally specified name and possibly distinct type.
+<li>  A function type describes a function with specified return type. A function type is
+ characterized by its return type and the number and types of its parameters. A
+ function type is said to be derived from its return type, and if its return type is T , the
+ function type is sometimes called ''function returning T ''. The construction of a
+ function type from a return type is called ''function type derivation''.
+<li>  A pointer type may be derived from a function type or an object type, called the
+ referenced type. A pointer type describes an object whose value provides a reference
+ to an entity of the referenced type. A pointer type derived from the referenced type T
+ is sometimes called ''pointer to T ''. The construction of a pointer type from a
+ referenced type is called ''pointer type derivation''. A pointer type is a complete
+ object type.
+<li>  An atomic type describes the type designated by the construct _Atomic ( type-
+ name ). (Atomic types are a conditional feature that implementations need not
+ support; see <a href="#6.10.8.3">6.10.8.3</a>.)
+</ul>
+ These methods of constructing derived types can be applied recursively.
+<p><!--para 21-->
+ Arithmetic types and pointer types are collectively called scalar types. Array and
+ structure types are collectively called aggregate types.<sup><a href="#note46"><b>46)</b></a></sup>
+<p><!--para 22-->
+ An array type of unknown size is an incomplete type. It is completed, for an identifier of
+ that type, by specifying the size in a later declaration (with internal or external linkage).
+ A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
+ 
+ 
+<!--page 61 indent 5-->
+ type. It is completed, for all declarations of that type, by declaring the same structure or
+ union tag with its defining content later in the same scope.
+<p><!--para 23-->
+ A type has known constant size if the type is not incomplete and is not a variable length
+ array type.
+<p><!--para 24-->
+ Array, function, and pointer types are collectively called derived declarator types. A
+ declarator type derivation from a type T is the construction of a derived declarator type
+ from T by the application of an array-type, a function-type, or a pointer-type derivation to
+ T.
+<p><!--para 25-->
+ A type is characterized by its type category, which is either the outermost derivation of a
+ derived type (as noted above in the construction of derived types), or the type itself if the
+ type consists of no derived types.
+<p><!--para 26-->
+ Any type so far mentioned is an unqualified type. Each unqualified type has several
+ qualified versions of its type,<sup><a href="#note47"><b>47)</b></a></sup> corresponding to the combinations of one, two, or all
+ three of the const, volatile, and restrict qualifiers. The qualified or unqualified
+ versions of a type are distinct types that belong to the same type category and have the
+ same representation and alignment requirements.<sup><a href="#note48"><b>48)</b></a></sup> A derived type is not qualified by the
+ qualifiers (if any) of the type from which it is derived.
+<p><!--para 27-->
+ Further, there is the _Atomic qualifier. The presence of the _Atomic qualifier
+ designates an atomic type. The size, representation, and alignment of an atomic type
+ need not be the same as those of the corresponding unqualified type. Therefore, this
+ Standard explicitly uses the phrase ''atomic, qualified or unqualified type'' whenever the
+ atomic version of a type is permitted along with the other qualified versions of a type.
+ The phrase ''qualified or unqualified type'', without specific mention of atomic, does not
+ include the atomic types.
+<p><!--para 28-->
+ A pointer to void shall have the same representation and alignment requirements as a
+ pointer to a character type.48) Similarly, pointers to qualified or unqualified versions of
+ compatible types shall have the same representation and alignment requirements. All
+ pointers to structure types shall have the same representation and alignment requirements
+ as each other. All pointers to union types shall have the same representation and
+ alignment requirements as each other. Pointers to other types need not have the same
+ representation or alignment requirements.
+<p><!--para 29-->
+ EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
+ pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
+ whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
+ 
+ 
+<!--page 62 indent 5-->
+ qualified float'' and is a pointer to a qualified type.
+ 
+<p><!--para 30-->
+ EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
+ function returning struct tag''. The array has length five and the function has a single parameter of type
+ float. Its type category is array.
+ 
+ Forward references: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
+
+<h6>footnotes</h6>
+<p><a name="note37">37)</a> A type may be incomplete or complete throughout an entire translation unit, or it may change states at
+ different points within a translation unit.
+
+<p><a name="note38">38)</a> Implementation-defined keywords shall have the form of an identifier reserved for any use as
+ described in <a href="#7.1.3">7.1.3</a>.
+
+<p><a name="note39">39)</a> Therefore, any statement in this Standard about signed integer types also applies to the extended
+ signed integer types.
+
+<p><a name="note40">40)</a> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
+ unsigned integer types.
+
+<p><a name="note41">41)</a> The same representation and alignment requirements are meant to imply interchangeability as
+ arguments to functions, return values from functions, and members of unions.
+
+<p><a name="note42">42)</a> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
+
+<p><a name="note43">43)</a> A specification for imaginary types is in <a href="#G">annex G</a>.
+
+<p><a name="note44">44)</a> An implementation may define new keywords that provide alternative ways to designate a basic (or
+ any other) type; this does not violate the requirement that all basic types be different.
+ Implementation-defined keywords shall have the form of an identifier reserved for any use as
+ described in <a href="#7.1.3">7.1.3</a>.
+
+<p><a name="note45">45)</a> CHAR_MIN, defined in &lt;limits.h&gt;, will have one of the values 0 or SCHAR_MIN, and this can be
+ used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
+ other two and is not compatible with either.
+
+<p><a name="note46">46)</a> Note that aggregate type does not include union type because an object with union type can only
+ contain one member at a time.
+
+<p><a name="note47">47)</a> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
+
+<p><a name="note48">48)</a> The same representation and alignment requirements are meant to imply interchangeability as
+ arguments to functions, return values from functions, and members of unions.
+
+
+<a name="6.2.6" href="#6.2.6"><h4>6.2.6 Representations of types</h4></a>
+
+<a name="6.2.6.1" href="#6.2.6.1"><h5>6.2.6.1 General</h5></a>
+<p><!--para 1-->
+ The representations of all types are unspecified except as stated in this subclause.
+<p><!--para 2-->
+ Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
+ the number, order, and encoding of which are either explicitly specified or
+ implementation-defined.
+<p><!--para 3-->
+ Values stored in unsigned bit-fields and objects of type unsigned char shall be
+ represented using a pure binary notation.<sup><a href="#note49"><b>49)</b></a></sup>
+<p><!--para 4-->
+ Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
+ bits, where n is the size of an object of that type, in bytes. The value may be copied into
+ an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
+ called the object representation of the value. Values stored in bit-fields consist of m bits,
+ where m is the size specified for the bit-field. The object representation is the set of m
+ bits the bit-field comprises in the addressable storage unit holding it. Two values (other
+ than NaNs) with the same object representation compare equal, but values that compare
+ equal may have different object representations.
+<p><!--para 5-->
+ Certain object representations need not represent a value of the object type. If the stored
+ value of an object has such a representation and is read by an lvalue expression that does
+ not have character type, the behavior is undefined. If such a representation is produced
+ by a side effect that modifies all or any part of the object by an lvalue expression that
+ does not have character type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup> Such a representation is called
+ a trap representation.
+<p><!--para 6-->
+ When a value is stored in an object of structure or union type, including in a member
+ object, the bytes of the object representation that correspond to any padding bytes take
+ unspecified values.<sup><a href="#note51"><b>51)</b></a></sup> The value of a structure or union object is never a trap
+ 
+ 
+<!--page 63 indent 4-->
+ representation, even though the value of a member of the structure or union object may be
+ a trap representation.
+<p><!--para 7-->
+ When a value is stored in a member of an object of union type, the bytes of the object
+ representation that do not correspond to that member but do correspond to other members
+ take unspecified values.
+<p><!--para 8-->
+ Where an operator is applied to a value that has more than one object representation,
+ which object representation is used shall not affect the value of the result.<sup><a href="#note52"><b>52)</b></a></sup> Where a
+ value is stored in an object using a type that has more than one object representation for
+ that value, it is unspecified which representation is used, but a trap representation shall
+ not be generated.
+<p><!--para 9-->
+ Loads and stores of objects with                            atomic       types     are     done      with
+ memory_order_seq_cst semantics.
+ Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
+ designators (<a href="#6.3.2.1">6.3.2.1</a>), order and consistency (<a href="#7.17.3">7.17.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note49">49)</a> A positional representation for integers that uses the binary digits 0 and 1, in which the values
+ represented by successive bits are additive, begin with 1, and are multiplied by successive integral
+ powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
+ Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
+ type unsigned char range from 0 to 2
+
+<pre>
+                                           CHAR_BIT
+                                                     - 1.</pre>
+
+<p><a name="note50">50)</a> Thus, an automatic variable can be initialized to a trap representation without causing undefined
+ behavior, but the value of the variable cannot be used until a proper value is stored in it.
+
+<p><a name="note51">51)</a> Thus, for example, structure assignment need not copy any padding bits.
+
+<p><a name="note52">52)</a> It is possible for objects x and y with the same effective type T to have the same value when they are
+ accessed as objects of type T, but to have different values in other contexts. In particular, if == is
+ defined for type T, then x == y does not imply that memcmp(&amp;x, &amp;y, sizeof (T)) == 0.
+ Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
+ on values of type T may distinguish between them.
+
+
+<a name="6.2.6.2" href="#6.2.6.2"><h5>6.2.6.2 Integer types</h5></a>
+<p><!--para 1-->
+ For unsigned integer types other than unsigned char, the bits of the object
+ representation shall be divided into two groups: value bits and padding bits (there need
+ not be any of the latter). If there are N value bits, each bit shall represent a different
+ power of 2 between 1 and 2 N -1 , so that objects of that type shall be capable of
+ representing values from 0 to 2 N - 1 using a pure binary representation; this shall be
+ known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note53"><b>53)</b></a></sup>
+<p><!--para 2-->
+ For signed integer types, the bits of the object representation shall be divided into three
+ groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
+ signed char shall not have any padding bits. There shall be exactly one sign bit.
+ Each bit that is a value bit shall have the same value as the same bit in the object
+ representation of the corresponding unsigned type (if there are M value bits in the signed
+ type and N in the unsigned type, then M &lt;= N ). If the sign bit is zero, it shall not affect
+ 
+<!--page 64 indent 4-->
+ the resulting value. If the sign bit is one, the value shall be modified in one of the
+ following ways:
+<ul>
+<li>  the corresponding value with sign bit 0 is negated (sign and magnitude);
+<li>  the sign bit has the value -(2 M ) (two's complement);
+<li>  the sign bit has the value -(2 M - 1) (ones' complement).
+</ul>
+ Which of these applies is implementation-defined, as is whether the value with sign bit 1
+ and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones'
+ complement), is a trap representation or a normal value. In the case of sign and
+ magnitude and ones' complement, if this representation is a normal value it is called a
+ negative zero.
+<p><!--para 3-->
+ If the implementation supports negative zeros, they shall be generated only by:
+<ul>
+<li>  the &amp;, |, ^, ~, &lt;&lt;, and &gt;&gt; operators with operands that produce such a value;
+<li>  the +, -, *, /, and % operators where one operand is a negative zero and the result is
+ zero;
+<li>  compound assignment operators based on the above cases.
+</ul>
+ It is unspecified whether these cases actually generate a negative zero or a normal zero,
+ and whether a negative zero becomes a normal zero when stored in an object.
+<p><!--para 4-->
+ If the implementation does not support negative zeros, the behavior of the &amp;, |, ^, ~, &lt;&lt;,
+ and &gt;&gt; operators with operands that would produce such a value is undefined.
+<p><!--para 5-->
+ The values of any padding bits are unspecified.<sup><a href="#note54"><b>54)</b></a></sup> A valid (non-trap) object representation
+ of a signed integer type where the sign bit is zero is a valid object representation of the
+ corresponding unsigned type, and shall represent the same value. For any integer type,
+ the object representation where all the bits are zero shall be a representation of the value
+ zero in that type.
+<p><!--para 6-->
+ The precision of an integer type is the number of bits it uses to represent values,
+ excluding any sign and padding bits. The width of an integer type is the same but
+ including any sign bit; thus for unsigned integer types the two values are the same, while
+ for signed integer types the width is one greater than the precision.
+ 
+ 
+ 
+ 
+<!--page 65 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note53">53)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
+ bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+ representation other than as part of an exceptional condition such as an overflow, and this cannot occur
+ with unsigned types. All other combinations of padding bits are alternative object representations of
+ the value specified by the value bits.
+
+<p><a name="note54">54)</a> Some combinations of padding bits might generate trap representations, for example, if one padding
+ bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+ representation other than as part of an exceptional condition such as an overflow. All other
+ combinations of padding bits are alternative object representations of the value specified by the value
+ bits.
+
+
+<a name="6.2.7" href="#6.2.7"><h4>6.2.7 Compatible type and composite type</h4></a>
+<p><!--para 1-->
+ Two types have compatible type if their types are the same. Additional rules for
+ determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
+ in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.6">6.7.6</a> for declarators.<sup><a href="#note55"><b>55)</b></a></sup> Moreover, two structure,
+ union, or enumerated types declared in separate translation units are compatible if their
+ tags and members satisfy the following requirements: If one is declared with a tag, the
+ other shall be declared with the same tag. If both are completed anywhere within their
+ respective translation units, then the following additional requirements apply: there shall
+ be a one-to-one correspondence between their members such that each pair of
+ corresponding members are declared with compatible types; if one member of the pair is
+ declared with an alignment specifier, the other is declared with an equivalent alignment
+ specifier; and if one member of the pair is declared with a name, the other is declared
+ with the same name. For two structures, corresponding members shall be declared in the
+ same order. For two structures or unions, corresponding bit-fields shall have the same
+ widths. For two enumerations, corresponding members shall have the same values.
+<p><!--para 2-->
+ All declarations that refer to the same object or function shall have compatible type;
+ otherwise, the behavior is undefined.
+<p><!--para 3-->
+ A composite type can be constructed from two types that are compatible; it is a type that
+ is compatible with both of the two types and satisfies the following conditions:
+<ul>
+<li>  If both types are array types, the following rules are applied:
+<ul>
+<li> If one type is an array of known constant size, the composite type is an array of
+ that size.
+<li> Otherwise, if one type is a variable length array whose size is specified by an
+ expression that is not evaluated, the behavior is undefined.
+<li> Otherwise, if one type is a variable length array whose size is specified, the
+ composite type is a variable length array of that size.
+<li> Otherwise, if one type is a variable length array of unspecified size, the composite
+ type is a variable length array of unspecified size.
+<li> Otherwise, both types are arrays of unknown size and the composite type is an
+ array of unknown size.
+</ul>
+   The element type of the composite type is the composite type of the two element
+   types.
+<li>  If only one type is a function type with a parameter type list (a function prototype),
+ the composite type is a function prototype with the parameter type list.
+ 
+ 
+<!--page 66 indent 4-->
+<li>  If both types are function types with parameter type lists, the type of each parameter
+ in the composite parameter type list is the composite type of the corresponding
+ parameters.
+</ul>
+ These rules apply recursively to the types from which the two types are derived.
+<p><!--para 4-->
+ For an identifier with internal or external linkage declared in a scope in which a prior
+ declaration of that identifier is visible,<sup><a href="#note56"><b>56)</b></a></sup> if the prior declaration specifies internal or
+ external linkage, the type of the identifier at the later declaration becomes the composite
+ type.
+ Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
+<p><!--para 5-->
+ EXAMPLE        Given the following two file scope declarations:
+<pre>
+          int f(int (*)(), double (*)[3]);
+          int f(int (*)(char *), double (*)[]);</pre>
+ The resulting composite type for the function is:
+<pre>
+          int f(int (*)(char *), double (*)[3]);</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note55">55)</a> Two types need not be identical to be compatible.
+
+<p><a name="note56">56)</a> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+
+
+<a name="6.2.8" href="#6.2.8"><h4>6.2.8 Alignment of objects</h4></a>
+<p><!--para 1-->
+ Complete object types have alignment requirements which place restrictions on the
+ addresses at which objects of that type may be allocated. An alignment is an
+ implementation-defined integer value representing the number of bytes between
+ successive addresses at which a given object can be allocated. An object type imposes an
+ alignment requirement on every object of that type: stricter alignment can be requested
+ using the _Alignas keyword.
+<p><!--para 2-->
+ A fundamental alignment is represented by an alignment less than or equal to the greatest
+ alignment supported by the implementation in all contexts, which is equal to
+ alignof(max_align_t).
+<p><!--para 3-->
+ An extended alignment is represented by an alignment greater than
+ alignof(max_align_t). It is implementation-defined whether any extended
+ alignments are supported and the contexts in which they are supported. A type having an
+ extended alignment requirement is an over-aligned type.<sup><a href="#note57"><b>57)</b></a></sup>
+<p><!--para 4-->
+ Alignments are represented as values of the type size_t. Valid alignments include only
+ those values returned by an alignof expression for fundamental types, plus an
+ additional implementation-defined set of values, which may be empty. Every valid
+ alignment value shall be a nonnegative integral power of two.
+ 
+ 
+<!--page 67 indent 4-->
+<p><!--para 5-->
+ Alignments have an order from weaker to stronger or stricter alignments. Stricter
+ alignments have larger alignment values. An address that satisfies an alignment
+ requirement also satisfies any weaker valid alignment requirement.
+<p><!--para 6-->
+ The alignment requirement of a complete type can be queried using an alignof
+ expression. The types char, signed char, and unsigned char shall have the
+ weakest alignment requirement.
+<p><!--para 7-->
+ Comparing alignments is meaningful and provides the obvious results:
+<ul>
+<li>  Two alignments are equal when their numeric values are equal.
+<li>  Two alignments are different when their numeric values are not equal.
+<li>  When an alignment is larger than another it represents a stricter alignment.
+<!--page 68 indent 4-->
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note57">57)</a> Every over-aligned type is, or contains, a structure or union type with a member to which an extended
+ alignment has been applied.
+
+
+<a name="6.3" href="#6.3"><h3>6.3 Conversions</h3></a>
+<p><!--para 1-->
+ Several operators convert operand values from one type to another automatically. This
+ subclause specifies the result required from such an implicit conversion, as well as those
+ that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
+ the conversions performed by most ordinary operators; it is supplemented as required by
+ the discussion of each operator in <a href="#6.5">6.5</a>.
+<p><!--para 2-->
+ Conversion of an operand value to a compatible type causes no change to the value or the
+ representation.
+ Forward references: cast operators (<a href="#6.5.4">6.5.4</a>).
+
+<a name="6.3.1" href="#6.3.1"><h4>6.3.1 Arithmetic operands</h4></a>
+
+<a name="6.3.1.1" href="#6.3.1.1"><h5>6.3.1.1 Boolean, characters, and integers</h5></a>
+<p><!--para 1-->
+ Every integer type has an integer conversion rank defined as follows:
+<ul>
+<li>  No two signed integer types shall have the same rank, even if they have the same
+ representation.
+<li>  The rank of a signed integer type shall be greater than the rank of any signed integer
+ type with less precision.
+<li>  The rank of long long int shall be greater than the rank of long int, which
+ shall be greater than the rank of int, which shall be greater than the rank of short
+ int, which shall be greater than the rank of signed char.
+<li>  The rank of any unsigned integer type shall equal the rank of the corresponding
+ signed integer type, if any.
+<li>  The rank of any standard integer type shall be greater than the rank of any extended
+ integer type with the same width.
+<li>  The rank of char shall equal the rank of signed char and unsigned char.
+<li>  The rank of _Bool shall be less than the rank of all other standard integer types.
+<li>  The rank of any enumerated type shall equal the rank of the compatible integer type
+ (see <a href="#6.7.2.2">6.7.2.2</a>).
+<li>  The rank of any extended signed integer type relative to another extended signed
+ integer type with the same precision is implementation-defined, but still subject to the
+ other rules for determining the integer conversion rank.
+<li>  For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
+ greater rank than T3, then T1 has greater rank than T3.
+</ul>
+<p><!--para 2-->
+ The following may be used in an expression wherever an int or unsigned int may
+ be used:
+<!--page 69 indent 4-->
+<ul>
+<li>  An object or expression with an integer type (other than int or unsigned int)
+ whose integer conversion rank is less than or equal to the rank of int and
+ unsigned int.
+<li>  A bit-field of type _Bool, int, signed int, or unsigned int.
+</ul>
+ If an int can represent all values of the original type (as restricted by the width, for a
+ bit-field), the value is converted to an int; otherwise, it is converted to an unsigned
+ int. These are called the integer promotions.<sup><a href="#note58"><b>58)</b></a></sup> All other types are unchanged by the
+ integer promotions.
+<p><!--para 3-->
+ The integer promotions preserve value including sign. As discussed earlier, whether a
+ ''plain'' char is treated as signed is implementation-defined.
+ Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note58">58)</a> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
+ argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
+ shift operators, as specified by their respective subclauses.
+
+
+<a name="6.3.1.2" href="#6.3.1.2"><h5>6.3.1.2 Boolean type</h5></a>
+<p><!--para 1-->
+ When any scalar value is converted to _Bool, the result is 0 if the value compares equal
+ to 0; otherwise, the result is 1.<sup><a href="#note59"><b>59)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note59">59)</a> NaNs do not compare equal to 0 and thus convert to 1.
+
+
+<a name="6.3.1.3" href="#6.3.1.3"><h5>6.3.1.3 Signed and unsigned integers</h5></a>
+<p><!--para 1-->
+ When a value with integer type is converted to another integer type other than _Bool, if
+ the value can be represented by the new type, it is unchanged.
+<p><!--para 2-->
+ Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
+ subtracting one more than the maximum value that can be represented in the new type
+ until the value is in the range of the new type.<sup><a href="#note60"><b>60)</b></a></sup>
+<p><!--para 3-->
+ Otherwise, the new type is signed and the value cannot be represented in it; either the
+ result is implementation-defined or an implementation-defined signal is raised.
+
+<h6>footnotes</h6>
+<p><a name="note60">60)</a> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
+
+
+<a name="6.3.1.4" href="#6.3.1.4"><h5>6.3.1.4 Real floating and integer</h5></a>
+<p><!--para 1-->
+ When a finite value of real floating type is converted to an integer type other than _Bool,
+ the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
+ the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note61"><b>61)</b></a></sup>
+ 
+ 
+<!--page 70 indent 4-->
+<p><!--para 2-->
+ When a value of integer type is converted to a real floating type, if the value being
+ converted can be represented exactly in the new type, it is unchanged. If the value being
+ converted is in the range of values that can be represented but cannot be represented
+ exactly, the result is either the nearest higher or nearest lower representable value, chosen
+ in an implementation-defined manner. If the value being converted is outside the range of
+ values that can be represented, the behavior is undefined. Results of some implicit
+ conversions (<a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>) may be represented in greater precision and range than that
+ required by the new type.
+
+<h6>footnotes</h6>
+<p><a name="note61">61)</a> The remaindering operation performed when a value of integer type is converted to unsigned type
+ need not be performed when a value of real floating type is converted to unsigned type. Thus, the
+ range of portable real floating values is (-1, Utype_MAX+1).
+
+
+<a name="6.3.1.5" href="#6.3.1.5"><h5>6.3.1.5 Real floating types</h5></a>
+<p><!--para 1-->
+ When a value of real floating type is converted to a real floating type, if the value being
+ converted can be represented exactly in the new type, it is unchanged. If the value being
+ converted is in the range of values that can be represented but cannot be represented
+ exactly, the result is either the nearest higher or nearest lower representable value, chosen
+ in an implementation-defined manner. If the value being converted is outside the range of
+ values that can be represented, the behavior is undefined. Results of some implicit
+ conversions (<a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>) may be represented in greater precision and range than that
+ required by the new type.
+
+<a name="6.3.1.6" href="#6.3.1.6"><h5>6.3.1.6 Complex types</h5></a>
+<p><!--para 1-->
+ When a value of complex type is converted to another complex type, both the real and
+ imaginary parts follow the conversion rules for the corresponding real types.
+
+<a name="6.3.1.7" href="#6.3.1.7"><h5>6.3.1.7 Real and complex</h5></a>
+<p><!--para 1-->
+ When a value of real type is converted to a complex type, the real part of the complex
+ result value is determined by the rules of conversion to the corresponding real type and
+ the imaginary part of the complex result value is a positive zero or an unsigned zero.
+<p><!--para 2-->
+ When a value of complex type is converted to a real type, the imaginary part of the
+ complex value is discarded and the value of the real part is converted according to the
+ conversion rules for the corresponding real type.
+
+<a name="6.3.1.8" href="#6.3.1.8"><h5>6.3.1.8 Usual arithmetic conversions</h5></a>
+<p><!--para 1-->
+ Many operators that expect operands of arithmetic type cause conversions and yield result
+ types in a similar way. The purpose is to determine a common real type for the operands
+ and result. For the specified operands, each operand is converted, without change of type
+ domain, to a type whose corresponding real type is the common real type. Unless
+ explicitly stated otherwise, the common real type is also the corresponding real type of
+ the result, whose type domain is the type domain of the operands if they are the same,
+ and complex otherwise. This pattern is called the usual arithmetic conversions:
+<!--page 71 indent 4-->
+<p><!--para 2-->
+<pre>
+       First, if the corresponding real type of either operand is long double, the other
+       operand is converted, without change of type domain, to a type whose
+        corresponding real type is long double.
+        Otherwise, if the corresponding real type of either operand is double, the other
+        operand is converted, without change of type domain, to a type whose
+        corresponding real type is double.
+        Otherwise, if the corresponding real type of either operand is float, the other
+        operand is converted, without change of type domain, to a type whose
+        corresponding real type is float.<sup><a href="#note62"><b>62)</b></a></sup>
+        Otherwise, the integer promotions are performed on both operands. Then the
+        following rules are applied to the promoted operands:
+               If both operands have the same type, then no further conversion is needed.
+               Otherwise, if both operands have signed integer types or both have unsigned
+               integer types, the operand with the type of lesser integer conversion rank is
+               converted to the type of the operand with greater rank.
+               Otherwise, if the operand that has unsigned integer type has rank greater or
+               equal to the rank of the type of the other operand, then the operand with
+               signed integer type is converted to the type of the operand with unsigned
+               integer type.
+               Otherwise, if the type of the operand with signed integer type can represent
+               all of the values of the type of the operand with unsigned integer type, then
+               the operand with unsigned integer type is converted to the type of the
+               operand with signed integer type.
+               Otherwise, both operands are converted to the unsigned integer type
+               corresponding to the type of the operand with signed integer type.</pre>
+ The values of floating operands and of the results of floating expressions may be
+ represented in greater precision and range than that required by the type; the types are not
+ changed thereby.<sup><a href="#note63"><b>63)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 72 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note62">62)</a> For example, addition of a double _Complex and a float entails just the conversion of the
+ float operand to double (and yields a double _Complex result).
+
+<p><a name="note63">63)</a> The cast and assignment operators are still required to remove extra range and precision.
+
+
+<a name="6.3.2" href="#6.3.2"><h4>6.3.2 Other operands</h4></a>
+
+<a name="6.3.2.1" href="#6.3.2.1"><h5>6.3.2.1 Lvalues, arrays, and function designators</h5></a>
+<p><!--para 1-->
+ An lvalue is an expression (with an object type other than void) that potentially
+ designates an object;<sup><a href="#note64"><b>64)</b></a></sup> if an lvalue does not designate an object when it is evaluated, the
+ behavior is undefined. When an object is said to have a particular type, the type is
+ specified by the lvalue used to designate the object. A modifiable lvalue is an lvalue that
+ does not have array type, does not have an incomplete type, does not have a const-
+ qualified type, and if it is a structure or union, does not have any member (including,
+ recursively, any member or element of all contained aggregates or unions) with a const-
+ qualified type.
+<p><!--para 2-->
+ Except when it is the operand of the sizeof operator, the unary &amp; operator, the ++
+ operator, the -- operator, or the left operand of the . operator or an assignment operator,
+ an lvalue that does not have array type is converted to the value stored in the designated
+ object (and is no longer an lvalue); this is called lvalue conversion. If the lvalue has
+ qualified type, the value has the unqualified version of the type of the lvalue; additionally,
+ if the lvalue has atomic type, the value has the non-atomic version of the type of the
+ lvalue; otherwise, the value has the type of the lvalue. If the lvalue has an incomplete
+ type and does not have array type, the behavior is undefined. If the lvalue designates an
+ object of automatic storage duration that could have been declared with the register
+ storage class (never had its address taken), and that object is uninitialized (not declared
+ with an initializer and no assignment to it has been performed prior to use), the behavior
+ is undefined.
+<p><!--para 3-->
+ Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a
+ string literal used to initialize an array, an expression that has type ''array of type'' is
+ converted to an expression with type ''pointer to type'' that points to the initial element of
+ the array object and is not an lvalue. If the array object has register storage class, the
+ behavior is undefined.
+<p><!--para 4-->
+ A function designator is an expression that has function type. Except when it is the
+ operand of the sizeof operator<sup><a href="#note65"><b>65)</b></a></sup> or the unary &amp; operator, a function designator with
+ type ''function returning type'' is converted to an expression that has type ''pointer to
+ 
+ 
+<!--page 73 indent 4-->
+ function returning type''.
+ Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
+ (<a href="#6.5.16">6.5.16</a>), common definitions &lt;stddef.h&gt; (<a href="#7.19">7.19</a>), initialization (<a href="#6.7.9">6.7.9</a>), postfix
+ increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+ (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note64">64)</a> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
+ operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
+ object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
+ as the ''value of an expression''.
+  An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
+  expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
+
+<p><a name="note65">65)</a> Because this conversion does not occur, the operand of the sizeof operator remains a function
+ designator and violates the constraint in <a href="#6.5.3.4">6.5.3.4</a>.
+
+
+<a name="6.3.2.2" href="#6.3.2.2"><h5>6.3.2.2 void</h5></a>
+<p><!--para 1-->
+ The (nonexistent) value of a void expression (an expression that has type void) shall not
+ be used in any way, and implicit or explicit conversions (except to void) shall not be
+ applied to such an expression. If an expression of any other type is evaluated as a void
+ expression, its value or designator is discarded. (A void expression is evaluated for its
+ side effects.)
+
+<a name="6.3.2.3" href="#6.3.2.3"><h5>6.3.2.3 Pointers</h5></a>
+<p><!--para 1-->
+ A pointer to void may be converted to or from a pointer to any object type. A pointer to
+ any object type may be converted to a pointer to void and back again; the result shall
+ compare equal to the original pointer.
+<p><!--para 2-->
+ For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
+ the q-qualified version of the type; the values stored in the original and converted pointers
+ shall compare equal.
+<p><!--para 3-->
+ An integer constant expression with the value 0, or such an expression cast to type
+ void *, is called a null pointer constant.<sup><a href="#note66"><b>66)</b></a></sup> If a null pointer constant is converted to a
+ pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
+ to a pointer to any object or function.
+<p><!--para 4-->
+ Conversion of a null pointer to another pointer type yields a null pointer of that type.
+ Any two null pointers shall compare equal.
+<p><!--para 5-->
+ An integer may be converted to any pointer type. Except as previously specified, the
+ result is implementation-defined, might not be correctly aligned, might not point to an
+ entity of the referenced type, and might be a trap representation.<sup><a href="#note67"><b>67)</b></a></sup>
+<p><!--para 6-->
+ Any pointer type may be converted to an integer type. Except as previously specified, the
+ result is implementation-defined. If the result cannot be represented in the integer type,
+ the behavior is undefined. The result need not be in the range of values of any integer
+ type.
+ 
+ 
+ 
+ 
+<!--page 74 indent 4-->
+<p><!--para 7-->
+ A pointer to an object type may be converted to a pointer to a different object type. If the
+ resulting pointer is not correctly aligned<sup><a href="#note68"><b>68)</b></a></sup> for the referenced type, the behavior is
+ undefined. Otherwise, when converted back again, the result shall compare equal to the
+ original pointer. When a pointer to an object is converted to a pointer to a character type,
+ the result points to the lowest addressed byte of the object. Successive increments of the
+ result, up to the size of the object, yield pointers to the remaining bytes of the object.
+<p><!--para 8-->
+ A pointer to a function of one type may be converted to a pointer to a function of another
+ type and back again; the result shall compare equal to the original pointer. If a converted
+ pointer is used to call a function whose type is not compatible with the referenced type,
+ the behavior is undefined.
+ Forward references: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
+ capable of holding object pointers (<a href="#7.20.1.4">7.20.1.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+ 
+ 
+ 
+ 
+<!--page 75 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note66">66)</a> The macro NULL is defined in &lt;stddef.h&gt; (and other headers) as a null pointer constant; see <a href="#7.19">7.19</a>.
+
+<p><a name="note67">67)</a> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
+ be consistent with the addressing structure of the execution environment.
+
+<p><a name="note68">68)</a> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
+ pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
+ correctly aligned for a pointer to type C.
+
+
+<a name="6.4" href="#6.4"><h3>6.4 Lexical elements</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          token:
+                   keyword
+                   identifier
+                   constant
+                   string-literal
+                   punctuator
+          preprocessing-token:
+                 header-name
+                 identifier
+                 pp-number
+                 character-constant
+                 string-literal
+                 punctuator
+                 each non-white-space character that cannot be one of the above</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each preprocessing token that is converted to a token shall have the lexical form of a
+ keyword, an identifier, a constant, a string literal, or a punctuator.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A token is the minimal lexical element of the language in translation phases 7 and 8. The
+ categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
+ A preprocessing token is the minimal lexical element of the language in translation
+ phases 3 through 6. The categories of preprocessing tokens are: header names,
+ identifiers, preprocessing numbers, character constants, string literals, punctuators, and
+ single non-white-space characters that do not lexically match the other preprocessing
+ token categories.<sup><a href="#note69"><b>69)</b></a></sup> If a ' or a " character matches the last category, the behavior is
+ undefined. Preprocessing tokens can be separated by white space; this consists of
+ comments (described later), or white-space characters (space, horizontal tab, new-line,
+ vertical tab, and form-feed), or both. As described in <a href="#6.10">6.10</a>, in certain circumstances
+ during translation phase 4, white space (or the absence thereof) serves as more than
+ preprocessing token separation. White space may appear within a preprocessing token
+ only as part of a header name or between the quotation characters in a character constant
+ or string literal.
+ 
+ 
+ 
+<!--page 76 indent 4-->
+<p><!--para 4-->
+ If the input stream has been parsed into preprocessing tokens up to a given character, the
+ next preprocessing token is the longest sequence of characters that could constitute a
+ preprocessing token. There is one exception to this rule: header name preprocessing
+ tokens are recognized only within #include preprocessing directives and in
+ implementation-defined locations within #pragma directives. In such contexts, a
+ sequence of characters that could be either a header name or a string literal is recognized
+ as the former.
+<p><!--para 5-->
+ EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
+ valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
+ might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
+ fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
+ not E is a macro name.
+ 
+<p><!--para 6-->
+ EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
+ increment operators, even though the parse x ++ + ++ y might yield a correct expression.
+ 
+ Forward references: character constants (<a href="#6.4.4.4">6.4.4.4</a>), comments (<a href="#6.4.9">6.4.9</a>), expressions (<a href="#6.5">6.5</a>),
+ floating constants (<a href="#6.4.4.2">6.4.4.2</a>), header names (<a href="#6.4.7">6.4.7</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), postfix
+ increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+ (<a href="#6.5.3.1">6.5.3.1</a>), preprocessing directives (<a href="#6.10">6.10</a>), preprocessing numbers (<a href="#6.4.8">6.4.8</a>), string literals
+ (<a href="#6.4.5">6.4.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note69">69)</a> An additional category, placemarkers, is used internally in translation phase 4 (see <a href="#6.10.3.3">6.10.3.3</a>); it cannot
+ occur in source files.
+
+
+<a name="6.4.1" href="#6.4.1"><h4>6.4.1 Keywords</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          keyword: one of
+                alignof                         goto                         union
+                auto                            if                           unsigned
+                break                           inline                       void
+                case                            int                          volatile
+                char                            long                         while
+                const                           register                     _Alignas
+                continue                        restrict                     _Atomic
+                default                         return                       _Bool
+                do                              short                        _Complex
+                double                          signed                       _Generic
+                else                            sizeof                       _Imaginary
+                enum                            static                       _Noreturn
+                extern                          struct                       _Static_assert
+                float                           switch                       _Thread_local
+                for                             typedef</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The above tokens (case sensitive) are reserved (in translation phases 7 and 8) for use as
+ keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
+<!--page 77 indent 4-->
+ specifying imaginary types.<sup><a href="#note70"><b>70)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note70">70)</a> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
+
+
+<a name="6.4.2" href="#6.4.2"><h4>6.4.2 Identifiers</h4></a>
+
+<a name="6.4.2.1" href="#6.4.2.1"><h5>6.4.2.1 General</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          identifier:
+                 identifier-nondigit
+                 identifier identifier-nondigit
+                 identifier digit
+          identifier-nondigit:
+                 nondigit
+                 universal-character-name
+                 other implementation-defined characters
+          nondigit: one of
+                 _ a b            c    d    e    f     g    h    i    j     k    l    m
+                     n o          p    q    r    s     t    u    v    w     x    y    z
+                     A B          C    D    E    F     G    H    I    J     K    L    M
+                     N O          P    Q    R    S     T    U    V    W     X    Y    Z
+          digit: one of
+                 0 1        2     3    4    5    6     7    8    9</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ An identifier is a sequence of nondigit characters (including the underscore _, the
+ lowercase and uppercase Latin letters, and other characters) and digits, which designates
+ one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
+ There is no specific limit on the maximum length of an identifier.
+<p><!--para 3-->
+ Each universal character name in an identifier shall designate a character whose encoding
+ in ISO/IEC 10646 falls into one of the ranges specified in D.1.<sup><a href="#note71"><b>71)</b></a></sup> The initial character
+ shall not be a universal character name designating a character whose encoding falls into
+ one of the ranges specified in <a href="#D.2">D.2</a>. An implementation may allow multibyte characters
+ that are not part of the basic source character set to appear in identifiers; which characters
+ and their correspondence to universal character names is implementation-defined.
+ 
+ 
+ 
+<!--page 78 indent 4-->
+<p><!--para 4-->
+ When preprocessing tokens are converted to tokens during translation phase 7, if a
+ preprocessing token could be converted to either a keyword or an identifier, it is converted
+ to a keyword.
+ Implementation limits
+<p><!--para 5-->
+ As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
+ characters in an identifier; the limit for an external name (an identifier that has external
+ linkage) may be more restrictive than that for an internal name (a macro name or an
+ identifier that does not have external linkage). The number of significant characters in an
+ identifier is implementation-defined.
+<p><!--para 6-->
+ Any identifiers that differ in a significant character are different identifiers. If two
+ identifiers differ only in nonsignificant characters, the behavior is undefined.
+ Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note71">71)</a> On systems in which linkers cannot accept extended characters, an encoding of the universal character
+ name may be used in forming valid external identifiers. For example, some otherwise unused
+ character or sequence of characters may be used to encode the \u in a universal character name.
+ Extended characters may produce a long external identifier.
+
+
+<a name="6.4.2.2" href="#6.4.2.2"><h5>6.4.2.2 Predefined identifiers</h5></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ The identifier __func__ shall be implicitly declared by the translator as if,
+ immediately following the opening brace of each function definition, the declaration
+<pre>
+          static const char __func__[] = "function-name";</pre>
+ appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note72"><b>72)</b></a></sup>
+<p><!--para 2-->
+ This name is encoded as if the implicit declaration had been written in the source
+ character set and then translated into the execution character set as indicated in translation
+ phase 5.
+<p><!--para 3-->
+ EXAMPLE        Consider the code fragment:
+<pre>
+          #include &lt;stdio.h&gt;
+          void myfunc(void)
+          {
+                printf("%s\n", __func__);
+                /* ... */
+          }</pre>
+ Each time the function is called, it will print to the standard output stream:
+<pre>
+          myfunc</pre>
+ 
+ Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+ 
+ 
+ 
+ 
+<!--page 79 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note72">72)</a> Since the name __func__ is reserved for any use by the implementation (<a href="#7.1.3">7.1.3</a>), if any other
+ identifier is explicitly declared using the name __func__, the behavior is undefined.
+
+
+<a name="6.4.3" href="#6.4.3"><h4>6.4.3 Universal character names</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          universal-character-name:
+                 \u hex-quad
+                 \U hex-quad hex-quad
+          hex-quad:
+                 hexadecimal-digit hexadecimal-digit
+                              hexadecimal-digit hexadecimal-digit</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A universal character name shall not specify a character whose short identifier is less than
+ 00A0 other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through
+ DFFF inclusive.<sup><a href="#note73"><b>73)</b></a></sup>
+<h6>Description</h6>
+<p><!--para 3-->
+ Universal character names may be used in identifiers, character constants, and string
+ literals to designate characters that are not in the basic character set.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The universal character name \Unnnnnnnn designates the character whose eight-digit
+ short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note74"><b>74)</b></a></sup> Similarly, the universal
+ character name \unnnn designates the character whose four-digit short identifier is nnnn
+ (and whose eight-digit short identifier is 0000nnnn).
+ 
+ 
+ 
+ 
+<!--page 80 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note73">73)</a> The disallowed characters are the characters in the basic character set and the code positions reserved
+ by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
+ UTF-16).
+ 
+
+<p><a name="note74">74)</a> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
+
+
+<a name="6.4.4" href="#6.4.4"><h4>6.4.4 Constants</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          constant:
+                 integer-constant
+                 floating-constant
+                 enumeration-constant
+                 character-constant</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each constant shall have a type and the value of a constant shall be in the range of
+ representable values for its type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ Each constant has a type, determined by its form and value, as detailed later.
+
+<a name="6.4.4.1" href="#6.4.4.1"><h5>6.4.4.1 Integer constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 81 indent 4-->
+<pre>
+          integer-constant:
+                  decimal-constant integer-suffixopt
+                  octal-constant integer-suffixopt
+                  hexadecimal-constant integer-suffixopt
+          decimal-constant:
+                nonzero-digit
+                decimal-constant digit
+          octal-constant:
+                 0
+                 octal-constant octal-digit
+          hexadecimal-constant:
+                hexadecimal-prefix hexadecimal-digit
+                hexadecimal-constant hexadecimal-digit
+          hexadecimal-prefix: one of
+                0x 0X
+          nonzero-digit: one of
+                 1 2 3 4          5     6     7   8    9
+          octal-digit: one of
+                  0 1 2 3         4     5     6   7
+         hexadecimal-digit:   one of
+               0 1 2           3 4     5    6   7     8   9
+               a b c           d e     f
+               A B C           D E     F
+         integer-suffix:
+                 unsigned-suffix long-suffixopt
+                 unsigned-suffix long-long-suffix
+                 long-suffix unsigned-suffixopt
+                 long-long-suffix unsigned-suffixopt
+         unsigned-suffix: one of
+                u U
+         long-suffix: one of
+                l L
+         long-long-suffix: one of
+                ll LL</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ An integer constant begins with a digit, but has no period or exponent part. It may have a
+ prefix that specifies its base and a suffix that specifies its type.
+<p><!--para 3-->
+ A decimal constant begins with a nonzero digit and consists of a sequence of decimal
+ digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
+ digits 0 through 7 only. A hexadecimal constant consists of the prefix 0x or 0X followed
+ by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
+ 10 through 15 respectively.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The value of a decimal constant is computed base 10; that of an octal constant, base 8;
+ that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
+<p><!--para 5-->
+ The type of an integer constant is the first of the corresponding list in which its value can
+ be represented.
+<!--page 82 indent 4-->
+<pre>
+                                                                  Octal or Hexadecimal</pre>
+ Suffix                       Decimal Constant                           Constant
+ 
+ none                int                                    int
+<pre>
+                     long int                               unsigned int
+                     long long int                          long int
+                                                            unsigned long int
+                                                            long long int
+                                                            unsigned long long int</pre>
+ 
+ u or U              unsigned int                           unsigned int
+<pre>
+                     unsigned long int                      unsigned long int
+                     unsigned long long int                 unsigned long long int</pre>
+ 
+ l or L              long int                               long int
+<pre>
+                     long long int                          unsigned long int
+                                                            long long int
+                                                            unsigned long long int</pre>
+ 
+ Both u or U         unsigned long int                      unsigned long int
+ and l or L          unsigned long long int                 unsigned long long int
+ 
+ ll or LL            long long int                          long long int
+<pre>
+                                                            unsigned long long int</pre>
+ 
+ Both u or U         unsigned long long int                 unsigned long long int
+ and ll or LL
+<p><!--para 6-->
+ If an integer constant cannot be represented by any type in its list, it may have an
+ extended integer type, if the extended integer type can represent its value. If all of the
+ types in the list for the constant are signed, the extended integer type shall be signed. If
+ all of the types in the list for the constant are unsigned, the extended integer type shall be
+ unsigned. If the list contains both signed and unsigned types, the extended integer type
+ may be signed or unsigned. If an integer constant cannot be represented by any type in
+ its list and has no extended integer type, then the integer constant has no type.
+<!--page 83 indent 4-->
+
+<a name="6.4.4.2" href="#6.4.4.2"><h5>6.4.4.2 Floating constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 84 indent 4-->
+<pre>
+          floating-constant:
+                 decimal-floating-constant
+                 hexadecimal-floating-constant
+          decimal-floating-constant:
+                fractional-constant exponent-partopt floating-suffixopt
+                digit-sequence exponent-part floating-suffixopt
+          hexadecimal-floating-constant:
+                hexadecimal-prefix hexadecimal-fractional-constant
+                               binary-exponent-part floating-suffixopt
+                hexadecimal-prefix hexadecimal-digit-sequence
+                               binary-exponent-part floating-suffixopt
+          fractional-constant:
+                  digit-sequenceopt . digit-sequence
+                  digit-sequence .
+          exponent-part:
+                e signopt digit-sequence
+                E signopt digit-sequence
+          sign: one of
+                 + -
+          digit-sequence:
+                  digit
+                  digit-sequence digit
+          hexadecimal-fractional-constant:
+                hexadecimal-digit-sequenceopt .
+                               hexadecimal-digit-sequence
+                hexadecimal-digit-sequence .
+          binary-exponent-part:
+                 p signopt digit-sequence
+                 P signopt digit-sequence
+          hexadecimal-digit-sequence:
+                hexadecimal-digit
+                hexadecimal-digit-sequence hexadecimal-digit
+          floating-suffix: one of
+                 f l F L</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A floating constant has a significand part that may be followed by an exponent part and a
+ suffix that specifies its type. The components of the significand part may include a digit
+ sequence representing the whole-number part, followed by a period (.), followed by a
+ digit sequence representing the fraction part. The components of the exponent part are an
+ e, E, p, or P followed by an exponent consisting of an optionally signed digit sequence.
+ Either the whole-number part or the fraction part has to be present; for decimal floating
+ constants, either the period or the exponent part has to be present.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The significand part is interpreted as a (decimal or hexadecimal) rational number; the
+ digit sequence in the exponent part is interpreted as a decimal integer. For decimal
+ floating constants, the exponent indicates the power of 10 by which the significand part is
+ to be scaled. For hexadecimal floating constants, the exponent indicates the power of 2
+ by which the significand part is to be scaled. For decimal floating constants, and also for
+ hexadecimal floating constants when FLT_RADIX is not a power of 2, the result is either
+ the nearest representable value, or the larger or smaller representable value immediately
+ adjacent to the nearest representable value, chosen in an implementation-defined manner.
+ For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
+ correctly rounded.
+<p><!--para 4-->
+ An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
+ type float. If suffixed by the letter l or L, it has type long double.
+<p><!--para 5-->
+ Floating constants are converted to internal format as if at translation-time. The
+ conversion of a floating constant shall not raise an exceptional condition or a floating-
+ point exception at execution time. All floating constants of the same source form<sup><a href="#note75"><b>75)</b></a></sup> shall
+ convert to the same internal format with the same value.
+ Recommended practice
+<p><!--para 6-->
+ The implementation should produce a diagnostic message if a hexadecimal constant
+ cannot be represented exactly in its evaluation format; the implementation should then
+ proceed with the translation of the program.
+<p><!--para 7-->
+ The translation-time conversion of floating constants should match the execution-time
+ conversion of character strings by library functions, such as strtod, given matching
+ inputs suitable for both conversions, the same result format, and default execution-time
+ rounding.<sup><a href="#note76"><b>76)</b></a></sup>
+ 
+<!--page 85 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note75">75)</a> <a href="#1.23">1.23</a>, 1.230, 123e-2, 123e-02, and 1.23L are all different source forms and thus need not
+ convert to the same internal format and value.
+
+<p><a name="note76">76)</a> The specification for the library functions recommends more accurate conversion than required for
+ floating constants (see <a href="#7.22.1.3">7.22.1.3</a>).
+
+
+<a name="6.4.4.3" href="#6.4.4.3"><h5>6.4.4.3 Enumeration constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          enumeration-constant:
+                identifier</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ An identifier declared as an enumeration constant has type int.
+ Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
+
+<a name="6.4.4.4" href="#6.4.4.4"><h5>6.4.4.4 Character constants</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 86 indent 4-->
+<pre>
+          character-constant:
+                 ' c-char-sequence '
+                 L' c-char-sequence '
+                 u' c-char-sequence '
+                 U' c-char-sequence '
+          c-char-sequence:
+                 c-char
+                 c-char-sequence c-char
+          c-char:
+                    any member of the source character set except
+                                 the single-quote ', backslash \, or new-line character
+                    escape-sequence
+          escape-sequence:
+                 simple-escape-sequence
+                 octal-escape-sequence
+                 hexadecimal-escape-sequence
+                 universal-character-name
+          simple-escape-sequence: one of
+                 \' \" \? \\
+                 \a \b \f \n \r                  \t    \v
+          octal-escape-sequence:
+                  \ octal-digit
+                  \ octal-digit octal-digit
+                  \ octal-digit octal-digit octal-digit
+        hexadecimal-escape-sequence:
+              \x hexadecimal-digit
+              hexadecimal-escape-sequence hexadecimal-digit</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ An integer character constant is a sequence of one or more multibyte characters enclosed
+ in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
+ letter L, u, or U. With a few exceptions detailed later, the elements of the sequence are
+ any members of the source character set; they are mapped in an implementation-defined
+ manner to members of the execution character set.
+<p><!--para 3-->
+ The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
+ arbitrary integer values are representable according to the following table of escape
+ sequences:
+<p><!--para 4-->
+<pre>
+       single quote '            \'
+       double quote "            \"
+       question mark ?           \?
+       backslash \               \\
+       octal character           \octal digits
+       hexadecimal character     \x hexadecimal digits</pre>
+ The double-quote " and question-mark ? are representable either by themselves or by the
+ escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
+ shall be represented, respectively, by the escape sequences \' and \\.
+<p><!--para 5-->
+ The octal digits that follow the backslash in an octal escape sequence are taken to be part
+ of the construction of a single character for an integer character constant or of a single
+ wide character for a wide character constant. The numerical value of the octal integer so
+ formed specifies the value of the desired character or wide character.
+<p><!--para 6-->
+ The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
+ sequence are taken to be part of the construction of a single character for an integer
+ character constant or of a single wide character for a wide character constant. The
+ numerical value of the hexadecimal integer so formed specifies the value of the desired
+ character or wide character.
+<p><!--para 7-->
+ Each octal or hexadecimal escape sequence is the longest sequence of characters that can
+ constitute the escape sequence.
+<p><!--para 8-->
+ In addition, characters not in the basic character set are representable by universal
+ character names and certain nongraphic characters are representable by escape sequences
+ consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
+ and \v.<sup><a href="#note77"><b>77)</b></a></sup>
+<!--page 87 indent 5-->
+<h6>Constraints</h6>
+<p><!--para 9-->
+ The value of an octal or hexadecimal escape sequence shall be in the range of
+ representable values for the corresponding type:
+<pre>
+        Prefix      Corresponding Type
+        none       unsigned char
+        L          the unsigned type corresponding to wchar_t
+        u          char16_t
+        U          char32_t</pre>
+<h6>Semantics</h6>
+<p><!--para 10-->
+ An integer character constant has type int. The value of an integer character constant
+ containing a single character that maps to a single-byte execution character is the
+ numerical value of the representation of the mapped character interpreted as an integer.
+ The value of an integer character constant containing more than one character (e.g.,
+ 'ab'), or containing a character or escape sequence that does not map to a single-byte
+ execution character, is implementation-defined. If an integer character constant contains
+ a single character or escape sequence, its value is the one that results when an object with
+ type char whose value is that of the single character or escape sequence is converted to
+ type int.
+<p><!--para 11-->
+ A wide character constant prefixed by the letter L has type wchar_t, an integer type
+ defined in the &lt;stddef.h&gt; header; a wide character constant prefixed by the letter u or
+ U has type char16_t or char32_t, respectively, unsigned integer types defined in the
+ &lt;uchar.h&gt; header. The value of a wide character constant containing a single
+ multibyte character that maps to a single member of the extended execution character set
+ is the wide character corresponding to that multibyte character, as defined by the
+ mbtowc, mbrtoc16, or mbrtoc32 function as appropriate for its type, with an
+ implementation-defined current locale. The value of a wide character constant containing
+ more than one multibyte character or a single multibyte character that maps to multiple
+ members of the extended execution character set, or containing a multibyte character or
+ escape sequence not represented in the extended execution character set, is
+ implementation-defined.
+<p><!--para 12-->
+ EXAMPLE 1      The construction '\0' is commonly used to represent the null character.
+ 
+<p><!--para 13-->
+ EXAMPLE 2 Consider implementations that use two's complement representation for integers and eight
+ bits for objects that have type char. In an implementation in which type char has the same range of
+ values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
+ same range of values as unsigned char, the character constant '\xFF' has the value +255.
+ 
+ 
+ 
+ 
+<!--page 88 indent 5-->
+<p><!--para 14-->
+ EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
+ specifies an integer character constant containing only one character, since a hexadecimal escape sequence
+ is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
+ two characters whose values are '\x12' and '3', the construction '\0223' may be used, since an octal
+ escape sequence is terminated after three octal digits. (The value of this two-character integer character
+ constant is implementation-defined.)
+ 
+<p><!--para 15-->
+ EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
+ L'\1234' specifies the implementation-defined value that results from the combination of the values
+ 0123 and '4'.
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.19">7.19</a>), the mbtowc function
+ (<a href="#7.22.7.2">7.22.7.2</a>), Unicode utilities &lt;uchar.h&gt; (<a href="#7.27">7.27</a>).
+
+<h6>footnotes</h6>
+<p><a name="note77">77)</a> The semantics of these characters were discussed in <a href="#5.2.2">5.2.2</a>. If any other character follows a backslash,
+ the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
+
+
+<a name="6.4.5" href="#6.4.5"><h4>6.4.5 String literals</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          string-literal:
+                  encoding-prefixopt " s-char-sequenceopt "
+          encoding-prefix:
+                 u8
+                 u
+                 U
+                 L
+          s-char-sequence:
+                 s-char
+                 s-char-sequence s-char
+          s-char:
+                    any member of the source character set except
+                                 the double-quote ", backslash \, or new-line character
+                    escape-sequence</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A sequence of adjacent string literal tokens shall not include both a wide string literal and
+ a UTF-8 string literal.
+<h6>Description</h6>
+<p><!--para 3-->
+ A character string literal is a sequence of zero or more multibyte characters enclosed in
+ double-quotes, as in "xyz". A UTF-8 string literal is the same, except prefixed by u8.
+ A wide string literal is the same, except prefixed by the letter L, u, or U.
+<p><!--para 4-->
+ The same considerations apply to each element of the sequence in a string literal as if it
+ were in an integer character constant (for a character or UTF-8 string literal) or a wide
+ character constant (for a wide string literal), except that the single-quote ' is
+ representable either by itself or by the escape sequence \', but the double-quote " shall
+<!--page 89 indent 4-->
+ be represented by the escape sequence \".
+<h6>Semantics</h6>
+<p><!--para 5-->
+ In translation phase 6, the multibyte character sequences specified by any sequence of
+ adjacent character and identically-prefixed string literal tokens are concatenated into a
+ single multibyte character sequence. If any of the tokens has an encoding prefix, the
+ resulting multibyte character sequence is treated as having the same prefix; otherwise, it
+ is treated as a character string literal. Whether differently-prefixed wide string literal
+ tokens can be concatenated and, if so, the treatment of the resulting multibyte character
+ sequence are implementation-defined.
+<p><!--para 6-->
+ In translation phase 7, a byte or code of value zero is appended to each multibyte
+ character sequence that results from a string literal or literals.<sup><a href="#note78"><b>78)</b></a></sup> The multibyte character
+ sequence is then used to initialize an array of static storage duration and length just
+ sufficient to contain the sequence. For character string literals, the array elements have
+ type char, and are initialized with the individual bytes of the multibyte character
+ sequence. For UTF-8 string literals, the array elements have type char, and are
+ initialized with the characters of the multibyte character sequence, as encoded in UTF-8.
+ For wide string literals prefixed by the letter L, the array elements have type wchar_t
+ and are initialized with the sequence of wide characters corresponding to the multibyte
+ character sequence, as defined by the mbstowcs function with an implementation-
+ defined current locale. For wide string literals prefixed by the letter u or U, the array
+ elements have type char16_t or char32_t, respectively, and are initialized with the
+ sequence of wide characters corresponding to the multibyte character sequence, as
+ defined by successive calls to the mbrtoc16, or mbrtoc32 function as appropriate for
+ its type, with an implementation-defined current locale. The value of a string literal
+ containing a multibyte character or escape sequence not represented in the execution
+ character set is implementation-defined.
+<p><!--para 7-->
+ It is unspecified whether these arrays are distinct provided their elements have the
+ appropriate values. If the program attempts to modify such an array, the behavior is
+ undefined.
+<p><!--para 8-->
+ EXAMPLE 1      This pair of adjacent character string literals
+<pre>
+          "\x12" "3"</pre>
+ produces a single character string literal containing the two characters whose values are '\x12' and '3',
+ because escape sequences are converted into single members of the execution character set just prior to
+ adjacent string literal concatenation.
+ 
+<p><!--para 9-->
+ EXAMPLE 2      Each of the sequences of adjacent string literal tokens
+ 
+ 
+ 
+<!--page 90 indent 4-->
+<pre>
+          "a" "b" L"c"
+          "a" L"b" "c"
+          L"a" "b" L"c"
+          L"a" L"b" L"c"</pre>
+ is equivalent to the string literal
+<pre>
+          L"abc"</pre>
+ Likewise, each of the sequences
+<pre>
+          "a" "b" u"c"
+          "a" u"b" "c"
+          u"a" "b" u"c"
+          u"a" u"b" u"c"</pre>
+ is equivalent to
+<pre>
+          u"abc"</pre>
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.19">7.19</a>), the mbstowcs
+ function (<a href="#7.22.8.1">7.22.8.1</a>), Unicode utilities &lt;uchar.h&gt; (<a href="#7.27">7.27</a>).
+
+<h6>footnotes</h6>
+<p><a name="note78">78)</a> A string literal need not be a string (see <a href="#7.1.1">7.1.1</a>), because a null character may be embedded in it by a
+ \0 escape sequence.
+
+
+<a name="6.4.6" href="#6.4.6"><h4>6.4.6 Punctuators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          punctuator: one of
+                 [ ] ( ) { } . -&gt;
+                 ++ -- &amp; * + - ~ !
+                 / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                         ==    !=    ^    |   &amp;&amp;   ||
+                 ? : ; ...
+                 = *= /= %= += -= &lt;&lt;=                        &gt;&gt;=    &amp;=       ^=   |=
+                 , # ##
+                 &lt;: :&gt; &lt;% %&gt; %: %:%:</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A punctuator is a symbol that has independent syntactic and semantic significance.
+ Depending on context, it may specify an operation to be performed (which in turn may
+ yield a value or a function designator, produce a side effect, or some combination thereof)
+ in which case it is known as an operator (other forms of operator also exist in some
+ contexts). An operand is an entity on which an operator acts.
+<!--page 91 indent 4-->
+<p><!--para 3-->
+ In all aspects of the language, the six tokens<sup><a href="#note79"><b>79)</b></a></sup>
+<pre>
+          &lt;:    :&gt;      &lt;%    %&gt;     %:     %:%:</pre>
+ behave, respectively, the same as the six tokens
+<pre>
+          [     ]       {     }      #      ##</pre>
+ except for their spelling.<sup><a href="#note80"><b>80)</b></a></sup>
+ Forward references: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
+ (<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note79">79)</a> These tokens are sometimes called ''digraphs''.
+
+<p><a name="note80">80)</a> Thus [ and &lt;: behave differently when ''stringized'' (see <a href="#6.10.3.2">6.10.3.2</a>), but can otherwise be freely
+ interchanged.
+
+
+<a name="6.4.7" href="#6.4.7"><h4>6.4.7 Header names</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          header-name:
+                 &lt; h-char-sequence &gt;
+                 " q-char-sequence "
+          h-char-sequence:
+                 h-char
+                 h-char-sequence h-char
+          h-char:
+                    any member of the source character set except
+                                 the new-line character and &gt;
+          q-char-sequence:
+                 q-char
+                 q-char-sequence q-char
+          q-char:
+                    any member of the source character set except
+                                 the new-line character and "</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The sequences in both forms of header names are mapped in an implementation-defined
+ manner to headers or external source file names as specified in <a href="#6.10.2">6.10.2</a>.
+<p><!--para 3-->
+ If the characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt; delimiters,
+ the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
+ 
+ 
+ 
+ 
+<!--page 92 indent 4-->
+ sequence between the " delimiters, the behavior is undefined.<sup><a href="#note81"><b>81)</b></a></sup> Header name
+ preprocessing tokens are recognized only within #include preprocessing directives and
+ in implementation-defined locations within #pragma directives.<sup><a href="#note82"><b>82)</b></a></sup>
+<p><!--para 4-->
+ EXAMPLE       The following sequence of characters:
+<pre>
+          0x3&lt;1/a.h&gt;1e2
+          #include &lt;1/a.h&gt;
+          #define const.member@$</pre>
+ forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
+ by a { on the left and a } on the right).
+<pre>
+          {0x3}{&lt;}{1}{/}{a}{.}{h}{&gt;}{1e2}
+          {#}{include} {&lt;1/a.h&gt;}
+          {#}{define} {const}{.}{member}{@}{$}</pre>
+ 
+ Forward references: source file inclusion (<a href="#6.10.2">6.10.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note81">81)</a> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
+
+<p><a name="note82">82)</a> For an example of a header name preprocessing token used in a #pragma directive, see <a href="#6.10.9">6.10.9</a>.
+
+
+<a name="6.4.8" href="#6.4.8"><h4>6.4.8 Preprocessing numbers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          pp-number:
+                digit
+                . digit
+                pp-number       digit
+                pp-number       identifier-nondigit
+                pp-number       e sign
+                pp-number       E sign
+                pp-number       p sign
+                pp-number       P sign
+                pp-number       .</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A preprocessing number begins with a digit optionally preceded by a period (.) and may
+ be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
+ p+, p-, P+, or P-.
+<p><!--para 3-->
+ Preprocessing number tokens lexically include all floating and integer constant tokens.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ A preprocessing number does not have type or a value; it acquires both after a successful
+ conversion (as part of translation phase 7) to a floating constant token or an integer
+ constant token.
+ 
+ 
+<!--page 93 indent 4-->
+
+<a name="6.4.9" href="#6.4.9"><h4>6.4.9 Comments</h4></a>
+<p><!--para 1-->
+ Except within a character constant, a string literal, or a comment, the characters /*
+ introduce a comment. The contents of such a comment are examined only to identify
+ multibyte characters and to find the characters */ that terminate it.<sup><a href="#note83"><b>83)</b></a></sup>
+<p><!--para 2-->
+ Except within a character constant, a string literal, or a comment, the characters //
+ introduce a comment that includes all multibyte characters up to, but not including, the
+ next new-line character. The contents of such a comment are examined only to identify
+ multibyte characters and to find the terminating new-line character.
+<p><!--para 3-->
+ EXAMPLE
+<pre>
+          "a//b"                             //   four-character string literal
+          #include "//e"                     //   undefined behavior
+          // */                              //   comment, not syntax error
+          f = g/**//h;                       //   equivalent to f = g / h;
+          //\
+          i();                               // part of a two-line comment
+          /\
+          / j();                             // part of a two-line comment
+          #define glue(x,y) x##y
+          glue(/,/) k();                     // syntax error, not comment
+          /*//*/ l();                        // equivalent to l();
+          m = n//**/o
+             + p;                            // equivalent to m = n + p;</pre>
+ 
+ 
+ 
+ 
+<!--page 94 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note83">83)</a> Thus, /* ... */ comments do not nest.
+
+
+<a name="6.5" href="#6.5"><h3>6.5 Expressions</h3></a>
+<p><!--para 1-->
+ An expression is a sequence of operators and operands that specifies computation of a
+ value, or that designates an object or a function, or that generates side effects, or that
+ performs a combination thereof. The value computations of the operands of an operator
+ are sequenced before the value computation of the result of the operator.
+<p><!--para 2-->
+ If a side effect on a scalar object is unsequenced relative to either a different side effect
+ on the same scalar object or a value computation using the value of the same scalar
+ object, the behavior is undefined. If there are multiple allowable orderings of the
+ subexpressions of an expression, the behavior is undefined if such an unsequenced side
+ effect occurs in any of the orderings.<sup><a href="#note84"><b>84)</b></a></sup>
+<p><!--para 3-->
+ The grouping of operators and operands is indicated by the syntax.<sup><a href="#note85"><b>85)</b></a></sup> Except as specified
+ later, side effects and value computations of subexpressions are unsequenced.<sup><a href="#note86"><b>86)</b></a></sup>         *
+<p><!--para 4-->
+ Some operators (the unary operator ~, and the binary operators &lt;&lt;, &gt;&gt;, &amp;, ^, and |,
+ collectively described as bitwise operators) are required to have operands that have
+ integer type. These operators yield values that depend on the internal representations of
+ integers, and have implementation-defined and undefined aspects for signed types.
+<p><!--para 5-->
+ If an exceptional condition occurs during the evaluation of an expression (that is, if the
+ result is not mathematically defined or not in the range of representable values for its
+ type), the behavior is undefined.
+ 
+ 
+ 
+<!--page 95 indent 4-->
+<p><!--para 6-->
+ The effective type of an object for an access to its stored value is the declared type of the
+ object, if any.<sup><a href="#note87"><b>87)</b></a></sup> If a value is stored into an object having no declared type through an
+ lvalue having a type that is not a character type, then the type of the lvalue becomes the
+ effective type of the object for that access and for subsequent accesses that do not modify
+ the stored value. If a value is copied into an object having no declared type using
+ memcpy or memmove, or is copied as an array of character type, then the effective type
+ of the modified object for that access and for subsequent accesses that do not modify the
+ value is the effective type of the object from which the value is copied, if it has one. For
+ all other accesses to an object having no declared type, the effective type of the object is
+ simply the type of the lvalue used for the access.
+<p><!--para 7-->
+ An object shall have its stored value accessed only by an lvalue expression that has one of
+ the following types:<sup><a href="#note88"><b>88)</b></a></sup>
+<ul>
+<li>  a type compatible with the effective type of the object,
+<li>  a qualified version of a type compatible with the effective type of the object,
+<li>  a type that is the signed or unsigned type corresponding to the effective type of the
+ object,
+<li>  a type that is the signed or unsigned type corresponding to a qualified version of the
+ effective type of the object,
+<li>  an aggregate or union type that includes one of the aforementioned types among its
+ members (including, recursively, a member of a subaggregate or contained union), or
+<li>  a character type.
+</ul>
+<p><!--para 8-->
+ A floating expression may be contracted, that is, evaluated as though it were a single
+ operation, thereby omitting rounding errors implied by the source code and the
+ expression evaluation method.<sup><a href="#note89"><b>89)</b></a></sup> The FP_CONTRACT pragma in &lt;math.h&gt; provides a
+ way to disallow contracted expressions. Otherwise, whether and how expressions are
+ contracted is implementation-defined.<sup><a href="#note90"><b>90)</b></a></sup>
+ Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.23.2">7.23.2</a>).
+ 
+ 
+<!--page 96 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note84">84)</a> This paragraph renders undefined statement expressions such as
+
+<pre>
+           i = ++i + 1;
+           a[i++] = i;</pre>
+  while allowing
+
+<pre>
+           i = i + 1;
+           a[i] = i;</pre>
+ 
+
+<p><a name="note85">85)</a> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
+ as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
+ expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
+ <a href="#6.5.1">6.5.1</a> through <a href="#6.5.6">6.5.6</a>. The exceptions are cast expressions (<a href="#6.5.4">6.5.4</a>) as operands of unary operators
+ (<a href="#6.5.3">6.5.3</a>), and an operand contained between any of the following pairs of operators: grouping
+ parentheses () (<a href="#6.5.1">6.5.1</a>), subscripting brackets [] (<a href="#6.5.2.1">6.5.2.1</a>), function-call parentheses () (<a href="#6.5.2.2">6.5.2.2</a>), and
+ the conditional operator ? : (<a href="#6.5.15">6.5.15</a>).
+  Within each major subclause, the operators have the same precedence. Left- or right-associativity is
+  indicated in each subclause by the syntax for the expressions discussed therein.
+
+<p><a name="note86">86)</a> In an expression that is evaluated more than once during the execution of a program, unsequenced and
+ indeterminately sequenced evaluations of its subexpressions need not be performed consistently in
+ different evaluations.
+
+<p><a name="note87">87)</a> Allocated objects have no declared type.
+
+<p><a name="note88">88)</a> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
+
+<p><a name="note89">89)</a> The intermediate operations in the contracted expression are evaluated as if to infinite precision and
+ range, while the final operation is rounded to the format determined by the expression evaluation
+ method. A contracted expression might also omit the raising of floating-point exceptions.
+
+<p><a name="note90">90)</a> This license is specifically intended to allow implementations to exploit fast machine instructions that
+ combine multiple C operators. As contractions potentially undermine predictability, and can even
+ decrease accuracy for containing expressions, their use needs to be well-defined and clearly
+ documented.
+
+
+<a name="6.5.1" href="#6.5.1"><h4>6.5.1 Primary expressions</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          primary-expression:
+                 identifier
+                 constant
+                 string-literal
+                 ( expression )
+                 generic-selection</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ An identifier is a primary expression, provided it has been declared as designating an
+ object (in which case it is an lvalue) or a function (in which case it is a function
+ designator).<sup><a href="#note91"><b>91)</b></a></sup>
+<p><!--para 3-->
+ A constant is a primary expression. Its type depends on its form and value, as detailed in
+ <a href="#6.4.4">6.4.4</a>.
+<p><!--para 4-->
+ A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
+<p><!--para 5-->
+ A parenthesized expression is a primary expression. Its type and value are identical to
+ those of the unparenthesized expression. It is an lvalue, a function designator, or a void
+ expression if the unparenthesized expression is, respectively, an lvalue, a function
+ designator, or a void expression.
+ Forward references: declarations (<a href="#6.7">6.7</a>).
+
+<h6>footnotes</h6>
+<p><a name="note91">91)</a> Thus, an undeclared identifier is a violation of the syntax.
+
+
+<a name="6.5.1.1" href="#6.5.1.1"><h5>6.5.1.1 Generic selection</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          generic-selection:
+                 _Generic ( assignment-expression , generic-assoc-list )
+          generic-assoc-list:
+                 generic-association
+                 generic-assoc-list , generic-association
+          generic-association:
+                 type-name : assignment-expression
+                 default : assignment-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A generic selection shall have no more than one default generic association. The type
+ name in a generic association shall specify a complete object type other than a variably
+ 
+<!--page 97 indent 4-->
+ modified type. No two generic associations in the same generic selection shall specify
+ compatible types. The controlling expression of a generic selection shall have type
+ compatible with at most one of the types named in its generic association list. If a
+ generic selection has no default generic association, its controlling expression shall
+ have type compatible with exactly one of the types named in its generic association list.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The controlling expression of a generic selection is not evaluated. If a generic selection
+ has a generic association with a type name that is compatible with the type of the
+ controlling expression, then the result expression of the generic selection is the
+ expression in that generic association. Otherwise, the result expression of the generic
+ selection is the expression in the default generic association. None of the expressions
+ from any other generic association of the generic selection is evaluated.
+<p><!--para 4-->
+ The type and value of a generic selection are identical to those of its result expression. It
+ is an lvalue, a function designator, or a void expression if its result expression is,
+ respectively, an lvalue, a function designator, or a void expression.
+<p><!--para 5-->
+ EXAMPLE      The cbrt type-generic macro could be implemented as follows:
+<pre>
+          #define cbrt(X) _Generic((X),                                      \
+                                  long double: cbrtl,                        \
+                                  default: cbrt,                             \
+                                  float: cbrtf                               \
+                                  )(X)</pre>
+ 
+
+<a name="6.5.2" href="#6.5.2"><h4>6.5.2 Postfix operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 98 indent 4-->
+<pre>
+          postfix-expression:
+                 primary-expression
+                 postfix-expression [ expression ]
+                 postfix-expression ( argument-expression-listopt )
+                 postfix-expression . identifier
+                 postfix-expression -&gt; identifier
+                 postfix-expression ++
+                 postfix-expression --
+                 ( type-name ) { initializer-list }
+                 ( type-name ) { initializer-list , }
+          argument-expression-list:
+                assignment-expression
+                argument-expression-list , assignment-expression</pre>
+
+<a name="6.5.2.1" href="#6.5.2.1"><h5>6.5.2.1 Array subscripting</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ One of the expressions shall have type ''pointer to complete object type'', the other
+ expression shall have integer type, and the result has type ''type''.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A postfix expression followed by an expression in square brackets [] is a subscripted
+ designation of an element of an array object. The definition of the subscript operator []
+ is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
+ apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
+ initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
+ element of E1 (counting from zero).
+<p><!--para 3-->
+ Successive subscript operators designate an element of a multidimensional array object.
+ If E is an n-dimensional array (n &gt;= 2) with dimensions i x j x . . . x k, then E (used as
+ other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
+ dimensions j x . . . x k. If the unary * operator is applied to this pointer explicitly, or
+ implicitly as a result of subscripting, the result is the referenced (n - 1)-dimensional
+ array, which itself is converted into a pointer if used as other than an lvalue. It follows
+ from this that arrays are stored in row-major order (last subscript varies fastest).
+<p><!--para 4-->
+ EXAMPLE        Consider the array object defined by the declaration
+<pre>
+          int x[3][5];</pre>
+ Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
+ array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
+ a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
+ entails multiplying i by the size of the object to which the pointer points, namely an array of five int
+ objects. The results are added and indirection is applied to yield an array of five ints. When used in the
+ expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
+ yields an int.
+ 
+ Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
+ (<a href="#6.5.3.2">6.5.3.2</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
+
+<a name="6.5.2.2" href="#6.5.2.2"><h5>6.5.2.2 Function calls</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The expression that denotes the called function<sup><a href="#note92"><b>92)</b></a></sup> shall have type pointer to function
+ returning void or returning a complete object type other than an array type.
+<p><!--para 2-->
+ If the expression that denotes the called function has a type that includes a prototype, the
+ number of arguments shall agree with the number of parameters. Each argument shall
+ 
+ 
+<!--page 99 indent 4-->
+ have a type such that its value may be assigned to an object with the unqualified version
+ of the type of its corresponding parameter.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A postfix expression followed by parentheses () containing a possibly empty, comma-
+ separated list of expressions is a function call. The postfix expression denotes the called
+ function. The list of expressions specifies the arguments to the function.
+<p><!--para 4-->
+ An argument may be an expression of any complete object type. In preparing for the call
+ to a function, the arguments are evaluated, and each parameter is assigned the value of the
+ corresponding argument.<sup><a href="#note93"><b>93)</b></a></sup>
+<p><!--para 5-->
+ If the expression that denotes the called function has type pointer to function returning an
+ object type, the function call expression has the same type as that object type, and has the
+ value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void.         *
+<p><!--para 6-->
+ If the expression that denotes the called function has a type that does not include a
+ prototype, the integer promotions are performed on each argument, and arguments that
+ have type float are promoted to double. These are called the default argument
+ promotions. If the number of arguments does not equal the number of parameters, the
+ behavior is undefined. If the function is defined with a type that includes a prototype, and
+ either the prototype ends with an ellipsis (, ...) or the types of the arguments after
+ promotion are not compatible with the types of the parameters, the behavior is undefined.
+ If the function is defined with a type that does not include a prototype, and the types of
+ the arguments after promotion are not compatible with those of the parameters after
+ promotion, the behavior is undefined, except for the following cases:
+<ul>
+<li>  one promoted type is a signed integer type, the other promoted type is the
+ corresponding unsigned integer type, and the value is representable in both types;
+<li>  both types are pointers to qualified or unqualified versions of a character type or
+ void.
+</ul>
+<p><!--para 7-->
+ If the expression that denotes the called function has a type that does include a prototype,
+ the arguments are implicitly converted, as if by assignment, to the types of the
+ corresponding parameters, taking the type of each parameter to be the unqualified version
+ of its declared type. The ellipsis notation in a function prototype declarator causes
+ argument type conversion to stop after the last declared parameter. The default argument
+ promotions are performed on trailing arguments.
+ 
+ 
+ 
+<!--page 100 indent 5-->
+<p><!--para 8-->
+ No other conversions are performed implicitly; in particular, the number and types of
+ arguments are not compared with those of the parameters in a function definition that
+ does not include a function prototype declarator.
+<p><!--para 9-->
+ If the function is defined with a type that is not compatible with the type (of the
+ expression) pointed to by the expression that denotes the called function, the behavior is
+ undefined.
+<p><!--para 10-->
+ There is a sequence point after the evaluations of the function designator and the actual
+ arguments but before the actual call. Every evaluation in the calling function (including
+ other function calls) that is not otherwise specifically sequenced before or after the
+ execution of the body of the called function is indeterminately sequenced with respect to
+ the execution of the called function.<sup><a href="#note94"><b>94)</b></a></sup>
+<p><!--para 11-->
+ Recursive function calls shall be permitted, both directly and indirectly through any chain
+ of other functions.
+<p><!--para 12-->
+ EXAMPLE        In the function call
+<pre>
+          (*pf[f1()]) (f2(), f3() + f4())</pre>
+ the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
+ the function pointed to by pf[f1()] is called.
+ 
+ Forward references: function declarators (including prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), function
+ definitions (<a href="#6.9.1">6.9.1</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note92">92)</a> Most often, this is the result of converting an identifier that is a function designator.
+
+<p><a name="note93">93)</a> A function may change the values of its parameters, but these changes cannot affect the values of the
+ arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
+ change the value of the object pointed to. A parameter declared to have array or function type is
+ adjusted to have a pointer type as described in <a href="#6.9.1">6.9.1</a>.
+
+<p><a name="note94">94)</a> In other words, function executions do not ''interleave'' with each other.
+
+
+<a name="6.5.2.3" href="#6.5.2.3"><h5>6.5.2.3 Structure and union members</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The first operand of the . operator shall have an atomic, qualified, or unqualified
+ structure or union type, and the second operand shall name a member of that type.
+<p><!--para 2-->
+ The first operand of the -&gt; operator shall have type ''pointer to atomic, qualified, or
+ unqualified structure'' or ''pointer to atomic, qualified, or unqualified union'', and the
+ second operand shall name a member of the type pointed to.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A postfix expression followed by the . operator and an identifier designates a member of
+ a structure or union object. The value is that of the named member,<sup><a href="#note95"><b>95)</b></a></sup> and is an lvalue if
+ the first expression is an lvalue. If the first expression has qualified type, the result has
+ the so-qualified version of the type of the designated member.
+ 
+<!--page 101 indent 4-->
+<p><!--para 4-->
+ A postfix expression followed by the -&gt; operator and an identifier designates a member
+ of a structure or union object. The value is that of the named member of the object to
+ which the first expression points, and is an lvalue.<sup><a href="#note96"><b>96)</b></a></sup> If the first expression is a pointer to
+ a qualified type, the result has the so-qualified version of the type of the designated
+ member.
+<p><!--para 5-->
+ Accessing a member of an atomic structure or union object results in undefined
+ behavior.<sup><a href="#note97"><b>97)</b></a></sup>
+<p><!--para 6-->
+ One special guarantee is made in order to simplify the use of unions: if a union contains
+ several structures that share a common initial sequence (see below), and if the union
+ object currently contains one of these structures, it is permitted to inspect the common
+ initial part of any of them anywhere that a declaration of the completed type of the union
+ is visible. Two structures share a common initial sequence if corresponding members
+ have compatible types (and, for bit-fields, the same widths) for a sequence of one or more
+ initial members.
+<p><!--para 7-->
+ EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
+ union, f().x is a valid postfix expression but is not an lvalue.
+ 
+<p><!--para 8-->
+ EXAMPLE 2       In:
+<pre>
+          struct s { int i; const int ci; };
+          struct s s;
+          const struct s cs;
+          volatile struct s vs;</pre>
+ the various members have the types:
+<pre>
+          s.i          int
+          s.ci         const int
+          cs.i         const int
+          cs.ci        const int
+          vs.i         volatile int
+          vs.ci        volatile const int</pre>
+ 
+ 
+ 
+ 
+<!--page 102 indent 4-->
+<p><!--para 9-->
+ EXAMPLE 3       The following is a valid fragment:
+<pre>
+          union {
                   struct {
-                        int f1;
-                        struct s f2;
-                  } u1;
+                        int      alltypes;
+                  } n;
                   struct {
-                        struct s f3;
-                        int f4;
-                  } u2;
-            } g;
-            struct s f(void)
-            {
-                  return g.u1.f2;
-            }
+                        int      type;
+                        int      intnode;
+                  } ni;
+                  struct {
+                        int      type;
+                        double doublenode;
+                  } nf;
+          } u;
+          u.nf.type = 1;
+          u.nf.doublenode = <a href="#3.14">3.14</a>;
+          /* ... */
+          if (u.n.alltypes == 1)
+                  if (sin(u.nf.doublenode) == 0.0)
+                        /* ... */</pre>
+ The following is not a valid fragment (because the union type is not visible within function f):
+<pre>
+          struct t1 { int m; };
+          struct t2 { int m; };
+          int f(struct t1 *p1, struct t2 *p2)
+          {
+                if (p1-&gt;m &lt; 0)
+                        p2-&gt;m = -p2-&gt;m;
+                return p1-&gt;m;
+          }
+          int g()
+          {
+                union {
+                        struct t1 s1;
+                        struct t2 s2;
+                } u;
+                /* ... */
+                return f(&amp;u.s1, &amp;u.s2);
+          }</pre>
+ 
+ Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
+ specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
+<!--page 103 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note95">95)</a> If the member used to read the contents of a union object is not the same as the member last used to
+ store a value in the object, the appropriate part of the object representation of the value is reinterpreted
+ as an object representation in the new type as described in <a href="#6.2.6">6.2.6</a> (a process sometimes called ''type
+ punning''). This might be a trap representation.
+
+<p><a name="note96">96)</a> If &amp;E is a valid pointer expression (where &amp; is the ''address-of '' operator, which generates a pointer to
+ its operand), the expression (&amp;E)-&gt;MOS is the same as E.MOS.
+
+<p><a name="note97">97)</a> For example, a data race would occur if access to the entire structure or union in one thread conflicts
+ with access to a member from another thread, where at least one access is a modification. Members
+ can be safely accessed using a non-atomic object which is assigned to or from the atomic object.
+
+
+<a name="6.5.2.4" href="#6.5.2.4"><h5>6.5.2.4 Postfix increment and decrement operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the postfix increment or decrement operator shall have atomic, qualified,
+ or unqualified real or pointer type, and shall be a modifiable lvalue.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The result of the postfix ++ operator is the value of the operand. As a side effect, the
+ value of the operand object is incremented (that is, the value 1 of the appropriate type is
+ added to it). See the discussions of additive operators and compound assignment for
+ information on constraints, types, and conversions and the effects of operations on
+ pointers. The value computation of the result is sequenced before the side effect of
+ updating the stored value of the operand. With respect to an indeterminately-sequenced
+ function call, the operation of postfix ++ is a single evaluation. Postfix ++ on an object
+ with atomic type is a read-modify-write operation with memory_order_seq_cst
+ memory order semantics.<sup><a href="#note98"><b>98)</b></a></sup>
+<p><!--para 3-->
+ The postfix -- operator is analogous to the postfix ++ operator, except that the value of
+ the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
+ it).
+ Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note98">98)</a> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
+ where T is the type of E:
+
+<pre>
+          T tmp;
+          T result = E;
+          do {
+                 tmp = result + 1;
+          } while (!atomic_compare_exchange_strong(&amp;E, &amp;result, tmp));</pre>
+  with result being the result of the operation.
+
+
+<a name="6.5.2.5" href="#6.5.2.5"><h5>6.5.2.5 Compound literals</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The type name shall specify a complete object type or an array of unknown size, but not a
+ variable length array type.
+<p><!--para 2-->
+ All the constraints for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A postfix expression that consists of a parenthesized type name followed by a brace-
+ enclosed list of initializers is a compound literal. It provides an unnamed object whose
+ value is given by the initializer list.<sup><a href="#note99"><b>99)</b></a></sup>
+ 
+ 
+<!--page 104 indent 5-->
+<p><!--para 4-->
+ If the type name specifies an array of unknown size, the size is determined by the
+ initializer list as specified in <a href="#6.7.9">6.7.9</a>, and the type of the compound literal is that of the
+ completed array type. Otherwise (when the type name specifies an object type), the type
+ of the compound literal is that specified by the type name. In either case, the result is an
+ lvalue.
+<p><!--para 5-->
+ The value of the compound literal is that of an unnamed object initialized by the
+ initializer list. If the compound literal occurs outside the body of a function, the object
+ has static storage duration; otherwise, it has automatic storage duration associated with
+ the enclosing block.
+<p><!--para 6-->
+ All the semantic rules for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.<sup><a href="#note100"><b>100)</b></a></sup>
+<p><!--para 7-->
+ String literals, and compound literals with const-qualified types, need not designate
+ distinct objects.<sup><a href="#note101"><b>101)</b></a></sup>
+<p><!--para 8-->
+ EXAMPLE 1       The file scope definition
+<pre>
+          int *p = (int []){2, 4};</pre>
+ initializes p to point to the first element of an array of two ints, the first having the value two and the
+ second, four. The expressions in this compound literal are required to be constant. The unnamed object
+ has static storage duration.
+ 
+<p><!--para 9-->
+ EXAMPLE 2       In contrast, in
+<pre>
+          void f(void)
+          {
+                int *p;
+                /*...*/
+                p = (int [2]){*p};
+                /*...*/
+          }</pre>
+ p is assigned the address of the first element of an array of two ints, the first having the value previously
+ pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
+ unnamed object has automatic storage duration.
+ 
+<p><!--para 10-->
+ EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
+ created using compound literals can be passed to functions without depending on member order:
+<pre>
+          drawline((struct point){.x=1, .y=1},
+                (struct point){.x=3, .y=4});</pre>
+ Or, if drawline instead expected pointers to struct point:
+ 
+ 
+ 
+<!--page 105 indent 5-->
+<pre>
+          drawline(&amp;(struct point){.x=1, .y=1},
+                &amp;(struct point){.x=3, .y=4});</pre>
+ 
+<p><!--para 11-->
+ EXAMPLE 4        A read-only compound literal can be specified through constructions like:
+<pre>
+          (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}</pre>
+ 
+<p><!--para 12-->
+ EXAMPLE 5        The following three expressions have different meanings:
+<pre>
+          "/tmp/fileXXXXXX"
+          (char []){"/tmp/fileXXXXXX"}
+          (const char []){"/tmp/fileXXXXXX"}</pre>
+ The first always has static storage duration and has type array of char, but need not be modifiable; the last
+ two have automatic storage duration when they occur within the body of a function, and the first of these
+ two is modifiable.
+ 
+<p><!--para 13-->
+ EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
+ and can even be shared. For example,
+<pre>
+          (const char []){"abc"} == "abc"</pre>
+ might yield 1 if the literals' storage is shared.
+ 
+<p><!--para 14-->
+ EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
+ linked object. For example, there is no way to write a self-referential compound literal that could be used
+ as the function argument in place of the named object endless_zeros below:
+<pre>
+          struct int_list { int car; struct int_list *cdr; };
+          struct int_list endless_zeros = {0, &amp;endless_zeros};
+          eval(endless_zeros);</pre>
+ 
+<p><!--para 15-->
+ EXAMPLE 8        Each compound literal creates only a single object in a given scope:
+<pre>
+          struct s { int i; };
+          int f (void)
+          {
+                struct s *p = 0, *q;
+                int j = 0;
+          again:
+                    q = p, p = &amp;((struct s){ j++ });
+                    if (j &lt; 2) goto again;
+                    return p == q &amp;&amp; q-&gt;i == 1;
+          }</pre>
+ The function f() always returns the value 1.
+<p><!--para 16-->
+ Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
+ lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
+ have an indeterminate value, which would result in undefined behavior.
+ 
+ Forward references: type names (<a href="#6.7.7">6.7.7</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+<!--page 106 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note99">99)</a> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
+ or void only, and the result of a cast expression is not an lvalue.
+
+<p><a name="note100">100)</a> For example, subobjects without explicit initializers are initialized to zero.
+
+<p><a name="note101">101)</a> This allows implementations to share storage for string literals and constant compound literals with
+ the same or overlapping representations.
+
+
+<a name="6.5.3" href="#6.5.3"><h4>6.5.3 Unary operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          unary-expression:
+                 postfix-expression
+                 ++ unary-expression
+                 -- unary-expression
+                 unary-operator cast-expression
+                 sizeof unary-expression
+                 sizeof ( type-name )
+                 alignof ( type-name )
+          unary-operator: one of
+                 &amp; * + - ~             !</pre>
+
+<a name="6.5.3.1" href="#6.5.3.1"><h5>6.5.3.1 Prefix increment and decrement operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the prefix increment or decrement operator shall have atomic, qualified,
+ or unqualified real or pointer type, and shall be a modifiable lvalue.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The value of the operand of the prefix ++ operator is incremented. The result is the new
+ value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
+ See the discussions of additive operators and compound assignment for information on
+ constraints, types, side effects, and conversions and the effects of operations on pointers.
+<p><!--para 3-->
+ The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
+ operand is decremented.
+ Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+
+<a name="6.5.3.2" href="#6.5.3.2"><h5>6.5.3.2 Address and indirection operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the unary &amp; operator shall be either a function designator, the result of a
+ [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
+ not declared with the register storage-class specifier.
+<p><!--para 2-->
+ The operand of the unary * operator shall have pointer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The unary &amp; operator yields the address of its operand. If the operand has type ''type'',
+ the result has type ''pointer to type''. If the operand is the result of a unary * operator,
+ neither that operator nor the &amp; operator is evaluated and the result is as if both were
+ omitted, except that the constraints on the operators still apply and the result is not an
+<!--page 107 indent 4-->
+ lvalue. Similarly, if the operand is the result of a [] operator, neither the &amp; operator nor
+ the unary * that is implied by the [] is evaluated and the result is as if the &amp; operator
+ were removed and the [] operator were changed to a + operator. Otherwise, the result is
+ a pointer to the object or function designated by its operand.
+<p><!--para 4-->
+ The unary * operator denotes indirection. If the operand points to a function, the result is
+ a function designator; if it points to an object, the result is an lvalue designating the
+ object. If the operand has type ''pointer to type'', the result has type ''type''. If an
+ invalid value has been assigned to the pointer, the behavior of the unary * operator is
+ undefined.<sup><a href="#note102"><b>102)</b></a></sup>
+ Forward references: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note102">102)</a> Thus, &amp;*E is equivalent to E (even if E is a null pointer), and &amp;(E1[E2]) to ((E1)+(E2)). It is
+ always true that if E is a function designator or an lvalue that is a valid operand of the unary &amp;
+ operator, *&amp;E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
+ an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
+ Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
+ address inappropriately aligned for the type of object pointed to, and the address of an object after the
+ end of its lifetime.
+
+
+<a name="6.5.3.3" href="#6.5.3.3"><h5>6.5.3.3 Unary arithmetic operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
+ integer type; of the ! operator, scalar type.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The result of the unary + operator is the value of its (promoted) operand. The integer
+ promotions are performed on the operand, and the result has the promoted type.
+<p><!--para 3-->
+ The result of the unary - operator is the negative of its (promoted) operand. The integer
+ promotions are performed on the operand, and the result has the promoted type.
+<p><!--para 4-->
+ The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
+ each bit in the result is set if and only if the corresponding bit in the converted operand is
+ not set). The integer promotions are performed on the operand, and the result has the
+ promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
+ to the maximum value representable in that type minus E.
+<p><!--para 5-->
+ The result of the logical negation operator ! is 0 if the value of its operand compares
+ unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int.
+ The expression !E is equivalent to (0==E).
+ 
+ 
+ 
+<!--page 108 indent 4-->
+
+<a name="6.5.3.4" href="#6.5.3.4"><h5>6.5.3.4 The sizeof and alignof operators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The sizeof operator shall not be applied to an expression that has function type or an
+ incomplete type, to the parenthesized name of such a type, or to an expression that
+ designates a bit-field member. The alignof operator shall not be applied to a function
+ type or an incomplete type.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The sizeof operator yields the size (in bytes) of its operand, which may be an
+ expression or the parenthesized name of a type. The size is determined from the type of
+ the operand. The result is an integer. If the type of the operand is a variable length array
+ type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
+ integer constant.
+<p><!--para 3-->
+ The alignof operator yields the alignment requirement of its operand type. The result
+ is an integer constant. When applied to an array type, the result is the alignment
+ requirement of the element type.
+<p><!--para 4-->
+ When sizeof is applied to an operand that has type char, unsigned char, or
+ signed char, (or a qualified version thereof) the result is 1. When applied to an
+ operand that has array type, the result is the total number of bytes in the array.<sup><a href="#note103"><b>103)</b></a></sup> When
+ applied to an operand that has structure or union type, the result is the total number of
+ bytes in such an object, including internal and trailing padding.
+<p><!--para 5-->
+ The value of the result of both operators is implementation-defined, and its type (an
+ unsigned integer type) is size_t, defined in &lt;stddef.h&gt; (and other headers).
+<p><!--para 6-->
+ EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
+ allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
+ allocate and return a pointer to void. For example:
+<pre>
+         extern void *alloc(size_t);
+         double *dp = alloc(sizeof *dp);</pre>
+ The implementation of the alloc function should ensure that its return value is aligned suitably for
+ conversion to a pointer to double.
+ 
+<p><!--para 7-->
+ EXAMPLE 2      Another use of the sizeof operator is to compute the number of elements in an array:
+<pre>
+         sizeof array / sizeof array[0]</pre>
+ 
+<p><!--para 8-->
+ EXAMPLE 3      In this example, the size of a variable length array is computed and returned from a
+ function:
+<pre>
+         #include &lt;stddef.h&gt;</pre>
+ 
+ 
+ 
+<!--page 109 indent 4-->
+<pre>
+          size_t fsize3(int n)
+          {
+                char b[n+3];                  // variable length array
+                return sizeof b;              // execution time sizeof
+          }
+          int main()
+          {
+                size_t size;
+                size = fsize3(10); // fsize3 returns 13
+                return 0;
+          }</pre>
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.19">7.19</a>), declarations (<a href="#6.7">6.7</a>),
+ structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.7">6.7.7</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note103">103)</a> When applied to a parameter declared to have array or function type, the sizeof operator yields the
+ size of the adjusted (pointer) type (see <a href="#6.9.1">6.9.1</a>).
+
+
+<a name="6.5.4" href="#6.5.4"><h4>6.5.4 Cast operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          cast-expression:
+                 unary-expression
+                 ( type-name ) cast-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Unless the type name specifies a void type, the type name shall specify atomic, qualified,
+ or unqualified scalar type, and the operand shall have scalar type.
+<p><!--para 3-->
+ Conversions that involve pointers, other than where permitted by the constraints of
+ <a href="#6.5.16.1">6.5.16.1</a>, shall be specified by means of an explicit cast.
+<p><!--para 4-->
+ A pointer type shall not be converted to any floating type. A floating type shall not be
+ converted to any pointer type.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ Preceding an expression by a parenthesized type name converts the value of the
+ expression to the named type. This construction is called a cast.<sup><a href="#note104"><b>104)</b></a></sup> A cast that specifies
+ no conversion has no effect on the type or value of an expression.
+<p><!--para 6-->
+ If the value of the expression is represented with greater precision or range than required
+ by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
+ type of the expression is the same as the named type and removes any extra range and
+ precision.
+ Forward references: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
+ prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
+ 
+<!--page 110 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note104">104)</a> A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the
+ unqualified version of the type.
+
+
+<a name="6.5.5" href="#6.5.5"><h4>6.5.5 Multiplicative operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          multiplicative-expression:
+                  cast-expression
+                  multiplicative-expression * cast-expression
+                  multiplicative-expression / cast-expression
+                  multiplicative-expression % cast-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have arithmetic type. The operands of the % operator shall
+ have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the binary * operator is the product of the operands.
+<p><!--para 5-->
+ The result of the / operator is the quotient from the division of the first operand by the
+ second; the result of the % operator is the remainder. In both operations, if the value of
+ the second operand is zero, the behavior is undefined.
+<p><!--para 6-->
+ When integers are divided, the result of the / operator is the algebraic quotient with any
+ fractional part discarded.<sup><a href="#note105"><b>105)</b></a></sup> If the quotient a/b is representable, the expression
+ (a/b)*b + a%b shall equal a; otherwise, the behavior of both a/b and a%b is
+ undefined.
+
+<h6>footnotes</h6>
+<p><a name="note105">105)</a> This is often called ''truncation toward zero''.
+
+
+<a name="6.5.6" href="#6.5.6"><h4>6.5.6 Additive operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          additive-expression:
+                 multiplicative-expression
+                 additive-expression + multiplicative-expression
+                 additive-expression - multiplicative-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ For addition, either both operands shall have arithmetic type, or one operand shall be a
+ pointer to a complete object type and the other shall have integer type. (Incrementing is
+ equivalent to adding 1.)
+<p><!--para 3-->
+ For subtraction, one of the following shall hold:
+ 
+ 
+ 
+ 
+<!--page 111 indent 4-->
+<ul>
+<li>  both operands have arithmetic type;
+<li>  both operands are pointers to qualified or unqualified versions of compatible complete
+ object types; or
+<li>  the left operand is a pointer to a complete object type and the right operand has
+ integer type.
+</ul>
+ (Decrementing is equivalent to subtracting 1.)
+<h6>Semantics</h6>
+<p><!--para 4-->
+ If both operands have arithmetic type, the usual arithmetic conversions are performed on
+ them.
+<p><!--para 5-->
+ The result of the binary + operator is the sum of the operands.
+<p><!--para 6-->
+ The result of the binary - operator is the difference resulting from the subtraction of the
+ second operand from the first.
+<p><!--para 7-->
+ For the purposes of these operators, a pointer to an object that is not an element of an
+ array behaves the same as a pointer to the first element of an array of length one with the
+ type of the object as its element type.
+<p><!--para 8-->
+ When an expression that has integer type is added to or subtracted from a pointer, the
+ result has the type of the pointer operand. If the pointer operand points to an element of
+ an array object, and the array is large enough, the result points to an element offset from
+ the original element such that the difference of the subscripts of the resulting and original
+ array elements equals the integer expression. In other words, if the expression P points to
+ the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and
+ (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of
+ the array object, provided they exist. Moreover, if the expression P points to the last
+ element of an array object, the expression (P)+1 points one past the last element of the
+ array object, and if the expression Q points one past the last element of an array object,
+ the expression (Q)-1 points to the last element of the array object. If both the pointer
+ operand and the result point to elements of the same array object, or one past the last
+ element of the array object, the evaluation shall not produce an overflow; otherwise, the
+ behavior is undefined. If the result points one past the last element of the array object, it
+ shall not be used as the operand of a unary * operator that is evaluated.
+<p><!--para 9-->
+ When two pointers are subtracted, both shall point to elements of the same array object,
+ or one past the last element of the array object; the result is the difference of the
+ subscripts of the two array elements. The size of the result is implementation-defined,
+ and its type (a signed integer type) is ptrdiff_t defined in the &lt;stddef.h&gt; header.
+ If the result is not representable in an object of that type, the behavior is undefined. In
+ other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
+ an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
+<!--page 112 indent 5-->
+ object of type ptrdiff_t. Moreover, if the expression P points either to an element of
+ an array object or one past the last element of an array object, and the expression Q points
+ to the last element of the same array object, the expression ((Q)+1)-(P) has the same
+ value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the
+ expression P points one past the last element of the array object, even though the
+ expression (Q)+1 does not point to an element of the array object.<sup><a href="#note106"><b>106)</b></a></sup>
+<p><!--para 10-->
+ EXAMPLE        Pointer arithmetic is well defined with pointers to variable length array types.
+<p><!--para 11-->
+<pre>
+          {
+                   int n = 4, m = 3;
+                   int a[n][m];
+                   int (*p)[m] = a;            //   p == &amp;a[0]
+                   p += 1;                     //   p == &amp;a[1]
+                   (*p)[2] = 99;               //   a[1][2] == 99
+                   n = p - a;                  //   n == 1
+          }</pre>
+ If array a in the above example were declared to be an array of known constant size, and pointer p were
+ declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
+ the same.
+ 
+ Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), common definitions &lt;stddef.h&gt;
+ (<a href="#7.19">7.19</a>).
+
+<h6>footnotes</h6>
+<p><a name="note106">106)</a> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
+ this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
+ by the size of the object originally pointed to, and the resulting pointer is converted back to the
+ original type. For pointer subtraction, the result of the difference between the character pointers is
+ similarly divided by the size of the object originally pointed to.
+ When viewed in this way, an implementation need only provide one extra byte (which may overlap
+ another object in the program) just after the end of the object in order to satisfy the ''one past the last
+ element'' requirements.
+
+
+<a name="6.5.7" href="#6.5.7"><h4>6.5.7 Bitwise shift operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          shift-expression:
+                  additive-expression
+                  shift-expression &lt;&lt; additive-expression
+                  shift-expression &gt;&gt; additive-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The integer promotions are performed on each of the operands. The type of the result is
+ that of the promoted left operand. If the value of the right operand is negative or is
+ 
+<!--page 113 indent 4-->
+ greater than or equal to the width of the promoted left operand, the behavior is undefined.
+<p><!--para 4-->
+ The result of E1 &lt;&lt; E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
+ zeros. If E1 has an unsigned type, the value of the result is E1 x 2E2 , reduced modulo
+ one more than the maximum value representable in the result type. If E1 has a signed
+ type and nonnegative value, and E1 x 2E2 is representable in the result type, then that is
+ the resulting value; otherwise, the behavior is undefined.
+<p><!--para 5-->
+ The result of E1 &gt;&gt; E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
+ or if E1 has a signed type and a nonnegative value, the value of the result is the integral
+ part of the quotient of E1 / 2E2 . If E1 has a signed type and a negative value, the
+ resulting value is implementation-defined.
+
+<a name="6.5.8" href="#6.5.8"><h4>6.5.8 Relational operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          relational-expression:
+                  shift-expression
+                  relational-expression   &lt;    shift-expression
+                  relational-expression   &gt;    shift-expression
+                  relational-expression   &lt;=   shift-expression
+                  relational-expression   &gt;=   shift-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ One of the following shall hold:
+<ul>
+<li>  both operands have real type; or                                                            *
+<li>  both operands are pointers to qualified or unqualified versions of compatible object
+ types.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 3-->
+ If both of the operands have arithmetic type, the usual arithmetic conversions are
+ performed.
+<p><!--para 4-->
+ For the purposes of these operators, a pointer to an object that is not an element of an
+ array behaves the same as a pointer to the first element of an array of length one with the
+ type of the object as its element type.
+<p><!--para 5-->
+ When two pointers are compared, the result depends on the relative locations in the
+ address space of the objects pointed to. If two pointers to object types both point to the
+ same object, or both point one past the last element of the same array object, they
+ compare equal. If the objects pointed to are members of the same aggregate object,
+ pointers to structure members declared later compare greater than pointers to members
+ declared earlier in the structure, and pointers to array elements with larger subscript
+ values compare greater than pointers to elements of the same array with lower subscript
+<!--page 114 indent 4-->
+ values. All pointers to members of the same union object compare equal. If the
+ expression P points to an element of an array object and the expression Q points to the
+ last element of the same array object, the pointer expression Q+1 compares greater than
+ P. In all other cases, the behavior is undefined.
+<p><!--para 6-->
+ Each of the operators &lt; (less than), &gt; (greater than), &lt;= (less than or equal to), and &gt;=
+ (greater than or equal to) shall yield 1 if the specified relation is true and 0 if it is
+ false.<sup><a href="#note107"><b>107)</b></a></sup> The result has type int.
+
+<h6>footnotes</h6>
+<p><a name="note107">107)</a> The expression a&lt;b&lt;c is not interpreted as in ordinary mathematics. As the syntax indicates, it
+ means (a&lt;b)&lt;c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
+
+
+<a name="6.5.9" href="#6.5.9"><h4>6.5.9 Equality operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          equality-expression:
+                 relational-expression
+                 equality-expression == relational-expression
+                 equality-expression != relational-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ One of the following shall hold:
+<ul>
+<li>  both operands have arithmetic type;
+<li>  both operands are pointers to qualified or unqualified versions of compatible types;
+<li>  one operand is a pointer to an object type and the other is a pointer to a qualified or
+ unqualified version of void; or
+<li>  one operand is a pointer and the other is a null pointer constant.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The == (equal to) and != (not equal to) operators are analogous to the relational
+ operators except for their lower precedence.<sup><a href="#note108"><b>108)</b></a></sup> Each of the operators yields 1 if the
+ specified relation is true and 0 if it is false. The result has type int. For any pair of
+ operands, exactly one of the relations is true.
+<p><!--para 4-->
+ If both of the operands have arithmetic type, the usual arithmetic conversions are
+ performed. Values of complex types are equal if and only if both their real parts are equal
+ and also their imaginary parts are equal. Any two values of arithmetic types from
+ different type domains are equal if and only if the results of their conversions to the
+ (complex) result type determined by the usual arithmetic conversions are equal.
+ 
+ 
+ 
+<!--page 115 indent 4-->
+<p><!--para 5-->
+ Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
+ null pointer constant, the null pointer constant is converted to the type of the pointer. If
+ one operand is a pointer to an object type and the other is a pointer to a qualified or
+ unqualified version of void, the former is converted to the type of the latter.
+<p><!--para 6-->
+ Two pointers compare equal if and only if both are null pointers, both are pointers to the
+ same object (including a pointer to an object and a subobject at its beginning) or function,
+ both are pointers to one past the last element of the same array object, or one is a pointer
+ to one past the end of one array object and the other is a pointer to the start of a different
+ array object that happens to immediately follow the first array object in the address
+ space.<sup><a href="#note109"><b>109)</b></a></sup>
+<p><!--para 7-->
+ For the purposes of these operators, a pointer to an object that is not an element of an
+ array behaves the same as a pointer to the first element of an array of length one with the
+ type of the object as its element type.
+
+<h6>footnotes</h6>
+<p><a name="note108">108)</a> Because of the precedences, a&lt;b == c&lt;d is 1 whenever a&lt;b and c&lt;d have the same truth-value.
+
+<p><a name="note109">109)</a> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
+ adjacent members of a structure with no padding between them, or because the implementation chose
+ to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
+ outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
+ behavior.
+
+
+<a name="6.5.10" href="#6.5.10"><h4>6.5.10 Bitwise AND operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          AND-expression:
+                equality-expression
+                AND-expression &amp; equality-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the binary &amp; operator is the bitwise AND of the operands (that is, each bit in
+ the result is set if and only if each of the corresponding bits in the converted operands is
+ set).
+ 
+ 
+ 
+ 
+<!--page 116 indent 4-->
+
+<a name="6.5.11" href="#6.5.11"><h4>6.5.11 Bitwise exclusive OR operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          exclusive-OR-expression:
+                  AND-expression
+                  exclusive-OR-expression ^ AND-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
+ in the result is set if and only if exactly one of the corresponding bits in the converted
+ operands is set).
+
+<a name="6.5.12" href="#6.5.12"><h4>6.5.12 Bitwise inclusive OR operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          inclusive-OR-expression:
+                  exclusive-OR-expression
+                  inclusive-OR-expression | exclusive-OR-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have integer type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The usual arithmetic conversions are performed on the operands.
+<p><!--para 4-->
+ The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
+ the result is set if and only if at least one of the corresponding bits in the converted
+ operands is set).
+<!--page 117 indent 4-->
+
+<a name="6.5.13" href="#6.5.13"><h4>6.5.13 Logical AND operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          logical-AND-expression:
+                  inclusive-OR-expression
+                  logical-AND-expression &amp;&amp; inclusive-OR-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have scalar type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The &amp;&amp; operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
+ yields 0. The result has type int.
+<p><!--para 4-->
+ Unlike the bitwise binary &amp; operator, the &amp;&amp; operator guarantees left-to-right evaluation;
+ if the second operand is evaluated, there is a sequence point between the evaluations of
+ the first and second operands. If the first operand compares equal to 0, the second
+ operand is not evaluated.
+
+<a name="6.5.14" href="#6.5.14"><h4>6.5.14 Logical OR operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          logical-OR-expression:
+                  logical-AND-expression
+                  logical-OR-expression || logical-AND-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Each of the operands shall have scalar type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
+ yields 0. The result has type int.
+<p><!--para 4-->
+ Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; if the
+ second operand is evaluated, there is a sequence point between the evaluations of the first
+ and second operands. If the first operand compares unequal to 0, the second operand is
+ not evaluated.
+<!--page 118 indent 4-->
+
+<a name="6.5.15" href="#6.5.15"><h4>6.5.15 Conditional operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          conditional-expression:
+                 logical-OR-expression
+                 logical-OR-expression ? expression : conditional-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The first operand shall have scalar type.
+<p><!--para 3-->
+ One of the following shall hold for the second and third operands:
+<ul>
+<li>  both operands have arithmetic type;
+<li>  both operands have the same structure or union type;
+<li>  both operands have void type;
+<li>  both operands are pointers to qualified or unqualified versions of compatible types;
+<li>  one operand is a pointer and the other is a null pointer constant; or
+<li>  one operand is a pointer to an object type and the other is a pointer to a qualified or
+ unqualified version of void.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The first operand is evaluated; there is a sequence point between its evaluation and the
+ evaluation of the second or third operand (whichever is evaluated). The second operand
+ is evaluated only if the first compares unequal to 0; the third operand is evaluated only if
+ the first compares equal to 0; the result is the value of the second or third operand
+ (whichever is evaluated), converted to the type described below.<sup><a href="#note110"><b>110)</b></a></sup>                        *
+<p><!--para 5-->
+ If both the second and third operands have arithmetic type, the result type that would be
+ determined by the usual arithmetic conversions, were they applied to those two operands,
+ is the type of the result. If both the operands have structure or union type, the result has
+ that type. If both operands have void type, the result has void type.
+<p><!--para 6-->
+ If both the second and third operands are pointers or one is a null pointer constant and the
+ other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
+ of the types referenced by both operands. Furthermore, if both operands are pointers to
+ compatible types or to differently qualified versions of compatible types, the result type is
+ a pointer to an appropriately qualified version of the composite type; if one operand is a
+ null pointer constant, the result has the type of the other operand; otherwise, one operand
+ is a pointer to void or a qualified version of void, in which case the result type is a
+ pointer to an appropriately qualified version of void.
+ 
+<!--page 119 indent 4-->
+<p><!--para 7-->
+ EXAMPLE The common type that results when the second and third operands are pointers is determined
+ in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
+ pointers have compatible types.
+<p><!--para 8-->
+ Given the declarations
+<pre>
+           const void *c_vp;
+           void *vp;
+           const int *c_ip;
+           volatile int *v_ip;
+           int *ip;
+           const char *c_cp;</pre>
+ the third column in the following table is the common type that is the result of a conditional expression in
+ which the first two columns are the second and third operands (in either order):
+<pre>
+           c_vp    c_ip      const void *
+           v_ip    0         volatile int *
+           c_ip    v_ip      const volatile int *
+           vp      c_cp      const void *
+           ip      c_ip      const int *
+           vp      ip        void *</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note110">110)</a> A conditional expression does not yield an lvalue.
+
+
+<a name="6.5.16" href="#6.5.16"><h4>6.5.16 Assignment operators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          assignment-expression:
+                 conditional-expression
+                 unary-expression assignment-operator assignment-expression
+          assignment-operator: one of
+                 = *= /= %= +=                       -=     &lt;&lt;=      &gt;&gt;=      &amp;=     ^=     |=</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ An assignment operator shall have a modifiable lvalue as its left operand.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ An assignment operator stores a value in the object designated by the left operand. An
+ assignment expression has the value of the left operand after the assignment,<sup><a href="#note111"><b>111)</b></a></sup> but is not
+ an lvalue. The type of an assignment expression is the type the left operand would have
+ after lvalue conversion. The side effect of updating the stored value of the left operand is
+ sequenced after the value computations of the left and right operands. The evaluations of
+ the operands are unsequenced.
+ 
+ 
+ 
+ 
+<!--page 120 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note111">111)</a> The implementation is permitted to read the object to determine the value but is not required to, even
+ when the object has volatile-qualified type.
+
+
+<a name="6.5.16.1" href="#6.5.16.1"><h5>6.5.16.1 Simple assignment</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ One of the following shall hold:<sup><a href="#note112"><b>112)</b></a></sup>
+<ul>
+<li>  the left operand has atomic, qualified, or unqualified arithmetic type, and the right has
+ arithmetic type;
+<li>  the left operand has an atomic, qualified, or unqualified version of a structure or union
+ type compatible with the type of the right;
+<li>  the left operand has atomic, qualified, or unqualified pointer type, and (considering
+ the type the left operand would have after lvalue conversion) both operands are
+ pointers to qualified or unqualified versions of compatible types, and the type pointed
+ to by the left has all the qualifiers of the type pointed to by the right;
+<li>  the left operand has atomic, qualified, or unqualified pointer type, and (considering
+ the type the left operand would have after lvalue conversion) one operand is a pointer
+ to an object type, and the other is a pointer to a qualified or unqualified version of
+ void, and the type pointed to by the left has all the qualifiers of the type pointed to
+ by the right;
+<li>  the left operand is an atomic, qualified, or unqualified pointer, and the right is a null
+ pointer constant; or
+<li>  the left operand has type atomic, qualified, or unqualified _Bool, and the right is a
+ pointer.
+</ul>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ In simple assignment (=), the value of the right operand is converted to the type of the
+ assignment expression and replaces the value stored in the object designated by the left
+ operand.
+<p><!--para 3-->
+ If the value being stored in an object is read from another object that overlaps in any way
+ the storage of the first object, then the overlap shall be exact and the two objects shall
+ have qualified or unqualified versions of a compatible type; otherwise, the behavior is
+ undefined.
+<p><!--para 4-->
+ EXAMPLE 1       In the program fragment
+ 
+ 
+ 
+ 
+<!--page 121 indent 4-->
+<pre>
+         int f(void);
+         char c;
+         /* ... */
+         if ((c = f()) == -1)
+                 /* ... */</pre>
+ the int value returned by the function may be truncated when stored in the char, and then converted back
+ to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
+ values as unsigned char (and char is narrower than int), the result of the conversion cannot be
+ negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
+ variable c should be declared as int.
+ 
+<p><!--para 5-->
+ EXAMPLE 2       In the fragment:
+<pre>
+         char c;
+         int i;
+         long l;
+         l = (c = i);</pre>
+ the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
+ of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
+ that is, long int type.
+ 
+<p><!--para 6-->
+ EXAMPLE 3       Consider the fragment:
+<pre>
+         const char **cpp;
+         char *p;
+         const char c = 'A';
+         cpp = &amp;p;                  // constraint violation
+         *cpp = &amp;c;                 // valid
+         *p = 0;                    // valid</pre>
+ The first assignment is unsafe because it would allow the following valid code to attempt to change the
+ value of the const object c.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note112">112)</a> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
+ (specified in <a href="#6.3.2.1">6.3.2.1</a>) that changes lvalues to ''the value of the expression'' and thus removes any type
+ qualifiers that were applied to the type category of the expression (for example, it removes const but
+ not volatile from the type int volatile * const).
+
+
+<a name="6.5.16.2" href="#6.5.16.2"><h5>6.5.16.2 Compound assignment</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ For the operators += and -= only, either the left operand shall be an atomic, qualified, or
+ unqualified pointer to a complete object type, and the right shall have integer type; or the
+ left operand shall have atomic, qualified, or unqualified arithmetic type, and the right
+ shall have arithmetic type.
+<p><!--para 2-->
+ For the other operators, the left operand shall have atomic, qualified, or unqualified
+ arithmetic type, and (considering the type the left operand would have after lvalue
+ conversion) each operand shall have arithmetic type consistent with those allowed by the
+ corresponding binary operator.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ A compound assignment of the form E1 op = E2 is equivalent to the simple assignment
+ expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once, and with
+ respect to an indeterminately-sequenced function call, the operation of a compound
+<!--page 122 indent 4-->
+ assignment is a single evaluation. If E1 has an atomic type, compound assignment is a
+ read-modify-write operation with memory_order_seq_cst memory order
+ semantics.<sup><a href="#note113"><b>113)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note113">113)</a> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
+ where T is the type of E1:
+
+<pre>
+          T tmp = E1;
+          T result;
+          do {
+                result = tmp op (E2);
+          } while (!atomic_compare_exchange_strong(&amp;E1, &amp;tmp, result));</pre>
+  with result being the result of the operation.
+
+
+<a name="6.5.17" href="#6.5.17"><h4>6.5.17 Comma operator</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          expression:
+                 assignment-expression
+                 expression , assignment-expression</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The left operand of a comma operator is evaluated as a void expression; there is a
+ sequence point between its evaluation and that of the right operand. Then the right
+ operand is evaluated; the result has its type and value.<sup><a href="#note114"><b>114)</b></a></sup>                        *
+<p><!--para 3-->
+ EXAMPLE As indicated by the syntax, the comma operator (as described in this subclause) cannot
+ appear in contexts where a comma is used to separate items in a list (such as arguments to functions or lists
+ of initializers). On the other hand, it can be used within a parenthesized expression or within the second
+ expression of a conditional operator in such contexts. In the function call
+<pre>
+          f(a, (t=3, t+2), c)</pre>
+ the function has three arguments, the second of which has the value 5.
+ 
+ Forward references: initialization (<a href="#6.7.9">6.7.9</a>).
+ 
+ 
+ 
+ 
+<!--page 123 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note114">114)</a> A comma operator does not yield an lvalue.
+
+
+<a name="6.6" href="#6.6"><h3>6.6 Constant expressions</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          constant-expression:
+                 conditional-expression</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A constant expression can be evaluated during translation rather than runtime, and
+ accordingly may be used in any place that a constant may be.
+<h6>Constraints</h6>
+<p><!--para 3-->
+ Constant expressions shall not contain assignment, increment, decrement, function-call,
+ or comma operators, except when they are contained within a subexpression that is not
+ evaluated.<sup><a href="#note115"><b>115)</b></a></sup>
+<p><!--para 4-->
+ Each constant expression shall evaluate to a constant that is in the range of representable
+ values for its type.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ An expression that evaluates to a constant is required in several contexts. If a floating
+ expression is evaluated in the translation environment, the arithmetic precision and range
+ shall be at least as great as if the expression were being evaluated in the execution
+ environment.<sup><a href="#note116"><b>116)</b></a></sup>
+<p><!--para 6-->
+ An integer constant expression<sup><a href="#note117"><b>117)</b></a></sup> shall have integer type and shall only have operands
+ that are integer constants, enumeration constants, character constants, sizeof
+ expressions whose results are integer constants, and floating constants that are the
+ immediate operands of casts. Cast operators in an integer constant expression shall only
+ convert arithmetic types to integer types, except as part of an operand to the sizeof
+ operator.
+<p><!--para 7-->
+ More latitude is permitted for constant expressions in initializers. Such a constant
+ expression shall be, or evaluate to, one of the following:
+<ul>
+<li>  an arithmetic constant expression,
+ 
+ 
+ 
+<!--page 124 indent 5-->
+<li>  a null pointer constant,
+<li>  an address constant, or
+<li>  an address constant for a complete object type plus or minus an integer constant
+ expression.
+</ul>
+<p><!--para 8-->
+ An arithmetic constant expression shall have arithmetic type and shall only have
+ operands that are integer constants, floating constants, enumeration constants, character
+ constants, and sizeof expressions. Cast operators in an arithmetic constant expression
+ shall only convert arithmetic types to arithmetic types, except as part of an operand to a
+ sizeof operator whose result is an integer constant.
+<p><!--para 9-->
+ An address constant is a null pointer, a pointer to an lvalue designating an object of static
+ storage duration, or a pointer to a function designator; it shall be created explicitly using
+ the unary &amp; operator or an integer constant cast to pointer type, or implicitly by the use of
+ an expression of array or function type. The array-subscript [] and member-access .
+ and -&gt; operators, the address &amp; and indirection * unary operators, and pointer casts may
+ be used in the creation of an address constant, but the value of an object shall not be
+ accessed by use of these operators.
+<p><!--para 10-->
+ An implementation may accept other forms of constant expressions.
+<p><!--para 11-->
+ The semantic rules for the evaluation of a constant expression are the same as for
+ nonconstant expressions.<sup><a href="#note118"><b>118)</b></a></sup>
+ Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+ 
+ 
+ 
+ 
+<!--page 125 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note115">115)</a> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
+
+<p><a name="note116">116)</a> The use of evaluation formats as characterized by FLT_EVAL_METHOD also applies to evaluation in
+ the translation environment.
+
+<p><a name="note117">117)</a> An integer constant expression is required in a number of contexts such as the size of a bit-field
+ member of a structure, the value of an enumeration constant, and the size of a non-variable length
+ array. Further constraints that apply to the integer constant expressions used in conditional-inclusion
+ preprocessing directives are discussed in <a href="#6.10.1">6.10.1</a>.
+
+<p><a name="note118">118)</a> Thus, in the following initialization,
+
+<pre>
+           static int i = 2 || 1 / 0;</pre>
+  the expression is a valid integer constant expression with value one.
+
+
+<a name="6.7" href="#6.7"><h3>6.7 Declarations</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          declaration:
+                 declaration-specifiers init-declarator-listopt ;
+                 static_assert-declaration
+          declaration-specifiers:
+                 storage-class-specifier declaration-specifiersopt
+                 type-specifier declaration-specifiersopt
+                 type-qualifier declaration-specifiersopt
+                 function-specifier declaration-specifiersopt
+                 alignment-specifier declaration-specifiersopt
+          init-declarator-list:
+                  init-declarator
+                  init-declarator-list , init-declarator
+          init-declarator:
+                  declarator
+                  declarator = initializer</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A declaration other than a static_assert declaration shall declare at least a declarator
+ (other than the parameters of a function or the members of a structure or union), a tag, or
+ the members of an enumeration.
+<p><!--para 3-->
+ If an identifier has no linkage, there shall be no more than one declaration of the identifier
+ (in a declarator or type specifier) with the same scope and in the same name space, except
+ that a typedef name can be redefined to denote the same type as it currently does and tags
+ may be redeclared as specified in <a href="#6.7.2.3">6.7.2.3</a>.
+<p><!--para 4-->
+ All declarations in the same scope that refer to the same object or function shall specify
+ compatible types.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ A declaration specifies the interpretation and attributes of a set of identifiers. A definition
+ of an identifier is a declaration for that identifier that:
+<ul>
+<li>  for an object, causes storage to be reserved for that object;
+<li>  for a function, includes the function body;<sup><a href="#note119"><b>119)</b></a></sup>
+ 
+ 
+ 
+<!--page 126 indent 4-->
+<li>  for an enumeration constant or typedef name, is the (only) declaration of the
+ identifier.
+</ul>
+<p><!--para 6-->
+ The declaration specifiers consist of a sequence of specifiers that indicate the linkage,
+ storage duration, and part of the type of the entities that the declarators denote. The init-
+ declarator-list is a comma-separated sequence of declarators, each of which may have
+ additional type information, or an initializer, or both. The declarators contain the
+ identifiers (if any) being declared.
+<p><!--para 7-->
+ If an identifier for an object is declared with no linkage, the type for the object shall be
+ complete by the end of its declarator, or by the end of its init-declarator if it has an
+ initializer; in the case of function parameters (including in prototypes), it is the adjusted
+ type (see <a href="#6.7.6.3">6.7.6.3</a>) that is required to be complete.
+ Forward references: declarators (<a href="#6.7.6">6.7.6</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
+ (<a href="#6.7.9">6.7.9</a>), type names (<a href="#6.7.7">6.7.7</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note119">119)</a> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
+
+
+<a name="6.7.1" href="#6.7.1"><h4>6.7.1 Storage-class specifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          storage-class-specifier:
+                 typedef
+                 extern
+                 static
+                 _Thread_local
+                 auto
+                 register</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ At most, one storage-class specifier may be given in the declaration specifiers in a
+ declaration, except that _Thread_local may appear with static or extern.<sup><a href="#note120"><b>120)</b></a></sup>
+<p><!--para 3-->
+ In the declaration of an object with block scope, if the declaration specifiers include
+ _Thread_local, they shall also include either static or extern. If
+ _Thread_local appears in any declaration of an object, it shall be present in every
+ declaration of that object.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
+ only; it is discussed in <a href="#6.7.8">6.7.8</a>. The meanings of the various linkages and storage durations
+ were discussed in <a href="#6.2.2">6.2.2</a> and <a href="#6.2.4">6.2.4</a>.
+ 
+ 
+ 
+<!--page 127 indent 4-->
+<p><!--para 5-->
+ A declaration of an identifier for an object with storage-class specifier register
+ suggests that access to the object be as fast as possible. The extent to which such
+ suggestions are effective is implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
+<p><!--para 6-->
+ The declaration of an identifier for a function that has block scope shall have no explicit
+ storage-class specifier other than extern.
+<p><!--para 7-->
+ If an aggregate or union object is declared with a storage-class specifier other than
+ typedef, the properties resulting from the storage-class specifier, except with respect to
+ linkage, also apply to the members of the object, and so on recursively for any aggregate
+ or union member objects.
+ Forward references: type definitions (<a href="#6.7.8">6.7.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note120">120)</a> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
+
+<p><a name="note121">121)</a> The implementation may treat any register declaration simply as an auto declaration. However,
+ whether or not addressable storage is actually used, the address of any part of an object declared with
+ storage-class specifier register cannot be computed, either explicitly (by use of the unary &amp;
+ operator as discussed in <a href="#6.5.3.2">6.5.3.2</a>) or implicitly (by converting an array name to a pointer as discussed in
+ <a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operator that can be applied to an array declared with storage-class specifier
+ register is sizeof.
+
+
+<a name="6.7.2" href="#6.7.2"><h4>6.7.2 Type specifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          type-specifier:
+                 void
+                 char
+                 short
+                 int
+                 long
+                 float
+                 double
+                 signed
+                 unsigned
+                 _Bool
+                 _Complex
+                 atomic-type-specifier
+                 struct-or-union-specifier
+                 enum-specifier
+                 typedef-name</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ At least one type specifier shall be given in the declaration specifiers in each declaration,
+ and in the specifier-qualifier list in each struct declaration and type name. Each list of
+ 
+ 
+<!--page 128 indent 4-->
+ type specifiers shall be one of the following multisets (delimited by commas, when there
+ is more than one multiset per item); the type specifiers may occur in any order, possibly
+ intermixed with the other declaration specifiers.
+<ul>
+<li>  void
+<li>  char
+<li>  signed char
+<li>  unsigned char
+<li>  short, signed short, short int, or signed short int
+<li>  unsigned short, or unsigned short int
+<li>  int, signed, or signed int
+<li>  unsigned, or unsigned int
+<li>  long, signed long, long int, or signed long int
+<li>  unsigned long, or unsigned long int
+<li>  long long, signed long long, long long int, or
+ signed long long int
+<li>  unsigned long long, or unsigned long long int
+<li>  float
+<li>  double
+<li>  long double
+<li>  _Bool
+<li>  float _Complex
+<li>  double _Complex
+<li>  long double _Complex
+<li>  atomic type specifier
+<li>  struct or union specifier
+<li>  enum specifier
+<li>  typedef name
+</ul>
+<p><!--para 3-->
+ The type specifier _Complex shall not be used if the implementation does not support
+ complex types (see <a href="#6.10.8.3">6.10.8.3</a>).
+<!--page 129 indent 4-->
+<h6>Semantics</h6>
+<p><!--para 4-->
+ Specifiers for structures, unions, enumerations, and atomic types are discussed in <a href="#6.7.2.1">6.7.2.1</a>
+ through <a href="#6.7.2.4">6.7.2.4</a>. Declarations of typedef names are discussed in <a href="#6.7.8">6.7.8</a>. The
+ characteristics of the other types are discussed in <a href="#6.2.5">6.2.5</a>.
+<p><!--para 5-->
+ Each of the comma-separated multisets designates the same type, except that for bit-
+ fields, it is implementation-defined whether the specifier int designates the same type as
+ signed int or the same type as unsigned int.
+ Forward references: atomic type specifiers (<a href="#6.7.2.4">6.7.2.4</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>),
+ structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+
+<a name="6.7.2.1" href="#6.7.2.1"><h5>6.7.2.1 Structure and union specifiers</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          struct-or-union-specifier:
+                  struct-or-union identifieropt { struct-declaration-list }
+                  struct-or-union identifier
+          struct-or-union:
+                  struct
+                  union
+          struct-declaration-list:
+                  struct-declaration
+                  struct-declaration-list struct-declaration
+          struct-declaration:
+                  specifier-qualifier-list struct-declarator-listopt ;
+                  static_assert-declaration
+          specifier-qualifier-list:
+                 type-specifier specifier-qualifier-listopt
+                 type-qualifier specifier-qualifier-listopt
+          struct-declarator-list:
+                  struct-declarator
+                  struct-declarator-list , struct-declarator
+          struct-declarator:
+                  declarator
+                  declaratoropt : constant-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A struct-declaration that does not declare an anonymous structure or anonymous union
+ shall contain a struct-declarator-list.
+<!--page 130 indent 5-->
+<p><!--para 3-->
+ A structure or union shall not contain a member with incomplete or function type (hence,
+ a structure shall not contain an instance of itself, but may contain a pointer to an instance
+ of itself), except that the last member of a structure with more than one named member
+ may have incomplete array type; such a structure (and any union containing, possibly
+ recursively, a member that is such a structure) shall not be a member of a structure or an
+ element of an array.
+<p><!--para 4-->
+ The expression that specifies the width of a bit-field shall be an integer constant
+ expression with a nonnegative value that does not exceed the width of an object of the
+ type that would be specified were the colon and expression omitted.<sup><a href="#note122"><b>122)</b></a></sup> If the value is
+ zero, the declaration shall have no declarator.
+<p><!--para 5-->
+ A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
+ int, unsigned int, or some other implementation-defined type. It is
+ implementation-defined whether atomic types are permitted.
+<h6>Semantics</h6>
+<p><!--para 6-->
+ As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
+ storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
+ of members whose storage overlap.
+<p><!--para 7-->
+ Structure and union specifiers have the same form. The keywords struct and union
+ indicate that the type being specified is, respectively, a structure type or a union type.
+<p><!--para 8-->
+ The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
+ within a translation unit. The struct-declaration-list is a sequence of declarations for the
+ members of the structure or union. If the struct-declaration-list contains no named
+ members, no anonymous structures, and no anonymous unions, the behavior is undefined.
+ The type is incomplete until immediately after the } that terminates the list, and complete
+ thereafter.
+<p><!--para 9-->
+ A member of a structure or union may have any complete object type other than a
+ variably modified type.<sup><a href="#note123"><b>123)</b></a></sup> In addition, a member may be declared to consist of a
+ specified number of bits (including a sign bit, if any). Such a member is called a
+ bit-field;<sup><a href="#note124"><b>124)</b></a></sup> its width is preceded by a colon.
+<p><!--para 10-->
+ A bit-field is interpreted as having a signed or unsigned integer type consisting of the
+ specified number of bits.<sup><a href="#note125"><b>125)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of
+ 
+<!--page 131 indent 5-->
+ type _Bool, the value of the bit-field shall compare equal to the value stored; a _Bool
+ bit-field has the semantics of a _Bool.
+<p><!--para 11-->
+ An implementation may allocate any addressable storage unit large enough to hold a bit-
+ field. If enough space remains, a bit-field that immediately follows another bit-field in a
+ structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
+ whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is
+ implementation-defined. The order of allocation of bit-fields within a unit (high-order to
+ low-order or low-order to high-order) is implementation-defined. The alignment of the
+ addressable storage unit is unspecified.
+<p><!--para 12-->
+ A bit-field declaration with no declarator, but only a colon and a width, indicates an
+ unnamed bit-field.<sup><a href="#note126"><b>126)</b></a></sup> As a special case, a bit-field structure member with a width of 0
+ indicates that no further bit-field is to be packed into the unit in which the previous bit-
+ field, if any, was placed.
+<p><!--para 13-->
+ An unnamed member of structure type with no tag is called an anonymous structure; an
+ unnamed member of union type with no tag is called an anonymous union. The members
+ of an anonymous structure or union are considered to be members of the containing
+ structure or union. This applies recursively if the containing structure or union is also
+ anonymous.
+<p><!--para 14-->
+ Each non-bit-field member of a structure or union object is aligned in an implementation-
+ defined manner appropriate to its type.
+<p><!--para 15-->
+ Within a structure object, the non-bit-field members and the units in which bit-fields
+ reside have addresses that increase in the order in which they are declared. A pointer to a
+ structure object, suitably converted, points to its initial member (or if that member is a
+ bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
+ padding within a structure object, but not at its beginning.
+<p><!--para 16-->
+ The size of a union is sufficient to contain the largest of its members. The value of at
+ most one of the members can be stored in a union object at any time. A pointer to a
+ union object, suitably converted, points to each of its members (or if a member is a bit-
+ field, then to the unit in which it resides), and vice versa.
+<p><!--para 17-->
+ There may be unnamed padding at the end of a structure or union.
+<p><!--para 18-->
+ As a special case, the last element of a structure with more than one named member may
+ have an incomplete array type; this is called a flexible array member. In most situations,
+ 
+ 
+<!--page 132 indent 5-->
+ the flexible array member is ignored. In particular, the size of the structure is as if the
+ flexible array member were omitted except that it may have more trailing padding than
+ the omission would imply. However, when a . (or -&gt;) operator has a left operand that is
+ (a pointer to) a structure with a flexible array member and the right operand names that
+ member, it behaves as if that member were replaced with the longest array (with the same
+ element type) that would not make the structure larger than the object being accessed; the
+ offset of the array shall remain that of the flexible array member, even if this would differ
+ from that of the replacement array. If this array would have no elements, it behaves as if
+ it had one element but the behavior is undefined if any attempt is made to access that
+ element or to generate a pointer one past it.
+<p><!--para 19-->
+ EXAMPLE 1       The following illustrates anonymous structures and unions:
+<pre>
+          struct v {
+                union {      // anonymous union
+                       struct { int i, j; };    // anonymous structure
+                       struct { long k, l; } w;
+                };
+                int m;
+          } v1;
+          v1.i = 2;   // valid
+          v1.k = 3;   // invalid: inner structure is not anonymous
+          v1.w.k = 5; // valid</pre>
+ 
+<p><!--para 20-->
+ EXAMPLE 2       After the declaration:
+<pre>
+          struct s { int n; double d[]; };</pre>
+ the structure struct s has a flexible array member d. A typical way to use this is:
+<pre>
+          int m = /* some value */;
+          struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));</pre>
+ and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
+ p had been declared as:
+<pre>
+          struct { int n; double d[m]; } *p;</pre>
+ (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
+ not be the same).
+<p><!--para 21-->
+ Following the above declaration:
+<pre>
+          struct s t1 = { 0 };                         //   valid
+          struct s t2 = { 1, { <a href="#4.2">4.2</a> }};                 //   invalid
+          t1.n = 4;                                    //   valid
+          t1.d[0] = <a href="#4.2">4.2</a>;                               //   might be undefined behavior</pre>
+ The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
+ contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
+<pre>
+          sizeof (struct s) &gt;= offsetof(struct s, d) + sizeof (double)</pre>
+ in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
+ code.
+<!--page 133 indent 5-->
+<p><!--para 22-->
+ After the further declaration:
+<pre>
+          struct ss { int n; };</pre>
+ the expressions:
+<pre>
+          sizeof (struct s) &gt;= sizeof (struct ss)
+          sizeof (struct s) &gt;= offsetof(struct s, d)</pre>
+ are always equal to 1.
+<p><!--para 23-->
+ If sizeof (double) is 8, then after the following code is executed:
+<pre>
+          struct s *s1;
+          struct s *s2;
+          s1 = malloc(sizeof (struct s) + 64);
+          s2 = malloc(sizeof (struct s) + 46);</pre>
+ and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
+ purposes, as if the identifiers had been declared as:
+<p><!--para 24-->
+<pre>
+          struct { int n; double d[8]; } *s1;
+          struct { int n; double d[5]; } *s2;</pre>
+ Following the further successful assignments:
+<pre>
+          s1 = malloc(sizeof (struct s) + 10);
+          s2 = malloc(sizeof (struct s) + 6);</pre>
+ they then behave as if the declarations were:
+<pre>
+          struct { int n; double d[1]; } *s1, *s2;</pre>
+ and:
+<p><!--para 25-->
+<pre>
+          double *dp;
+          dp = &amp;(s1-&gt;d[0]);          //   valid
+          *dp = 42;                  //   valid
+          dp = &amp;(s2-&gt;d[0]);          //   valid
+          *dp = 42;                  //   undefined behavior</pre>
+ The assignment:
+<pre>
+          *s1 = *s2;</pre>
+ only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
+ of the structure, they might be copied or simply overwritten with indeterminate values.
+ 
+ Forward references: declarators (<a href="#6.7.6">6.7.6</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>).
+<!--page 134 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note122">122)</a> While the number of bits in a _Bool object is at least CHAR_BIT, the width (number of sign and
+ value bits) of a _Bool may be just 1 bit.
+
+<p><a name="note123">123)</a> A structure or union cannot contain a member with a variably modified type because member names
+ are not ordinary identifiers as defined in <a href="#6.2.3">6.2.3</a>.
+
+<p><a name="note124">124)</a> The unary &amp; (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
+ or arrays of bit-field objects.
+
+<p><a name="note125">125)</a> As specified in <a href="#6.7.2">6.7.2</a> above, if the actual type specifier used is int or a typedef-name defined as int,
+ then it is implementation-defined whether the bit-field is signed or unsigned.
+
+<p><a name="note126">126)</a> An unnamed bit-field structure member is useful for padding to conform to externally imposed
+ layouts.
+
+
+<a name="6.7.2.2" href="#6.7.2.2"><h5>6.7.2.2 Enumeration specifiers</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          enum-specifier:
+                enum identifieropt { enumerator-list }
+                enum identifieropt { enumerator-list , }
+                enum identifier
+          enumerator-list:
+                enumerator
+                enumerator-list , enumerator
+          enumerator:
+                enumeration-constant
+                enumeration-constant = constant-expression</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The expression that defines the value of an enumeration constant shall be an integer
+ constant expression that has a value representable as an int.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The identifiers in an enumerator list are declared as constants that have type int and
+ may appear wherever such are permitted.<sup><a href="#note127"><b>127)</b></a></sup> An enumerator with = defines its
+ enumeration constant as the value of the constant expression. If the first enumerator has
+ no =, the value of its enumeration constant is 0. Each subsequent enumerator with no =
+ defines its enumeration constant as the value of the constant expression obtained by
+ adding 1 to the value of the previous enumeration constant. (The use of enumerators with
+ = may produce enumeration constants with values that duplicate other values in the same
+ enumeration.) The enumerators of an enumeration are also known as its members.
+<p><!--para 4-->
+ Each enumerated type shall be compatible with char, a signed integer type, or an
+ unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note128"><b>128)</b></a></sup> but shall be
+ capable of representing the values of all the members of the enumeration. The
+ enumerated type is incomplete until immediately after the } that terminates the list of
+ enumerator declarations, and complete thereafter.
+ 
+ 
+ 
+ 
+<!--page 135 indent 4-->
+<p><!--para 5-->
+ EXAMPLE       The following fragment:
+<pre>
+          enum hue { chartreuse, burgundy, claret=20, winedark };
+          enum hue col, *cp;
+          col = claret;
+          cp = &amp;col;
+          if (*cp != burgundy)
+                /* ... */</pre>
+ makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
+ pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
+ 
+ Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note127">127)</a> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
+ each other and from other identifiers declared in ordinary declarators.
+
+<p><a name="note128">128)</a> An implementation may delay the choice of which integer type until all enumeration constants have
+ been seen.
+
+
+<a name="6.7.2.3" href="#6.7.2.3"><h5>6.7.2.3 Tags</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A specific type shall have its content defined at most once.
+<p><!--para 2-->
+ Where two declarations that use the same tag declare the same type, they shall both use
+ the same choice of struct, union, or enum.
+<p><!--para 3-->
+ A type specifier of the form
+<pre>
+         enum identifier</pre>
+ without an enumerator list shall only appear after the type it specifies is complete.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ All declarations of structure, union, or enumerated types that have the same scope and
+ use the same tag declare the same type. Irrespective of whether there is a tag or what
+ other declarations of the type are in the same translation unit, the type is incomplete<sup><a href="#note129"><b>129)</b></a></sup>
+ until immediately after the closing brace of the list defining the content, and complete
+ thereafter.
+<p><!--para 5-->
+ Two declarations of structure, union, or enumerated types which are in different scopes or
+ use different tags declare distinct types. Each declaration of a structure, union, or
+ enumerated type which does not include a tag declares a distinct type.
+<p><!--para 6-->
+ A type specifier of the form
+ 
+ 
+ 
+ 
+<!--page 136 indent 5-->
+<pre>
+          struct-or-union identifieropt { struct-declaration-list }</pre>
+ or
+<pre>
+          enum identifieropt { enumerator-list }</pre>
+ or
+<pre>
+          enum identifieropt { enumerator-list , }</pre>
+ declares a structure, union, or enumerated type. The list defines the structure content,
+ union content, or enumeration content. If an identifier is provided,<sup><a href="#note130"><b>130)</b></a></sup> the type specifier
+ also declares the identifier to be the tag of that type.
+<p><!--para 7-->
+ A declaration of the form
+<pre>
+          struct-or-union identifier ;</pre>
+ specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note131"><b>131)</b></a></sup>
+<p><!--para 8-->
+ If a type specifier of the form
+<pre>
+          struct-or-union identifier</pre>
+ occurs other than as part of one of the above forms, and no other declaration of the
+ identifier as a tag is visible, then it declares an incomplete structure or union type, and
+ declares the identifier as the tag of that type.131)
+<p><!--para 9-->
+ If a type specifier of the form
+<pre>
+          struct-or-union identifier</pre>
+ or
+<pre>
+          enum identifier</pre>
+ occurs other than as part of one of the above forms, and a declaration of the identifier as a
+ tag is visible, then it specifies the same type as that other declaration, and does not
+ redeclare the tag.
+<p><!--para 10-->
+ EXAMPLE 1       This mechanism allows declaration of a self-referential structure.
+<pre>
+          struct tnode {
+                int count;
+                struct tnode *left, *right;
+          };</pre>
+ specifies a structure that contains an integer and two pointers to objects of the same type. Once this
+ declaration has been given, the declaration
+ 
+ 
+ 
+ 
+<!--page 137 indent 5-->
+<pre>
+          struct tnode s, *sp;</pre>
+ declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
+ these declarations, the expression sp-&gt;left refers to the left struct tnode pointer of the object to
+ which sp points; the expression s.right-&gt;count designates the count member of the right struct
+ tnode pointed to from s.
+<p><!--para 11-->
+ The following alternative formulation uses the typedef mechanism:
+<pre>
+          typedef struct tnode TNODE;
+          struct tnode {
+                int count;
+                TNODE *left, *right;
+          };
+          TNODE s, *sp;</pre>
+ 
+<p><!--para 12-->
+ EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
+ structures, the declarations
+<pre>
+          struct s1 { struct s2 *s2p; /* ... */ }; // D1
+          struct s2 { struct s1 *s1p; /* ... */ }; // D2</pre>
+ specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
+ declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
+ D2. To eliminate this context sensitivity, the declaration
+<pre>
+          struct s2;</pre>
+ may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
+ completes the specification of the new type.
+ 
+ Forward references: declarators (<a href="#6.7.6">6.7.6</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+
+<h6>footnotes</h6>
+<p><a name="note129">129)</a> An incomplete type may only by used when the size of an object of that type is not needed. It is not
+ needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
+ when a pointer to or a function returning a structure or union is being declared. (See incomplete types
+ in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
+
+<p><a name="note130">130)</a> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
+ of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
+ can make use of that typedef name to declare objects having the specified structure, union, or
+ enumerated type.
+
+<p><a name="note131">131)</a> A similar construction with enum does not exist.
+
+
+<a name="6.7.2.4" href="#6.7.2.4"><h5>6.7.2.4 Atomic type specifiers</h5></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          atomic-type-specifier:
+                 _Atomic ( type-name )</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Atomic type specifiers shall not be used if the implementation does not support atomic
+ types (see <a href="#6.10.8.3">6.10.8.3</a>).
+<p><!--para 3-->
+ The type name in an atomic type specifier shall not refer to an array type, a function type,
+ an atomic type, or a qualified type.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The properties associated with atomic types are meaningful only for expressions that are
+ lvalues. If the _Atomic keyword is immediately followed by a left parenthesis, it is
+ interpreted as a type specifier (with a type name), not as a type qualifier.
+<!--page 138 indent 4-->
+
+<a name="6.7.3" href="#6.7.3"><h4>6.7.3 Type qualifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          type-qualifier:
+                 const
+                 restrict
+                 volatile
+                 _Atomic</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Types other than pointer types whose referenced type is an object type shall not be
+ restrict-qualified.
+<p><!--para 3-->
+ The type modified by the _Atomic qualifier shall not be an array type or a function
+ type.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ The properties associated with qualified types are meaningful only for expressions that
+ are lvalues.<sup><a href="#note132"><b>132)</b></a></sup>
+<p><!--para 5-->
+ If the same qualifier appears more than once in the same specifier-qualifier-list, either
+ directly or via one or more typedefs, the behavior is the same as if it appeared only
+ once. If other qualifiers appear along with the _Atomic qualifier in a specifier-qualifier-
+ list, the resulting type is the so-qualified atomic type.
+<p><!--para 6-->
+ If an attempt is made to modify an object defined with a const-qualified type through use
+ of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
+ made to refer to an object defined with a volatile-qualified type through use of an lvalue
+ with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note133"><b>133)</b></a></sup>
+<p><!--para 7-->
+ An object that has volatile-qualified type may be modified in ways unknown to the
+ implementation or have other unknown side effects. Therefore any expression referring
+ to such an object shall be evaluated strictly according to the rules of the abstract machine,
+ as described in <a href="#5.1.2.3">5.1.2.3</a>. Furthermore, at every sequence point the value last stored in the
+ object shall agree with that prescribed by the abstract machine, except as modified by the
+ 
+ 
+ 
+ 
+<!--page 139 indent 5-->
+ unknown factors mentioned previously.<sup><a href="#note134"><b>134)</b></a></sup> What constitutes an access to an object that
+ has volatile-qualified type is implementation-defined.
+<p><!--para 8-->
+ An object that is accessed through a restrict-qualified pointer has a special association
+ with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
+ that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note135"><b>135)</b></a></sup> The intended
+ use of the restrict qualifier (like the register storage class) is to promote
+ optimization, and deleting all instances of the qualifier from all preprocessing translation
+ units composing a conforming program does not change its meaning (i.e., observable
+ behavior).
+<p><!--para 9-->
+ If the specification of an array type includes any type qualifiers, the element type is so-
+ qualified, not the array type. If the specification of a function type includes any type
+ qualifiers, the behavior is undefined.<sup><a href="#note136"><b>136)</b></a></sup>
+<p><!--para 10-->
+ For two qualified types to be compatible, both shall have the identically qualified version
+ of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
+ does not affect the specified type.
+<p><!--para 11-->
+ EXAMPLE 1      An object declared
+<pre>
+          extern const volatile int real_time_clock;</pre>
+ may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
+ 
+<p><!--para 12-->
+ EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
+ modify an aggregate type:
+<pre>
+          const struct s { int mem; } cs = { 1 };
+          struct s ncs; // the object ncs is modifiable
+          typedef int A[2][3];
+          const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
+          int *pi;
+          const int *pci;
+          ncs = cs;            //    valid
+          cs = ncs;            //    violates modifiable lvalue constraint for =
+          pi = &amp;ncs.mem;       //    valid
+          pi = &amp;cs.mem;        //    violates type constraints for =
+          pci = &amp;cs.mem;       //    valid
+          pi = a[0];           //    invalid: a[0] has type ''const int *''</pre>
+ 
+ 
+ 
+<!--page 140 indent 5-->
+<p><!--para 13-->
+ EXAMPLE 3       The declaration
+<pre>
+          _Atomic volatile int *p;</pre>
+ specifies that p has the type ''pointer to volatile atomic int'', a pointer to a volatile-qualified atomic type.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note132">132)</a> The implementation may place a const object that is not volatile in a read-only region of
+ storage. Moreover, the implementation need not allocate storage for such an object if its address is
+ never used.
+
+<p><a name="note133">133)</a> This applies to those objects that behave as if they were defined with qualified types, even if they are
+ never actually defined as objects in the program (such as an object at a memory-mapped input/output
+ address).
+
+<p><a name="note134">134)</a> A volatile declaration may be used to describe an object corresponding to a memory-mapped
+ input/output port or an object accessed by an asynchronously interrupting function. Actions on
+ objects so declared shall not be ''optimized out'' by an implementation or reordered except as
+ permitted by the rules for evaluating expressions.
+
+<p><a name="note135">135)</a> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
+ association between the allocated object and the pointer.
+
+<p><a name="note136">136)</a> Both of these can occur through the use of typedefs.
+
+
+<a name="6.7.3.1" href="#6.7.3.1"><h5>6.7.3.1 Formal definition of restrict</h5></a>
+<p><!--para 1-->
+ Let D be a declaration of an ordinary identifier that provides a means of designating an
+ object P as a restrict-qualified pointer to type T.
+<p><!--para 2-->
+ If D appears inside a block and does not have storage class extern, let B denote the
+ block. If D appears in the list of parameter declarations of a function definition, let B
+ denote the associated block. Otherwise, let B denote the block of main (or the block of
+ whatever function is called at program startup in a freestanding environment).
+<p><!--para 3-->
+ In what follows, a pointer expression E is said to be based on object P if (at some
+ sequence point in the execution of B prior to the evaluation of E) modifying P to point to
+ a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note137"><b>137)</b></a></sup>
+ Note that ''based'' is defined only for expressions with pointer types.
+<p><!--para 4-->
+ During each execution of B, let L be any lvalue that has &amp;L based on P. If L is used to
+ access the value of the object X that it designates, and X is also modified (by any means),
+ then the following requirements apply: T shall not be const-qualified. Every other lvalue
+ used to access the value of X shall also have its address based on P. Every access that
+ modifies X shall be considered also to modify P, for the purposes of this subclause. If P
+ is assigned the value of a pointer expression E that is based on another restricted pointer
+ object P2, associated with block B2, then either the execution of B2 shall begin before
+ the execution of B, or the execution of B2 shall end prior to the assignment. If these
+ requirements are not met, then the behavior is undefined.
+<p><!--para 5-->
+ Here an execution of B means that portion of the execution of the program that would
+ correspond to the lifetime of an object with scalar type and automatic storage duration
+ associated with B.
+<p><!--para 6-->
+ A translator is free to ignore any or all aliasing implications of uses of restrict.
+<p><!--para 7-->
+ EXAMPLE 1       The file scope declarations
+<pre>
+          int * restrict a;
+          int * restrict b;
+          extern int c[];</pre>
+ assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
+ program, then it is never accessed using either of the other two.
+ 
+ 
+<!--page 141 indent 5-->
+<p><!--para 8-->
+ EXAMPLE 2       The function parameter declarations in the following example
+<pre>
+         void f(int n, int * restrict p, int * restrict q)
+         {
+               while (n-- &gt; 0)
+                     *p++ = *q++;
+         }</pre>
+ assert that, during each execution of the function, if an object is accessed through one of the pointer
+ parameters, then it is not also accessed through the other.
+<p><!--para 9-->
+ The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
+ analysis of function f without examining any of the calls of f in the program. The cost is that the
+ programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
+ second call of f in g has undefined behavior because each of d[1] through d[49] is accessed through
+ both p and q.
+<pre>
+          void g(void)
+          {
+                extern int d[100];
+                f(50, d + 50, d); // valid
+                f(50, d + 1, d); // undefined behavior
+          }</pre>
+ 
+<p><!--para 10-->
+ EXAMPLE 3       The function parameter declarations
+<pre>
+         void h(int n, int * restrict p, int * restrict q, int * restrict r)
+         {
+               int i;
+               for (i = 0; i &lt; n; i++)
+                      p[i] = q[i] + r[i];
+         }</pre>
+ illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
+ are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
+ modified within function h.
+ 
+<p><!--para 11-->
+ EXAMPLE 4 The rule limiting assignments between restricted pointers does not distinguish between a
+ function call and an equivalent nested block. With one exception, only ''outer-to-inner'' assignments
+ between restricted pointers declared in nested blocks have defined behavior.
+<!--page 142 indent 5-->
+<p><!--para 12-->
+<pre>
+         {
+                  int * restrict p1;
+                  int * restrict q1;
+                  p1 = q1; // undefined behavior
+                  {
+                        int * restrict p2 = p1; // valid
+                        int * restrict q2 = q1; // valid
+                        p1 = q2;                // undefined behavior
+                        p2 = q2;                // undefined behavior
+                  }
+         }</pre>
+ The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
+ precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
+ example, this permits new_vector to return a vector.
+<pre>
+          typedef struct { int n; float * restrict v; } vector;
+          vector new_vector(int n)
+          {
+                vector t;
+                t.n = n;
+                t.v = malloc(n * sizeof (float));
+                return t;
+          }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note137">137)</a> In other words, E depends on the value of P itself rather than on the value of an object referenced
+ indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
+ expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
+ expressions *p and p[1] are not.
+
+
+<a name="6.7.4" href="#6.7.4"><h4>6.7.4 Function specifiers</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          function-specifier:
+                 inline
+                 _Noreturn</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ Function specifiers shall be used only in the declaration of an identifier for a function.
+<p><!--para 3-->
+ An inline definition of a function with external linkage shall not contain a definition of a
+ modifiable object with static or thread storage duration, and shall not contain a reference
+ to an identifier with internal linkage.
+<p><!--para 4-->
+ In a hosted environment, no function specifier(s) shall appear in a declaration of main.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ A function specifier may appear more than once; the behavior is the same as if it
+ appeared only once.
+<p><!--para 6-->
+ A function declared with an inline function specifier is an inline function. Making a *
+ function an inline function suggests that calls to the function be as fast as possible.<sup><a href="#note138"><b>138)</b></a></sup>
+ The extent to which such suggestions are effective is implementation-defined.<sup><a href="#note139"><b>139)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 143 indent 5-->
+<p><!--para 7-->
+ Any function with internal linkage can be an inline function. For a function with external
+ linkage, the following restrictions apply: If a function is declared with an inline
+ function specifier, then it shall also be defined in the same translation unit. If all of the
+ file scope declarations for a function in a translation unit include the inline function
+ specifier without extern, then the definition in that translation unit is an inline
+ definition. An inline definition does not provide an external definition for the function,
+ and does not forbid an external definition in another translation unit. An inline definition
+ provides an alternative to an external definition, which a translator may use to implement
+ any call to the function in the same translation unit. It is unspecified whether a call to the
+ function uses the inline definition or the external definition.<sup><a href="#note140"><b>140)</b></a></sup>
+<p><!--para 8-->
+ A function declared with a _Noreturn function specifier shall not return to its caller.
+ Recommended practice
+<p><!--para 9-->
+ The implementation should produce a diagnostic message for a function declared with a
+ _Noreturn function specifier that appears to be capable of returning to its caller.
+<p><!--para 10-->
+ EXAMPLE 1 The declaration of an inline function with external linkage can result in either an external
+ definition, or a definition available for use only within the translation unit. A file scope declaration with
+ extern creates an external definition. The following example shows an entire translation unit.
+<p><!--para 11-->
+<pre>
+          inline double fahr(double t)
+          {
+                return (9.0 * t) / 5.0 + 32.0;
+          }
+          inline double cels(double t)
+          {
+                return (5.0 * (t - 32.0)) / 9.0;
+          }
+          extern double fahr(double);                  // creates an external definition
+          double convert(int is_fahr, double temp)
+          {
+                /* A translator may perform inline substitutions */
+                return is_fahr ? cels(temp) : fahr(temp);
+          }</pre>
+ Note that the definition of fahr is an external definition because fahr is also declared with extern, but
+ the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
+ external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
+ definition are distinct and either may be used for the call.
+ 
+<p><!--para 12-->
+ EXAMPLE 2
+ 
+ 
+ 
+ 
+<!--page 144 indent 4-->
+<pre>
+          _Noreturn void f () {
+                abort(); // ok
+          }
+          _Noreturn void g (int i) { // causes undefined behavior if i &lt;= 0
+                if (i &gt; 0) abort();
+          }</pre>
+ 
+ Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note138">138)</a> By using, for example, an alternative to the usual function call mechanism, such as ''inline
+ substitution''. Inline substitution is not textual substitution, nor does it create a new function.
+ Therefore, for example, the expansion of a macro used within the body of the function uses the
+ definition it had at the point the function body appears, and not where the function is called; and
+ identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
+ single address, regardless of the number of inline definitions that occur in addition to the external
+ definition.
+
+<p><a name="note139">139)</a> For example, an implementation might never perform inline substitution, or might only perform inline
+ substitutions to calls in the scope of an inline declaration.
+
+<p><a name="note140">140)</a> Since an inline definition is distinct from the corresponding external definition and from any other
+ corresponding inline definitions in other translation units, all corresponding objects with static storage
+ duration are also distinct in each of the definitions.
+
+
+<a name="6.7.5" href="#6.7.5"><h4>6.7.5 Alignment specifier</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          alignment-specifier:
+                _Alignas ( type-name )
+                _Alignas ( constant-expression )</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ An alignment attribute shall not be specified in a declaration of a typedef, or a bit-field, or
+ a function, or a parameter, or an object declared with the register storage-class
+ specifier.
+<p><!--para 3-->
+ The constant expression shall be an integer constant expression. It shall evaluate to a
+ valid fundamental alignment, or to a valid extended alignment supported by the
+ implementation in the context in which it appears, or to zero.
+<p><!--para 4-->
+ The combined effect of all alignment attributes in a declaration shall not specify an
+ alignment that is less strict than the alignment that would otherwise be required for the
+ type of the object or member being declared.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ The first form is equivalent to _Alignas(alignof(type-name)).
+<p><!--para 6-->
+ The alignment requirement of the declared object or member is taken to be the specified
+ alignment. An alignment specification of zero has no effect.<sup><a href="#note141"><b>141)</b></a></sup> When multiple
+ alignment specifiers occur in a declaration, the effective alignment requirement is the
+ strictest specified alignment.
+<p><!--para 7-->
+ If the definition of an object has an alignment specifier, any other declaration of that
+ object shall either specify equivalent alignment or have no alignment specifier. If the
+ definition of an object does not have an alignment specifier, any other declaration of that
+ object shall also have no alignment specifier. If declarations of an object in different
+ translation units have different alignment specifiers, the behavior is undefined.
+ 
+ 
+ 
+<!--page 145 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note141">141)</a> An alignment specification of zero also does not affect other alignment specifications in the same
+ declaration.
+
+
+<a name="6.7.6" href="#6.7.6"><h4>6.7.6 Declarators</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          declarator:
+                 pointeropt direct-declarator
+          direct-declarator:
+                  identifier
+                  ( declarator )
+                  direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+                  direct-declarator [ static type-qualifier-listopt assignment-expression ]
+                  direct-declarator [ type-qualifier-list static assignment-expression ]
+                  direct-declarator [ type-qualifier-listopt * ]
+                  direct-declarator ( parameter-type-list )
+                  direct-declarator ( identifier-listopt )
+          pointer:
+                 * type-qualifier-listopt
+                 * type-qualifier-listopt pointer
+          type-qualifier-list:
+                 type-qualifier
+                 type-qualifier-list type-qualifier
+          parameter-type-list:
+                parameter-list
+                parameter-list , ...
+          parameter-list:
+                parameter-declaration
+                parameter-list , parameter-declaration
+          parameter-declaration:
+                declaration-specifiers declarator
+                declaration-specifiers abstract-declaratoropt
+          identifier-list:
+                 identifier
+                 identifier-list , identifier</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ Each declarator declares one identifier, and asserts that when an operand of the same
+ form as the declarator appears in an expression, it designates a function or object with the
+ scope, storage duration, and type indicated by the declaration specifiers.
+<p><!--para 3-->
+ A full declarator is a declarator that is not part of another declarator. The end of a full
+ declarator is a sequence point. If, in the nested sequence of declarators in a full
+<!--page 146 indent 4-->
+ declarator, there is a declarator specifying a variable length array type, the type specified
+ by the full declarator is said to be variably modified. Furthermore, any type derived by
+ declarator type derivation from a variably modified type is itself variably modified.
+<p><!--para 4-->
+ In the following subclauses, consider a declaration
+<pre>
+         T D1</pre>
+ where T contains the declaration specifiers that specify a type T (such as int) and D1 is
+ a declarator that contains an identifier ident. The type specified for the identifier ident in
+ the various forms of declarator is described inductively using this notation.
+<p><!--para 5-->
+ If, in the declaration ''T D1'', D1 has the form
+<pre>
+         identifier</pre>
+ then the type specified for ident is T .
+<p><!--para 6-->
+ If, in the declaration ''T D1'', D1 has the form
+<pre>
+         ( D )</pre>
+ then ident has the type specified by the declaration ''T D''. Thus, a declarator in
+ parentheses is identical to the unparenthesized declarator, but the binding of complicated
+ declarators may be altered by parentheses.
+ Implementation limits
+<p><!--para 7-->
+ As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
+ function declarators that modify an arithmetic, structure, union, or void type, either
+ directly or via one or more typedefs.
+ Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+
+<a name="6.7.6.1" href="#6.7.6.1"><h5>6.7.6.1 Pointer declarators</h5></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If, in the declaration ''T D1'', D1 has the form
+<pre>
+         * type-qualifier-listopt D</pre>
+ and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+ T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
+ pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
+<p><!--para 2-->
+ For two pointer types to be compatible, both shall be identically qualified and both shall
+ be pointers to compatible types.
+<p><!--para 3-->
+ EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
+ to a constant value'' and a ''constant pointer to a variable value''.
+<!--page 147 indent 4-->
+<pre>
+          const int *ptr_to_constant;
+          int *const constant_ptr;</pre>
+ The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
+ but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
+ int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
+ same location.
+<p><!--para 4-->
+ The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
+ type ''pointer to int''.
+<pre>
+          typedef int *int_ptr;
+          const int_ptr constant_ptr;</pre>
+ declares constant_ptr as an object that has type ''const-qualified pointer to int''.
+ 
+
+<a name="6.7.6.2" href="#6.7.6.2"><h5>6.7.6.2 Array declarators</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
+ an expression or *. If they delimit an expression (which specifies the size of an array), the
+ expression shall have an integer type. If the expression is a constant expression, it shall
+ have a value greater than zero. The element type shall not be an incomplete or function
+ type. The optional type qualifiers and the keyword static shall appear only in a
+ declaration of a function parameter with an array type, and then only in the outermost
+ array type derivation.
+<p><!--para 2-->
+ If an identifier is declared as having a variably modified type, it shall be an ordinary
+ identifier (as defined in <a href="#6.2.3">6.2.3</a>), have no linkage, and have either block scope or function
+ prototype scope. If an identifier is declared to be an object with static or thread storage
+ duration, it shall not have a variable length array type.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ If, in the declaration ''T D1'', D1 has one of the forms:
+<pre>
+          D[ type-qualifier-listopt assignment-expressionopt ]
+          D[ static type-qualifier-listopt assignment-expression ]
+          D[ type-qualifier-list static assignment-expression ]
+          D[ type-qualifier-listopt * ]</pre>
+ and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+ T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note142"><b>142)</b></a></sup>
+ (See <a href="#6.7.6.3">6.7.6.3</a> for the meaning of the optional type qualifiers and the keyword static.)
+<p><!--para 4-->
+ If the size is not present, the array type is an incomplete type. If the size is * instead of
+ being an expression, the array type is a variable length array type of unspecified size,
+ which can only be used in declarations or type names with function prototype scope;<sup><a href="#note143"><b>143)</b></a></sup>
+ 
+<!--page 148 indent 4-->
+ such arrays are nonetheless complete types. If the size is an integer constant expression
+ and the element type has a known constant size, the array type is not a variable length
+ array type; otherwise, the array type is a variable length array type. (Variable length
+ arrays are a conditional feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.)
+<p><!--para 5-->
+ If the size is an expression that is not an integer constant expression: if it occurs in a
+ declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
+ each time it is evaluated it shall have a value greater than zero. The size of each instance
+ of a variable length array type does not change during its lifetime. Where a size
+ expression is part of the operand of a sizeof operator and changing the value of the
+ size expression would not affect the result of the operator, it is unspecified whether or not
+ the size expression is evaluated.
+<p><!--para 6-->
+ For two array types to be compatible, both shall have compatible element types, and if
+ both size specifiers are present, and are integer constant expressions, then both size
+ specifiers shall have the same constant value. If the two array types are used in a context
+ which requires them to be compatible, it is undefined behavior if the two size specifiers
+ evaluate to unequal values.
+<p><!--para 7-->
+ EXAMPLE 1
+<pre>
+          float fa[11], *afp[17];</pre>
+ declares an array of float numbers and an array of pointers to float numbers.
+ 
+<p><!--para 8-->
+ EXAMPLE 2       Note the distinction between the declarations
+<pre>
+          extern int *x;
+          extern int y[];</pre>
+ The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
+ (an incomplete type), the storage for which is defined elsewhere.
+ 
+<p><!--para 9-->
+ EXAMPLE 3       The following declarations demonstrate the compatibility rules for variably modified types.
+<pre>
+          extern int n;
+          extern int m;
+          void fcompat(void)
+          {
+                int a[n][6][m];
+                int (*p)[4][n+1];
+                int c[n][n][6][m];
+                int (*r)[n][n][n+1];
+                p = a;       // invalid: not compatible because 4 != 6
+                r = c;       // compatible, but defined behavior only if
+                             // n == 6 and m == n+1
+          }</pre>
+ 
+ 
+ 
+ 
+<!--page 149 indent 5-->
+<p><!--para 10-->
+ EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
+ function prototype scope. Array objects declared with the _Thread_local, static, or extern
+ storage-class specifier cannot have a variable length array (VLA) type. However, an object declared with
+ the static storage-class specifier can have a VM type (that is, a pointer to a VLA type). Finally, all
+ identifiers declared with a VM type have to be ordinary identifiers and cannot, therefore, be members of
+ structures or unions.
+<pre>
+         extern int n;
+         int A[n];                                           // invalid: file scope VLA
+         extern int (*p2)[n];                                // invalid: file scope VM
+         int B[100];                                         // valid: file scope but not VM
+         void fvla(int m, int C[m][m]);                      // valid: VLA with prototype scope
+         void fvla(int m, int C[m][m])                       // valid: adjusted to auto pointer to VLA
+         {
+               typedef int VLA[m][m];                        // valid: block scope typedef VLA
+                  struct tag {
+                        int (*y)[n];                         // invalid: y not ordinary identifier
+                        int z[n];                            // invalid: z not ordinary identifier
+                  };
+                  int D[m];                                  //   valid: auto VLA
+                  static int E[m];                           //   invalid: static block scope VLA
+                  extern int F[m];                           //   invalid: F has linkage and is VLA
+                  int (*s)[m];                               //   valid: auto pointer to VLA
+                  extern int (*r)[m];                        //   invalid: r has linkage and points to VLA
+                  static int (*q)[m] = &amp;B;                   //   valid: q is a static block pointer to VLA
+         }</pre>
+ 
+ Forward references:          function declarators (<a href="#6.7.6.3">6.7.6.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
+ initialization (<a href="#6.7.9">6.7.9</a>).
+
+<h6>footnotes</h6>
+<p><a name="note142">142)</a> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
+
+<p><a name="note143">143)</a> Thus, * can be used only in function declarations that are not definitions (see <a href="#6.7.6.3">6.7.6.3</a>).
+
+
+<a name="6.7.6.3" href="#6.7.6.3"><h5>6.7.6.3 Function declarators (including prototypes)</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A function declarator shall not specify a return type that is a function type or an array
+ type.
+<p><!--para 2-->
+ The only storage-class specifier that shall occur in a parameter declaration is register.
+<p><!--para 3-->
+ An identifier list in a function declarator that is not part of a definition of that function
+ shall be empty.
+<p><!--para 4-->
+ After adjustment, the parameters in a parameter type list in a function declarator that is
+ part of a definition of that function shall not have incomplete type.
+<h6>Semantics</h6>
+<p><!--para 5-->
+ If, in the declaration ''T D1'', D1 has the form
+<!--page 150 indent 5-->
+<pre>
+        D( parameter-type-list )</pre>
+ or
+<pre>
+        D( identifier-listopt )</pre>
+ and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+ T '', then the type specified for ident is ''derived-declarator-type-list function returning
+ T ''.
+<p><!--para 6-->
+ A parameter type list specifies the types of, and may declare identifiers for, the
+ parameters of the function.
+<p><!--para 7-->
+ A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
+ type'', where the type qualifiers (if any) are those specified within the [ and ] of the
+ array type derivation. If the keyword static also appears within the [ and ] of the
+ array type derivation, then for each call to the function, the value of the corresponding
+ actual argument shall provide access to the first element of an array with at least as many
+ elements as specified by the size expression.
+<p><!--para 8-->
+ A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
+ function returning type'', as in <a href="#6.3.2.1">6.3.2.1</a>.
+<p><!--para 9-->
+ If the list terminates with an ellipsis (, ...), no information about the number or types
+ of the parameters after the comma is supplied.<sup><a href="#note144"><b>144)</b></a></sup>
+<p><!--para 10-->
+ The special case of an unnamed parameter of type void as the only item in the list
+ specifies that the function has no parameters.
+<p><!--para 11-->
+ If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
+ parameter name, it shall be taken as a typedef name.
+<p><!--para 12-->
+ If the function declarator is not part of a definition of that function, parameters may have
+ incomplete type and may use the [*] notation in their sequences of declarator specifiers
+ to specify variable length array types.
+<p><!--para 13-->
+ The storage-class specifier in the declaration specifiers for a parameter declaration, if
+ present, is ignored unless the declared parameter is one of the members of the parameter
+ type list for a function definition.
+<p><!--para 14-->
+ An identifier list declares only the identifiers of the parameters of the function. An empty
+ list in a function declarator that is part of a definition of that function specifies that the
+ function has no parameters. The empty list in a function declarator that is not part of a
+ definition of that function specifies that no information about the number or types of the
+ parameters is supplied.<sup><a href="#note145"><b>145)</b></a></sup>
+ 
+ 
+ 
+<!--page 151 indent 5-->
+<p><!--para 15-->
+ For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note146"><b>146)</b></a></sup>
+ Moreover, the parameter type lists, if both are present, shall agree in the number of
+ parameters and in use of the ellipsis terminator; corresponding parameters shall have
+ compatible types. If one type has a parameter type list and the other type is specified by a
+ function declarator that is not part of a function definition and that contains an empty
+ identifier list, the parameter list shall not have an ellipsis terminator and the type of each
+ parameter shall be compatible with the type that results from the application of the
+ default argument promotions. If one type has a parameter type list and the other type is
+ specified by a function definition that contains a (possibly empty) identifier list, both shall
+ agree in the number of parameters, and the type of each prototype parameter shall be
+ compatible with the type that results from the application of the default argument
+ promotions to the type of the corresponding identifier. (In the determination of type
+ compatibility and of a composite type, each parameter declared with function or array
+ type is taken as having the adjusted type and each parameter declared with qualified type
+ is taken as having the unqualified version of its declared type.)
+<p><!--para 16-->
+ EXAMPLE 1       The declaration
+<pre>
+          int f(void), *fip(), (*pfi)();</pre>
+ declares a function f with no parameters returning an int, a function fip with no parameter specification
+ returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
+ int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
+ declaration suggests, and the same construction in an expression requires, the calling of a function fip,
+ and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
+ extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
+ designator, which is then used to call the function; it returns an int.
+<p><!--para 17-->
+ If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
+ declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
+ internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
+ the identifier of the pointer pfi has block scope and no linkage.
+ 
+<p><!--para 18-->
+ EXAMPLE 2       The declaration
+<pre>
+          int (*apfi[3])(int *x, int *y);</pre>
+ declares an array apfi of three pointers to functions returning int. Each of these functions has two
+ parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
+ go out of scope at the end of the declaration of apfi.
+ 
+<p><!--para 19-->
+ EXAMPLE 3       The declaration
+<pre>
+          int (*fpfi(int (*)(long), int))(int, ...);</pre>
+ declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
+ parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
+ The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
+ 
+ 
+<!--page 152 indent 5-->
+ additional arguments of any type.
+ 
+<p><!--para 20-->
+ EXAMPLE 4        The following prototype has a variably modified parameter.
+<pre>
+           void addscalar(int n, int m,
+                 double a[n][n*m+300], double x);
+           int main()
+           {
+                 double b[4][308];
+                 addscalar(4, 2, b, <a href="#2.17">2.17</a>);
+                 return 0;
+           }
+           void addscalar(int n, int m,
+                 double a[n][n*m+300], double x)
+           {
+                 for (int i = 0; i &lt; n; i++)
+                       for (int j = 0, k = n*m+300; j &lt; k; j++)
+                             // a is a pointer to a VLA with n*m+300 elements
+                             a[i][j] += x;
+           }</pre>
+ 
+<p><!--para 21-->
+ EXAMPLE 5        The following are all compatible function prototype declarators.
+<pre>
+           double    maximum(int       n,   int   m,   double   a[n][m]);
+           double    maximum(int       n,   int   m,   double   a[*][*]);
+           double    maximum(int       n,   int   m,   double   a[ ][*]);
+           double    maximum(int       n,   int   m,   double   a[ ][m]);</pre>
+ as are:
+<pre>
+           void   f(double     (* restrict a)[5]);
+           void   f(double     a[restrict][5]);
+           void   f(double     a[restrict 3][5]);
+           void   f(double     a[restrict static 3][5]);</pre>
+ (Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
+ non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
+ 
+ Forward references: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
+<!--page 153 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note144">144)</a> The macros defined in the &lt;stdarg.h&gt; header (<a href="#7.16">7.16</a>) may be used to access arguments that
+ correspond to the ellipsis.
+
+<p><a name="note145">145)</a> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
+
+<p><a name="note146">146)</a> If both function types are ''old style'', parameter types are not compared.
+
+
+<a name="6.7.7" href="#6.7.7"><h4>6.7.7 Type names</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          type-name:
+                 specifier-qualifier-list abstract-declaratoropt
+          abstract-declarator:
+                 pointer
+                 pointeropt direct-abstract-declarator
+          direct-abstract-declarator:
+                  ( abstract-declarator )
+                  direct-abstract-declaratoropt [ type-qualifier-listopt
+                                 assignment-expressionopt ]
+                  direct-abstract-declaratoropt [ static type-qualifier-listopt
+                                 assignment-expression ]
+                  direct-abstract-declaratoropt [ type-qualifier-list static
+                                 assignment-expression ]
+                  direct-abstract-declaratoropt [ * ]
+                  direct-abstract-declaratoropt ( parameter-type-listopt )</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ In several contexts, it is necessary to specify a type. This is accomplished using a type
+ name, which is syntactically a declaration for a function or an object of that type that
+ omits the identifier.<sup><a href="#note147"><b>147)</b></a></sup>
+<p><!--para 3-->
+ EXAMPLE        The constructions
+<pre>
+          (a)      int
+          (b)      int   *
+          (c)      int   *[3]
+          (d)      int   (*)[3]
+          (e)      int   (*)[*]
+          (f)      int   *()
+          (g)      int   (*)(void)
+          (h)      int   (*const [])(unsigned int, ...)</pre>
+ name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
+ array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
+ with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
+ returning an int, and (h) array of an unspecified number of constant pointers to functions, each with one
+ parameter that has type unsigned int and an unspecified number of other parameters, returning an
+ int.
+ 
+ 
+ 
+ 
+<!--page 154 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note147">147)</a> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
+ parameter specification'', rather than redundant parentheses around the omitted identifier.
+
+
+<a name="6.7.8" href="#6.7.8"><h4>6.7.8 Type definitions</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          typedef-name:
+                 identifier</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ If a typedef name specifies a variably modified type then it shall have block scope.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ In a declaration whose storage-class specifier is typedef, each declarator defines an
+ identifier to be a typedef name that denotes the type specified for the identifier in the way
+ described in <a href="#6.7.6">6.7.6</a>. Any array size expressions associated with variable length array
+ declarators are evaluated each time the declaration of the typedef name is reached in the
+ order of execution. A typedef declaration does not introduce a new type, only a
+ synonym for the type so specified. That is, in the following declarations:
+<pre>
+          typedef T type_ident;
+          type_ident D;</pre>
+ type_ident is defined as a typedef name with the type specified by the declaration
+ specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
+ type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
+ typedef name shares the same name space as other identifiers declared in ordinary
+ declarators.
+<p><!--para 4-->
+ EXAMPLE 1       After
+<pre>
+          typedef int MILES, KLICKSP();
+          typedef struct { double hi, lo; } range;</pre>
+ the constructions
+<pre>
+          MILES distance;
+          extern KLICKSP *metricp;
+          range x;
+          range z, *zp;</pre>
+ are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
+ parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
+ such a structure. The object distance has a type compatible with any other int object.
+ 
+<p><!--para 5-->
+ EXAMPLE 2       After the declarations
+<pre>
+          typedef struct s1 { int x; } t1, *tp1;
+          typedef struct s2 { int x; } t2, *tp2;</pre>
+ type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
+ s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
+<!--page 155 indent 4-->
+<p><!--para 6-->
+ EXAMPLE 3       The following obscure constructions
+<pre>
+          typedef signed int t;
+          typedef int plain;
+          struct tag {
+                unsigned t:4;
+                const t:5;
+                plain r:5;
+          };</pre>
+ declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
+ with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
+ qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
+ [-16, +15], and one named r that contains values in one of the ranges [0, 31], [-15, +15], or [-16, +15].
+ (The choice of range is implementation-defined.) The first two bit-field declarations differ in that
+ unsigned is a type specifier (which forces t to be the name of a structure member), while const is a
+ type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed
+ in an inner scope by
+<pre>
+          t f(t (t));
+          long t;</pre>
+ then a function f is declared with type ''function returning signed int with one unnamed parameter
+ with type pointer to function returning signed int with one unnamed parameter with type signed
+ int'', and an identifier t with type long int.
+ 
+<p><!--para 7-->
+ EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
+ following declarations of the signal function specify exactly the same type, the first without making use
+ of any typedef names.
+<pre>
+          typedef void fv(int), (*pfv)(int);
+          void (*signal(int, void (*)(int)))(int);
+          fv *signal(int, fv *);
+          pfv signal(int, pfv);</pre>
+ 
+<p><!--para 8-->
+ EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
+ time the typedef name is defined, not each time it is used:
+<!--page 156 indent 4-->
+<pre>
+          void copyt(int n)
+          {
+                typedef int B[n];   //               B is n ints, n evaluated now
+                n += 1;
+                B a;                //               a is n ints, n without += 1
+                int b[n];           //               a and b are different sizes
+                for (int i = 1; i &lt; n;               i++)
+                      a[i-1] = b[i];
+          }</pre>
+
+<a name="6.7.9" href="#6.7.9"><h4>6.7.9 Initialization</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          initializer:
+                   assignment-expression
+                   { initializer-list }
+                   { initializer-list , }
+          initializer-list:
+                   designationopt initializer
+                   initializer-list , designationopt initializer
+          designation:
+                 designator-list =
+          designator-list:
+                 designator
+                 designator-list designator
+          designator:
+                 [ constant-expression ]
+                 . identifier</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ No initializer shall attempt to provide a value for an object not contained within the entity
+ being initialized.
+<p><!--para 3-->
+ The type of the entity to be initialized shall be an array of unknown size or a complete
+ object type that is not a variable length array type.
+<p><!--para 4-->
+ All the expressions in an initializer for an object that has static or thread storage duration
+ shall be constant expressions or string literals.
+<p><!--para 5-->
+ If the declaration of an identifier has block scope, and the identifier has external or
+ internal linkage, the declaration shall have no initializer for the identifier.
+<p><!--para 6-->
+ If a designator has the form
+<pre>
+          [ constant-expression ]</pre>
+ then the current object (defined below) shall have array type and the expression shall be
+ an integer constant expression. If the array is of unknown size, any nonnegative value is
+ valid.
+<p><!--para 7-->
+ If a designator has the form
+<pre>
+          . identifier</pre>
+ then the current object (defined below) shall have structure or union type and the
+ identifier shall be the name of a member of that type.
+<!--page 157 indent 5-->
+<h6>Semantics</h6>
+<p><!--para 8-->
+ An initializer specifies the initial value stored in an object.
+<p><!--para 9-->
+ Except where explicitly stated otherwise, for the purposes of this subclause unnamed
+ members of objects of structure and union type do not participate in initialization.
+ Unnamed members of structure objects have indeterminate value even after initialization.
+<p><!--para 10-->
+ If an object that has automatic storage duration is not initialized explicitly, its value is
+ indeterminate. If an object that has static or thread storage duration is not initialized
+ explicitly, then:
+<ul>
+<li>  if it has pointer type, it is initialized to a null pointer;
+<li>  if it has arithmetic type, it is initialized to (positive or unsigned) zero;
+<li>  if it is an aggregate, every member is initialized (recursively) according to these rules,
+ and any padding is initialized to zero bits;
+<li>  if it is a union, the first named member is initialized (recursively) according to these
+ rules, and any padding is initialized to zero bits;
+</ul>
+<p><!--para 11-->
+ The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
+ initial value of the object is that of the expression (after conversion); the same type
+ constraints and conversions as for simple assignment apply, taking the type of the scalar
+ to be the unqualified version of its declared type.
+<p><!--para 12-->
+ The rest of this subclause deals with initializers for objects that have aggregate or union
+ type.
+<p><!--para 13-->
+ The initializer for a structure or union object that has automatic storage duration shall be
+ either an initializer list as described below, or a single expression that has compatible
+ structure or union type. In the latter case, the initial value of the object, including
+ unnamed members, is that of the expression.
+<p><!--para 14-->
+ An array of character type may be initialized by a character string literal or UTF-8 string
+ literal, optionally enclosed in braces. Successive bytes of the string literal (including the
+ terminating null character if there is room or if the array is of unknown size) initialize the
+ elements of the array.
+<p><!--para 15-->
+ An array with element type compatible with a qualified or unqualified version of
+ wchar_t may be initialized by a wide string literal, optionally enclosed in braces.
+ Successive wide characters of the wide string literal (including the terminating null wide
+ character if there is room or if the array is of unknown size) initialize the elements of the
+ array.
+<p><!--para 16-->
+ Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
+ enclosed list of initializers for the elements or named members.
+<!--page 158 indent 5-->
+<p><!--para 17-->
+ Each brace-enclosed initializer list has an associated current object. When no
+ designations are present, subobjects of the current object are initialized in order according
+ to the type of the current object: array elements in increasing subscript order, structure
+ members in declaration order, and the first named member of a union.<sup><a href="#note148"><b>148)</b></a></sup> In contrast, a
+ designation causes the following initializer to begin initialization of the subobject
+ described by the designator. Initialization then continues forward in order, beginning
+ with the next subobject after that described by the designator.<sup><a href="#note149"><b>149)</b></a></sup>
+<p><!--para 18-->
+ Each designator list begins its description with the current object associated with the
+ closest surrounding brace pair. Each item in the designator list (in order) specifies a
+ particular member of its current object and changes the current object for the next
+ designator (if any) to be that member.<sup><a href="#note150"><b>150)</b></a></sup> The current object that results at the end of the
+ designator list is the subobject to be initialized by the following initializer.
+<p><!--para 19-->
+ The initialization shall occur in initializer list order, each initializer provided for a
+ particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note151"><b>151)</b></a></sup>
+ all subobjects that are not initialized explicitly shall be initialized implicitly the same as
+ objects that have static storage duration.
+<p><!--para 20-->
+ If the aggregate or union contains elements or members that are aggregates or unions,
+ these rules apply recursively to the subaggregates or contained unions. If the initializer of
+ a subaggregate or contained union begins with a left brace, the initializers enclosed by
+ that brace and its matching right brace initialize the elements or members of the
+ subaggregate or the contained union. Otherwise, only enough initializers from the list are
+ taken to account for the elements or members of the subaggregate or the first member of
+ the contained union; any remaining initializers are left to initialize the next element or
+ member of the aggregate of which the current subaggregate or contained union is a part.
+<p><!--para 21-->
+ If there are fewer initializers in a brace-enclosed list than there are elements or members
+ of an aggregate, or fewer characters in a string literal used to initialize an array of known
+ size than there are elements in the array, the remainder of the aggregate shall be
+ initialized implicitly the same as objects that have static storage duration.
+ 
+ 
+ 
+<!--page 159 indent 5-->
+<p><!--para 22-->
+ If an array of unknown size is initialized, its size is determined by the largest indexed
+ element with an explicit initializer. The array type is completed at the end of its
+ initializer list.
+<p><!--para 23-->
+ The evaluations of the initialization list expressions are indeterminately sequenced with
+ respect to one another and thus the order in which any side effects occur is
+ unspecified.<sup><a href="#note152"><b>152)</b></a></sup>
+<p><!--para 24-->
+ EXAMPLE 1       Provided that &lt;complex.h&gt; has been #included, the declarations
+<pre>
+          int i = <a href="#3.5">3.5</a>;
+          double complex c = 5 + 3 * I;</pre>
+ define and initialize i with the value 3 and c with the value 5.0 + i3.0.
+ 
+<p><!--para 25-->
+ EXAMPLE 2       The declaration
+<pre>
+          int x[] = { 1, 3, 5 };</pre>
+ defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
+ and there are three initializers.
+ 
+<p><!--para 26-->
+ EXAMPLE 3       The declaration
+<pre>
+          int y[4][3] =         {
+                { 1, 3,         5 },
+                { 2, 4,         6 },
+                { 3, 5,         7 },
+          };</pre>
+ is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
+ y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
+ y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
+ been achieved by
+<pre>
+          int y[4][3] = {
+                1, 3, 5, 2, 4, 6, 3, 5, 7
+          };</pre>
+ The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
+ next three are taken successively for y[1] and y[2].
+ 
+<p><!--para 27-->
+ EXAMPLE 4       The declaration
+<pre>
+          int z[4][3] = {
+                { 1 }, { 2 }, { 3 }, { 4 }
+          };</pre>
+ initializes the first column of z as specified and initializes the rest with zeros.
+ 
+<p><!--para 28-->
+ EXAMPLE 5       The declaration
+<pre>
+          struct { int a[3], b; } w[] = { { 1 }, 2 };</pre>
+ is a definition with an inconsistently bracketed initialization. It defines an array with two element
+ 
+ 
+ 
+<!--page 160 indent 5-->
+ structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
+ 
+<p><!--para 29-->
+ EXAMPLE 6         The declaration
+<pre>
+           short q[4][3][2] = {
+                 { 1 },
+                 { 2, 3 },
+                 { 4, 5, 6 }
+           };</pre>
+ contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
+ object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
+ q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
+ q[0][0] does not begin with a left brace, so up to six items from the current list may be used. There is
+ only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers
+ for q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their
+ respective two-dimensional subaggregates. If there had been more than six items in any of the lists, a
+ diagnostic message would have been issued. The same initialization result could have been achieved by:
+<pre>
+           short q[4][3][2] = {
+                 1, 0, 0, 0, 0, 0,
+                 2, 3, 0, 0, 0, 0,
+                 4, 5, 6
+           };</pre>
+ or by:
+<pre>
+           short q[4][3][2] = {
+                 {
+                       { 1 },
+                 },
+                 {
+                       { 2, 3 },
+                 },
+                 {
+                       { 4, 5 },
+                       { 6 },
+                 }
+           };</pre>
+ in a fully bracketed form.
+<p><!--para 30-->
+ Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
+ cause confusion.
+ 
+<p><!--para 31-->
+ EXAMPLE 7         One form of initialization that completes array types involves typedef names. Given the
+ declaration
+<pre>
+           typedef int A[];          // OK - declared with block scope</pre>
+ the declaration
+<pre>
+           A a = { 1, 2 }, b = { 3, 4, 5 };</pre>
+ is identical to
+<pre>
+           int a[] = { 1, 2 }, b[] = { 3, 4, 5 };</pre>
+ due to the rules for incomplete types.
+<!--page 161 indent 5-->
+<p><!--para 32-->
+ EXAMPLE 8       The declaration
+<pre>
+          char s[] = "abc", t[3] = "abc";</pre>
+ defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
+ This declaration is identical to
+<pre>
+          char s[] = { 'a', 'b', 'c', '\0' },
+               t[] = { 'a', 'b', 'c' };</pre>
+ The contents of the arrays are modifiable. On the other hand, the declaration
+<pre>
+          char *p = "abc";</pre>
+ defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
+ with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
+ modify the contents of the array, the behavior is undefined.
+ 
+<p><!--para 33-->
+ EXAMPLE 9       Arrays can be initialized to correspond to the elements of an enumeration by using
+ designators:
+<pre>
+          enum { member_one,           member_two };
+          const char *nm[] =           {
+                [member_two]           = "member two",
+                [member_one]           = "member one",
+          };</pre>
+ 
+<p><!--para 34-->
+ EXAMPLE 10       Structure members can be initialized to nonzero values without depending on their order:
+<pre>
+          div_t answer = { .quot = 2, .rem = -1 };</pre>
+ 
+<p><!--para 35-->
+ EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
+ might be misunderstood:
+<pre>
+          struct { int a[3], b; } w[] =
+                { [0].a = {1}, [1].a[0] = 2 };</pre>
+ 
+<p><!--para 36-->
+ EXAMPLE 12       Space can be ''allocated'' from both ends of an array by using a single designator:
+<p><!--para 37-->
+<pre>
+          int a[MAX] = {
+                1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
+          };</pre>
+ In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
+ than ten, some of the values provided by the first five initializers will be overridden by the second five.
+ 
+<p><!--para 38-->
+ EXAMPLE 13       Any member of a union can be initialized:
+<pre>
+          union { /* ... */ } u = { .any_member = 42 };</pre>
+ 
+ Forward references: common definitions &lt;stddef.h&gt; (<a href="#7.19">7.19</a>).
+<!--page 162 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note148">148)</a> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
+ subobjects are initialized as usual, but the subaggregate or contained union does not become the
+ current object: current objects are associated only with brace-enclosed initializer lists.
+
+<p><a name="note149">149)</a> After a union member is initialized, the next object is not the next member of the union; instead, it is
+ the next subobject of an object containing the union.
+
+<p><a name="note150">150)</a> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
+ the surrounding brace pair. Note, too, that each separate designator list is independent.
+
+<p><a name="note151">151)</a> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
+ not be evaluated at all.
+
+<p><a name="note152">152)</a> In particular, the evaluation order need not be the same as the order of subobject initialization.
+
+
+<a name="6.7.10" href="#6.7.10"><h4>6.7.10 Static assertions</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          static_assert-declaration:
+                  _Static_assert ( constant-expression , string-literal ) ;</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The constant expression shall compare unequal to 0.
+<h6>Semantics</h6>
+<p><!--para 3-->
+ The constant expression shall be an integer constant expression. If the value of the
+ constant expression compares unequal to 0, the declaration has no effect. Otherwise, the
+ constraint is violated and the implementation shall produce a diagnostic message that
+ includes the text of the string literal, except that characters not in the basic source
+ character set are not required to appear in the message.
+ Forward references: diagnostics (<a href="#7.2">7.2</a>).
+<!--page 163 indent 4-->
+
+<a name="6.8" href="#6.8"><h3>6.8 Statements and blocks</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          statement:
+                 labeled-statement
+                 compound-statement
+                 expression-statement
+                 selection-statement
+                 iteration-statement
+                 jump-statement</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A statement specifies an action to be performed. Except as indicated, statements are
+ executed in sequence.
+<p><!--para 3-->
+ A block allows a set of declarations and statements to be grouped into one syntactic unit.
+ The initializers of objects that have automatic storage duration, and the variable length
+ array declarators of ordinary identifiers with block scope, are evaluated and the values are
+ stored in the objects (including storing an indeterminate value in objects without an
+ initializer) each time the declaration is reached in the order of execution, as if it were a
+ statement, and within each declaration in the order that declarators appear.
+<p><!--para 4-->
+ A full expression is an expression that is not part of another expression or of a declarator.
+ Each of the following is a full expression: an initializer that is not part of a compound
+ literal; the expression in an expression statement; the controlling expression of a selection
+ statement (if or switch); the controlling expression of a while or do statement; each
+ of the (optional) expressions of a for statement; the (optional) expression in a return
+ statement. There is a sequence point between the evaluation of a full expression and the
+ evaluation of the next full expression to be evaluated.
+ Forward references: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
+ (<a href="#6.8.4">6.8.4</a>), iteration statements (<a href="#6.8.5">6.8.5</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>).
+
+<a name="6.8.1" href="#6.8.1"><h4>6.8.1 Labeled statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          labeled-statement:
+                 identifier : statement
+                 case constant-expression : statement
+                 default : statement</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ A case or default label shall appear only in a switch statement. Further
+ constraints on such labels are discussed under the switch statement.
+<!--page 164 indent 4-->
+<p><!--para 3-->
+ Label names shall be unique within a function.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ Any statement may be preceded by a prefix that declares an identifier as a label name.
+ Labels in themselves do not alter the flow of control, which continues unimpeded across
+ them.
+ Forward references: the goto statement (<a href="#6.8.6.1">6.8.6.1</a>), the switch statement (<a href="#6.8.4.2">6.8.4.2</a>).
+
+<a name="6.8.2" href="#6.8.2"><h4>6.8.2 Compound statement</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          compound-statement:
+                { block-item-listopt }
+          block-item-list:
+                  block-item
+                  block-item-list block-item
+          block-item:
+                  declaration
+                  statement</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A compound statement is a block.
+
+<a name="6.8.3" href="#6.8.3"><h4>6.8.3 Expression and null statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          expression-statement:
+                 expressionopt ;</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The expression in an expression statement is evaluated as a void expression for its side
+ effects.<sup><a href="#note153"><b>153)</b></a></sup>
+<p><!--para 3-->
+ A null statement (consisting of just a semicolon) performs no operations.
+<p><!--para 4-->
+ EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
+ discarding of its value may be made explicit by converting the expression to a void expression by means of
+ a cast:
+<pre>
+          int p(int);
+          /* ... */
+          (void)p(0);</pre>
+ 
+ 
+ 
+<!--page 165 indent 4-->
+<p><!--para 5-->
+ EXAMPLE 2       In the program fragment
+<pre>
+          char *s;
+          /* ... */
+          while (*s++ != '\0')
+                  ;</pre>
+ a null statement is used to supply an empty loop body to the iteration statement.
+ 
+<p><!--para 6-->
+ EXAMPLE 3       A null statement may also be used to carry a label just before the closing } of a compound
+ statement.
+<pre>
+          while (loop1) {
+                /* ... */
+                while (loop2) {
+                        /* ... */
+                        if (want_out)
+                                goto end_loop1;
+                        /* ... */
+                }
+                /* ... */
+          end_loop1: ;
+          }</pre>
+ 
+ Forward references: iteration statements (<a href="#6.8.5">6.8.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note153">153)</a> Such as assignments, and function calls which have side effects.
+
+
+<a name="6.8.4" href="#6.8.4"><h4>6.8.4 Selection statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          selection-statement:
+                  if ( expression ) statement
+                  if ( expression ) statement else statement
+                  switch ( expression ) statement</pre>
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A selection statement selects among a set of statements depending on the value of a
+ controlling expression.
+<p><!--para 3-->
+ A selection statement is a block whose scope is a strict subset of the scope of its
+ enclosing block. Each associated substatement is also a block whose scope is a strict
+ subset of the scope of the selection statement.
+
+<a name="6.8.4.1" href="#6.8.4.1"><h5>6.8.4.1 The if statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The controlling expression of an if statement shall have scalar type.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ In both forms, the first substatement is executed if the expression compares unequal to 0.
+ In the else form, the second substatement is executed if the expression compares equal
+<!--page 166 indent 4-->
+ to 0. If the first substatement is reached via a label, the second substatement is not
+ executed.
+<p><!--para 3-->
+ An else is associated with the lexically nearest preceding if that is allowed by the
+ syntax.
+
+<a name="6.8.4.2" href="#6.8.4.2"><h5>6.8.4.2 The switch statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The controlling expression of a switch statement shall have integer type.
+<p><!--para 2-->
+ If a switch statement has an associated case or default label within the scope of an
+ identifier with a variably modified type, the entire switch statement shall be within the
+ scope of that identifier.<sup><a href="#note154"><b>154)</b></a></sup>
+<p><!--para 3-->
+ The expression of each case label shall be an integer constant expression and no two of
+ the case constant expressions in the same switch statement shall have the same value
+ after conversion. There may be at most one default label in a switch statement.
+ (Any enclosed switch statement may have a default label or case constant
+ expressions with values that duplicate case constant expressions in the enclosing
+ switch statement.)
+<h6>Semantics</h6>
+<p><!--para 4-->
+ A switch statement causes control to jump to, into, or past the statement that is the
+ switch body, depending on the value of a controlling expression, and on the presence of a
+ default label and the values of any case labels on or in the switch body. A case or
+ default label is accessible only within the closest enclosing switch statement.
+<p><!--para 5-->
+ The integer promotions are performed on the controlling expression. The constant
+ expression in each case label is converted to the promoted type of the controlling
+ expression. If a converted value matches that of the promoted controlling expression,
+ control jumps to the statement following the matched case label. Otherwise, if there is
+ a default label, control jumps to the labeled statement. If no converted case constant
+ expression matches and there is no default label, no part of the switch body is
+ executed.
+ Implementation limits
+<p><!--para 6-->
+ As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
+ switch statement.
+ 
+ 
+ 
+ 
+<!--page 167 indent 4-->
+<p><!--para 7-->
+ EXAMPLE        In the artificial program fragment
+<pre>
+          switch (expr)
+          {
+                int i = 4;
+                f(i);
+          case 0:
+                i = 17;
+                /* falls through into default code */
+          default:
+                printf("%d\n", i);
+          }</pre>
+ the object whose identifier is i exists with automatic storage duration (within the block) but is never
+ initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
+ access an indeterminate value. Similarly, the call to the function f cannot be reached.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note154">154)</a> That is, the declaration either precedes the switch statement, or it follows the last case or
+ default label associated with the switch that is in the block containing the declaration.
+
+
+<a name="6.8.5" href="#6.8.5"><h4>6.8.5 Iteration statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          iteration-statement:
+                  while ( expression ) statement
+                  do statement while ( expression ) ;
+                  for ( expressionopt ; expressionopt ; expressionopt ) statement
+                  for ( declaration expressionopt ; expressionopt ) statement</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The controlling expression of an iteration statement shall have scalar type.
+<p><!--para 3-->
+ The declaration part of a for statement shall only declare identifiers for objects having
+ storage class auto or register.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ An iteration statement causes a statement called the loop body to be executed repeatedly
+ until the controlling expression compares equal to 0. The repetition occurs regardless of
+ whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note155"><b>155)</b></a></sup>
+<p><!--para 5-->
+ An iteration statement is a block whose scope is a strict subset of the scope of its
+ enclosing block. The loop body is also a block whose scope is a strict subset of the scope
+ of the iteration statement.
+<p><!--para 6-->
+ An iteration statement whose controlling expression is not a constant expression,<sup><a href="#note156"><b>156)</b></a></sup> that
+ performs no input/output operations, does not access volatile objects, and performs no
+ synchronization or atomic operations in its body, controlling expression, or (in the case of
+ 
+<!--page 168 indent 4-->
+ a for statement) its expression-3, may be assumed by the implementation to
+ terminate.<sup><a href="#note157"><b>157)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note155">155)</a> Code jumped over is not executed. In particular, the controlling expression of a for or while
+ statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
+
+<p><a name="note156">156)</a> An omitted controlling expression is replaced by a nonzero constant, which is a constant expression.
+
+<p><a name="note157">157)</a> This is intended to allow compiler transformations such as removal of empty loops even when
+ termination cannot be proven.
+
+
+<a name="6.8.5.1" href="#6.8.5.1"><h5>6.8.5.1 The while statement</h5></a>
+<p><!--para 1-->
+ The evaluation of the controlling expression takes place before each execution of the loop
+ body.
+
+<a name="6.8.5.2" href="#6.8.5.2"><h5>6.8.5.2 The do statement</h5></a>
+<p><!--para 1-->
+ The evaluation of the controlling expression takes place after each execution of the loop
+ body.
+
+<a name="6.8.5.3" href="#6.8.5.3"><h5>6.8.5.3 The for statement</h5></a>
+<p><!--para 1-->
+ The statement
+<pre>
+          for ( clause-1 ; expression-2 ; expression-3 ) statement</pre>
+ behaves as follows: The expression expression-2 is the controlling expression that is
+ evaluated before each execution of the loop body. The expression expression-3 is
+ evaluated as a void expression after each execution of the loop body. If clause-1 is a
+ declaration, the scope of any identifiers it declares is the remainder of the declaration and
+ the entire loop, including the other two expressions; it is reached in the order of execution
+ before the first evaluation of the controlling expression. If clause-1 is an expression, it is
+ evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note158"><b>158)</b></a></sup>
+<p><!--para 2-->
+ Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a
+ nonzero constant.
+
+<h6>footnotes</h6>
+<p><a name="note158">158)</a> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
+ the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
+ such that execution of the loop continues until the expression compares equal to 0; and expression-3
+ specifies an operation (such as incrementing) that is performed after each iteration.
+
+
+<a name="6.8.6" href="#6.8.6"><h4>6.8.6 Jump statements</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          jump-statement:
+                 goto identifier ;
+                 continue ;
+                 break ;
+                 return expressionopt ;</pre>
+ 
+ 
+ 
+ 
+<!--page 169 indent 4-->
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A jump statement causes an unconditional jump to another place.
+
+<a name="6.8.6.1" href="#6.8.6.1"><h5>6.8.6.1 The goto statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The identifier in a goto statement shall name a label located somewhere in the enclosing
+ function. A goto statement shall not jump from outside the scope of an identifier having
+ a variably modified type to inside the scope of that identifier.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A goto statement causes an unconditional jump to the statement prefixed by the named
+ label in the enclosing function.
+<p><!--para 3-->
+ EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
+ following outline presents one possible approach to a problem based on these three assumptions:
+<ol>
+<li>  The general initialization code accesses objects only visible to the current function.
+<li>  The general initialization code is too large to warrant duplication.
+<li>  The code to determine the next operation is at the head of the loop. (To allow it to be reached by
+ continue statements, for example.)
+<!--page 170 indent 4-->
+</ol>
+<p><!--para 4-->
+<pre>
+    /* ... */
+    goto first_time;
+    for (;;) {
+            // determine next operation
             /* ... */
-            g.u2.f3 = f();
-    there is no undefined behavior, although there would be if the assignment were done directly (without using
-    a function call to fetch the value).
-
-
-
-
-    <sup><a name="note160" href="#note160"><b>160)</b></a></sup> The return statement is not an assignment. The overlap restriction of subclause <a href="#6.5.16.1">6.5.16.1</a> does not
-         apply to the case of function return. The representation of floating-point values may have wider range
-         or precision than implied by the type; a cast may be used to remove this extra range and precision.
-
-[<a name="p153" href="#p153">page 153</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.9" href="#6.9"><b>    6.9 External definitions</b></a>
-<b>    Syntax</b>
-1            translation-unit:
-                     external-declaration
-                     translation-unit external-declaration
-             external-declaration:
-                    function-definition
-                    declaration
-<b>    Constraints</b>
-2   The storage-class specifiers auto and register shall not appear in the declaration
-    specifiers in an external declaration.
-3   There shall be no more than one external definition for each identifier declared with
-    internal linkage in a translation unit. Moreover, if an identifier declared with internal
-    linkage is used in an expression (other than as a part of the operand of a sizeof
-    operator whose result is an integer constant), there shall be exactly one external definition
-    for the identifier in the translation unit.
-<b>    Semantics</b>
-4   As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
-    which consists of a sequence of external declarations. These are described as ''external''
-    because they appear outside any function (and hence have file scope). As discussed in
-    <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
-    by the identifier is a definition.
-5   An external definition is an external declaration that is also a definition of a function
-    (other than an inline definition) or an object. If an identifier declared with external
-    linkage is used in an expression (other than as part of the operand of a sizeof operator
-    whose result is an integer constant), somewhere in the entire program there shall be
-    exactly one external definition for the identifier; otherwise, there shall be no more than
-    one.<sup><a href="#note161"><b>161)</b></a></sup>
-
-
-
-
-    <sup><a name="note161" href="#note161"><b>161)</b></a></sup> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
-         external definition for it.
-
-[<a name="p154" href="#p154">page 154</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.9.1" href="#6.9.1"><b>    6.9.1 Function definitions</b></a>
-<b>    Syntax</b>
-1            function-definition:
-                    declaration-specifiers declarator declaration-listopt compound-statement
-             declaration-list:
-                    declaration
-                    declaration-list declaration
-<b>    Constraints</b>
-2   The identifier declared in a function definition (which is the name of the function) shall
-    have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note162"><b>162)</b></a></sup>
-3   The return type of a function shall be void or a complete object type other than array
-    type.
-4   The storage-class specifier, if any, in the declaration specifiers shall be either extern or
-    static.
-5   If the declarator includes a parameter type list, the declaration of each parameter shall
-    include an identifier, except for the special case of a parameter list consisting of a single
-    parameter of type void, in which case there shall not be an identifier. No declaration list
-    shall follow.
-6   If the declarator includes an identifier list, each declaration in the declaration list shall
-    have at least one declarator, those declarators shall declare only identifiers from the
-    identifier list, and every identifier in the identifier list shall be declared. An identifier
-    declared as a typedef name shall not be redeclared as a parameter. The declarations in the
-    declaration list shall contain no storage-class specifier other than register and no
-    initializations.
-
-
-
-    <sup><a name="note162" href="#note162"><b>162)</b></a></sup> The intent is that the type category in a function definition cannot be inherited from a typedef:
-                  typedef int F(void);                          //   type F is ''function with no parameters
-                                                                //                  returning int''
-                  F f, g;                                       //   f and g both have type compatible with F
-                  F f { /* ... */ }                             //   WRONG: syntax/constraint error
-                  F g() { /* ... */ }                           //   WRONG: declares that g returns a function
-                  int f(void) { /* ... */ }                     //   RIGHT: f has type compatible with F
-                  int g() { /* ... */ }                         //   RIGHT: g has type compatible with F
-                  F *e(void) { /* ... */ }                      //   e returns a pointer to a function
-                  F *((e))(void) { /* ... */ }                  //   same: parentheses irrelevant
-                  int (*fp)(void);                              //   fp points to a function that has type F
-                  F *Fp;                                        //   Fp points to a function that has type F
-
-[<a name="p155" href="#p155">page 155</a>] (<a href="#Contents">Contents</a>)
-
-<b>     Semantics</b>
-7    The declarator in a function definition specifies the name of the function being defined
-     and the identifiers of its parameters. If the declarator includes a parameter type list, the
-     list also specifies the types of all the parameters; such a declarator also serves as a
-     function prototype for later calls to the same function in the same translation unit. If the
-     declarator includes an identifier list,<sup><a href="#note163"><b>163)</b></a></sup> the types of the parameters shall be declared in a
-     following declaration list. In either case, the type of each parameter is adjusted as
-     described in <a href="#6.7.6.3">6.7.6.3</a> for a parameter type list; the resulting type shall be a complete object
-     type.
-8    If a function that accepts a variable number of arguments is defined without a parameter
-     type list that ends with the ellipsis notation, the behavior is undefined.
-9    Each parameter has automatic storage duration; its identifier is an lvalue.<sup><a href="#note164"><b>164)</b></a></sup> The layout
-     of the storage for parameters is unspecified.
-10   On entry to the function, the size expressions of each variably modified parameter are
-     evaluated and the value of each argument expression is converted to the type of the
-     corresponding parameter as if by assignment. (Array expressions and function
-     designators as arguments were converted to pointers before the call.)
-11   After all parameters have been assigned, the compound statement that constitutes the
-     body of the function definition is executed.
-12   If the } that terminates a function is reached, and the value of the function call is used by
-     the caller, the behavior is undefined.
-13   EXAMPLE 1       In the following:
-              extern int max(int a, int b)
-              {
-                    return a &gt; b ? a : b;
-              }
-     extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
-     function declarator; and
-              { return a &gt; b ? a : b; }
-     is the function body. The following similar definition uses the identifier-list form for the parameter
-     declarations:
-
-
-
-
-     <sup><a name="note163" href="#note163"><b>163)</b></a></sup> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
-     <sup><a name="note164" href="#note164"><b>164)</b></a></sup> A parameter identifier cannot be redeclared in the function body except in an enclosed block.
-
-[<a name="p156" href="#p156">page 156</a>] (<a href="#Contents">Contents</a>)
-
-              extern int max(a, b)
-              int a, b;
-              {
-                    return a &gt; b ? a : b;
-              }
-     Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
-     that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
-     to the function, whereas the second form does not.
-
-14   EXAMPLE 2           To pass one function to another, one might say
-                          int f(void);
-                          /* ... */
-                          g(f);
-     Then the definition of g might read
-              void g(int (*funcp)(void))
-              {
+            if (need to reinitialize) {
+                    // reinitialize-only code
                     /* ... */
-                    (*funcp)(); /* or funcp(); ...                    */
-              }
-     or, equivalently,
-              void g(int func(void))
-              {
+            first_time:
+                    // general initialization code
                     /* ... */
-                    func(); /* or (*func)(); ...                   */
-              }
-
-<a name="6.9.2" href="#6.9.2"><b>     6.9.2 External object definitions</b></a>
-<b>     Semantics</b>
-1    If the declaration of an identifier for an object has file scope and an initializer, the
-     declaration is an external definition for the identifier.
-2    A declaration of an identifier for an object that has file scope without an initializer, and
-     without a storage-class specifier or with the storage-class specifier static, constitutes a
-     tentative definition. If a translation unit contains one or more tentative definitions for an
-     identifier, and the translation unit contains no external definition for that identifier, then
-     the behavior is exactly as if the translation unit contains a file scope declaration of that
-     identifier, with the composite type as of the end of the translation unit, with an initializer
-     equal to 0.
-3    If the declaration of an identifier for an object is a tentative definition and has internal
-     linkage, the declared type shall not be an incomplete type.
-
-[<a name="p157" href="#p157">page 157</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE 1
-             int i1 = 1;                    // definition, external linkage
-             static int i2 = 2;             // definition, internal linkage
-             extern int i3 = 3;             // definition, external linkage
-             int i4;                        // tentative definition, external linkage
-             static int i5;                 // tentative definition, internal linkage
-             int   i1;                      // valid tentative definition, refers to previous
-             int   i2;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
-             int   i3;                      // valid tentative definition, refers to previous
-             int   i4;                      // valid tentative definition, refers to previous
-             int   i5;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
-             extern    int   i1;            // refers to previous, whose linkage is external
-             extern    int   i2;            // refers to previous, whose linkage is internal
-             extern    int   i3;            // refers to previous, whose linkage is external
-             extern    int   i4;            // refers to previous, whose linkage is external
-             extern    int   i5;            // refers to previous, whose linkage is internal
-
-5   EXAMPLE 2       If at the end of the translation unit containing
-             int i[];
-    the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
-    zero on program startup.
-
-[<a name="p158" href="#p158">page 158</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10" href="#6.10"><b>    6.10 Preprocessing directives</b></a>
-<b>    Syntax</b>
-1            preprocessing-file:
-                    groupopt
-             group:
-                      group-part
-                      group group-part
-             group-part:
-                    if-section
-                    control-line
-                    text-line
-                    # non-directive
-             if-section:
-                      if-group elif-groupsopt else-groupopt endif-line
-             if-group:
-                     # if     constant-expression new-line groupopt
-                     # ifdef identifier new-line groupopt
-                     # ifndef identifier new-line groupopt
-             elif-groups:
-                     elif-group
-                     elif-groups elif-group
-             elif-group:
-                     # elif       constant-expression new-line groupopt
-             else-group:
-                     # else       new-line groupopt
-             endif-line:
-                     # endif      new-line
-
-[<a name="p159" href="#p159">page 159</a>] (<a href="#Contents">Contents</a>)
-
-             control-line:
-                    # include pp-tokens new-line
-                    # define identifier replacement-list new-line
-                    # define identifier lparen identifier-listopt )
-                                                    replacement-list new-line
-                    # define identifier lparen ... ) replacement-list new-line
-                    # define identifier lparen identifier-list , ... )
-                                                    replacement-list new-line
-                    # undef   identifier new-line
-                    # line    pp-tokens new-line
-                    # error   pp-tokensopt new-line
-                    # pragma pp-tokensopt new-line
-                    #         new-line
-             text-line:
-                     pp-tokensopt new-line
-             non-directive:
-                    pp-tokens new-line
-             lparen:
-                       a ( character not immediately preceded by white-space
-             replacement-list:
-                    pp-tokensopt
-             pp-tokens:
-                    preprocessing-token
-                    pp-tokens preprocessing-token
-             new-line:
-                    the new-line character
-<b>    Description</b>
-2   A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
-    following constraints: The first token in the sequence is a # preprocessing token that (at
-    the start of translation phase 4) is either the first character in the source file (optionally
-    after white space containing no new-line characters) or that follows white space
-    containing at least one new-line character. The last token in the sequence is the first new-
-    line character that follows the first token in the sequence.<sup><a href="#note165"><b>165)</b></a></sup> A new-line character ends
-    the preprocessing directive even if it occurs within what would otherwise be an
-
-    <sup><a name="note165" href="#note165"><b>165)</b></a></sup> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
-         significance, as all white space is equivalent except in certain situations during preprocessing (see the
-         # character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
-
-[<a name="p160" href="#p160">page 160</a>] (<a href="#Contents">Contents</a>)
-
-    invocation of a function-like macro.
-3   A text line shall not begin with a # preprocessing token. A non-directive shall not begin
-    with any of the directive names appearing in the syntax.
-4   When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
-    sequence of preprocessing tokens to occur between the directive name and the following
-    new-line character.
-<b>    Constraints</b>
-5   The only white-space characters that shall appear between preprocessing tokens within a
-    preprocessing directive (from just after the introducing # preprocessing token through
-    just before the terminating new-line character) are space and horizontal-tab (including
-    spaces that have replaced comments or possibly other white-space characters in
-    translation phase 3).
-<b>    Semantics</b>
-6   The implementation can process and skip sections of source files conditionally, include
-    other source files, and replace macros. These capabilities are called preprocessing,
-    because conceptually they occur before translation of the resulting translation unit.
-7   The preprocessing tokens within a preprocessing directive are not subject to macro
-    expansion unless otherwise stated.
-8   EXAMPLE        In:
-              #define EMPTY
-              EMPTY # include &lt;file.h&gt;
-    the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
-    begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
-    replaced.
-
-<a name="6.10.1" href="#6.10.1"><b>    6.10.1 Conditional inclusion</b></a>
-<b>    Constraints</b>
-1   The expression that controls conditional inclusion shall be an integer constant expression
-    except that: identifiers (including those lexically identical to keywords) are interpreted as *
-    described below;<sup><a href="#note166"><b>166)</b></a></sup> and it may contain unary operator expressions of the form
-         defined identifier
-    or
-         defined ( identifier )
-    which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
-
-
-    <sup><a name="note166" href="#note166"><b>166)</b></a></sup> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
-         either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
-
-[<a name="p161" href="#p161">page 161</a>] (<a href="#Contents">Contents</a>)
-
-    predefined or if it has been the subject of a #define preprocessing directive without an
-    intervening #undef directive with the same subject identifier), 0 if it is not.
-2   Each preprocessing token that remains (in the list of preprocessing tokens that will
-    become the controlling expression) after all macro replacements have occurred shall be in
-    the lexical form of a token (<a href="#6.4">6.4</a>).
-<b>    Semantics</b>
-3   Preprocessing directives of the forms
-       # if   constant-expression new-line groupopt
-       # elif constant-expression new-line groupopt
-    check whether the controlling constant expression evaluates to nonzero.
-4   Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
-    the controlling constant expression are replaced (except for those macro names modified
-    by the defined unary operator), just as in normal text. If the token defined is
-    generated as a result of this replacement process or use of the defined unary operator
-    does not match one of the two specified forms prior to macro replacement, the behavior is
-    undefined. After all replacements due to macro expansion and the defined unary
-    operator have been performed, all remaining identifiers (including those lexically
-    identical to keywords) are replaced with the pp-number 0, and then each preprocessing
-    token is converted into a token. The resulting tokens compose the controlling constant
-    expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
-    token conversion and evaluation, all signed integer types and all unsigned integer types
-    act as if they have the same representation as, respectively, the types intmax_t and
-    uintmax_t defined in the header <a href="#7.20">&lt;stdint.h&gt;</a>.<sup><a href="#note167"><b>167)</b></a></sup> This includes interpreting
-    character constants, which may involve converting escape sequences into execution
-    character set members. Whether the numeric value for these character constants matches
-    the value obtained when an identical character constant occurs in an expression (other
-    than within a #if or #elif directive) is implementation-defined.<sup><a href="#note168"><b>168)</b></a></sup> Also, whether a
-    single-character character constant may have a negative value is implementation-defined.
-
-
-
-
-    <sup><a name="note167" href="#note167"><b>167)</b></a></sup> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
-         0x8000 is signed and positive within a #if expression even though it would be unsigned in
-         translation phase 7.
-    <sup><a name="note168" href="#note168"><b>168)</b></a></sup> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
-         evaluate to the same value in these two contexts.
-           #if 'z' - 'a' == 25
-           if ('z' - 'a' == 25)
-
-[<a name="p162" href="#p162">page 162</a>] (<a href="#Contents">Contents</a>)
-
-5   Preprocessing directives of the forms
-       # ifdef identifier new-line groupopt
-       # ifndef identifier new-line groupopt
-    check whether the identifier is or is not currently defined as a macro name. Their
-    conditions are equivalent to #if defined identifier and #if !defined identifier
-    respectively.
-6   Each directive's condition is checked in order. If it evaluates to false (zero), the group
-    that it controls is skipped: directives are processed only through the name that determines
-    the directive in order to keep track of the level of nested conditionals; the rest of the
-    directives' preprocessing tokens are ignored, as are the other preprocessing tokens in the
-    group. Only the first group whose control condition evaluates to true (nonzero) is
-    processed. If none of the conditions evaluates to true, and there is a #else directive, the
-    group controlled by the #else is processed; lacking a #else directive, all the groups
-    until the #endif are skipped.<sup><a href="#note169"><b>169)</b></a></sup>
-    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
-    integer types (<a href="#7.20.1.5">7.20.1.5</a>).
-<a name="6.10.2" href="#6.10.2"><b>    6.10.2 Source file inclusion</b></a>
-<b>    Constraints</b>
-1   A #include directive shall identify a header or source file that can be processed by the
-    implementation.
-<b>    Semantics</b>
-2   A preprocessing directive of the form
-       # include &lt;h-char-sequence&gt; new-line
-    searches a sequence of implementation-defined places for a header identified uniquely by
-    the specified sequence between the &lt; and &gt; delimiters, and causes the replacement of that
-    directive by the entire contents of the header. How the places are specified or the header
-    identified is implementation-defined.
-3   A preprocessing directive of the form
-       # include "q-char-sequence" new-line
-    causes the replacement of that directive by the entire contents of the source file identified
-    by the specified sequence between the " delimiters. The named source file is searched
-
-
-    <sup><a name="note169" href="#note169"><b>169)</b></a></sup> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
-         before the terminating new-line character. However, comments may appear anywhere in a source file,
-         including within a preprocessing directive.
-
-[<a name="p163" href="#p163">page 163</a>] (<a href="#Contents">Contents</a>)
-
-    for in an implementation-defined manner. If this search is not supported, or if the search
-    fails, the directive is reprocessed as if it read
-       # include &lt;h-char-sequence&gt; new-line
-    with the identical contained sequence (including &gt; characters, if any) from the original
-    directive.
-4   A preprocessing directive of the form
-       # include pp-tokens new-line
-    (that does not match one of the two previous forms) is permitted. The preprocessing
-    tokens after include in the directive are processed just as in normal text. (Each
-    identifier currently defined as a macro name is replaced by its replacement list of
-    preprocessing tokens.) The directive resulting after all replacements shall match one of
-    the two previous forms.<sup><a href="#note170"><b>170)</b></a></sup> The method by which a sequence of preprocessing tokens
-    between a &lt; and a &gt; preprocessing token pair or a pair of " characters is combined into a
-    single header name preprocessing token is implementation-defined.
-5   The implementation shall provide unique mappings for sequences consisting of one or
-    more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
-    first character shall not be a digit. The implementation may ignore distinctions of
-    alphabetical case and restrict the mapping to eight significant characters before the
-    period.
-6   A #include preprocessing directive may appear in a source file that has been read
-    because of a #include directive in another file, up to an implementation-defined
-    nesting limit (see <a href="#5.2.4.1">5.2.4.1</a>).
-7   EXAMPLE 1       The most common uses of #include preprocessing directives are as in the following:
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             #include "myprog.h"
-
-
-
-
-    <sup><a name="note170" href="#note170"><b>170)</b></a></sup> Note that adjacent string literals are not concatenated into a single string literal (see the translation
-         phases in <a href="#5.1.1.2">5.1.1.2</a>); thus, an expansion that results in two string literals is an invalid directive.
-
-[<a name="p164" href="#p164">page 164</a>] (<a href="#Contents">Contents</a>)
-
-8   EXAMPLE 2      This illustrates macro-replaced #include directives:
-              #if VERSION == 1
-                    #define INCFILE          "vers1.h"
-              #elif VERSION == 2
-                    #define INCFILE          "vers2.h"        // and so on
-              #else
-                     #define INCFILE         "versN.h"
-              #endif
-              #include INCFILE
-
-    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>).
-<a name="6.10.3" href="#6.10.3"><b>    6.10.3 Macro replacement</b></a>
-<b>    Constraints</b>
-1   Two replacement lists are identical if and only if the preprocessing tokens in both have
-    the same number, ordering, spelling, and white-space separation, where all white-space
-    separations are considered identical.
-2   An identifier currently defined as an object-like macro shall not be redefined by another
-    #define preprocessing directive unless the second definition is an object-like macro
-    definition and the two replacement lists are identical. Likewise, an identifier currently
-    defined as a function-like macro shall not be redefined by another #define
-    preprocessing directive unless the second definition is a function-like macro definition
-    that has the same number and spelling of parameters, and the two replacement lists are
-    identical.
-3   There shall be white-space between the identifier and the replacement list in the definition
-    of an object-like macro.
-4   If the identifier-list in the macro definition does not end with an ellipsis, the number of
-    arguments (including those arguments consisting of no preprocessing tokens) in an
-    invocation of a function-like macro shall equal the number of parameters in the macro
-    definition. Otherwise, there shall be more arguments in the invocation than there are
-    parameters in the macro definition (excluding the ...). There shall exist a )
-    preprocessing token that terminates the invocation.
-5   The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
-    macro that uses the ellipsis notation in the parameters.
-6   A parameter identifier in a function-like macro shall be uniquely declared within its
-    scope.
-<b>    Semantics</b>
-7   The identifier immediately following the define is called the macro name. There is one
-    name space for macro names. Any white-space characters preceding or following the
-    replacement list of preprocessing tokens are not considered part of the replacement list
-
-[<a name="p165" href="#p165">page 165</a>] (<a href="#Contents">Contents</a>)
-
-     for either form of macro.
-8    If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
-     a preprocessing directive could begin, the identifier is not subject to macro replacement.
-9    A preprocessing directive of the form
-        # define identifier replacement-list new-line
-     defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note171"><b>171)</b></a></sup>
-     to be replaced by the replacement list of preprocessing tokens that constitute the
-     remainder of the directive. The replacement list is then rescanned for more macro names
-     as specified below.
-10   A preprocessing directive of the form
-        # define identifier lparen identifier-listopt ) replacement-list new-line
-        # define identifier lparen ... ) replacement-list new-line
-        # define identifier lparen identifier-list , ... ) replacement-list new-line
-     defines a function-like macro with parameters, whose use is similar syntactically to a
-     function call. The parameters are specified by the optional list of identifiers, whose scope
-     extends from their declaration in the identifier list until the new-line character that
-     terminates the #define preprocessing directive. Each subsequent instance of the
-     function-like macro name followed by a ( as the next preprocessing token introduces the
-     sequence of preprocessing tokens that is replaced by the replacement list in the definition
-     (an invocation of the macro). The replaced sequence of preprocessing tokens is
-     terminated by the matching ) preprocessing token, skipping intervening matched pairs of
-     left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
-     tokens making up an invocation of a function-like macro, new-line is considered a normal
-     white-space character.
-11   The sequence of preprocessing tokens bounded by the outside-most matching parentheses
-     forms the list of arguments for the function-like macro. The individual arguments within
-     the list are separated by comma preprocessing tokens, but comma preprocessing tokens
-     between matching inner parentheses do not separate arguments. If there are sequences of
-     preprocessing tokens within the list of arguments that would otherwise act as
-     preprocessing directives,<sup><a href="#note172"><b>172)</b></a></sup> the behavior is undefined.
-12   If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
-     including any separating comma preprocessing tokens, are merged to form a single item:
-
-
-     <sup><a name="note171" href="#note171"><b>171)</b></a></sup> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
-          not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
-          are never scanned for macro names or parameters.
-     <sup><a name="note172" href="#note172"><b>172)</b></a></sup> Despite the name, a non-directive is a preprocessing directive.
-
-[<a name="p166" href="#p166">page 166</a>] (<a href="#Contents">Contents</a>)
-
-    the variable arguments. The number of arguments so combined is such that, following
-    merger, the number of arguments is one more than the number of parameters in the macro
-    definition (excluding the ...).
-<a name="6.10.3.1" href="#6.10.3.1"><b>    6.10.3.1 Argument substitution</b></a>
-1   After the arguments for the invocation of a function-like macro have been identified,
-    argument substitution takes place. A parameter in the replacement list, unless preceded
-    by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
-    replaced by the corresponding argument after all macros contained therein have been
-    expanded. Before being substituted, each argument's preprocessing tokens are
-    completely macro replaced as if they formed the rest of the preprocessing file; no other
-    preprocessing tokens are available.
-2   An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
-    were a parameter, and the variable arguments shall form the preprocessing tokens used to
-    replace it.
-<a name="6.10.3.2" href="#6.10.3.2"><b>    6.10.3.2 The # operator</b></a>
-<b>    Constraints</b>
-1   Each # preprocessing token in the replacement list for a function-like macro shall be
-    followed by a parameter as the next preprocessing token in the replacement list.
-<b>    Semantics</b>
-2   If, in the replacement list, a parameter is immediately preceded by a # preprocessing
-    token, both are replaced by a single character string literal preprocessing token that
-    contains the spelling of the preprocessing token sequence for the corresponding
-    argument. Each occurrence of white space between the argument's preprocessing tokens
-    becomes a single space character in the character string literal. White space before the
-    first preprocessing token and after the last preprocessing token composing the argument
-    is deleted. Otherwise, the original spelling of each preprocessing token in the argument
-    is retained in the character string literal, except for special handling for producing the
-    spelling of string literals and character constants: a \ character is inserted before each "
-    and \ character of a character constant or string literal (including the delimiting "
-    characters), except that it is implementation-defined whether a \ character is inserted
-    before the \ character beginning a universal character name. If the replacement that
-    results is not a valid character string literal, the behavior is undefined. The character
-    string literal corresponding to an empty argument is "". The order of evaluation of # and
-    ## operators is unspecified.
-
-[<a name="p167" href="#p167">page 167</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.3.3" href="#6.10.3.3"><b>    6.10.3.3 The ## operator</b></a>
-<b>    Constraints</b>
-1   A ## preprocessing token shall not occur at the beginning or at the end of a replacement
-    list for either form of macro definition.
-<b>    Semantics</b>
-2   If, in the replacement list of a function-like macro, a parameter is immediately preceded
-    or followed by a ## preprocessing token, the parameter is replaced by the corresponding
-    argument's preprocessing token sequence; however, if an argument consists of no
-    preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
-    instead.<sup><a href="#note173"><b>173)</b></a></sup>
-3   For both object-like and function-like macro invocations, before the replacement list is
-    reexamined for more macro names to replace, each instance of a ## preprocessing token
-    in the replacement list (not from an argument) is deleted and the preceding preprocessing
-    token is concatenated with the following preprocessing token. Placemarker
-    preprocessing tokens are handled specially: concatenation of two placemarkers results in
-    a single placemarker preprocessing token, and concatenation of a placemarker with a
-    non-placemarker preprocessing token results in the non-placemarker preprocessing token.
-    If the result is not a valid preprocessing token, the behavior is undefined. The resulting
-    token is available for further macro replacement. The order of evaluation of ## operators
-    is unspecified.
-4   EXAMPLE       In the following fragment:
-            #define     hash_hash # ## #
-            #define     mkstr(a) # a
-            #define     in_between(a) mkstr(a)
-            #define     join(c, d) in_between(c hash_hash d)
-            char p[] = join(x, y); // equivalent to
-                                   // char p[] = "x ## y";
-    The expansion produces, at various stages:
-            join(x, y)
-            in_between(x hash_hash y)
-            in_between(x ## y)
-            mkstr(x ## y)
-            "x ## y"
-    In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
-    this new token is not the ## operator.
-
-
-    <sup><a name="note173" href="#note173"><b>173)</b></a></sup> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
-         exist only within translation phase 4.
-
-[<a name="p168" href="#p168">page 168</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.3.4" href="#6.10.3.4"><b>    6.10.3.4 Rescanning and further replacement</b></a>
-1   After all parameters in the replacement list have been substituted and # and ##
-    processing has taken place, all placemarker preprocessing tokens are removed. The
-    resulting preprocessing token sequence is then rescanned, along with all subsequent
-    preprocessing tokens of the source file, for more macro names to replace.
-2   If the name of the macro being replaced is found during this scan of the replacement list
-    (not including the rest of the source file's preprocessing tokens), it is not replaced.
-    Furthermore, if any nested replacements encounter the name of the macro being replaced,
-    it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
-    available for further replacement even if they are later (re)examined in contexts in which
-    that macro name preprocessing token would otherwise have been replaced.
-3   The resulting completely macro-replaced preprocessing token sequence is not processed
-    as a preprocessing directive even if it resembles one, but all pragma unary operator
-    expressions within it are then processed as specified in <a href="#6.10.9">6.10.9</a> below.
-<a name="6.10.3.5" href="#6.10.3.5"><b>    6.10.3.5 Scope of macro definitions</b></a>
-1   A macro definition lasts (independent of block structure) until a corresponding #undef
-    directive is encountered or (if none is encountered) until the end of the preprocessing
-    translation unit. Macro definitions have no significance after translation phase 4.
-2   A preprocessing directive of the form
-       # undef identifier new-line
-    causes the specified identifier no longer to be defined as a macro name. It is ignored if
-    the specified identifier is not currently defined as a macro name.
-3   EXAMPLE 1      The simplest use of this facility is to define a ''manifest constant'', as in
-            #define TABSIZE 100
-            int table[TABSIZE];
-
-4   EXAMPLE 2 The following defines a function-like macro whose value is the maximum of its arguments.
-    It has the advantages of working for any compatible types of the arguments and of generating in-line code
-    without the overhead of function calling. It has the disadvantages of evaluating one or the other of its
-    arguments a second time (including side effects) and generating more code than a function if invoked
-    several times. It also cannot have its address taken, as it has none.
-            #define max(a, b) ((a) &gt; (b) ? (a) : (b))
-    The parentheses ensure that the arguments and the resulting expression are bound properly.
-
-[<a name="p169" href="#p169">page 169</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE 3     To illustrate the rules for redefinition and reexamination, the sequence
-             #define   x         3
-             #define   f(a)      f(x * (a))
-             #undef    x
-             #define   x         2
-             #define   g         f
-             #define   z         z[0]
-             #define   h         g(~
-             #define   m(a)      a(w)
-             #define   w         0,1
-             #define   t(a)      a
-             #define   p()       int
-             #define   q(x)      x
-             #define   r(x,y)    x ## y
-             #define   str(x)    # x
-             f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);
-             g(x+(3,4)-w) | h 5) &amp; m
-                   (f)^m(m);
-             p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
-             char c[2][6] = { str(hello), str() };
-    results in
-             f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
-             f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) &amp; f(2 * (0,1))^m(0,1);
-             int i[] = { 1, 23, 4, 5, };
-             char c[2][6] = { "hello", "" };
-
-6   EXAMPLE 4     To illustrate the rules for creating character string literals and concatenating tokens, the
-    sequence
-             #define str(s)      # s
-             #define xstr(s)     str(s)
-             #define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
-                                     x ## s, x ## t)
-             #define INCFILE(n) vers ## n
-             #define glue(a, b) a ## b
-             #define xglue(a, b) glue(a, b)
-             #define HIGHLOW     "hello"
-             #define LOW         LOW ", world"
-             debug(1, 2);
-             fputs(str(strncmp("abc\0d", "abc", '\4') // this goes away
-                   == 0) str(: @\n), s);
-             #include xstr(INCFILE(2).h)
-             glue(HIGH, LOW);
-             xglue(HIGH, LOW)
-    results in
-
-[<a name="p170" href="#p170">page 170</a>] (<a href="#Contents">Contents</a>)
-
-             printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
-             fputs(
-               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0" ": @\n",
-               s);
-             #include "vers2.h"    (after macro replacement, before file access)
-             "hello";
-             "hello" ", world"
-    or, after concatenation of the character string literals,
-             printf("x1= %d, x2= %s", x1, x2);
-             fputs(
-               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: @\n",
-               s);
-             #include "vers2.h"    (after macro replacement, before file access)
-             "hello";
-             "hello, world"
-    Space around the # and ## tokens in the macro definition is optional.
-
-7   EXAMPLE 5        To illustrate the rules for placemarker preprocessing tokens, the sequence
-             #define t(x,y,z) x ## y ## z
-             int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
-                        t(10,,), t(,11,), t(,,12), t(,,) };
-    results in
-             int j[] = { 123, 45, 67, 89,
-                         10, 11, 12, };
-
-8   EXAMPLE 6        To demonstrate the redefinition rules, the following sequence is valid.
-             #define      OBJ_LIKE      (1-1)
-             #define      OBJ_LIKE      /* white space */ (1-1) /* other */
-             #define      FUNC_LIKE(a)   ( a )
-             #define      FUNC_LIKE( a )( /* note the white space */ \
-                                          a /* other stuff on this line
-                                              */ )
-    But the following redefinitions are invalid:
-             #define      OBJ_LIKE    (0)     // different token sequence
-             #define      OBJ_LIKE    (1 - 1) // different white space
-             #define      FUNC_LIKE(b) ( a ) // different parameter usage
-             #define      FUNC_LIKE(b) ( b ) // different parameter spelling
-
-9   EXAMPLE 7        Finally, to show the variable argument list macro facilities:
-             #define debug(...)       fprintf(stderr, __VA_ARGS__)
-             #define showlist(...)    puts(#__VA_ARGS__)
-             #define report(test, ...) ((test)?puts(#test):\
-                         printf(__VA_ARGS__))
-             debug("Flag");
-             debug("X = %d\n", x);
-             showlist(The first, second, and third items.);
-             report(x&gt;y, "x is %d but y is %d", x, y);
-
-[<a name="p171" href="#p171">page 171</a>] (<a href="#Contents">Contents</a>)
-
-    results in
-             fprintf(stderr, "Flag" );
-             fprintf(stderr, "X = %d\n", x );
-             puts( "The first, second, and third items." );
-             ((x&gt;y)?puts("x&gt;y"):
-                         printf("x is %d but y is %d", x, y));
-
-<a name="6.10.4" href="#6.10.4"><b>    6.10.4 Line control</b></a>
-<b>    Constraints</b>
-1   The string literal of a #line directive, if present, shall be a character string literal.
-<b>    Semantics</b>
-2   The line number of the current source line is one greater than the number of new-line
-    characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
-    file to the current token.
-3   A preprocessing directive of the form
-       # line digit-sequence new-line
-    causes the implementation to behave as if the following sequence of source lines begins
-    with a source line that has a line number as specified by the digit sequence (interpreted as
-    a decimal integer). The digit sequence shall not specify zero, nor a number greater than
-    2147483647.
-4   A preprocessing directive of the form
-       # line digit-sequence "s-char-sequenceopt" new-line
-    sets the presumed line number similarly and changes the presumed name of the source
-    file to be the contents of the character string literal.
-5   A preprocessing directive of the form
-       # line pp-tokens new-line
-    (that does not match one of the two previous forms) is permitted. The preprocessing
-    tokens after line on the directive are processed just as in normal text (each identifier
-    currently defined as a macro name is replaced by its replacement list of preprocessing
-    tokens). The directive resulting after all replacements shall match one of the two
-    previous forms and is then processed as appropriate.
-
-[<a name="p172" href="#p172">page 172</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.5" href="#6.10.5"><b>    6.10.5 Error directive</b></a>
-<b>    Semantics</b>
-1   A preprocessing directive of the form
-       # error pp-tokensopt new-line
-    causes the implementation to produce a diagnostic message that includes the specified
-    sequence of preprocessing tokens.
-<a name="6.10.6" href="#6.10.6"><b>    6.10.6 Pragma directive</b></a>
-<b>    Semantics</b>
-1   A preprocessing directive of the form
-       # pragma pp-tokensopt new-line
-    where the preprocessing token STDC does not immediately follow pragma in the
-    directive (prior to any macro replacement)<sup><a href="#note174"><b>174)</b></a></sup> causes the implementation to behave in an
-    implementation-defined manner. The behavior might cause translation to fail or cause the
-    translator or the resulting program to behave in a non-conforming manner. Any such
-    pragma that is not recognized by the implementation is ignored.
-2   If the preprocessing token STDC does immediately follow pragma in the directive (prior
-    to any macro replacement), then no macro replacement is performed on the directive, and
-    the directive shall have one of the following forms<sup><a href="#note175"><b>175)</b></a></sup> whose meanings are described
-    elsewhere:
-       #pragma STDC FP_CONTRACT on-off-switch
-       #pragma STDC FENV_ACCESS on-off-switch
-       #pragma STDC CX_LIMITED_RANGE on-off-switch
-       on-off-switch: one of
-                   ON     OFF           DEFAULT
-    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
-    (<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
-
-
-
-
-    <sup><a name="note174" href="#note174"><b>174)</b></a></sup> An implementation is not required to perform macro replacement in pragmas, but it is permitted
-         except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
-         replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
-         implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
-         but is not required to.
-    <sup><a name="note175" href="#note175"><b>175)</b></a></sup> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
-
-[<a name="p173" href="#p173">page 173</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.7" href="#6.10.7"><b>    6.10.7 Null directive</b></a>
-<b>    Semantics</b>
-1   A preprocessing directive of the form
-       # new-line
-    has no effect.
-<a name="6.10.8" href="#6.10.8"><b>    6.10.8 Predefined macro names</b></a>
-1   The values of the predefined macros listed in the following subclauses<sup><a href="#note176"><b>176)</b></a></sup> (except for
-    __FILE__ and __LINE__) remain constant throughout the translation unit.
-2   None of these macro names, nor the identifier defined, shall be the subject of a
-    #define or a #undef preprocessing directive. Any other predefined macro names
-    shall begin with a leading underscore followed by an uppercase letter or a second
-    underscore.
-3   The implementation shall not predefine the macro __cplusplus, nor shall it define it
-    in any standard header.
-    Forward references: standard headers (<a href="#7.1.2">7.1.2</a>).
-<a name="6.10.8.1" href="#6.10.8.1"><b>    6.10.8.1 Mandatory macros</b></a>
-1   The following macro names shall be defined by the implementation:
-    __DATE__ The date of translation of the preprocessing translation unit: a character
-               string literal of the form "Mmm dd yyyy", where the names of the
-               months are the same as those generated by the asctime function, and the
-               first character of dd is a space character if the value is less than 10. If the
-               date of translation is not available, an implementation-defined valid date
-               shall be supplied.
-    __FILE__ The presumed name of the current source file (a character string literal).<sup><a href="#note177"><b>177)</b></a></sup>
-    __LINE__ The presumed line number (within the current source file) of the current
-               source line (an integer constant).177)
-    __STDC__ The integer constant 1, intended to indicate a conforming implementation.
-    __STDC_HOSTED__ The integer constant 1 if the implementation is a hosted
-              implementation or the integer constant 0 if it is not.
-
-
-
-
-    <sup><a name="note176" href="#note176"><b>176)</b></a></sup> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
-    <sup><a name="note177" href="#note177"><b>177)</b></a></sup> The presumed source file name and line number can be changed by the #line directive.
-
-[<a name="p174" href="#p174">page 174</a>] (<a href="#Contents">Contents</a>)
-
-    __STDC_VERSION__ The integer constant 201ymmL.<sup><a href="#note178"><b>178)</b></a></sup>
-    __TIME__ The time of translation of the preprocessing translation unit: a character
-               string literal of the form "hh:mm:ss" as in the time generated by the
-               asctime function. If the time of translation is not available, an
-               implementation-defined valid time shall be supplied.
-    Forward references: the asctime function (<a href="#7.26.3.1">7.26.3.1</a>).
-<a name="6.10.8.2" href="#6.10.8.2"><b>    6.10.8.2 Environment macros</b></a>
-1   The following macro names are conditionally defined by the implementation:
-    __STDC_ISO_10646__ An integer constant of the form yyyymmL (for example,
-              199712L). If this symbol is defined, then every character in the Unicode
-              required set, when stored in an object of type wchar_t, has the same
-              value as the short identifier of that character. The Unicode required set
-              consists of all the characters that are defined by ISO/IEC 10646, along with
-              all amendments and technical corrigenda, as of the specified year and
-              month. If some other encoding is used, the macro shall not be defined and
-              the actual encoding used is implementation-defined.
-    __STDC_MB_MIGHT_NEQ_WC__ The integer constant 1, intended to indicate that, in
-              the encoding for wchar_t, a member of the basic character set need not
-              have a code value equal to its value when used as the lone character in an
-              integer character constant.
-    __STDC_UTF_16__ The integer constant 1, intended to indicate that values of type
-              char16_t are UTF-16 encoded. If some other encoding is used, the
-              macro shall not be defined and the actual encoding used is implementation-
-              defined.
-    __STDC_UTF_32__ The integer constant 1, intended to indicate that values of type
-              char32_t are UTF-32 encoded. If some other encoding is used, the
-              macro shall not be defined and the actual encoding used is implementation-
-              defined.
-    Forward references: common definitions (<a href="#7.19">7.19</a>), unicode utilities (<a href="#7.27">7.27</a>).
-
-
-
-
-    <sup><a name="note178" href="#note178"><b>178)</b></a></sup> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
-         ISO/IEC 9899/AMD1:1995 and as 199901L in ISO/IEC 9899:1999. The intention is that this will
-         remain an integer constant of type long int that is increased with each revision of this International
-         Standard.
-
-[<a name="p175" href="#p175">page 175</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.10.8.3" href="#6.10.8.3"><b>    6.10.8.3 Conditional feature macros</b></a>
-1   The following macro names are conditionally defined by the implementation:
-    __STDC_ANALYZABLE__ The integer constant 1, intended to indicate conformance to
-              the specifications in <a href="#L">annex L</a> (Analyzability).
-    __STDC_IEC_559__ The integer constant 1, intended to indicate conformance to the
-              specifications in <a href="#F">annex F</a> (IEC 60559 floating-point arithmetic).
-    __STDC_IEC_559_COMPLEX__ The integer constant 1, intended to indicate
-              adherence to the specifications in <a href="#G">annex G</a> (IEC 60559 compatible complex
-              arithmetic).
-    __STDC_LIB_EXT1__ The integer constant 201ymmL, intended to indicate support
-              for the extensions defined in <a href="#K">annex K</a> (Bounds-checking interfaces).<sup><a href="#note179"><b>179)</b></a></sup>
-    __STDC_NO_COMPLEX__ The integer constant 1, intended to indicate that the
-              implementation does not support complex types or the <a href="#7.3">&lt;complex.h&gt;</a>
-              header.
-    __STDC_NO_THREADS__ The integer constant 1, intended to indicate that the
-              implementation does not support atomic types (including the _Atomic
-              type qualifier and the <a href="#7.17">&lt;stdatomic.h&gt;</a> header) or the <a href="#7.25">&lt;threads.h&gt;</a>
-              header.
-    __STDC_NO_VLA__ The integer constant 1, intended to indicate that the
-              implementation does not support variable length arrays or variably
-              modified types.
-2   An implementation that defines __STDC_NO_COMPLEX__ shall not define
-    __STDC_IEC_559_COMPLEX__.
-<a name="6.10.9" href="#6.10.9"><b>    6.10.9 Pragma operator</b></a>
-<b>    Semantics</b>
-1   A unary operator expression of the form:
-       _Pragma ( string-literal )
-    is processed as follows: The string literal is destringized by deleting the L prefix, if
-    present, deleting the leading and trailing double-quotes, replacing each escape sequence
-    \" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
-    resulting sequence of characters is processed through translation phase 3 to produce
-    preprocessing tokens that are executed as if they were the pp-tokens in a pragma
-
-
-    <sup><a name="note179" href="#note179"><b>179)</b></a></sup> The intention is that this will remain an integer constant of type long int that is increased with
-         each revision of this International Standard.
-
-[<a name="p176" href="#p176">page 176</a>] (<a href="#Contents">Contents</a>)
-
-    directive. The original four preprocessing tokens in the unary operator expression are
-    removed.
-2   EXAMPLE       A directive of the form:
-              #pragma listing on "..\listing.dir"
-    can also be expressed as:
-              _Pragma ( "listing on \"..\\listing.dir\"" )
-    The latter form is processed in the same way whether it appears literally as shown, or results from macro
-    replacement, as in:
-              #define LISTING(x) PRAGMA(listing on #x)
-              #define PRAGMA(x) _Pragma(#x)
-              LISTING ( ..\listing.dir )
-
-[<a name="p177" href="#p177">page 177</a>] (<a href="#Contents">Contents</a>)
-
-<a name="6.11" href="#6.11"><b>    6.11 Future language directions</b></a>
-<a name="6.11.1" href="#6.11.1"><b>    6.11.1 Floating types</b></a>
-1   Future standardization may include additional floating-point types, including those with
-    greater range, precision, or both than long double.
-<a name="6.11.2" href="#6.11.2"><b>    6.11.2 Linkages of identifiers</b></a>
-1   Declaring an identifier with internal linkage at file scope without the static storage-
-    class specifier is an obsolescent feature.
-<a name="6.11.3" href="#6.11.3"><b>    6.11.3 External names</b></a>
-1   Restriction of the significance of an external name to fewer than 255 characters
-    (considering each universal character name or extended source character as a single
-    character) is an obsolescent feature that is a concession to existing implementations.
-<a name="6.11.4" href="#6.11.4"><b>    6.11.4 Character escape sequences</b></a>
-1   Lowercase letters as escape sequences are reserved for future standardization. Other
-    characters may be used in extensions.
-<a name="6.11.5" href="#6.11.5"><b>    6.11.5 Storage-class specifiers</b></a>
-1   The placement of a storage-class specifier other than at the beginning of the declaration
-    specifiers in a declaration is an obsolescent feature.
-<a name="6.11.6" href="#6.11.6"><b>    6.11.6 Function declarators</b></a>
-1   The use of function declarators with empty parentheses (not prototype-format parameter
-    type declarators) is an obsolescent feature.
-<a name="6.11.7" href="#6.11.7"><b>    6.11.7 Function definitions</b></a>
-1   The use of function definitions with separate parameter identifier and declaration lists
-    (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
-<a name="6.11.8" href="#6.11.8"><b>    6.11.8 Pragma directives</b></a>
-1   Pragmas whose first preprocessing token is STDC are reserved for future standardization.
-<a name="6.11.9" href="#6.11.9"><b>    6.11.9 Predefined macro names</b></a>
-1   Macro names beginning with __STDC_ are reserved for future standardization.
-
-[<a name="p178" href="#p178">page 178</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="7" href="#7"><b>    7. Library</b></a>
-<a name="7.1" href="#7.1"><b>    7.1 Introduction</b></a>
-<a name="7.1.1" href="#7.1.1"><b>    7.1.1 Definitions of terms</b></a>
-1   A string is a contiguous sequence of characters terminated by and including the first null
-    character. The term multibyte string is sometimes used instead to emphasize special
-    processing given to multibyte characters contained in the string or to avoid confusion
-    with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
-    character. The length of a string is the number of bytes preceding the null character and
-    the value of a string is the sequence of the values of the contained characters, in order.
-2   The decimal-point character is the character used by functions that convert floating-point
-    numbers to or from character sequences to denote the beginning of the fractional part of
-    such character sequences.<sup><a href="#note180"><b>180)</b></a></sup> It is represented in the text and examples by a period, but
-    may be changed by the setlocale function.
-3   A null wide character is a wide character with code value zero.
-4   A wide string is a contiguous sequence of wide characters terminated by and including
-    the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
-    addressed) wide character. The length of a wide string is the number of wide characters
-    preceding the null wide character and the value of a wide string is the sequence of code
-    values of the contained wide characters, in order.
-5   A shift sequence is a contiguous sequence of bytes within a multibyte string that
-    (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
-    corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
-    character.<sup><a href="#note181"><b>181)</b></a></sup>
-    Forward references: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
-
-
-
-
-    <sup><a name="note180" href="#note180"><b>180)</b></a></sup> The functions that make use of the decimal-point character are the numeric conversion functions
-         (<a href="#7.22.1">7.22.1</a>, <a href="#7.28.4.1">7.28.4.1</a>) and the formatted input/output functions (<a href="#7.21.6">7.21.6</a>, <a href="#7.28.2">7.28.2</a>).
-    <sup><a name="note181" href="#note181"><b>181)</b></a></sup> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
-         enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
-         sequence of maximum length. Whether these counts provide for more than one shift sequence is the
-         implementation's choice.
-
-[<a name="p179" href="#p179">page 179</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.1.2" href="#7.1.2"><b>    7.1.2 Standard headers</b></a>
-1   Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note182"><b>182)</b></a></sup>
-    whose contents are made available by the #include preprocessing directive. The
-    header declares a set of related functions, plus any necessary types and additional macros
-    needed to facilitate their use. Declarations of types described in this clause shall not
-    include type qualifiers, unless explicitly stated otherwise.
-2   The standard headers are<sup><a href="#note183"><b>183)</b></a></sup>
-           <a href="#7.2">&lt;assert.h&gt;</a>             <a href="#7.9">&lt;iso646.h&gt;</a>              <a href="#7.16">&lt;stdarg.h&gt;</a>              <a href="#7.23">&lt;string.h&gt;</a>
-           <a href="#7.3">&lt;complex.h&gt;</a>            <a href="#7.10">&lt;limits.h&gt;</a>              <a href="#7.17">&lt;stdatomic.h&gt;</a>           <a href="#7.24">&lt;tgmath.h&gt;</a>
-           <a href="#7.4">&lt;ctype.h&gt;</a>              <a href="#7.11">&lt;locale.h&gt;</a>              <a href="#7.18">&lt;stdbool.h&gt;</a>             <a href="#7.25">&lt;threads.h&gt;</a>
-           <a href="#7.5">&lt;errno.h&gt;</a>              <a href="#7.12">&lt;math.h&gt;</a>                <a href="#7.19">&lt;stddef.h&gt;</a>              <a href="#7.26">&lt;time.h&gt;</a>
-           <a href="#7.6">&lt;fenv.h&gt;</a>               <a href="#7.13">&lt;setjmp.h&gt;</a>              <a href="#7.20">&lt;stdint.h&gt;</a>              <a href="#7.27">&lt;uchar.h&gt;</a>
-           <a href="#7.7">&lt;float.h&gt;</a>              <a href="#7.14">&lt;signal.h&gt;</a>              <a href="#7.21">&lt;stdio.h&gt;</a>               <a href="#7.28">&lt;wchar.h&gt;</a>
-           <a href="#7.8">&lt;inttypes.h&gt;</a>           <a href="#7.15">&lt;stdalign.h&gt;</a>            <a href="#7.22">&lt;stdlib.h&gt;</a>              <a href="#7.29">&lt;wctype.h&gt;</a>
-3   If a file with the same name as one of the above &lt; and &gt; delimited sequences, not
-    provided as part of the implementation, is placed in any of the standard places that are
-    searched for included source files, the behavior is undefined.
-4   Standard headers may be included in any order; each may be included more than once in
-    a given scope, with no effect different from being included only once, except that the
-    effect of including <a href="#7.2">&lt;assert.h&gt;</a> depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
-    used, a header shall be included outside of any external declaration or definition, and it
-    shall first be included before the first reference to any of the functions or objects it
-    declares, or to any of the types or macros it defines. However, if an identifier is declared
-    or defined in more than one header, the second and subsequent associated headers may be
-    included after the initial reference to the identifier. The program shall not have any
-    macros with names lexically identical to keywords currently defined prior to the
-    inclusion.
-5   Any definition of an object-like macro described in this clause shall expand to code that is
-    fully protected by parentheses where necessary, so that it groups in an arbitrary
-    expression as if it were a single identifier.
-6   Any declaration of a library function shall have external linkage.
-
-
-
-
-    <sup><a name="note182" href="#note182"><b>182)</b></a></sup> A header is not necessarily a source file, nor are the &lt; and &gt; delimited sequences in header names
-         necessarily valid source file names.
-    <sup><a name="note183" href="#note183"><b>183)</b></a></sup> The headers <a href="#7.3">&lt;complex.h&gt;</a>, <a href="#7.17">&lt;stdatomic.h&gt;</a>, and <a href="#7.25">&lt;threads.h&gt;</a> are conditional features that
-         implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.
-
-[<a name="p180" href="#p180">page 180</a>] (<a href="#Contents">Contents</a>)
-
-7   A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
-    Forward references: diagnostics (<a href="#7.2">7.2</a>).
-<a name="7.1.3" href="#7.1.3"><b>    7.1.3 Reserved identifiers</b></a>
-1   Each header declares or defines all identifiers listed in its associated subclause, and
-    optionally declares or defines identifiers listed in its associated future library directions
-    subclause and identifiers which are always reserved either for any use or for use as file
-    scope identifiers.
-    -- All identifiers that begin with an underscore and either an uppercase letter or another
-      underscore are always reserved for any use.
-    -- All identifiers that begin with an underscore are always reserved for use as identifiers
-      with file scope in both the ordinary and tag name spaces.
-    -- Each macro name in any of the following subclauses (including the future library
-      directions) is reserved for use as specified if any of its associated headers is included;
-      unless explicitly stated otherwise (see <a href="#7.1.4">7.1.4</a>).
-    -- All identifiers with external linkage in any of the following subclauses (including the
-      future library directions) and errno are always reserved for use as identifiers with
-      external linkage.<sup><a href="#note184"><b>184)</b></a></sup>
-    -- Each identifier with file scope listed in any of the following subclauses (including the
-      future library directions) is reserved for use as a macro name and as an identifier with
-      file scope in the same name space if any of its associated headers is included.
-2   No other identifiers are reserved. If the program declares or defines an identifier in a
-    context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
-    identifier as a macro name, the behavior is undefined.
-3   If the program removes (with #undef) any macro definition of an identifier in the first
-    group listed above, the behavior is undefined.
-
-
-
-
-    <sup><a name="note184" href="#note184"><b>184)</b></a></sup> The list of reserved identifiers with external linkage includes math_errhandling, setjmp,
-         va_copy, and va_end.
-
-[<a name="p181" href="#p181">page 181</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.1.4" href="#7.1.4"><b>    7.1.4 Use of library functions</b></a>
-1   Each of the following statements applies unless explicitly stated otherwise in the detailed
-    descriptions that follow: If an argument to a function has an invalid value (such as a value
-    outside the domain of the function, or a pointer outside the address space of the program,
-    or a null pointer, or a pointer to non-modifiable storage when the corresponding
-    parameter is not const-qualified) or a type (after promotion) not expected by a function
-    with variable number of arguments, the behavior is undefined. If a function argument is
-    described as being an array, the pointer actually passed to the function shall have a value
-    such that all address computations and accesses to objects (that would be valid if the
-    pointer did point to the first element of such an array) are in fact valid. Any function
-    declared in a header may be additionally implemented as a function-like macro defined in
-    the header, so if a library function is declared explicitly when its header is included, one
-    of the techniques shown below can be used to ensure the declaration is not affected by
-    such a macro. Any macro definition of a function can be suppressed locally by enclosing
-    the name of the function in parentheses, because the name is then not followed by the left
-    parenthesis that indicates expansion of a macro function name. For the same syntactic
-    reason, it is permitted to take the address of a library function even if it is also defined as
-    a macro.<sup><a href="#note185"><b>185)</b></a></sup> The use of #undef to remove any macro definition will also ensure that an
-    actual function is referred to. Any invocation of a library function that is implemented as
-    a macro shall expand to code that evaluates each of its arguments exactly once, fully
-    protected by parentheses where necessary, so it is generally safe to use arbitrary
-    expressions as arguments.<sup><a href="#note186"><b>186)</b></a></sup> Likewise, those function-like macros described in the
-    following subclauses may be invoked in an expression anywhere a function with a
-    compatible return type could be called.<sup><a href="#note187"><b>187)</b></a></sup> All object-like macros listed as expanding to
-
-
-    <sup><a name="note185" href="#note185"><b>185)</b></a></sup> This means that an implementation shall provide an actual function for each library function, even if it
-         also provides a macro for that function.
-    <sup><a name="note186" href="#note186"><b>186)</b></a></sup> Such macros might not contain the sequence points that the corresponding function calls do.
-    <sup><a name="note187" href="#note187"><b>187)</b></a></sup> Because external identifiers and some macro names beginning with an underscore are reserved,
-         implementations may provide special semantics for such names. For example, the identifier
-         _BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
-         appropriate header could specify
-                   #define abs(x) _BUILTIN_abs(x)
-          for a compiler whose code generator will accept it.
-          In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
-          function may write
-                   #undef abs
-          whether the implementation's header provides a macro implementation of abs or a built-in
-          implementation. The prototype for the function, which precedes and is hidden by any macro
-          definition, is thereby revealed also.
-
-[<a name="p182" href="#p182">page 182</a>] (<a href="#Contents">Contents</a>)
-
-    integer constant expressions shall additionally be suitable for use in #if preprocessing
-    directives.
-2   Provided that a library function can be declared without reference to any type defined in a
-    header, it is also permissible to declare the function and use it without including its
-    associated header.
-3   There is a sequence point immediately before a library function returns.
-4   The functions in the standard library are not guaranteed to be reentrant and may modify
-    objects with static or thread storage duration.<sup><a href="#note188"><b>188)</b></a></sup>
-5   Unless explicitly stated otherwise in the detailed descriptions that follow, library
-    functions shall prevent data races as follows: A library function shall not directly or
-    indirectly access objects accessible by threads other than the current thread unless the
-    objects are accessed directly or indirectly via the function's arguments. A library
-    function shall not directly or indirectly modify objects accessible by threads other than
-    the current thread unless the objects are accessed directly or indirectly via the function's
-    non-const arguments.<sup><a href="#note189"><b>189)</b></a></sup> Implementations may share their own internal objects between
-    threads if the objects are not visible to users and are protected against data races.
-6   Unless otherwise specified, library functions shall perform all operations solely within the
-    current thread if those operations have effects that are visible to users.<sup><a href="#note190"><b>190)</b></a></sup>
-7   EXAMPLE        The function atoi may be used in any of several ways:
-    -- by use of its associated header (possibly generating a macro expansion)
-                 #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-                 const char *str;
-                 /* ... */
-                 i = atoi(str);
-    -- by use of its associated header (assuredly generating a true function reference)
-
-
-
-
-    <sup><a name="note188" href="#note188"><b>188)</b></a></sup> Thus, a signal handler cannot, in general, call standard library functions.
-    <sup><a name="note189" href="#note189"><b>189)</b></a></sup> This means, for example, that an implementation is not permitted to use a static object for internal
-         purposes without synchronization because it could cause a data race even in programs that do not
-         explicitly share objects between threads.
-    <sup><a name="note190" href="#note190"><b>190)</b></a></sup> This allows implementations to parallelize operations if there are no visible side effects.
-
-[<a name="p183" href="#p183">page 183</a>] (<a href="#Contents">Contents</a>)
-
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            #undef atoi
-            const char *str;
-            /* ... */
-            i = atoi(str);
-   or
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            const char *str;
-            /* ... */
-            i = (atoi)(str);
--- by explicit declaration
-            extern int atoi(const char *);
-            const char *str;
-            /* ... */
-            i = atoi(str);
-
-[<a name="p184" href="#p184">page 184</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.2" href="#7.2"><b>    7.2 Diagnostics &lt;assert.h&gt;</b></a>
-1   The header <a href="#7.2">&lt;assert.h&gt;</a> defines the assert and static_assert macros and
-    refers to another macro,
-            NDEBUG
-    which is not defined by <a href="#7.2">&lt;assert.h&gt;</a>. If NDEBUG is defined as a macro name at the
-    point in the source file where <a href="#7.2">&lt;assert.h&gt;</a> is included, the assert macro is defined
-    simply as
-            #define assert(ignore) ((void)0)
-    The assert macro is redefined according to the current state of NDEBUG each time that
-    <a href="#7.2">&lt;assert.h&gt;</a> is included.
-2   The assert macro shall be implemented as a macro, not as an actual function. If the
-    macro definition is suppressed in order to access an actual function, the behavior is
-    undefined.
-3   The macro
-            static_assert
-    expands to _Static_assert.
-<a name="7.2.1" href="#7.2.1"><b>    7.2.1 Program diagnostics</b></a>
-<a name="7.2.1.1" href="#7.2.1.1"><b>    7.2.1.1 The assert macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.2">&lt;assert.h&gt;</a>
-            void assert(scalar expression);
-<b>    Description</b>
-2   The assert macro puts diagnostic tests into programs; it expands to a void expression.
-    When it is executed, if expression (which shall have a scalar type) is false (that is,
-    compares equal to 0), the assert macro writes information about the particular call that
-    failed (including the text of the argument, the name of the source file, the source line
-    number, and the name of the enclosing function -- the latter are respectively the values of
-    the preprocessing macros __FILE__ and __LINE__ and of the identifier
-    __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note191"><b>191)</b></a></sup> It
-    then calls the abort function.
-
-
-
-    <sup><a name="note191" href="#note191"><b>191)</b></a></sup> The message written might be of the form:
-         Assertion failed: expression, function abc, file xyz, line nnn.
-
-[<a name="p185" href="#p185">page 185</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The assert macro returns no value.
-    Forward references: the abort function (<a href="#7.22.4.1">7.22.4.1</a>).
-
-[<a name="p186" href="#p186">page 186</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3" href="#7.3"><b>    7.3 Complex arithmetic &lt;complex.h&gt;</b></a>
-<a name="7.3.1" href="#7.3.1"><b>    7.3.1 Introduction</b></a>
-1   The header <a href="#7.3">&lt;complex.h&gt;</a> defines macros and declares functions that support complex
-    arithmetic.<sup><a href="#note192"><b>192)</b></a></sup>
-2   Implementations that define the macro __STDC_NO_COMPLEX__ need not provide
-    this header nor support any of its facilities.
-3   Each synopsis specifies a family of functions consisting of a principal function with one
-    or more double complex parameters and a double complex or double return
-    value; and other functions with the same name but with f and l suffixes which are
-    corresponding functions with float and long double parameters and return values.
-4   The macro
-             complex
-    expands to _Complex; the macro
-             _Complex_I
-    expands to a constant expression of type const float _Complex, with the value of
-    the imaginary unit.<sup><a href="#note193"><b>193)</b></a></sup>
-5   The macros
-             imaginary
-    and
-             _Imaginary_I
-    are defined if and only if the implementation supports imaginary types;<sup><a href="#note194"><b>194)</b></a></sup> if defined,
-    they expand to _Imaginary and a constant expression of type const float
-    _Imaginary with the value of the imaginary unit.
-6   The macro
-             I
-    expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
-    defined, I shall expand to _Complex_I.
-7   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
-    redefine the macros complex, imaginary, and I.
-
-    <sup><a name="note192" href="#note192"><b>192)</b></a></sup> See ''future library directions'' (<a href="#7.30.1">7.30.1</a>).
-    <sup><a name="note193" href="#note193"><b>193)</b></a></sup> The imaginary unit is a number i such that i 2 = -1.
-    <sup><a name="note194" href="#note194"><b>194)</b></a></sup> A specification for imaginary types is in informative <a href="#G">annex G</a>.
-
-[<a name="p187" href="#p187">page 187</a>] (<a href="#Contents">Contents</a>)
-
-    Forward references: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
-<a name="7.3.2" href="#7.3.2"><b>    7.3.2 Conventions</b></a>
-1   Values are interpreted as radians, not degrees. An implementation may set errno but is
-    not required to.
-<a name="7.3.3" href="#7.3.3"><b>    7.3.3 Branch cuts</b></a>
-1   Some of the functions below have branch cuts, across which the function is
-    discontinuous. For implementations with a signed zero (including all IEC 60559
-    implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
-    one side of a cut from another so the function is continuous (except for format
-    limitations) as the cut is approached from either side. For example, for the square root
-    function, which has a branch cut along the negative real axis, the top of the cut, with
-    imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
-    imaginary part -0, maps to the negative imaginary axis.
-2   Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
-    sides of branch cuts. These implementations shall map a cut so the function is continuous
-    as the cut is approached coming around the finite endpoint of the cut in a counter
-    clockwise direction. (Branch cuts for the functions specified here have just one finite
-    endpoint.) For example, for the square root function, coming counter clockwise around
-    the finite endpoint of the cut along the negative real axis approaches the cut from above,
-    so the cut maps to the positive imaginary axis.
-<a name="7.3.4" href="#7.3.4"><b>    7.3.4 The CX_LIMITED_RANGE pragma</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           #pragma STDC CX_LIMITED_RANGE on-off-switch
-<b>    Description</b>
-2   The usual mathematical formulas for complex multiply, divide, and absolute value are
-    problematic because of their treatment of infinities and because of undue overflow and
-    underflow. The CX_LIMITED_RANGE pragma can be used to inform the
-    implementation that (where the state is ''on'') the usual mathematical formulas are
-    acceptable.<sup><a href="#note195"><b>195)</b></a></sup> The pragma can occur either outside external declarations or preceding all
-    explicit declarations and statements inside a compound statement. When outside external
-    declarations, the pragma takes effect from its occurrence until another
-    CX_LIMITED_RANGE pragma is encountered, or until the end of the translation unit.
-    When inside a compound statement, the pragma takes effect from its occurrence until
-    another CX_LIMITED_RANGE pragma is encountered (including within a nested
-    compound statement), or until the end of the compound statement; at the end of a
-    compound statement the state for the pragma is restored to its condition just before the
-
-[<a name="p188" href="#p188">page 188</a>] (<a href="#Contents">Contents</a>)
-
-    compound statement. If this pragma is used in any other context, the behavior is
-    undefined. The default state for the pragma is ''off''.
-<a name="7.3.5" href="#7.3.5"><b>    7.3.5 Trigonometric functions</b></a>
-<a name="7.3.5.1" href="#7.3.5.1"><b>    7.3.5.1 The cacos functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex cacos(double complex z);
-            float complex cacosf(float complex z);
-            long double complex cacosl(long double complex z);
-<b>    Description</b>
-2   The cacos functions compute the complex arc cosine of z, with branch cuts outside the
-    interval [-1, +1] along the real axis.
-<b>    Returns</b>
-3   The cacos functions return the complex arc cosine value, in the range of a strip
-    mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
-    real axis.
-<a name="7.3.5.2" href="#7.3.5.2"><b>    7.3.5.2 The casin functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex casin(double complex z);
-            float complex casinf(float complex z);
-            long double complex casinl(long double complex z);
-<b>    Description</b>
-2   The casin functions compute the complex arc sine of z, with branch cuts outside the
-    interval [-1, +1] along the real axis.
-<b>    Returns</b>
-3   The casin functions return the complex arc sine value, in the range of a strip
-    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
-
-    <sup><a name="note195" href="#note195"><b>195)</b></a></sup> The purpose of the pragma is to allow the implementation to use the formulas:
-            (x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
-            (x + iy) / (u + iv) = [(xu + yv) + i(yu - xv)]/(u2 + v 2 )
-            | x + iy | = (sqrt) x 2 + y 2
-                         -----
-         where the programmer can determine they are safe.
-
-[<a name="p189" href="#p189">page 189</a>] (<a href="#Contents">Contents</a>)
-
-    along the real axis.
-<a name="7.3.5.3" href="#7.3.5.3"><b>    7.3.5.3 The catan functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex catan(double complex z);
-           float complex catanf(float complex z);
-           long double complex catanl(long double complex z);
-<b>    Description</b>
-2   The catan functions compute the complex arc tangent of z, with branch cuts outside the
-    interval [-i, +i] along the imaginary axis.
-<b>    Returns</b>
-3   The catan functions return the complex arc tangent value, in the range of a strip
-    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
-    along the real axis.
-<a name="7.3.5.4" href="#7.3.5.4"><b>    7.3.5.4 The ccos functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex ccos(double complex z);
-           float complex ccosf(float complex z);
-           long double complex ccosl(long double complex z);
-<b>    Description</b>
-2   The ccos functions compute the complex cosine of z.
-<b>    Returns</b>
-3   The ccos functions return the complex cosine value.
-<a name="7.3.5.5" href="#7.3.5.5"><b>    7.3.5.5 The csin functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex csin(double complex z);
-           float complex csinf(float complex z);
-           long double complex csinl(long double complex z);
-<b>    Description</b>
-2   The csin functions compute the complex sine of z.
-
-[<a name="p190" href="#p190">page 190</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The csin functions return the complex sine value.
-<a name="7.3.5.6" href="#7.3.5.6"><b>    7.3.5.6 The ctan functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex ctan(double complex z);
-            float complex ctanf(float complex z);
-            long double complex ctanl(long double complex z);
-<b>    Description</b>
-2   The ctan functions compute the complex tangent of z.
-<b>    Returns</b>
-3   The ctan functions return the complex tangent value.
-<a name="7.3.6" href="#7.3.6"><b>    7.3.6 Hyperbolic functions</b></a>
-<a name="7.3.6.1" href="#7.3.6.1"><b>    7.3.6.1 The cacosh functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex cacosh(double complex z);
-            float complex cacoshf(float complex z);
-            long double complex cacoshl(long double complex z);
-<b>    Description</b>
-2   The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
-    cut at values less than 1 along the real axis.
-<b>    Returns</b>
-3   The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
-    half-strip of nonnegative values along the real axis and in the interval [-ipi , +ipi ] along the
-    imaginary axis.
-<a name="7.3.6.2" href="#7.3.6.2"><b>    7.3.6.2 The casinh functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex casinh(double complex z);
-            float complex casinhf(float complex z);
-            long double complex casinhl(long double complex z);
-
-[<a name="p191" href="#p191">page 191</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
-    outside the interval [-i, +i] along the imaginary axis.
-<b>    Returns</b>
-3   The casinh functions return the complex arc hyperbolic sine value, in the range of a
-    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
-    along the imaginary axis.
-<a name="7.3.6.3" href="#7.3.6.3"><b>    7.3.6.3 The catanh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex catanh(double complex z);
-           float complex catanhf(float complex z);
-           long double complex catanhl(long double complex z);
-<b>    Description</b>
-2   The catanh functions compute the complex arc hyperbolic tangent of z, with branch
-    cuts outside the interval [-1, +1] along the real axis.
-<b>    Returns</b>
-3   The catanh functions return the complex arc hyperbolic tangent value, in the range of a
-    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
-    along the imaginary axis.
-<a name="7.3.6.4" href="#7.3.6.4"><b>    7.3.6.4 The ccosh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex ccosh(double complex z);
-           float complex ccoshf(float complex z);
-           long double complex ccoshl(long double complex z);
-<b>    Description</b>
-2   The ccosh functions compute the complex hyperbolic cosine of z.
-<b>    Returns</b>
-3   The ccosh functions return the complex hyperbolic cosine value.
-
-[<a name="p192" href="#p192">page 192</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.6.5" href="#7.3.6.5"><b>    7.3.6.5 The csinh functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex csinh(double complex z);
-            float complex csinhf(float complex z);
-            long double complex csinhl(long double complex z);
-<b>    Description</b>
-2   The csinh functions compute the complex hyperbolic sine of z.
-<b>    Returns</b>
-3   The csinh functions return the complex hyperbolic sine value.
-<a name="7.3.6.6" href="#7.3.6.6"><b>    7.3.6.6 The ctanh functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex ctanh(double complex z);
-            float complex ctanhf(float complex z);
-            long double complex ctanhl(long double complex z);
-<b>    Description</b>
-2   The ctanh functions compute the complex hyperbolic tangent of z.
-<b>    Returns</b>
-3   The ctanh functions return the complex hyperbolic tangent value.
-<a name="7.3.7" href="#7.3.7"><b>    7.3.7 Exponential and logarithmic functions</b></a>
-<a name="7.3.7.1" href="#7.3.7.1"><b>    7.3.7.1 The cexp functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex cexp(double complex z);
-            float complex cexpf(float complex z);
-            long double complex cexpl(long double complex z);
-<b>    Description</b>
-2   The cexp functions compute the complex base-e exponential of z.
-<b>    Returns</b>
-3   The cexp functions return the complex base-e exponential value.
-
-[<a name="p193" href="#p193">page 193</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.7.2" href="#7.3.7.2"><b>    7.3.7.2 The clog functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex clog(double complex z);
-           float complex clogf(float complex z);
-           long double complex clogl(long double complex z);
-<b>    Description</b>
-2   The clog functions compute the complex natural (base-e) logarithm of z, with a branch
-    cut along the negative real axis.
-<b>    Returns</b>
-3   The clog functions return the complex natural logarithm value, in the range of a strip
-    mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
-    imaginary axis.
-<a name="7.3.8" href="#7.3.8"><b>    7.3.8 Power and absolute-value functions</b></a>
-<a name="7.3.8.1" href="#7.3.8.1"><b>    7.3.8.1 The cabs functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double cabs(double complex z);
-           float cabsf(float complex z);
-           long double cabsl(long double complex z);
-<b>    Description</b>
-2   The cabs functions compute the complex absolute value (also called norm, modulus, or
-    magnitude) of z.
-<b>    Returns</b>
-3   The cabs functions return the complex absolute value.
-<a name="7.3.8.2" href="#7.3.8.2"><b>    7.3.8.2 The cpow functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex cpow(double complex x, double complex y);
-           float complex cpowf(float complex x, float complex y);
-           long double complex cpowl(long double complex x,
-                long double complex y);
-
-[<a name="p194" href="#p194">page 194</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The cpow functions compute the complex power function xy , with a branch cut for the
-    first parameter along the negative real axis.
-<b>    Returns</b>
-3   The cpow functions return the complex power function value.
-<a name="7.3.8.3" href="#7.3.8.3"><b>    7.3.8.3 The csqrt functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex csqrt(double complex z);
-            float complex csqrtf(float complex z);
-            long double complex csqrtl(long double complex z);
-<b>    Description</b>
-2   The csqrt functions compute the complex square root of z, with a branch cut along the
-    negative real axis.
-<b>    Returns</b>
-3   The csqrt functions return the complex square root value, in the range of the right half-
-    plane (including the imaginary axis).
-<a name="7.3.9" href="#7.3.9"><b>    7.3.9 Manipulation functions</b></a>
-<a name="7.3.9.1" href="#7.3.9.1"><b>    7.3.9.1 The carg functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double carg(double complex z);
-            float cargf(float complex z);
-            long double cargl(long double complex z);
-<b>    Description</b>
-2   The carg functions compute the argument (also called phase angle) of z, with a branch
-    cut along the negative real axis.
-<b>    Returns</b>
-3   The carg functions return the value of the argument in the interval [-pi , +pi ].
-
-[<a name="p195" href="#p195">page 195</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.9.2" href="#7.3.9.2"><b>    7.3.9.2 The cimag functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double cimag(double complex z);
-           float cimagf(float complex z);
-           long double cimagl(long double complex z);
-<b>    Description</b>
-2   The cimag functions compute the imaginary part of z.<sup><a href="#note196"><b>196)</b></a></sup>
-<b>    Returns</b>
-3   The cimag functions return the imaginary part value (as a real).
-<a name="7.3.9.3" href="#7.3.9.3"><b>    7.3.9.3 The CMPLX macros</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.3">&lt;complex.h&gt;</a>
-           double complex CMPLX(double x, double y);
-           float complex CMPLXF(float x, float y);
-           long double complex CMPLXL(long double x, long double y);
-<b>    Description</b>
-2   The CMPLX macros expand to an expression of the specified complex type, with the real
-    part having the (converted) value of x and the imaginary part having the (converted)
-    value of y.
-    Recommended practice
-3   The resulting expression should be suitable for use as an initializer for an object with
-    static or thread storage duration, provided both arguments are likewise suitable.
-<b>    Returns</b>
-4   The CMPLX macros return the complex value x + i y.
-5   NOTE    These macros act as if the implementation supported imaginary types and the definitions were:
-          #define CMPLX(x, y)  ((double complex)((double)(x) + \
-                                        _Imaginary_I * (double)(y)))
-          #define CMPLXF(x, y) ((float complex)((float)(x) + \
-                                        _Imaginary_I * (float)(y)))
-          #define CMPLXL(x, y) ((long double complex)((long double)(x) + \
-                                        _Imaginary_I * (long double)(y)))
-
-
-
-
-    <sup><a name="note196" href="#note196"><b>196)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
-
-[<a name="p196" href="#p196">page 196</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.3.9.4" href="#7.3.9.4"><b>    7.3.9.4 The conj functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex conj(double complex z);
-            float complex conjf(float complex z);
-            long double complex conjl(long double complex z);
-<b>    Description</b>
-2   The conj functions compute the complex conjugate of z, by reversing the sign of its
-    imaginary part.
-<b>    Returns</b>
-3   The conj functions return the complex conjugate value.
-<a name="7.3.9.5" href="#7.3.9.5"><b>    7.3.9.5 The cproj functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double complex cproj(double complex z);
-            float complex cprojf(float complex z);
-            long double complex cprojl(long double complex z);
-<b>    Description</b>
-2   The cproj functions compute a projection of z onto the Riemann sphere: z projects to
-    z except that all complex infinities (even those with one infinite part and one NaN part)
-    project to positive infinity on the real axis. If z has an infinite part, then cproj(z) is
-    equivalent to
-            INFINITY + I * copysign(0.0, cimag(z))
-<b>    Returns</b>
-3   The cproj functions return the value of the projection onto the Riemann sphere.
-<a name="7.3.9.6" href="#7.3.9.6"><b>    7.3.9.6 The creal functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.3">&lt;complex.h&gt;</a>
-            double creal(double complex z);
-            float crealf(float complex z);
-            long double creall(long double complex z);
-<b>    Description</b>
-2   The creal functions compute the real part of z.<sup><a href="#note197"><b>197)</b></a></sup>
-
-[<a name="p197" href="#p197">page 197</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The creal functions return the real part value.
-
-
-
-
-    <sup><a name="note197" href="#note197"><b>197)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
-
-[<a name="p198" href="#p198">page 198</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.4" href="#7.4"><b>    7.4 Character handling &lt;ctype.h&gt;</b></a>
-1   The header <a href="#7.4">&lt;ctype.h&gt;</a> declares several functions useful for classifying and mapping
-    characters.<sup><a href="#note198"><b>198)</b></a></sup> In all cases the argument is an int, the value of which shall be
-    representable as an unsigned char or shall equal the value of the macro EOF. If the
-    argument has any other value, the behavior is undefined.
-2   The behavior of these functions is affected by the current locale. Those functions that
-    have locale-specific aspects only when not in the "C" locale are noted below.
-3   The term printing character refers to a member of a locale-specific set of characters, each
-    of which occupies one printing position on a display device; the term control character
-    refers to a member of a locale-specific set of characters that are not printing
-    characters.<sup><a href="#note199"><b>199)</b></a></sup> All letters and digits are printing characters.
-    Forward references: EOF (<a href="#7.21.1">7.21.1</a>), localization (<a href="#7.11">7.11</a>).
-<a name="7.4.1" href="#7.4.1"><b>    7.4.1 Character classification functions</b></a>
-1   The functions in this subclause return nonzero (true) if and only if the value of the
-    argument c conforms to that in the description of the function.
-<a name="7.4.1.1" href="#7.4.1.1"><b>    7.4.1.1 The isalnum function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
-             int isalnum(int c);
-<b>    Description</b>
-2   The isalnum function tests for any character for which isalpha or isdigit is true.
-<a name="7.4.1.2" href="#7.4.1.2"><b>    7.4.1.2 The isalpha function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
-             int isalpha(int c);
-<b>    Description</b>
-2   The isalpha function tests for any character for which isupper or islower is true,
-    or any character that is one of a locale-specific set of alphabetic characters for which
-
-
-
-    <sup><a name="note198" href="#note198"><b>198)</b></a></sup> See ''future library directions'' (<a href="#7.30.2">7.30.2</a>).
-    <sup><a name="note199" href="#note199"><b>199)</b></a></sup> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
-         whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
-         values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
-
-[<a name="p199" href="#p199">page 199</a>] (<a href="#Contents">Contents</a>)
-
-    none of iscntrl, isdigit, ispunct, or isspace is true.<sup><a href="#note200"><b>200)</b></a></sup> In the "C" locale,
-    isalpha returns true only for the characters for which isupper or islower is true.
-<a name="7.4.1.3" href="#7.4.1.3"><b>    7.4.1.3 The isblank function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isblank(int c);
-<b>    Description</b>
-2   The isblank function tests for any character that is a standard blank character or is one
-    of a locale-specific set of characters for which isspace is true and that is used to
-    separate words within a line of text. The standard blank characters are the following:
-    space (' '), and horizontal tab ('\t'). In the "C" locale, isblank returns true only
-    for the standard blank characters.
-<a name="7.4.1.4" href="#7.4.1.4"><b>    7.4.1.4 The iscntrl function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int iscntrl(int c);
-<b>    Description</b>
-2   The iscntrl function tests for any control character.
-<a name="7.4.1.5" href="#7.4.1.5"><b>    7.4.1.5 The isdigit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isdigit(int c);
-<b>    Description</b>
-2   The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.4.1.6" href="#7.4.1.6"><b>    7.4.1.6 The isgraph function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isgraph(int c);
-
-
-
-
-    <sup><a name="note200" href="#note200"><b>200)</b></a></sup> The functions islower and isupper test true or false separately for each of these additional
-         characters; all four combinations are possible.
-
-[<a name="p200" href="#p200">page 200</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The isgraph function tests for any printing character except space (' ').
-<a name="7.4.1.7" href="#7.4.1.7"><b>    7.4.1.7 The islower function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int islower(int c);
-<b>    Description</b>
-2   The islower function tests for any character that is a lowercase letter or is one of a
-    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
-    isspace is true. In the "C" locale, islower returns true only for the lowercase
-    letters (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.4.1.8" href="#7.4.1.8"><b>    7.4.1.8 The isprint function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isprint(int c);
-<b>    Description</b>
-2   The isprint function tests for any printing character including space (' ').
-<a name="7.4.1.9" href="#7.4.1.9"><b>    7.4.1.9 The ispunct function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int ispunct(int c);
-<b>    Description</b>
-2   The ispunct function tests for any printing character that is one of a locale-specific set
-    of punctuation characters for which neither isspace nor isalnum is true. In the "C"
-    locale, ispunct returns true for every printing character for which neither isspace
-    nor isalnum is true.
-<a name="7.4.1.10" href="#7.4.1.10"><b>    7.4.1.10 The isspace function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int isspace(int c);
-<b>    Description</b>
-2   The isspace function tests for any character that is a standard white-space character or
-    is one of a locale-specific set of characters for which isalnum is false. The standard
-
-[<a name="p201" href="#p201">page 201</a>] (<a href="#Contents">Contents</a>)
-
-    white-space characters are the following: space (' '), form feed ('\f'), new-line
-    ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). In the
-    "C" locale, isspace returns true only for the standard white-space characters.
-<a name="7.4.1.11" href="#7.4.1.11"><b>    7.4.1.11 The isupper function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int isupper(int c);
-<b>    Description</b>
-2   The isupper function tests for any character that is an uppercase letter or is one of a
-    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
-    isspace is true. In the "C" locale, isupper returns true only for the uppercase
-    letters (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.4.1.12" href="#7.4.1.12"><b>    7.4.1.12 The isxdigit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int isxdigit(int c);
-<b>    Description</b>
-2   The isxdigit function tests for any hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
-<a name="7.4.2" href="#7.4.2"><b>    7.4.2 Character case mapping functions</b></a>
-<a name="7.4.2.1" href="#7.4.2.1"><b>    7.4.2.1 The tolower function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
-           int tolower(int c);
-<b>    Description</b>
-2   The tolower function converts an uppercase letter to a corresponding lowercase letter.
-<b>    Returns</b>
-3   If the argument is a character for which isupper is true and there are one or more
-    corresponding characters, as specified by the current locale, for which islower is true,
-    the tolower function returns one of the corresponding characters (always the same one
-    for any given locale); otherwise, the argument is returned unchanged.
-
-[<a name="p202" href="#p202">page 202</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.4.2.2" href="#7.4.2.2"><b>    7.4.2.2 The toupper function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
-            int toupper(int c);
-<b>    Description</b>
-2   The toupper function converts a lowercase letter to a corresponding uppercase letter.
-<b>    Returns</b>
-3   If the argument is a character for which islower is true and there are one or more
-    corresponding characters, as specified by the current locale, for which isupper is true,
-    the toupper function returns one of the corresponding characters (always the same one
-    for any given locale); otherwise, the argument is returned unchanged.
-
-[<a name="p203" href="#p203">page 203</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.5" href="#7.5"><b>    7.5 Errors &lt;errno.h&gt;</b></a>
-1   The header <a href="#7.5">&lt;errno.h&gt;</a> defines several macros, all relating to the reporting of error
-    conditions.
-2   The macros are
-             EDOM
-             EILSEQ
-             ERANGE
-    which expand to integer constant expressions with type int, distinct positive values, and
-    which are suitable for use in #if preprocessing directives; and
-             errno
-    which expands to a modifiable lvalue<sup><a href="#note201"><b>201)</b></a></sup> that has type int and thread local storage
-    duration, the value of which is set to a positive error number by several library functions.
-    If a macro definition is suppressed in order to access an actual object, or a program
-    defines an identifier with the name errno, the behavior is undefined.
-3   The value of errno in the initial thread is zero at program startup (the initial value of
-    errno in other threads is an indeterminate value), but is never set to zero by any library
-    function.<sup><a href="#note202"><b>202)</b></a></sup> The value of errno may be set to nonzero by a library function call
-    whether or not there is an error, provided the use of errno is not documented in the
-    description of the function in this International Standard.
-4   Additional macro definitions, beginning with E and a digit or E and an uppercase
-    letter,<sup><a href="#note203"><b>203)</b></a></sup> may also be specified by the implementation.
-
-
-
-
-    <sup><a name="note201" href="#note201"><b>201)</b></a></sup> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
-         resulting from a function call (for example, *errno()).
-    <sup><a name="note202" href="#note202"><b>202)</b></a></sup> Thus, a program that uses errno for error checking should set it to zero before a library function call,
-         then inspect it before a subsequent library function call. Of course, a library function can save the
-         value of errno on entry and then set it to zero, as long as the original value is restored if errno's
-         value is still zero just before the return.
-    <sup><a name="note203" href="#note203"><b>203)</b></a></sup> See ''future library directions'' (<a href="#7.30.3">7.30.3</a>).
-
-[<a name="p204" href="#p204">page 204</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.6" href="#7.6"><b>    7.6 Floating-point environment &lt;fenv.h&gt;</b></a>
-1   The header <a href="#7.6">&lt;fenv.h&gt;</a> defines several macros, and declares types and functions that
-    provide access to the floating-point environment. The floating-point environment refers
-    collectively to any floating-point status flags and control modes supported by the
-    implementation.<sup><a href="#note204"><b>204)</b></a></sup> A floating-point status flag is a system variable whose value is set
-    (but never cleared) when a floating-point exception is raised, which occurs as a side effect
-    of exceptional floating-point arithmetic to provide auxiliary information.<sup><a href="#note205"><b>205)</b></a></sup> A floating-
-    point control mode is a system variable whose value may be set by the user to affect the
-    subsequent behavior of floating-point arithmetic.
-2   The floating-point environment has thread storage duration. The initial state for a
-    thread's floating-point environment is the current state of the floating-point environment
-    of the thread that creates it at the time of creation.
-3   Certain programming conventions support the intended model of use for the floating-
-    point environment:<sup><a href="#note206"><b>206)</b></a></sup>
-    -- a function call does not alter its caller's floating-point control modes, clear its caller's
-      floating-point status flags, nor depend on the state of its caller's floating-point status
-      flags unless the function is so documented;
-    -- a function call is assumed to require default floating-point control modes, unless its
-      documentation promises otherwise;
-    -- a function call is assumed to have the potential for raising floating-point exceptions,
-      unless its documentation promises otherwise.
-4   The type
-            fenv_t
-    represents the entire floating-point environment.
-5   The type
-            fexcept_t
-    represents the floating-point status flags collectively, including any status the
-    implementation associates with the flags.
-
-
-    <sup><a name="note204" href="#note204"><b>204)</b></a></sup> This header is designed to support the floating-point exception status flags and directed-rounding
-         control modes required by IEC 60559, and other similar floating-point state information. It is also
-         designed to facilitate code portability among all systems.
-    <sup><a name="note205" href="#note205"><b>205)</b></a></sup> A floating-point status flag is not an object and can be set more than once within an expression.
-    <sup><a name="note206" href="#note206"><b>206)</b></a></sup> With these conventions, a programmer can safely assume default floating-point control modes (or be
-         unaware of them). The responsibilities associated with accessing the floating-point environment fall
-         on the programmer or program that does so explicitly.
-
-[<a name="p205" href="#p205">page 205</a>] (<a href="#Contents">Contents</a>)
-
-6   Each of the macros
-             FE_DIVBYZERO
-             FE_INEXACT
-             FE_INVALID
-             FE_OVERFLOW
-             FE_UNDERFLOW
-    is defined if and only if the implementation supports the floating-point exception by
-    means of the functions in 7.6.2.<sup><a href="#note207"><b>207)</b></a></sup> Additional implementation-defined floating-point
-    exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
-    be specified by the implementation. The defined macros expand to integer constant
-    expressions with values such that bitwise ORs of all combinations of the macros result in
-    distinct values, and furthermore, bitwise ANDs of all combinations of the macros result in
-    zero.<sup><a href="#note208"><b>208)</b></a></sup>
-7   The macro
-             FE_ALL_EXCEPT
-    is simply the bitwise OR of all floating-point exception macros defined by the
-    implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
-8   Each of the macros
-             FE_DOWNWARD
-             FE_TONEAREST
-             FE_TOWARDZERO
-             FE_UPWARD
-    is defined if and only if the implementation supports getting and setting the represented
-    rounding direction by means of the fegetround and fesetround functions.
-    Additional implementation-defined rounding directions, with macro definitions beginning
-    with FE_ and an uppercase letter, may also be specified by the implementation. The
-    defined macros expand to integer constant expressions whose values are distinct
-    nonnegative values.<sup><a href="#note209"><b>209)</b></a></sup>
-9   The macro
-
-
-
-    <sup><a name="note207" href="#note207"><b>207)</b></a></sup> The implementation supports a floating-point exception if there are circumstances where a call to at
-         least one of the functions in <a href="#7.6.2">7.6.2</a>, using the macro as the appropriate argument, will succeed. It is not
-         necessary for all the functions to succeed all the time.
-    <sup><a name="note208" href="#note208"><b>208)</b></a></sup> The macros should be distinct powers of two.
-    <sup><a name="note209" href="#note209"><b>209)</b></a></sup> Even though the rounding direction macros may expand to constants corresponding to the values of
-         FLT_ROUNDS, they are not required to do so.
-
-[<a name="p206" href="#p206">page 206</a>] (<a href="#Contents">Contents</a>)
-
-              FE_DFL_ENV
-     represents the default floating-point environment -- the one installed at program startup
-     -- and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
-     <a href="#7.6">&lt;fenv.h&gt;</a> functions that manage the floating-point environment.
-10   Additional implementation-defined environments, with macro definitions beginning with
-     FE_ and an uppercase letter, and having type ''pointer to const-qualified fenv_t'', may
-     also be specified by the implementation.
-<a name="7.6.1" href="#7.6.1"><b>     7.6.1 The FENV_ACCESS pragma</b></a>
-<b>     Synopsis</b>
-1             #include <a href="#7.6">&lt;fenv.h&gt;</a>
-              #pragma STDC FENV_ACCESS on-off-switch
-<b>     Description</b>
-2    The FENV_ACCESS pragma provides a means to inform the implementation when a
-     program might access the floating-point environment to test floating-point status flags or
-     run under non-default floating-point control modes.<sup><a href="#note210"><b>210)</b></a></sup> The pragma shall occur either
-     outside external declarations or preceding all explicit declarations and statements inside a
-     compound statement. When outside external declarations, the pragma takes effect from
-     its occurrence until another FENV_ACCESS pragma is encountered, or until the end of
-     the translation unit. When inside a compound statement, the pragma takes effect from its
-     occurrence until another FENV_ACCESS pragma is encountered (including within a
-     nested compound statement), or until the end of the compound statement; at the end of a
-     compound statement the state for the pragma is restored to its condition just before the
-     compound statement. If this pragma is used in any other context, the behavior is
-     undefined. If part of a program tests floating-point status flags, sets floating-point control
-     modes, or runs under non-default mode settings, but was translated with the state for the
-     FENV_ACCESS pragma ''off'', the behavior is undefined. The default state (''on'' or
-     ''off'') for the pragma is implementation-defined. (When execution passes from a part of
-     the program translated with FENV_ACCESS ''off'' to a part translated with
-     FENV_ACCESS ''on'', the state of the floating-point status flags is unspecified and the
-     floating-point control modes have their default settings.)
-
-
-
-
-     <sup><a name="note210" href="#note210"><b>210)</b></a></sup> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
-          tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
-          folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
-          modes are in effect and the flags are not tested.
-
-[<a name="p207" href="#p207">page 207</a>] (<a href="#Contents">Contents</a>)
-
-3   EXAMPLE
-            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            void f(double x)
-            {
-                  #pragma STDC FENV_ACCESS ON
-                  void g(double);
-                  void h(double);
-                  /* ... */
-                  g(x + 1);
-                  h(x + 1);
-                  /* ... */
+                    continue;
             }
-4   If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
-    x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
-    contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note211"><b>211)</b></a></sup>
-
-<a name="7.6.2" href="#7.6.2"><b>    7.6.2 Floating-point exceptions</b></a>
-1   The following functions provide access to the floating-point status flags.<sup><a href="#note212"><b>212)</b></a></sup> The int
-    input argument for the functions represents a subset of floating-point exceptions, and can
-    be zero or the bitwise OR of one or more floating-point exception macros, for example
-    FE_OVERFLOW | FE_INEXACT. For other argument values the behavior of these
-    functions is undefined.
-<a name="7.6.2.1" href="#7.6.2.1"><b>    7.6.2.1 The feclearexcept function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int feclearexcept(int excepts);
-<b>    Description</b>
-2   The feclearexcept function attempts to clear the supported floating-point exceptions
-    represented by its argument.
-<b>    Returns</b>
-3   The feclearexcept function returns zero if the excepts argument is zero or if all
-    the specified exceptions were successfully cleared. Otherwise, it returns a nonzero value.
-
-
-    <sup><a name="note211" href="#note211"><b>211)</b></a></sup> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
-         hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
-         ''off'', just one evaluation of x + 1 would suffice.
-    <sup><a name="note212" href="#note212"><b>212)</b></a></sup> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
-         abstraction of flags that are either set or clear. An implementation may endow floating-point status
-         flags with more information -- for example, the address of the code which first raised the floating-
-         point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
-         content of flags.
-
-[<a name="p208" href="#p208">page 208</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.6.2.2" href="#7.6.2.2"><b>    7.6.2.2 The fegetexceptflag function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             int fegetexceptflag(fexcept_t *flagp,
-                  int excepts);
-<b>    Description</b>
-2   The fegetexceptflag function attempts to store an implementation-defined
-    representation of the states of the floating-point status flags indicated by the argument
-    excepts in the object pointed to by the argument flagp.
-<b>    Returns</b>
-3   The fegetexceptflag function returns zero if the representation was successfully
-    stored. Otherwise, it returns a nonzero value.
-<a name="7.6.2.3" href="#7.6.2.3"><b>    7.6.2.3 The feraiseexcept function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             int feraiseexcept(int excepts);
-<b>    Description</b>
-2   The feraiseexcept function attempts to raise the supported floating-point exceptions
-    represented by its argument.<sup><a href="#note213"><b>213)</b></a></sup> The order in which these floating-point exceptions are
-    raised is unspecified, except as stated in <a href="#F.8.6">F.8.6</a>. Whether the feraiseexcept function
-    additionally raises the ''inexact'' floating-point exception whenever it raises the
-    ''overflow'' or ''underflow'' floating-point exception is implementation-defined.
-<b>    Returns</b>
-3   The feraiseexcept function returns zero if the excepts argument is zero or if all
-    the specified exceptions were successfully raised. Otherwise, it returns a nonzero value.
-
-
-
-
-    <sup><a name="note213" href="#note213"><b>213)</b></a></sup> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
-         Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
-         in <a href="#F.8.6">F.8.6</a> is in the same spirit.
-
-[<a name="p209" href="#p209">page 209</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.6.2.4" href="#7.6.2.4"><b>    7.6.2.4 The fesetexceptflag function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fesetexceptflag(const fexcept_t *flagp,
-                 int excepts);
-<b>    Description</b>
-2   The fesetexceptflag function attempts to set the floating-point status flags
-    indicated by the argument excepts to the states stored in the object pointed to by
-    flagp. The value of *flagp shall have been set by a previous call to
-    fegetexceptflag whose second argument represented at least those floating-point
-    exceptions represented by the argument excepts. This function does not raise floating-
-    point exceptions, but only sets the state of the flags.
-<b>    Returns</b>
-3   The fesetexceptflag function returns zero if the excepts argument is zero or if
-    all the specified flags were successfully set to the appropriate state. Otherwise, it returns
-    a nonzero value.
-<a name="7.6.2.5" href="#7.6.2.5"><b>    7.6.2.5 The fetestexcept function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fetestexcept(int excepts);
-<b>    Description</b>
-2   The fetestexcept function determines which of a specified subset of the floating-
-    point exception flags are currently set. The excepts argument specifies the floating-
-    point status flags to be queried.<sup><a href="#note214"><b>214)</b></a></sup>
-<b>    Returns</b>
-3   The fetestexcept function returns the value of the bitwise OR of the floating-point
-    exception macros corresponding to the currently set floating-point exceptions included in
-    excepts.
-4   EXAMPLE       Call f if ''invalid'' is set, then g if ''overflow'' is set:
-
-
-
-
-    <sup><a name="note214" href="#note214"><b>214)</b></a></sup> This mechanism allows testing several floating-point exceptions with just one function call.
-
-[<a name="p210" href="#p210">page 210</a>] (<a href="#Contents">Contents</a>)
-
-            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            // handle other operations
             /* ... */
-            {
-                    #pragma STDC FENV_ACCESS ON
-                    int set_excepts;
-                    feclearexcept(FE_INVALID | FE_OVERFLOW);
-                    // maybe raise exceptions
-                    set_excepts = fetestexcept(FE_INVALID | FE_OVERFLOW);
-                    if (set_excepts &amp; FE_INVALID) f();
-                    if (set_excepts &amp; FE_OVERFLOW) g();
-                    /* ... */
-            }
-
-<a name="7.6.3" href="#7.6.3"><b>    7.6.3 Rounding</b></a>
-1   The fegetround and fesetround functions provide control of rounding direction
-    modes.
-<a name="7.6.3.1" href="#7.6.3.1"><b>    7.6.3.1 The fegetround function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fegetround(void);
-<b>    Description</b>
-2   The fegetround function gets the current rounding direction.
-<b>    Returns</b>
-3   The fegetround function returns the value of the rounding direction macro
-    representing the current rounding direction or a negative value if there is no such
-    rounding direction macro or the current rounding direction is not determinable.
-<a name="7.6.3.2" href="#7.6.3.2"><b>    7.6.3.2 The fesetround function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fesetround(int round);
-<b>    Description</b>
-2   The fesetround function establishes the rounding direction represented by its
-    argument round. If the argument is not equal to the value of a rounding direction macro,
-    the rounding direction is not changed.
-<b>    Returns</b>
-3   The fesetround function returns zero if and only if the requested rounding direction
-    was established.
-
-[<a name="p211" href="#p211">page 211</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
-    rounding direction fails.
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           #include <a href="#7.2">&lt;assert.h&gt;</a>
-           void f(int round_dir)
-           {
-                 #pragma STDC FENV_ACCESS ON
-                 int save_round;
-                 int setround_ok;
-                 save_round = fegetround();
-                 setround_ok = fesetround(round_dir);
-                 assert(setround_ok == 0);
-                 /* ... */
-                 fesetround(save_round);
-                 /* ... */
-           }
-
-<a name="7.6.4" href="#7.6.4"><b>    7.6.4 Environment</b></a>
-1   The functions in this section manage the floating-point environment -- status flags and
-    control modes -- as one entity.
-<a name="7.6.4.1" href="#7.6.4.1"><b>    7.6.4.1 The fegetenv function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           int fegetenv(fenv_t *envp);
-<b>    Description</b>
-2   The fegetenv function attempts to store the current floating-point environment in the
-    object pointed to by envp.
-<b>    Returns</b>
-3   The fegetenv function returns zero if the environment was successfully stored.
-    Otherwise, it returns a nonzero value.
-<a name="7.6.4.2" href="#7.6.4.2"><b>    7.6.4.2 The feholdexcept function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           int feholdexcept(fenv_t *envp);
-<b>    Description</b>
-2   The feholdexcept function saves the current floating-point environment in the object
-    pointed to by envp, clears the floating-point status flags, and then installs a non-stop
-    (continue on floating-point exceptions) mode, if available, for all floating-point
-    exceptions.<sup><a href="#note215"><b>215)</b></a></sup>
-
-[<a name="p212" href="#p212">page 212</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The feholdexcept function returns zero if and only if non-stop floating-point
-    exception handling was successfully installed.
-<a name="7.6.4.3" href="#7.6.4.3"><b>    7.6.4.3 The fesetenv function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int fesetenv(const fenv_t *envp);
-<b>    Description</b>
-2   The fesetenv function attempts to establish the floating-point environment represented
-    by the object pointed to by envp. The argument envp shall point to an object set by a
-    call to fegetenv or feholdexcept, or equal a floating-point environment macro.
-    Note that fesetenv merely installs the state of the floating-point status flags
-    represented through its argument, and does not raise these floating-point exceptions.
-<b>    Returns</b>
-3   The fesetenv function returns zero if the environment was successfully established.
-    Otherwise, it returns a nonzero value.
-<a name="7.6.4.4" href="#7.6.4.4"><b>    7.6.4.4 The feupdateenv function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            int feupdateenv(const fenv_t *envp);
-<b>    Description</b>
-2   The feupdateenv function attempts to save the currently raised floating-point
-    exceptions in its automatic storage, install the floating-point environment represented by
-    the object pointed to by envp, and then raise the saved floating-point exceptions. The
-    argument envp shall point to an object set by a call to feholdexcept or fegetenv,
-    or equal a floating-point environment macro.
-<b>    Returns</b>
-3   The feupdateenv function returns zero if all the actions were successfully carried out.
-    Otherwise, it returns a nonzero value.
-
-
-
-
-    <sup><a name="note215" href="#note215"><b>215)</b></a></sup> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
-         handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
-         such systems, the feholdexcept function can be used in conjunction with the feupdateenv
-         function to write routines that hide spurious floating-point exceptions from their callers.
-
-[<a name="p213" href="#p213">page 213</a>] (<a href="#Contents">Contents</a>)
-
-4   EXAMPLE   Hide spurious underflow floating-point exceptions:
-          #include <a href="#7.6">&lt;fenv.h&gt;</a>
-          double f(double x)
+    }</pre>
+ EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
+ modified types. A jump within the scope, however, is permitted.
+<pre>
+         goto lab3;                         // invalid: going INTO scope of VLA.
+         {
+               double a[n];
+               a[j] = <a href="#4.4">4.4</a>;
+         lab3:
+               a[j] = <a href="#3.3">3.3</a>;
+               goto lab4;                   // valid: going WITHIN scope of VLA.
+               a[j] = <a href="#5.5">5.5</a>;
+         lab4:
+               a[j] = <a href="#6.6">6.6</a>;
+         }
+         goto lab4;                         // invalid: going INTO scope of VLA.</pre>
+ 
+
+<a name="6.8.6.2" href="#6.8.6.2"><h5>6.8.6.2 The continue statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A continue statement shall appear only in or as a loop body.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A continue statement causes a jump to the loop-continuation portion of the smallest
+ enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
+ of the statements
+ while (/* ... */) {                  do {                                 for (/* ... */) {
+<pre>
+    /* ... */                            /* ... */                            /* ... */
+    continue;                            continue;                            continue;
+    /* ... */                            /* ... */                            /* ... */</pre>
+ contin: ;                            contin: ;                            contin: ;
+ }                                    } while (/* ... */);                 }
+ unless the continue statement shown is in an enclosed iteration statement (in which
+ case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note159"><b>159)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note159">159)</a> Following the contin: label is a null statement.
+
+
+<a name="6.8.6.3" href="#6.8.6.3"><h5>6.8.6.3 The break statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A break statement shall appear only in or as a switch body or loop body.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A break statement terminates execution of the smallest enclosing switch or iteration
+ statement.
+ 
+ 
+ 
+<!--page 171 indent 4-->
+
+<a name="6.8.6.4" href="#6.8.6.4"><h5>6.8.6.4 The return statement</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A return statement with an expression shall not appear in a function whose return type
+ is void. A return statement without an expression shall only appear in a function
+ whose return type is void.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A return statement terminates execution of the current function and returns control to
+ its caller. A function may have any number of return statements.
+<p><!--para 3-->
+ If a return statement with an expression is executed, the value of the expression is
+ returned to the caller as the value of the function call expression. If the expression has a
+ type different from the return type of the function in which it appears, the value is
+ converted as if by assignment to an object having the return type of the function.<sup><a href="#note160"><b>160)</b></a></sup>
+<p><!--para 4-->
+ EXAMPLE       In:
+<pre>
+         struct s { double i; } f(void);
+         union {
+               struct {
+                     int f1;
+                     struct s f2;
+               } u1;
+               struct {
+                     struct s f3;
+                     int f4;
+               } u2;
+         } g;
+         struct s f(void)
+         {
+               return g.u1.f2;
+         }
+         /* ... */
+         g.u2.f3 = f();</pre>
+ there is no undefined behavior, although there would be if the assignment were done directly (without using
+ a function call to fetch the value).
+ 
+ 
+ 
+ 
+<!--page 172 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note160">160)</a> The return statement is not an assignment. The overlap restriction of subclause <a href="#6.5.16.1">6.5.16.1</a> does not
+ apply to the case of function return. The representation of floating-point values may have wider range
+ or precision than implied by the type; a cast may be used to remove this extra range and precision.
+
+
+<a name="6.9" href="#6.9"><h3>6.9 External definitions</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          translation-unit:
+                  external-declaration
+                  translation-unit external-declaration
+          external-declaration:
+                 function-definition
+                 declaration</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The storage-class specifiers auto and register shall not appear in the declaration
+ specifiers in an external declaration.
+<p><!--para 3-->
+ There shall be no more than one external definition for each identifier declared with
+ internal linkage in a translation unit. Moreover, if an identifier declared with internal
+ linkage is used in an expression (other than as a part of the operand of a sizeof
+ operator whose result is an integer constant), there shall be exactly one external definition
+ for the identifier in the translation unit.
+<h6>Semantics</h6>
+<p><!--para 4-->
+ As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
+ which consists of a sequence of external declarations. These are described as ''external''
+ because they appear outside any function (and hence have file scope). As discussed in
+ <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
+ by the identifier is a definition.
+<p><!--para 5-->
+ An external definition is an external declaration that is also a definition of a function
+ (other than an inline definition) or an object. If an identifier declared with external
+ linkage is used in an expression (other than as part of the operand of a sizeof operator
+ whose result is an integer constant), somewhere in the entire program there shall be
+ exactly one external definition for the identifier; otherwise, there shall be no more than
+ one.<sup><a href="#note161"><b>161)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 173 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note161">161)</a> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
+ external definition for it.
+
+
+<a name="6.9.1" href="#6.9.1"><h4>6.9.1 Function definitions</h4></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<pre>
+          function-definition:
+                 declaration-specifiers declarator declaration-listopt compound-statement
+          declaration-list:
+                 declaration
+                 declaration-list declaration</pre>
+<h6>Constraints</h6>
+<p><!--para 2-->
+ The identifier declared in a function definition (which is the name of the function) shall
+ have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note162"><b>162)</b></a></sup>
+<p><!--para 3-->
+ The return type of a function shall be void or a complete object type other than array
+ type.
+<p><!--para 4-->
+ The storage-class specifier, if any, in the declaration specifiers shall be either extern or
+ static.
+<p><!--para 5-->
+ If the declarator includes a parameter type list, the declaration of each parameter shall
+ include an identifier, except for the special case of a parameter list consisting of a single
+ parameter of type void, in which case there shall not be an identifier. No declaration list
+ shall follow.
+<p><!--para 6-->
+ If the declarator includes an identifier list, each declaration in the declaration list shall
+ have at least one declarator, those declarators shall declare only identifiers from the
+ identifier list, and every identifier in the identifier list shall be declared. An identifier
+ declared as a typedef name shall not be redeclared as a parameter. The declarations in the
+ declaration list shall contain no storage-class specifier other than register and no
+ initializations.
+ 
+ 
+ 
+<!--page 174 indent 5-->
+<h6>Semantics</h6>
+<p><!--para 7-->
+ The declarator in a function definition specifies the name of the function being defined
+ and the identifiers of its parameters. If the declarator includes a parameter type list, the
+ list also specifies the types of all the parameters; such a declarator also serves as a
+ function prototype for later calls to the same function in the same translation unit. If the
+ declarator includes an identifier list,<sup><a href="#note163"><b>163)</b></a></sup> the types of the parameters shall be declared in a
+ following declaration list. In either case, the type of each parameter is adjusted as
+ described in <a href="#6.7.6.3">6.7.6.3</a> for a parameter type list; the resulting type shall be a complete object
+ type.
+<p><!--para 8-->
+ If a function that accepts a variable number of arguments is defined without a parameter
+ type list that ends with the ellipsis notation, the behavior is undefined.
+<p><!--para 9-->
+ Each parameter has automatic storage duration; its identifier is an lvalue.<sup><a href="#note164"><b>164)</b></a></sup> The layout
+ of the storage for parameters is unspecified.
+<p><!--para 10-->
+ On entry to the function, the size expressions of each variably modified parameter are
+ evaluated and the value of each argument expression is converted to the type of the
+ corresponding parameter as if by assignment. (Array expressions and function
+ designators as arguments were converted to pointers before the call.)
+<p><!--para 11-->
+ After all parameters have been assigned, the compound statement that constitutes the
+ body of the function definition is executed.
+<p><!--para 12-->
+ If the } that terminates a function is reached, and the value of the function call is used by
+ the caller, the behavior is undefined.
+<p><!--para 13-->
+ EXAMPLE 1       In the following:
+<pre>
+          extern int max(int a, int b)
           {
-                #pragma STDC FENV_ACCESS ON
-                double result;
-                fenv_t save_env;
-                if (feholdexcept(&amp;save_env))
-                      return /* indication of an environmental problem */;
-                // compute result
-                if (/* test spurious underflow */)
-                      if (feclearexcept(FE_UNDERFLOW))
-                               return /* indication of an environmental problem */;
-                if (feupdateenv(&amp;save_env))
-                      return /* indication of an environmental problem */;
-                return result;
-          }
-
-[<a name="p214" href="#p214">page 214</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.7" href="#7.7"><b>    7.7 Characteristics of floating types &lt;float.h&gt;</b></a>
-1   The header <a href="#7.7">&lt;float.h&gt;</a> defines several macros that expand to various limits and
-    parameters of the standard floating-point types.
-2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
-    in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
-
-[<a name="p215" href="#p215">page 215</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.8" href="#7.8"><b>    7.8 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
-1   The header <a href="#7.8">&lt;inttypes.h&gt;</a> includes the header <a href="#7.20">&lt;stdint.h&gt;</a> and extends it with
-    additional facilities provided by hosted implementations.
-2   It declares functions for manipulating greatest-width integers and converting numeric
-    character strings to greatest-width integers, and it declares the type
-             imaxdiv_t
-    which is a structure type that is the type of the value returned by the imaxdiv function.
-    For each type declared in <a href="#7.20">&lt;stdint.h&gt;</a>, it defines corresponding macros for conversion
-    specifiers for use with the formatted input/output functions.<sup><a href="#note216"><b>216)</b></a></sup>
-    Forward references: integer types <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#7.20">7.20</a>), formatted input/output
-    functions (<a href="#7.21.6">7.21.6</a>), formatted wide character input/output functions (<a href="#7.28.2">7.28.2</a>).
-<a name="7.8.1" href="#7.8.1"><b>    7.8.1 Macros for format specifiers</b></a>
-1   Each of the following object-like macros expands to a character string literal containing a *
-    conversion specifier, possibly modified by a length modifier, suitable for use within the
-    format argument of a formatted input/output function when converting the corresponding
-    integer type. These macro names have the general form of PRI (character string literals
-    for the fprintf and fwprintf family) or SCN (character string literals for the
-    fscanf and fwscanf family),<sup><a href="#note217"><b>217)</b></a></sup> followed by the conversion specifier, followed by a
-    name corresponding to a similar type name in <a href="#7.20.1">7.20.1</a>. In these names, N represents the
-    width of the type as described in <a href="#7.20.1">7.20.1</a>. For example, PRIdFAST32 can be used in a
-    format string to print the value of an integer of type int_fast32_t.
-2   The fprintf macros for signed integers are:
-           PRIdN             PRIdLEASTN                PRIdFASTN          PRIdMAX             PRIdPTR
-           PRIiN             PRIiLEASTN                PRIiFASTN          PRIiMAX             PRIiPTR
-3   The fprintf macros for unsigned integers are:
-           PRIoN             PRIoLEASTN                PRIoFASTN          PRIoMAX             PRIoPTR
-           PRIuN             PRIuLEASTN                PRIuFASTN          PRIuMAX             PRIuPTR
-           PRIxN             PRIxLEASTN                PRIxFASTN          PRIxMAX             PRIxPTR
-           PRIXN             PRIXLEASTN                PRIXFASTN          PRIXMAX             PRIXPTR
-4   The fscanf macros for signed integers are:
-
-
-
-    <sup><a name="note216" href="#note216"><b>216)</b></a></sup> See ''future library directions'' (<a href="#7.30.4">7.30.4</a>).
-    <sup><a name="note217" href="#note217"><b>217)</b></a></sup> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
-         different format specifiers may be required for fprintf and fscanf, even when the type is the
-         same.
-
-[<a name="p216" href="#p216">page 216</a>] (<a href="#Contents">Contents</a>)
-
-           SCNdN           SCNdLEASTN               SCNdFASTN              SCNdMAX             SCNdPTR
-           SCNiN           SCNiLEASTN               SCNiFASTN              SCNiMAX             SCNiPTR
-5   The fscanf macros for unsigned integers are:
-           SCNoN           SCNoLEASTN               SCNoFASTN              SCNoMAX             SCNoPTR
-           SCNuN           SCNuLEASTN               SCNuFASTN              SCNuMAX             SCNuPTR
-           SCNxN           SCNxLEASTN               SCNxFASTN              SCNxMAX             SCNxPTR
-6   For each type that the implementation provides in <a href="#7.20">&lt;stdint.h&gt;</a>, the corresponding
-    fprintf macros shall be defined and the corresponding fscanf macros shall be
-    defined unless the implementation does not have a suitable fscanf length modifier for
-    the type.
-7   EXAMPLE
-            #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int main(void)
-            {
-                  uintmax_t i = UINTMAX_MAX;    // this type always exists
-                  wprintf(L"The largest integer value is %020"
-                        PRIxMAX "\n", i);
-                  return 0;
-            }
-
-<a name="7.8.2" href="#7.8.2"><b>    7.8.2 Functions for greatest-width integer types</b></a>
-<a name="7.8.2.1" href="#7.8.2.1"><b>    7.8.2.1 The imaxabs function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-            intmax_t imaxabs(intmax_t j);
-<b>    Description</b>
-2   The imaxabs function computes the absolute value of an integer j. If the result cannot
-    be represented, the behavior is undefined.<sup><a href="#note218"><b>218)</b></a></sup>
-<b>    Returns</b>
-3   The imaxabs function returns the absolute value.
-
-
-
-
-    <sup><a name="note218" href="#note218"><b>218)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
-
-[<a name="p217" href="#p217">page 217</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.8.2.2" href="#7.8.2.2"><b>    7.8.2.2 The imaxdiv function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-           imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
-<b>    Description</b>
-2   The imaxdiv function computes numer / denom and numer % denom in a single
-    operation.
-<b>    Returns</b>
-3   The imaxdiv function returns a structure of type imaxdiv_t comprising both the
-    quotient and the remainder. The structure shall contain (in either order) the members
-    quot (the quotient) and rem (the remainder), each of which has type intmax_t. If
-    either part of the result cannot be represented, the behavior is undefined.
-<a name="7.8.2.3" href="#7.8.2.3"><b>    7.8.2.3 The strtoimax and strtoumax functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-           intmax_t strtoimax(const char * restrict nptr,
-                char ** restrict endptr, int base);
-           uintmax_t strtoumax(const char * restrict nptr,
-                char ** restrict endptr, int base);
-<b>    Description</b>
-2   The strtoimax and strtoumax functions are equivalent to the strtol, strtoll,
-    strtoul, and strtoull functions, except that the initial portion of the string is
-    converted to intmax_t and uintmax_t representation, respectively.
-<b>    Returns</b>
-3   The strtoimax and strtoumax functions return the converted value, if any. If no
-    conversion could be performed, zero is returned. If the correct value is outside the range
-    of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
-    (according to the return type and sign of the value, if any), and the value of the macro
-    ERANGE is stored in errno.
-    Forward references: the strtol, strtoll, strtoul, and strtoull functions
-    (<a href="#7.22.1.4">7.22.1.4</a>).
-
-[<a name="p218" href="#p218">page 218</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.8.2.4" href="#7.8.2.4"><b>    7.8.2.4 The wcstoimax and wcstoumax functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.19">&lt;stddef.h&gt;</a>           // for wchar_t
-            #include <a href="#7.8">&lt;inttypes.h&gt;</a>
-            intmax_t wcstoimax(const wchar_t * restrict nptr,
-                 wchar_t ** restrict endptr, int base);
-            uintmax_t wcstoumax(const wchar_t * restrict nptr,
-                 wchar_t ** restrict endptr, int base);
-<b>    Description</b>
-2   The wcstoimax and wcstoumax functions are equivalent to the wcstol, wcstoll,
-    wcstoul, and wcstoull functions except that the initial portion of the wide string is
-    converted to intmax_t and uintmax_t representation, respectively.
-<b>    Returns</b>
-3   The wcstoimax function returns the converted value, if any. If no conversion could be
-    performed, zero is returned. If the correct value is outside the range of representable
-    values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
-    return type and sign of the value, if any), and the value of the macro ERANGE is stored in
-    errno.
-    Forward references: the wcstol, wcstoll, wcstoul, and wcstoull functions
-    (<a href="#7.28.4.1.2">7.28.4.1.2</a>).
-
-[<a name="p219" href="#p219">page 219</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.9" href="#7.9"><b>    7.9 Alternative spellings &lt;iso646.h&gt;</b></a>
-1   The header <a href="#7.9">&lt;iso646.h&gt;</a> defines the following eleven macros (on the left) that expand
-    to the corresponding tokens (on the right):
-          and           &amp;&amp;
-          and_eq        &amp;=
-          bitand        &amp;
-          bitor         |
-          compl         ~
-          not           !
-          not_eq        !=
-          or            ||
-          or_eq         |=
-          xor           ^
-          xor_eq        ^=
-
-[<a name="p220" href="#p220">page 220</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.10" href="#7.10"><b>    7.10 Sizes of integer types &lt;limits.h&gt;</b></a>
-1   The header <a href="#7.10">&lt;limits.h&gt;</a> defines several macros that expand to various limits and
-    parameters of the standard integer types.
-2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
-    in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
-
-[<a name="p221" href="#p221">page 221</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.11" href="#7.11"><b>    7.11 Localization &lt;locale.h&gt;</b></a>
-1   The header <a href="#7.11">&lt;locale.h&gt;</a> declares two functions, one type, and defines several macros.
-2   The type is
-           struct lconv
-    which contains members related to the formatting of numeric values. The structure shall
-    contain at least the following members, in any order. The semantics of the members and
-    their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
-    the values specified in the comments.
-           char   *decimal_point;                 //   "."
-           char   *thousands_sep;                 //   ""
-           char   *grouping;                      //   ""
-           char   *mon_decimal_point;             //   ""
-           char   *mon_thousands_sep;             //   ""
-           char   *mon_grouping;                  //   ""
-           char   *positive_sign;                 //   ""
-           char   *negative_sign;                 //   ""
-           char   *currency_symbol;               //   ""
-           char   frac_digits;                    //   CHAR_MAX
-           char   p_cs_precedes;                  //   CHAR_MAX
-           char   n_cs_precedes;                  //   CHAR_MAX
-           char   p_sep_by_space;                 //   CHAR_MAX
-           char   n_sep_by_space;                 //   CHAR_MAX
-           char   p_sign_posn;                    //   CHAR_MAX
-           char   n_sign_posn;                    //   CHAR_MAX
-           char   *int_curr_symbol;               //   ""
-           char   int_frac_digits;                //   CHAR_MAX
-           char   int_p_cs_precedes;              //   CHAR_MAX
-           char   int_n_cs_precedes;              //   CHAR_MAX
-           char   int_p_sep_by_space;             //   CHAR_MAX
-           char   int_n_sep_by_space;             //   CHAR_MAX
-           char   int_p_sign_posn;                //   CHAR_MAX
-           char   int_n_sign_posn;                //   CHAR_MAX
-
-[<a name="p222" href="#p222">page 222</a>] (<a href="#Contents">Contents</a>)
-
-3   The macros defined are NULL (described in <a href="#7.19">7.19</a>); and
-             LC_ALL
-             LC_COLLATE
-             LC_CTYPE
-             LC_MONETARY
-             LC_NUMERIC
-             LC_TIME
-    which expand to integer constant expressions with distinct values, suitable for use as the
-    first argument to the setlocale function.<sup><a href="#note219"><b>219)</b></a></sup> Additional macro definitions, beginning
-    with the characters LC_ and an uppercase letter,<sup><a href="#note220"><b>220)</b></a></sup> may also be specified by the
-    implementation.
-<a name="7.11.1" href="#7.11.1"><b>    7.11.1 Locale control</b></a>
-<a name="7.11.1.1" href="#7.11.1.1"><b>    7.11.1.1 The setlocale function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.11">&lt;locale.h&gt;</a>
-             char *setlocale(int category, const char *locale);
-<b>    Description</b>
-2   The setlocale function selects the appropriate portion of the program's locale as
-    specified by the category and locale arguments. The setlocale function may be
-    used to change or query the program's entire current locale or portions thereof. The value
-    LC_ALL for category names the program's entire locale; the other values for
-    category name only a portion of the program's locale. LC_COLLATE affects the
-    behavior of the strcoll and strxfrm functions. LC_CTYPE affects the behavior of
-    the character handling functions<sup><a href="#note221"><b>221)</b></a></sup> and the multibyte and wide character functions.
-    LC_MONETARY affects the monetary formatting information returned by the
-    localeconv function. LC_NUMERIC affects the decimal-point character for the
-    formatted input/output functions and the string conversion functions, as well as the
-    nonmonetary formatting information returned by the localeconv function. LC_TIME
-    affects the behavior of the strftime and wcsftime functions.
-3   A value of "C" for locale specifies the minimal environment for C translation; a value
-    of "" for locale specifies the locale-specific native environment. Other
-    implementation-defined strings may be passed as the second argument to setlocale.
-
-    <sup><a name="note219" href="#note219"><b>219)</b></a></sup> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
-    <sup><a name="note220" href="#note220"><b>220)</b></a></sup> See ''future library directions'' (<a href="#7.30.5">7.30.5</a>).
-    <sup><a name="note221" href="#note221"><b>221)</b></a></sup> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
-         isxdigit.
-
-[<a name="p223" href="#p223">page 223</a>] (<a href="#Contents">Contents</a>)
-
-4   At program startup, the equivalent of
-            setlocale(LC_ALL, "C");
-    is executed.
-5   A call to the setlocale function may introduce a data race with other calls to the
-    setlocale function or with calls to functions that are affected by the current locale.
-    The implementation shall behave as if no library function calls the setlocale function.
-<b>    Returns</b>
-6   If a pointer to a string is given for locale and the selection can be honored, the
-    setlocale function returns a pointer to the string associated with the specified
-    category for the new locale. If the selection cannot be honored, the setlocale
-    function returns a null pointer and the program's locale is not changed.
-7   A null pointer for locale causes the setlocale function to return a pointer to the
-    string associated with the category for the program's current locale; the program's
-    locale is not changed.<sup><a href="#note222"><b>222)</b></a></sup>
-8   The pointer to string returned by the setlocale function is such that a subsequent call
-    with that string value and its associated category will restore that part of the program's
-    locale. The string pointed to shall not be modified by the program, but may be
-    overwritten by a subsequent call to the setlocale function.
-    Forward references: formatted input/output functions (<a href="#7.21.6">7.21.6</a>), multibyte/wide
-    character conversion functions (<a href="#7.22.7">7.22.7</a>), multibyte/wide string conversion functions
-    (<a href="#7.22.8">7.22.8</a>), numeric conversion functions (<a href="#7.22.1">7.22.1</a>), the strcoll function (<a href="#7.23.4.3">7.23.4.3</a>), the
-    strftime function (<a href="#7.26.3.5">7.26.3.5</a>), the strxfrm function (<a href="#7.23.4.5">7.23.4.5</a>).
-<a name="7.11.2" href="#7.11.2"><b>    7.11.2 Numeric formatting convention inquiry</b></a>
-<a name="7.11.2.1" href="#7.11.2.1"><b>    7.11.2.1 The localeconv function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.11">&lt;locale.h&gt;</a>
-            struct lconv *localeconv(void);
-<b>    Description</b>
-2   The localeconv function sets the components of an object with type struct lconv
-    with values appropriate for the formatting of numeric quantities (monetary and otherwise)
-    according to the rules of the current locale.
-
-
-
-    <sup><a name="note222" href="#note222"><b>222)</b></a></sup> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
-         locale when category has the value LC_ALL.
-
-[<a name="p224" href="#p224">page 224</a>] (<a href="#Contents">Contents</a>)
-
-3   The members of the structure with type char * are pointers to strings, any of which
-    (except decimal_point) can point to "", to indicate that the value is not available in
-    the current locale or is of zero length. Apart from grouping and mon_grouping, the
-    strings shall start and end in the initial shift state. The members with type char are
-    nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not
-    available in the current locale. The members include the following:
-    char *decimal_point
-              The decimal-point character used to format nonmonetary quantities.
-    char *thousands_sep
-              The character used to separate groups of digits before the decimal-point
-              character in formatted nonmonetary quantities.
-    char *grouping
-              A string whose elements indicate the size of each group of digits in
-              formatted nonmonetary quantities.
-    char *mon_decimal_point
-              The decimal-point used to format monetary quantities.
-    char *mon_thousands_sep
-              The separator for groups of digits before the decimal-point in formatted
-              monetary quantities.
-    char *mon_grouping
-              A string whose elements indicate the size of each group of digits in
-              formatted monetary quantities.
-    char *positive_sign
-              The string used to indicate a nonnegative-valued formatted monetary
-              quantity.
-    char *negative_sign
-              The string used to indicate a negative-valued formatted monetary quantity.
-    char *currency_symbol
-              The local currency symbol applicable to the current locale.
-    char frac_digits
-              The number of fractional digits (those after the decimal-point) to be
-              displayed in a locally formatted monetary quantity.
-    char p_cs_precedes
-              Set to 1 or 0 if the currency_symbol respectively precedes or
-              succeeds the value for a nonnegative locally formatted monetary quantity.
-
-[<a name="p225" href="#p225">page 225</a>] (<a href="#Contents">Contents</a>)
-
-char n_cs_precedes
-          Set to 1 or 0 if the currency_symbol respectively precedes or
-          succeeds the value for a negative locally formatted monetary quantity.
-char p_sep_by_space
-          Set to a value indicating the separation of the currency_symbol, the
-          sign string, and the value for a nonnegative locally formatted monetary
-          quantity.
-char n_sep_by_space
-          Set to a value indicating the separation of the currency_symbol, the
-          sign string, and the value for a negative locally formatted monetary
-          quantity.
-char p_sign_posn
-          Set to a value indicating the positioning of the positive_sign for a
-          nonnegative locally formatted monetary quantity.
-char n_sign_posn
-          Set to a value indicating the positioning of the negative_sign for a
-          negative locally formatted monetary quantity.
-char *int_curr_symbol
-          The international currency symbol applicable to the current locale. The
-          first three characters contain the alphabetic international currency symbol
-          in accordance with those specified in ISO 4217. The fourth character
-          (immediately preceding the null character) is the character used to separate
-          the international currency symbol from the monetary quantity.
-char int_frac_digits
-          The number of fractional digits (those after the decimal-point) to be
-          displayed in an internationally formatted monetary quantity.
-char int_p_cs_precedes
-          Set to 1 or 0 if the int_curr_symbol respectively precedes or
-          succeeds the value for a nonnegative internationally formatted monetary
-          quantity.
-char int_n_cs_precedes
-          Set to 1 or 0 if the int_curr_symbol respectively precedes or
-          succeeds the value for a negative internationally formatted monetary
-          quantity.
-char int_p_sep_by_space
-          Set to a value indicating the separation of the int_curr_symbol, the
-          sign string, and the value for a nonnegative internationally formatted
-          monetary quantity.
-
-[<a name="p226" href="#p226">page 226</a>] (<a href="#Contents">Contents</a>)
-
-    char int_n_sep_by_space
-              Set to a value indicating the separation of the int_curr_symbol, the
-              sign string, and the value for a negative internationally formatted monetary
-              quantity.
-    char int_p_sign_posn
-              Set to a value indicating the positioning of the positive_sign for a
-              nonnegative internationally formatted monetary quantity.
-    char int_n_sign_posn
-              Set to a value indicating the positioning of the negative_sign for a
-              negative internationally formatted monetary quantity.
-4   The elements of grouping and mon_grouping are interpreted according to the
-    following:
-    CHAR_MAX      No further grouping is to be performed.
-    0             The previous element is to be repeatedly used for the remainder of the
-                  digits.
-    other         The integer value is the number of digits that compose the current group.
-                  The next element is examined to determine the size of the next group of
-                  digits before the current group.
-5   The values of p_sep_by_space, n_sep_by_space, int_p_sep_by_space,
-    and int_n_sep_by_space are interpreted according to the following:
-    0   No space separates the currency symbol and value.
-    1   If the currency symbol and sign string are adjacent, a space separates them from the
-        value; otherwise, a space separates the currency symbol from the value.
-    2   If the currency symbol and sign string are adjacent, a space separates them;
-        otherwise, a space separates the sign string from the value.
-    For int_p_sep_by_space and int_n_sep_by_space, the fourth character of
-    int_curr_symbol is used instead of a space.
-6   The values of p_sign_posn, n_sign_posn, int_p_sign_posn,                            and
-    int_n_sign_posn are interpreted according to the following:
-    0   Parentheses surround the quantity and currency symbol.
-    1   The sign string precedes the quantity and currency symbol.
-    2   The sign string succeeds the quantity and currency symbol.
-    3   The sign string immediately precedes the currency symbol.
-    4   The sign string immediately succeeds the currency symbol.
-
-[<a name="p227" href="#p227">page 227</a>] (<a href="#Contents">Contents</a>)
-
-7    The implementation shall behave as if no library function calls the localeconv
-     function.
-<b>     Returns</b>
-8    The localeconv function returns a pointer to the filled-in object. The structure
-     pointed to by the return value shall not be modified by the program, but may be
-     overwritten by a subsequent call to the localeconv function. In addition, calls to the
-     setlocale function with categories LC_ALL, LC_MONETARY, or LC_NUMERIC may
-     overwrite the contents of the structure.
-9    EXAMPLE 1 The following table illustrates rules which may well be used by four countries to format
-     monetary quantities.
-                                   Local format                                     International format
-
-     Country            Positive                  Negative                    Positive               Negative
-
-     Country1     1.234,56 mk             -1.234,56 mk                  FIM   1.234,56         FIM -1.234,56
-     Country2     L.1.234                 -L.1.234                      ITL   1.234            -ITL 1.234
-     Country3     fl. 1.234,56              fl. -1.234,56                   NLG   1.234,56         NLG -1.234,56
-     Country4     SFrs.1,234.56           SFrs.1,234.56C                CHF   1,234.56         CHF 1,234.56C
-10   For these four countries, the respective values for the monetary members of the structure returned by
-     localeconv could be:
-                                       Country1              Country2              Country3            Country4
-
-     mon_decimal_point                 ","                   ""                   ","                 "."
-     mon_thousands_sep                 "."                   "."                  "."                 ","
-     mon_grouping                      "\3"                  "\3"                 "\3"                "\3"
-     positive_sign                     ""                    ""                   ""                  ""
-     negative_sign                     "-"                   "-"                  "-"                 "C"
-     currency_symbol                   "mk"                  "L."                 "\u0192"            "SFrs."
-     frac_digits                       2                     0                    2                   2
-     p_cs_precedes                     0                     1                    1                   1
-     n_cs_precedes                     0                     1                    1                   1
-     p_sep_by_space                    1                     0                    1                   0
-     n_sep_by_space                    1                     0                    2                   0
-     p_sign_posn                       1                     1                    1                   1
-     n_sign_posn                       1                     1                    4                   2
-     int_curr_symbol                   "FIM "                "ITL "               "NLG "              "CHF "
-     int_frac_digits                   2                     0                    2                   2
-     int_p_cs_precedes                 1                     1                    1                   1
-     int_n_cs_precedes                 1                     1                    1                   1
-     int_p_sep_by_space                1                     1                    1                   1
-     int_n_sep_by_space                2                     1                    2                   1
-     int_p_sign_posn                   1                     1                    1                   1
-     int_n_sign_posn                   4                     1                    4                   2
-
-[<a name="p228" href="#p228">page 228</a>] (<a href="#Contents">Contents</a>)
-
-11   EXAMPLE 2 The following table illustrates how the cs_precedes, sep_by_space, and sign_posn members
-     affect the formatted value.
-                                                                   p_sep_by_space
-
-     p_cs_precedes           p_sign_posn                0                   1                  2
-
-                     0                    0         (<a href="#1.25">1.25</a>$)            (<a href="#1.25">1.25</a> $)            (<a href="#1.25">1.25</a>$)
-                                          1         +1.25$             +1.25 $             + <a href="#1.25">1.25</a>$
-                                          2         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
-                                          3         <a href="#1.25">1.25</a>+$             <a href="#1.25">1.25</a> +$             <a href="#1.25">1.25</a>+ $
-                                          4         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
-
-                     1                    0         ($1.25)            ($ <a href="#1.25">1.25</a>)            ($1.25)
-                                          1         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
-                                          2         $1.25+             $ <a href="#1.25">1.25</a>+             $1.25 +
-                                          3         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
-                                          4         $+1.25             $+ <a href="#1.25">1.25</a>             $ +1.25
-
-[<a name="p229" href="#p229">page 229</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12" href="#7.12"><b>    7.12 Mathematics &lt;math.h&gt;</b></a>
-1   The header <a href="#7.12">&lt;math.h&gt;</a> declares two types and many mathematical functions and defines
-    several macros. Most synopses specify a family of functions consisting of a principal
-    function with one or more double parameters, a double return value, or both; and
-    other functions with the same name but with f and l suffixes, which are corresponding
-    functions with float and long double parameters, return values, or both.<sup><a href="#note223"><b>223)</b></a></sup>
-    Integer arithmetic functions and conversion functions are discussed later.
-2   The types
-            float_t
-            double_t
-    are floating types at least as wide as float and double, respectively, and such that
-    double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
-    float_t and double_t are float and double, respectively; if
-    FLT_EVAL_METHOD equals 1, they are both double; if FLT_EVAL_METHOD equals
-    2, they are both long double; and for other values of FLT_EVAL_METHOD, they are
-    otherwise implementation-defined.<sup><a href="#note224"><b>224)</b></a></sup>
-3   The macro
-            HUGE_VAL
-    expands to a positive double constant expression, not necessarily representable as a
-    float. The macros
-            HUGE_VALF
-            HUGE_VALL
-    are respectively float and long double analogs of HUGE_VAL.<sup><a href="#note225"><b>225)</b></a></sup>
-4   The macro
-            INFINITY
-    expands to a constant expression of type float representing positive or unsigned
-    infinity, if available; else to a positive constant of type float that overflows at
-
-
-
-    <sup><a name="note223" href="#note223"><b>223)</b></a></sup> Particularly on systems with wide expression evaluation, a <a href="#7.12">&lt;math.h&gt;</a> function might pass arguments
-         and return values in wider format than the synopsis prototype indicates.
-    <sup><a name="note224" href="#note224"><b>224)</b></a></sup> The types float_t and double_t are intended to be the implementation's most efficient types at
-         least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
-         type float_t is the narrowest type used by the implementation to evaluate floating expressions.
-    <sup><a name="note225" href="#note225"><b>225)</b></a></sup> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
-         supports infinities.
-
-[<a name="p230" href="#p230">page 230</a>] (<a href="#Contents">Contents</a>)
-
-    translation time.<sup><a href="#note226"><b>226)</b></a></sup>
-5   The macro
-             NAN
-    is defined if and only if the implementation supports quiet NaNs for the float type. It
-    expands to a constant expression of type float representing a quiet NaN.
-6   The number classification macros
-             FP_INFINITE
-             FP_NAN
-             FP_NORMAL
-             FP_SUBNORMAL
-             FP_ZERO
-    represent the mutually exclusive kinds of floating-point values. They expand to integer
-    constant expressions with distinct values. Additional implementation-defined floating-
-    point classifications, with macro definitions beginning with FP_ and an uppercase letter,
-    may also be specified by the implementation.
-7   The macro
-             FP_FAST_FMA
-    is optionally defined. If defined, it indicates that the fma function generally executes
-    about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note227"><b>227)</b></a></sup> The
-    macros
-             FP_FAST_FMAF
-             FP_FAST_FMAL
-    are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
-    these macros expand to the integer constant 1.
-8   The macros
-             FP_ILOGB0
-             FP_ILOGBNAN
-    expand to integer constant expressions whose values are returned by ilogb(x) if x is
-    zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
-    -INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
-
-
-    <sup><a name="note226" href="#note226"><b>226)</b></a></sup> In this case, using INFINITY will violate the constraint in <a href="#6.4.4">6.4.4</a> and thus require a diagnostic.
-    <sup><a name="note227" href="#note227"><b>227)</b></a></sup> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
-         directly with a hardware multiply-add instruction. Software implementations are expected to be
-         substantially slower.
-
-[<a name="p231" href="#p231">page 231</a>] (<a href="#Contents">Contents</a>)
-
-9   The macros
-            MATH_ERRNO
-            MATH_ERREXCEPT
-    expand to the integer constants 1 and 2, respectively; the macro
-            math_errhandling
-    expands to an expression that has type int and the value MATH_ERRNO,
-    MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
-    constant for the duration of the program. It is unspecified whether
-    math_errhandling is a macro or an identifier with external linkage. If a macro
-    definition is suppressed or a program defines an identifier with the name
-    math_errhandling, the behavior is undefined.               If the expression
-    math_errhandling &amp; MATH_ERREXCEPT can be nonzero, the implementation
-    shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
-    <a href="#7.6">&lt;fenv.h&gt;</a>.
-<a name="7.12.1" href="#7.12.1"><b>    7.12.1 Treatment of error conditions</b></a>
-1   The behavior of each of the functions in <a href="#7.12">&lt;math.h&gt;</a> is specified for all representable
-    values of its input arguments, except where stated otherwise. Each function shall execute
-    as if it were a single operation without raising SIGFPE and without generating any of the
-    floating-point exceptions ''invalid'', ''divide-by-zero'', or ''overflow'' except to reflect
-    the result of the function.
-2   For all functions, a domain error occurs if an input argument is outside the domain over
-    which the mathematical function is defined. The description of each function lists any
-    required domain errors; an implementation may define additional domain errors, provided
-    that such errors are consistent with the mathematical definition of the function.<sup><a href="#note228"><b>228)</b></a></sup> On a
-    domain error, the function returns an implementation-defined value; if the integer
-    expression math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression
-    errno acquires the value EDOM; if the integer expression math_errhandling &amp;
-    MATH_ERREXCEPT is nonzero, the ''invalid'' floating-point exception is raised.
-3   Similarly, a pole error (also known as a singularity or infinitary) occurs if the
-    mathematical function has an exact infinite result as the finite input argument(s) are
-    approached in the limit (for example, log(0.0)). The description of each function lists
-    any required pole errors; an implementation may define additional pole errors, provided
-    that such errors are consistent with the mathematical definition of the function. On a pole
-    error, the function returns an implementation-defined value; if the integer expression
-
-
-    <sup><a name="note228" href="#note228"><b>228)</b></a></sup> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
-         error if the mathematical domain of the function does not include the infinity.
-
-[<a name="p232" href="#p232">page 232</a>] (<a href="#Contents">Contents</a>)
-
-    math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression errno
-    acquires the value ERANGE; if the integer expression math_errhandling &amp;
-    MATH_ERREXCEPT is nonzero, the ''divide-by-zero'' floating-point exception is raised.
-4   Likewise, a range error occurs if the mathematical result of the function cannot be
-    represented in an object of the specified type, due to extreme magnitude.
-5   A floating result overflows if the magnitude of the mathematical result is finite but so
-    large that the mathematical result cannot be represented without extraordinary roundoff
-    error in an object of the specified type. If a floating result overflows and default rounding
-    is in effect, then the function returns the value of the macro HUGE_VAL, HUGE_VALF, or *
-    HUGE_VALL according to the return type, with the same sign as the correct value of the
-    function; if the integer expression math_errhandling &amp; MATH_ERRNO is nonzero,
-    the integer expression errno acquires the value ERANGE; if the integer expression
-    math_errhandling &amp; MATH_ERREXCEPT is nonzero, the ''overflow'' floating-
-    point exception is raised.
-6   The result underflows if the magnitude of the mathematical result is so small that the
-    mathematical result cannot be represented, without extraordinary roundoff error, in an
-    object of the specified type.<sup><a href="#note229"><b>229)</b></a></sup> If the result underflows, the function returns an
-    implementation-defined value whose magnitude is no greater than the smallest
-    normalized positive number in the specified type; if the integer expression
-    math_errhandling &amp; MATH_ERRNO is nonzero, whether errno acquires the
-    value    ERANGE       is    implementation-defined;     if   the  integer   expression
-    math_errhandling &amp; MATH_ERREXCEPT is nonzero, whether the ''underflow''
-    floating-point exception is raised is implementation-defined.
-7   If a domain, pole, or range error occurs and the integer expression
-    math_errhandling &amp; MATH_ERRNO is zero,<sup><a href="#note230"><b>230)</b></a></sup> then errno shall either be set to
-    the value corresponding to the error or left unmodified. If no such error occurs, errno
-    shall be left unmodified regardless of the setting of math_errhandling.
-
-
-
-
-    <sup><a name="note229" href="#note229"><b>229)</b></a></sup> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
-         also ''flush-to-zero'' underflow.
-    <sup><a name="note230" href="#note230"><b>230)</b></a></sup> Math errors are being indicated by the floating-point exception flags rather than by errno.
-
-[<a name="p233" href="#p233">page 233</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.2" href="#7.12.2"><b>    7.12.2 The FP_CONTRACT pragma</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             #pragma STDC FP_CONTRACT on-off-switch
-<b>    Description</b>
-2   The FP_CONTRACT pragma can be used to allow (if the state is ''on'') or disallow (if the
-    state is ''off'') the implementation to contract expressions (<a href="#6.5">6.5</a>). Each pragma can occur
-    either outside external declarations or preceding all explicit declarations and statements
-    inside a compound statement. When outside external declarations, the pragma takes
-    effect from its occurrence until another FP_CONTRACT pragma is encountered, or until
-    the end of the translation unit. When inside a compound statement, the pragma takes
-    effect from its occurrence until another FP_CONTRACT pragma is encountered
-    (including within a nested compound statement), or until the end of the compound
-    statement; at the end of a compound statement the state for the pragma is restored to its
-    condition just before the compound statement. If this pragma is used in any other
-    context, the behavior is undefined. The default state (''on'' or ''off'') for the pragma is
-    implementation-defined.
-<a name="7.12.3" href="#7.12.3"><b>    7.12.3 Classification macros</b></a>
-1   In the synopses in this subclause, real-floating indicates that the argument shall be an
-    expression of real floating type.
-<a name="7.12.3.1" href="#7.12.3.1"><b>    7.12.3.1 The fpclassify macro</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             int fpclassify(real-floating x);
-<b>    Description</b>
-2   The fpclassify macro classifies its argument value as NaN, infinite, normal,
-    subnormal, zero, or into another implementation-defined category. First, an argument
-    represented in a format wider than its semantic type is converted to its semantic type.
-    Then classification is based on the type of the argument.<sup><a href="#note231"><b>231)</b></a></sup>
-<b>    Returns</b>
-3   The fpclassify macro returns the value of the number classification macro
-    appropriate to the value of its argument.                                *
-
-
-    <sup><a name="note231" href="#note231"><b>231)</b></a></sup> Since an expression can be evaluated with more range and precision than its type has, it is important to
-         know the type that classification is based on. For example, a normal long double value might
-         become subnormal when converted to double, and zero when converted to float.
-
-[<a name="p234" href="#p234">page 234</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.3.2" href="#7.12.3.2"><b>    7.12.3.2 The isfinite macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isfinite(real-floating x);
-<b>    Description</b>
-2   The isfinite macro determines whether its argument has a finite value (zero,
-    subnormal, or normal, and not infinite or NaN). First, an argument represented in a
-    format wider than its semantic type is converted to its semantic type. Then determination
-    is based on the type of the argument.
-<b>    Returns</b>
-3   The isfinite macro returns a nonzero value if and only if its argument has a finite
-    value.
-<a name="7.12.3.3" href="#7.12.3.3"><b>    7.12.3.3 The isinf macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isinf(real-floating x);
-<b>    Description</b>
-2   The isinf macro determines whether its argument value is an infinity (positive or
-    negative). First, an argument represented in a format wider than its semantic type is
-    converted to its semantic type. Then determination is based on the type of the argument.
-<b>    Returns</b>
-3   The isinf macro returns a nonzero value if and only if its argument has an infinite
-    value.
-<a name="7.12.3.4" href="#7.12.3.4"><b>    7.12.3.4 The isnan macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isnan(real-floating x);
-<b>    Description</b>
-2   The isnan macro determines whether its argument value is a NaN. First, an argument
-    represented in a format wider than its semantic type is converted to its semantic type.
-    Then determination is based on the type of the argument.<sup><a href="#note232"><b>232)</b></a></sup>
-
-
-    <sup><a name="note232" href="#note232"><b>232)</b></a></sup> For the isnan macro, the type for determination does not matter unless the implementation supports
-         NaNs in the evaluation type but not in the semantic type.
-
-[<a name="p235" href="#p235">page 235</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The isnan macro returns a nonzero value if and only if its argument has a NaN value.
-<a name="7.12.3.5" href="#7.12.3.5"><b>    7.12.3.5 The isnormal macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isnormal(real-floating x);
-<b>    Description</b>
-2   The isnormal macro determines whether its argument value is normal (neither zero,
-    subnormal, infinite, nor NaN). First, an argument represented in a format wider than its
-    semantic type is converted to its semantic type. Then determination is based on the type
-    of the argument.
-<b>    Returns</b>
-3   The isnormal macro returns a nonzero value if and only if its argument has a normal
-    value.
-<a name="7.12.3.6" href="#7.12.3.6"><b>    7.12.3.6 The signbit macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int signbit(real-floating x);
-<b>    Description</b>
-2   The signbit macro determines whether the sign of its argument value is negative.<sup><a href="#note233"><b>233)</b></a></sup>
-<b>    Returns</b>
-3   The signbit macro returns a nonzero value if and only if the sign of its argument value
-    is negative.
-
-
-
-
-    <sup><a name="note233" href="#note233"><b>233)</b></a></sup> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
-         unsigned, it is treated as positive.
-
-[<a name="p236" href="#p236">page 236</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.4" href="#7.12.4"><b>    7.12.4 Trigonometric functions</b></a>
-<a name="7.12.4.1" href="#7.12.4.1"><b>    7.12.4.1 The acos functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double acos(double x);
-            float acosf(float x);
-            long double acosl(long double x);
-<b>    Description</b>
-2   The acos functions compute the principal value of the arc cosine of x. A domain error
-    occurs for arguments not in the interval [-1, +1].
-<b>    Returns</b>
-3   The acos functions return arccos x in the interval [0, pi ] radians.
-<a name="7.12.4.2" href="#7.12.4.2"><b>    7.12.4.2 The asin functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double asin(double x);
-            float asinf(float x);
-            long double asinl(long double x);
-<b>    Description</b>
-2   The asin functions compute the principal value of the arc sine of x. A domain error
-    occurs for arguments not in the interval [-1, +1].
-<b>    Returns</b>
-3   The asin functions return arcsin x in the interval [-pi /2, +pi /2] radians.
-<a name="7.12.4.3" href="#7.12.4.3"><b>    7.12.4.3 The atan functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double atan(double x);
-            float atanf(float x);
-            long double atanl(long double x);
-<b>    Description</b>
-2   The atan functions compute the principal value of the arc tangent of x.
-
-[<a name="p237" href="#p237">page 237</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The atan functions return arctan x in the interval [-pi /2, +pi /2] radians.
-<a name="7.12.4.4" href="#7.12.4.4"><b>    7.12.4.4 The atan2 functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double atan2(double y, double x);
-           float atan2f(float y, float x);
-           long double atan2l(long double y, long double x);
-<b>    Description</b>
-2   The atan2 functions compute the value of the arc tangent of y/x, using the signs of both
-    arguments to determine the quadrant of the return value. A domain error may occur if
-    both arguments are zero.
-<b>    Returns</b>
-3   The atan2 functions return arctan y/x in the interval [-pi , +pi ] radians.
-<a name="7.12.4.5" href="#7.12.4.5"><b>    7.12.4.5 The cos functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double cos(double x);
-           float cosf(float x);
-           long double cosl(long double x);
-<b>    Description</b>
-2   The cos functions compute the cosine of x (measured in radians).
-<b>    Returns</b>
-3   The cos functions return cos x.
-<a name="7.12.4.6" href="#7.12.4.6"><b>    7.12.4.6 The sin functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double sin(double x);
-           float sinf(float x);
-           long double sinl(long double x);
-<b>    Description</b>
-2   The sin functions compute the sine of x (measured in radians).
-
-[<a name="p238" href="#p238">page 238</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The sin functions return sin x.
-<a name="7.12.4.7" href="#7.12.4.7"><b>    7.12.4.7 The tan functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double tan(double x);
-            float tanf(float x);
-            long double tanl(long double x);
-<b>    Description</b>
-2   The tan functions return the tangent of x (measured in radians).
-<b>    Returns</b>
-3   The tan functions return tan x.
-<a name="7.12.5" href="#7.12.5"><b>    7.12.5 Hyperbolic functions</b></a>
-<a name="7.12.5.1" href="#7.12.5.1"><b>    7.12.5.1 The acosh functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double acosh(double x);
-            float acoshf(float x);
-            long double acoshl(long double x);
-<b>    Description</b>
-2   The acosh functions compute the (nonnegative) arc hyperbolic cosine of x. A domain
-    error occurs for arguments less than 1.
-<b>    Returns</b>
-3   The acosh functions return arcosh x in the interval [0, +(inf)].
-<a name="7.12.5.2" href="#7.12.5.2"><b>    7.12.5.2 The asinh functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double asinh(double x);
-            float asinhf(float x);
-            long double asinhl(long double x);
-<b>    Description</b>
-2   The asinh functions compute the arc hyperbolic sine of x.
-
-[<a name="p239" href="#p239">page 239</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The asinh functions return arsinh x.
-<a name="7.12.5.3" href="#7.12.5.3"><b>    7.12.5.3 The atanh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double atanh(double x);
-           float atanhf(float x);
-           long double atanhl(long double x);
-<b>    Description</b>
-2   The atanh functions compute the arc hyperbolic tangent of x. A domain error occurs
-    for arguments not in the interval [-1, +1]. A pole error may occur if the argument equals
-    -1 or +1.
-<b>    Returns</b>
-3   The atanh functions return artanh x.
-<a name="7.12.5.4" href="#7.12.5.4"><b>    7.12.5.4 The cosh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double cosh(double x);
-           float coshf(float x);
-           long double coshl(long double x);
-<b>    Description</b>
-2   The cosh functions compute the hyperbolic cosine of x. A range error occurs if the
-    magnitude of x is too large.
-<b>    Returns</b>
-3   The cosh functions return cosh x.
-<a name="7.12.5.5" href="#7.12.5.5"><b>    7.12.5.5 The sinh functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double sinh(double x);
-           float sinhf(float x);
-           long double sinhl(long double x);
-<b>    Description</b>
-2   The sinh functions compute the hyperbolic sine of x. A range error occurs if the
-    magnitude of x is too large.
-
-[<a name="p240" href="#p240">page 240</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The sinh functions return sinh x.
-<a name="7.12.5.6" href="#7.12.5.6"><b>    7.12.5.6 The tanh functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double tanh(double x);
-            float tanhf(float x);
-            long double tanhl(long double x);
-<b>    Description</b>
-2   The tanh functions compute the hyperbolic tangent of x.
-<b>    Returns</b>
-3   The tanh functions return tanh x.
-<a name="7.12.6" href="#7.12.6"><b>    7.12.6 Exponential and logarithmic functions</b></a>
-<a name="7.12.6.1" href="#7.12.6.1"><b>    7.12.6.1 The exp functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double exp(double x);
-            float expf(float x);
-            long double expl(long double x);
-<b>    Description</b>
-2   The exp functions compute the base-e exponential of x. A range error occurs if the
-    magnitude of x is too large.
-<b>    Returns</b>
-3   The exp functions return ex .
-<a name="7.12.6.2" href="#7.12.6.2"><b>    7.12.6.2 The exp2 functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double exp2(double x);
-            float exp2f(float x);
-            long double exp2l(long double x);
-<b>    Description</b>
-2   The exp2 functions compute the base-2 exponential of x. A range error occurs if the
-    magnitude of x is too large.
-
-[<a name="p241" href="#p241">page 241</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The exp2 functions return 2x .
-<a name="7.12.6.3" href="#7.12.6.3"><b>    7.12.6.3 The expm1 functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double expm1(double x);
-            float expm1f(float x);
-            long double expm1l(long double x);
-<b>    Description</b>
-2   The expm1 functions compute the base-e exponential of the argument, minus 1. A range
-    error occurs if x is too large.<sup><a href="#note234"><b>234)</b></a></sup>
-<b>    Returns</b>
-3   The expm1 functions return ex - 1.
-<a name="7.12.6.4" href="#7.12.6.4"><b>    7.12.6.4 The frexp functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double frexp(double value, int *exp);
-            float frexpf(float value, int *exp);
-            long double frexpl(long double value, int *exp);
-<b>    Description</b>
-2   The frexp functions break a floating-point number into a normalized fraction and an
-    integral power of 2. They store the integer in the int object pointed to by exp.
-<b>    Returns</b>
-3   If value is not a floating-point number or if the integral power of 2 is outside the range
-    of int, the results are unspecified. Otherwise, the frexp functions return the value x,
-    such that x has a magnitude in the interval [1/2, 1) or zero, and value equals x x 2*exp .
-    If value is zero, both parts of the result are zero.
-
-
-
-
-    <sup><a name="note234" href="#note234"><b>234)</b></a></sup> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
-
-[<a name="p242" href="#p242">page 242</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.6.5" href="#7.12.6.5"><b>    7.12.6.5 The ilogb functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int ilogb(double x);
-            int ilogbf(float x);
-            int ilogbl(long double x);
-<b>    Description</b>
-2   The ilogb functions extract the exponent of x as a signed int value. If x is zero they
-    compute the value FP_ILOGB0; if x is infinite they compute the value INT_MAX; if x is
-    a NaN they compute the value FP_ILOGBNAN; otherwise, they are equivalent to calling
-    the corresponding logb function and casting the returned value to type int. A domain
-    error or range error may occur if x is zero, infinite, or NaN. If the correct value is outside
-    the range of the return type, the numeric result is unspecified.
-<b>    Returns</b>
-3   The ilogb functions return the exponent of x as a signed int value.
-    Forward references: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
-<a name="7.12.6.6" href="#7.12.6.6"><b>    7.12.6.6 The ldexp functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double ldexp(double x, int exp);
-            float ldexpf(float x, int exp);
-            long double ldexpl(long double x, int exp);
-<b>    Description</b>
-2   The ldexp functions multiply a floating-point number by an integral power of 2. A
-    range error may occur.
-<b>    Returns</b>
-3   The ldexp functions return x x 2exp .
-<a name="7.12.6.7" href="#7.12.6.7"><b>    7.12.6.7 The log functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double log(double x);
-            float logf(float x);
-            long double logl(long double x);
-
-[<a name="p243" href="#p243">page 243</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The log functions compute the base-e (natural) logarithm of x. A domain error occurs if
-    the argument is negative. A pole error may occur if the argument is zero.
-<b>    Returns</b>
-3   The log functions return loge x.
-<a name="7.12.6.8" href="#7.12.6.8"><b>    7.12.6.8 The log10 functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double log10(double x);
-            float log10f(float x);
-            long double log10l(long double x);
-<b>    Description</b>
-2   The log10 functions compute the base-10 (common) logarithm of x. A domain error
-    occurs if the argument is negative. A pole error may occur if the argument is zero.
-<b>    Returns</b>
-3   The log10 functions return log10 x.
-<a name="7.12.6.9" href="#7.12.6.9"><b>    7.12.6.9 The log1p functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double log1p(double x);
-            float log1pf(float x);
-            long double log1pl(long double x);
-<b>    Description</b>
-2   The log1p functions compute the base-e (natural) logarithm of 1 plus the argument.<sup><a href="#note235"><b>235)</b></a></sup>
-    A domain error occurs if the argument is less than -1. A pole error may occur if the
-    argument equals -1.
-<b>    Returns</b>
-3   The log1p functions return loge (1 + x).
-
-
-
-
-    <sup><a name="note235" href="#note235"><b>235)</b></a></sup> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
-
-[<a name="p244" href="#p244">page 244</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.6.10" href="#7.12.6.10"><b>    7.12.6.10 The log2 functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double log2(double x);
-            float log2f(float x);
-            long double log2l(long double x);
-<b>    Description</b>
-2   The log2 functions compute the base-2 logarithm of x. A domain error occurs if the
-    argument is less than zero. A pole error may occur if the argument is zero.
-<b>    Returns</b>
-3   The log2 functions return log2 x.
-<a name="7.12.6.11" href="#7.12.6.11"><b>    7.12.6.11 The logb functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double logb(double x);
-            float logbf(float x);
-            long double logbl(long double x);
-<b>    Description</b>
-2   The logb functions extract the exponent of x, as a signed integer value in floating-point
-    format. If x is subnormal it is treated as though it were normalized; thus, for positive
-    finite x,
-          1 &lt;= x x FLT_RADIX-logb(x) &lt; FLT_RADIX
-    A domain error or pole error may occur if the argument is zero.
-<b>    Returns</b>
-3   The logb functions return the signed exponent of x.
-<a name="7.12.6.12" href="#7.12.6.12"><b>    7.12.6.12 The modf functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double modf(double value, double *iptr);
-            float modff(float value, float *iptr);
-            long double modfl(long double value, long double *iptr);
-<b>    Description</b>
-2   The modf functions break the argument value into integral and fractional parts, each of
-    which has the same type and sign as the argument. They store the integral part (in
-
-[<a name="p245" href="#p245">page 245</a>] (<a href="#Contents">Contents</a>)
-
-    floating-point format) in the object pointed to by iptr.
-<b>    Returns</b>
-3   The modf functions return the signed fractional part of value.
-<a name="7.12.6.13" href="#7.12.6.13"><b>    7.12.6.13 The scalbn and scalbln functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double scalbn(double x, int n);
-           float scalbnf(float x, int n);
-           long double scalbnl(long double x, int n);
-           double scalbln(double x, long int n);
-           float scalblnf(float x, long int n);
-           long double scalblnl(long double x, long int n);
-<b>    Description</b>
-2   The scalbn and scalbln functions compute x x FLT_RADIXn efficiently, not
-    normally by computing FLT_RADIXn explicitly. A range error may occur.
-<b>    Returns</b>
-3   The scalbn and scalbln functions return x x FLT_RADIXn .
-<a name="7.12.7" href="#7.12.7"><b>    7.12.7 Power and absolute-value functions</b></a>
-<a name="7.12.7.1" href="#7.12.7.1"><b>    7.12.7.1 The cbrt functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double cbrt(double x);
-           float cbrtf(float x);
-           long double cbrtl(long double x);
-<b>    Description</b>
-2   The cbrt functions compute the real cube root of x.
-<b>    Returns</b>
-3   The cbrt functions return x1/3 .
-
-[<a name="p246" href="#p246">page 246</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.7.2" href="#7.12.7.2"><b>    7.12.7.2 The fabs functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fabs(double x);
-            float fabsf(float x);
-            long double fabsl(long double x);
-<b>    Description</b>
-2   The fabs functions compute the absolute value of a floating-point number x.
-<b>    Returns</b>
-3   The fabs functions return | x |.
-<a name="7.12.7.3" href="#7.12.7.3"><b>    7.12.7.3 The hypot functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double hypot(double x, double y);
-            float hypotf(float x, float y);
-            long double hypotl(long double x, long double y);
-<b>    Description</b>
-2   The hypot functions compute the square root of the sum of the squares of x and y,
-    without undue overflow or underflow. A range error may occur.
-3   Returns
-4   The hypot functions return (sqrt)x2 + y2 .
-                               -
-                               -----
-<a name="7.12.7.4" href="#7.12.7.4"><b>    7.12.7.4 The pow functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double pow(double x, double y);
-            float powf(float x, float y);
-            long double powl(long double x, long double y);
-<b>    Description</b>
-2   The pow functions compute x raised to the power y. A domain error occurs if x is finite
-    and negative and y is finite and not an integer value. A range error may occur. A domain
-    error may occur if x is zero and y is zero. A domain error or pole error may occur if x is
-    zero and y is less than zero.
-
-[<a name="p247" href="#p247">page 247</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The pow functions return xy .
-<a name="7.12.7.5" href="#7.12.7.5"><b>    7.12.7.5 The sqrt functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double sqrt(double x);
-           float sqrtf(float x);
-           long double sqrtl(long double x);
-<b>    Description</b>
-2   The sqrt functions compute the nonnegative square root of x. A domain error occurs if
-    the argument is less than zero.
-<b>    Returns</b>
-3   The sqrt functions return (sqrt)x.
-                              -
-                              -
-<a name="7.12.8" href="#7.12.8"><b>    7.12.8 Error and gamma functions</b></a>
-<a name="7.12.8.1" href="#7.12.8.1"><b>    7.12.8.1 The erf functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double erf(double x);
-           float erff(float x);
-           long double erfl(long double x);
-<b>    Description</b>
-2   The erf functions compute the error function of x.
-<b>    Returns</b>
-3                                      2        x
-                                            (integral)       e-t dt.
-                                                      2
-    The erf functions return erf x =
-                                       (sqrt)pi
-                                       -
-                                       -    0
-
-<a name="7.12.8.2" href="#7.12.8.2"><b>    7.12.8.2 The erfc functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double erfc(double x);
-           float erfcf(float x);
-           long double erfcl(long double x);
-<b>    Description</b>
-2   The erfc functions compute the complementary error function of x. A range error
-    occurs if x is too large.
-
-[<a name="p248" href="#p248">page 248</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3                                                       2       (inf)
-                                                            (integral)       e-t dt.
-                                                                      2
-    The erfc functions return erfc x = 1 - erf x =
-                                                     (sqrt)pi
-                                                     -
-                                                     -      x
-
-<a name="7.12.8.3" href="#7.12.8.3"><b>    7.12.8.3 The lgamma functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double lgamma(double x);
-            float lgammaf(float x);
-            long double lgammal(long double x);
-<b>    Description</b>
-2   The lgamma functions compute the natural logarithm of the absolute value of gamma of
-    x. A range error occurs if x is too large. A pole error may occur if x is a negative integer
-    or zero.
-<b>    Returns</b>
-3   The lgamma functions return loge | (Gamma)(x) |.
-<a name="7.12.8.4" href="#7.12.8.4"><b>    7.12.8.4 The tgamma functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double tgamma(double x);
-            float tgammaf(float x);
-            long double tgammal(long double x);
-<b>    Description</b>
-2   The tgamma functions compute the gamma function of x. A domain error or pole error
-    may occur if x is a negative integer or zero. A range error occurs if the magnitude of x is
-    too large and may occur if the magnitude of x is too small.
-<b>    Returns</b>
-3   The tgamma functions return (Gamma)(x).
-
-[<a name="p249" href="#p249">page 249</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.9" href="#7.12.9"><b>    7.12.9 Nearest integer functions</b></a>
-<a name="7.12.9.1" href="#7.12.9.1"><b>    7.12.9.1 The ceil functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double ceil(double x);
-           float ceilf(float x);
-           long double ceill(long double x);
-<b>    Description</b>
-2   The ceil functions compute the smallest integer value not less than x.
-<b>    Returns</b>
-3   The ceil functions return [^x^], expressed as a floating-point number.
-<a name="7.12.9.2" href="#7.12.9.2"><b>    7.12.9.2 The floor functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double floor(double x);
-           float floorf(float x);
-           long double floorl(long double x);
-<b>    Description</b>
-2   The floor functions compute the largest integer value not greater than x.
-<b>    Returns</b>
-3   The floor functions return [_x_], expressed as a floating-point number.
-<a name="7.12.9.3" href="#7.12.9.3"><b>    7.12.9.3 The nearbyint functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double nearbyint(double x);
-           float nearbyintf(float x);
-           long double nearbyintl(long double x);
-<b>    Description</b>
-2   The nearbyint functions round their argument to an integer value in floating-point
-    format, using the current rounding direction and without raising the ''inexact'' floating-
-    point exception.
-
-[<a name="p250" href="#p250">page 250</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The nearbyint functions return the rounded integer value.
-<a name="7.12.9.4" href="#7.12.9.4"><b>    7.12.9.4 The rint functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double rint(double x);
-            float rintf(float x);
-            long double rintl(long double x);
-<b>    Description</b>
-2   The rint functions differ from the nearbyint functions (<a href="#7.12.9.3">7.12.9.3</a>) only in that the
-    rint functions may raise the ''inexact'' floating-point exception if the result differs in
-    value from the argument.
-<b>    Returns</b>
-3   The rint functions return the rounded integer value.
-<a name="7.12.9.5" href="#7.12.9.5"><b>    7.12.9.5 The lrint and llrint functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            long int lrint(double x);
-            long int lrintf(float x);
-            long int lrintl(long double x);
-            long long int llrint(double x);
-            long long int llrintf(float x);
-            long long int llrintl(long double x);
-<b>    Description</b>
-2   The lrint and llrint functions round their argument to the nearest integer value,
-    rounding according to the current rounding direction. If the rounded value is outside the
-    range of the return type, the numeric result is unspecified and a domain error or range
-    error may occur.
-<b>    Returns</b>
-3   The lrint and llrint functions return the rounded integer value.
-
-[<a name="p251" href="#p251">page 251</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.9.6" href="#7.12.9.6"><b>    7.12.9.6 The round functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double round(double x);
-           float roundf(float x);
-           long double roundl(long double x);
-<b>    Description</b>
-2   The round functions round their argument to the nearest integer value in floating-point
-    format, rounding halfway cases away from zero, regardless of the current rounding
-    direction.
-<b>    Returns</b>
-3   The round functions return the rounded integer value.
-<a name="7.12.9.7" href="#7.12.9.7"><b>    7.12.9.7 The lround and llround functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           long int lround(double x);
-           long int lroundf(float x);
-           long int lroundl(long double x);
-           long long int llround(double x);
-           long long int llroundf(float x);
-           long long int llroundl(long double x);
-<b>    Description</b>
-2   The lround and llround functions round their argument to the nearest integer value,
-    rounding halfway cases away from zero, regardless of the current rounding direction. If
-    the rounded value is outside the range of the return type, the numeric result is unspecified
-    and a domain error or range error may occur.
-<b>    Returns</b>
-3   The lround and llround functions return the rounded integer value.
-<a name="7.12.9.8" href="#7.12.9.8"><b>    7.12.9.8 The trunc functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double trunc(double x);
-           float truncf(float x);
-           long double truncl(long double x);
-
-[<a name="p252" href="#p252">page 252</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The trunc functions round their argument to the integer value, in floating format,
-    nearest to but no larger in magnitude than the argument.
-<b>    Returns</b>
-3   The trunc functions return the truncated integer value.
-<a name="7.12.10" href="#7.12.10"><b>    7.12.10 Remainder functions</b></a>
-<a name="7.12.10.1" href="#7.12.10.1"><b>    7.12.10.1 The fmod functions</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             double fmod(double x, double y);
-             float fmodf(float x, float y);
-             long double fmodl(long double x, long double y);
-<b>    Description</b>
-2   The fmod functions compute the floating-point remainder of x/y.
-<b>    Returns</b>
-3   The fmod functions return the value x - ny, for some integer n such that, if y is nonzero,
-    the result has the same sign as x and magnitude less than the magnitude of y. If y is zero,
-    whether a domain error occurs or the fmod functions return zero is implementation-
-    defined.
-<a name="7.12.10.2" href="#7.12.10.2"><b>    7.12.10.2 The remainder functions</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             double remainder(double x, double y);
-             float remainderf(float x, float y);
-             long double remainderl(long double x, long double y);
-<b>    Description</b>
-2   The remainder functions compute the remainder x REM y required by IEC 60559.<sup><a href="#note236"><b>236)</b></a></sup>
-
-
-
-
-    <sup><a name="note236" href="#note236"><b>236)</b></a></sup> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
-         mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
-         | n - x/y | = 1/2, then n is even. If r = 0, its sign shall be that of x.'' This definition is applicable for *
-         all implementations.
-
-[<a name="p253" href="#p253">page 253</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The remainder functions return x REM y. If y is zero, whether a domain error occurs
-    or the functions return zero is implementation defined.
-<a name="7.12.10.3" href="#7.12.10.3"><b>    7.12.10.3 The remquo functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double remquo(double x, double y, int *quo);
-           float remquof(float x, float y, int *quo);
-           long double remquol(long double x, long double y,
-                int *quo);
-<b>    Description</b>
-2   The remquo functions compute the same remainder as the remainder functions. In
-    the object pointed to by quo they store a value whose sign is the sign of x/y and whose
-    magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where
-    n is an implementation-defined integer greater than or equal to 3.
-<b>    Returns</b>
-3   The remquo functions return x REM y. If y is zero, the value stored in the object
-    pointed to by quo is unspecified and whether a domain error occurs or the functions
-    return zero is implementation defined.
-<a name="7.12.11" href="#7.12.11"><b>    7.12.11 Manipulation functions</b></a>
-<a name="7.12.11.1" href="#7.12.11.1"><b>    7.12.11.1 The copysign functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           double copysign(double x, double y);
-           float copysignf(float x, float y);
-           long double copysignl(long double x, long double y);
-<b>    Description</b>
-2   The copysign functions produce a value with the magnitude of x and the sign of y.
-    They produce a NaN (with the sign of y) if x is a NaN. On implementations that
-    represent a signed zero but do not treat negative zero consistently in arithmetic
-    operations, the copysign functions regard the sign of zero as positive.
-<b>    Returns</b>
-3   The copysign functions return a value with the magnitude of x and the sign of y.
-
-[<a name="p254" href="#p254">page 254</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.11.2" href="#7.12.11.2"><b>    7.12.11.2 The nan functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double nan(const char *tagp);
-            float nanf(const char *tagp);
-            long double nanl(const char *tagp);
-<b>    Description</b>
-2   The call nan("n-char-sequence") is equivalent to strtod("NAN(n-char-
-    sequence)",     (char**)       NULL); the call nan("") is equivalent to
-    strtod("NAN()", (char**) NULL). If tagp does not point to an n-char
-    sequence or an empty string, the call is equivalent to strtod("NAN", (char**)
-    NULL). Calls to nanf and nanl are equivalent to the corresponding calls to strtof
-    and strtold.
-<b>    Returns</b>
-3   The nan functions return a quiet NaN, if available, with content indicated through tagp.
-    If the implementation does not support quiet NaNs, the functions return zero.
-    Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
-<a name="7.12.11.3" href="#7.12.11.3"><b>    7.12.11.3 The nextafter functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double nextafter(double x, double y);
-            float nextafterf(float x, float y);
-            long double nextafterl(long double x, long double y);
-<b>    Description</b>
-2   The nextafter functions determine the next representable value, in the type of the
-    function, after x in the direction of y, where x and y are first converted to the type of the
-    function.<sup><a href="#note237"><b>237)</b></a></sup> The nextafter functions return y if x equals y. A range error may occur
-    if the magnitude of x is the largest finite value representable in the type and the result is
-    infinite or not representable in the type.
-<b>    Returns</b>
-3   The nextafter functions return the next representable value in the specified format
-    after x in the direction of y.
-
-
-    <sup><a name="note237" href="#note237"><b>237)</b></a></sup> The argument values are converted to the type of the function, even by a macro implementation of the
-         function.
-
-[<a name="p255" href="#p255">page 255</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.11.4" href="#7.12.11.4"><b>    7.12.11.4 The nexttoward functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double nexttoward(double x, long double y);
-            float nexttowardf(float x, long double y);
-            long double nexttowardl(long double x, long double y);
-<b>    Description</b>
-2   The nexttoward functions are equivalent to the nextafter functions except that the
-    second parameter has type long double and the functions return y converted to the
-    type of the function if x equals y.<sup><a href="#note238"><b>238)</b></a></sup>
-<a name="7.12.12" href="#7.12.12"><b>    7.12.12 Maximum, minimum, and positive difference functions</b></a>
-<a name="7.12.12.1" href="#7.12.12.1"><b>    7.12.12.1 The fdim functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fdim(double x, double y);
-            float fdimf(float x, float y);
-            long double fdiml(long double x, long double y);
-<b>    Description</b>
-2   The fdim functions determine the positive difference between their arguments:
-          {x - y if x &gt; y
+                return a &gt; b ? a : b;
+          }</pre>
+ extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
+ function declarator; and
+<pre>
+          { return a &gt; b ? a : b; }</pre>
+ is the function body. The following similar definition uses the identifier-list form for the parameter
+ declarations:
+ 
+ 
+ 
+ 
+<!--page 175 indent 5-->
+<pre>
+          extern int max(a, b)
+          int a, b;
           {
-          {+0     if x &lt;= y
-    A range error may occur.
-<b>    Returns</b>
-3   The fdim functions return the positive difference value.
-<a name="7.12.12.2" href="#7.12.12.2"><b>    7.12.12.2 The fmax functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fmax(double x, double y);
-            float fmaxf(float x, float y);
-            long double fmaxl(long double x, long double y);
-
-
-
-    <sup><a name="note238" href="#note238"><b>238)</b></a></sup> The result of the nexttoward functions is determined in the type of the function, without loss of
-         range or precision in a floating second argument.
-
-[<a name="p256" href="#p256">page 256</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The fmax functions determine the maximum numeric value of their arguments.<sup><a href="#note239"><b>239)</b></a></sup>
-<b>    Returns</b>
-3   The fmax functions return the maximum numeric value of their arguments.
-<a name="7.12.12.3" href="#7.12.12.3"><b>    7.12.12.3 The fmin functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fmin(double x, double y);
-            float fminf(float x, float y);
-            long double fminl(long double x, long double y);
-<b>    Description</b>
-2   The fmin functions determine the minimum numeric value of their arguments.<sup><a href="#note240"><b>240)</b></a></sup>
-<b>    Returns</b>
-3   The fmin functions return the minimum numeric value of their arguments.
-<a name="7.12.13" href="#7.12.13"><b>    7.12.13 Floating multiply-add</b></a>
-<a name="7.12.13.1" href="#7.12.13.1"><b>    7.12.13.1 The fma functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            double fma(double x, double y, double z);
-            float fmaf(float x, float y, float z);
-            long double fmal(long double x, long double y,
-                 long double z);
-<b>    Description</b>
-2   The fma functions compute (x x y) + z, rounded as one ternary operation: they compute
-    the value (as if) to infinite precision and round once to the result format, according to the
-    current rounding mode. A range error may occur.
-<b>    Returns</b>
-3   The fma functions return (x x y) + z, rounded as one ternary operation.
-
-
-
-
-    <sup><a name="note239" href="#note239"><b>239)</b></a></sup> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
-         fmax functions choose the numeric value. See <a href="#F.10.9.2">F.10.9.2</a>.
-    <sup><a name="note240" href="#note240"><b>240)</b></a></sup> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
-
-[<a name="p257" href="#p257">page 257</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.14" href="#7.12.14"><b>    7.12.14 Comparison macros</b></a>
-1   The relational and equality operators support the usual mathematical relationships
-    between numeric values. For any ordered pair of numeric values exactly one of the
-    relationships -- less, greater, and equal -- is true. Relational operators may raise the
-    ''invalid'' floating-point exception when argument values are NaNs. For a NaN and a
-    numeric value, or for two NaNs, just the unordered relationship is true.<sup><a href="#note241"><b>241)</b></a></sup> The following
-    subclauses provide macros that are quiet (non floating-point exception raising) versions
-    of the relational operators, and other comparison macros that facilitate writing efficient
-    code that accounts for NaNs without suffering the ''invalid'' floating-point exception. In
-    the synopses in this subclause, real-floating indicates that the argument shall be an
-    expression of real floating type<sup><a href="#note242"><b>242)</b></a></sup> (both arguments need not have the same type).<sup><a href="#note243"><b>243)</b></a></sup>
-<a name="7.12.14.1" href="#7.12.14.1"><b>    7.12.14.1 The isgreater macro</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             int isgreater(real-floating x, real-floating y);
-<b>    Description</b>
-2   The isgreater macro determines whether its first argument is greater than its second
-    argument. The value of isgreater(x, y) is always equal to (x) &gt; (y); however,
-    unlike (x) &gt; (y), isgreater(x, y) does not raise the ''invalid'' floating-point
-    exception when x and y are unordered.
-<b>    Returns</b>
-3   The isgreater macro returns the value of (x) &gt; (y).
-<a name="7.12.14.2" href="#7.12.14.2"><b>    7.12.14.2 The isgreaterequal macro</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.12">&lt;math.h&gt;</a>
-             int isgreaterequal(real-floating x, real-floating y);
-
-
-
-
-    <sup><a name="note241" href="#note241"><b>241)</b></a></sup> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
-         the operands compare unordered, as an error indicator for programs written without consideration of
-         NaNs; the result in these cases is false.
-    <sup><a name="note242" href="#note242"><b>242)</b></a></sup> If any argument is of integer type, or any other type that is not a real floating type, the behavior is
-         undefined.
-    <sup><a name="note243" href="#note243"><b>243)</b></a></sup> Whether an argument represented in a format wider than its semantic type is converted to the semantic
-         type is unspecified.
-
-[<a name="p258" href="#p258">page 258</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The isgreaterequal macro determines whether its first argument is greater than or
-    equal to its second argument. The value of isgreaterequal(x, y) is always equal
-    to (x) &gt;= (y); however, unlike (x) &gt;= (y), isgreaterequal(x, y) does
-    not raise the ''invalid'' floating-point exception when x and y are unordered.
-<b>    Returns</b>
-3   The isgreaterequal macro returns the value of (x) &gt;= (y).
-<a name="7.12.14.3" href="#7.12.14.3"><b>    7.12.14.3 The isless macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int isless(real-floating x, real-floating y);
-<b>    Description</b>
-2   The isless macro determines whether its first argument is less than its second
-    argument. The value of isless(x, y) is always equal to (x) &lt; (y); however,
-    unlike (x) &lt; (y), isless(x, y) does not raise the ''invalid'' floating-point
-    exception when x and y are unordered.
-<b>    Returns</b>
-3   The isless macro returns the value of (x) &lt; (y).
-<a name="7.12.14.4" href="#7.12.14.4"><b>    7.12.14.4 The islessequal macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.12">&lt;math.h&gt;</a>
-            int islessequal(real-floating x, real-floating y);
-<b>    Description</b>
-2   The islessequal macro determines whether its first argument is less than or equal to
-    its second argument. The value of islessequal(x, y) is always equal to
-    (x) &lt;= (y); however, unlike (x) &lt;= (y), islessequal(x, y) does not raise
-    the ''invalid'' floating-point exception when x and y are unordered.
-<b>    Returns</b>
-3   The islessequal macro returns the value of (x) &lt;= (y).
-
-[<a name="p259" href="#p259">page 259</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.12.14.5" href="#7.12.14.5"><b>    7.12.14.5 The islessgreater macro</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           int islessgreater(real-floating x, real-floating y);
-<b>    Description</b>
-2   The islessgreater macro determines whether its first argument is less than or
-    greater than its second argument. The islessgreater(x, y) macro is similar to
-    (x) &lt; (y) || (x) &gt; (y); however, islessgreater(x, y) does not raise
-    the ''invalid'' floating-point exception when x and y are unordered (nor does it evaluate x
-    and y twice).
-<b>    Returns</b>
-3   The islessgreater macro returns the value of (x) &lt; (y) || (x) &gt; (y).
-<a name="7.12.14.6" href="#7.12.14.6"><b>    7.12.14.6 The isunordered macro</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.12">&lt;math.h&gt;</a>
-           int isunordered(real-floating x, real-floating y);
-<b>    Description</b>
-2   The isunordered macro determines whether its arguments are unordered.
-<b>    Returns</b>
-3   The isunordered macro returns 1 if its arguments are unordered and 0 otherwise.
-
-[<a name="p260" href="#p260">page 260</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.13" href="#7.13"><b>    7.13 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
-1   The header <a href="#7.13">&lt;setjmp.h&gt;</a> defines the macro setjmp, and declares one function and
-    one type, for bypassing the normal function call and return discipline.<sup><a href="#note244"><b>244)</b></a></sup>
-2   The type declared is
-            jmp_buf
-    which is an array type suitable for holding the information needed to restore a calling
-    environment. The environment of a call to the setjmp macro consists of information
-    sufficient for a call to the longjmp function to return execution to the correct block and
-    invocation of that block, were it called recursively. It does not include the state of the
-    floating-point status flags, of open files, or of any other component of the abstract
-    machine.
-3   It is unspecified whether setjmp is a macro or an identifier declared with external
-    linkage. If a macro definition is suppressed in order to access an actual function, or a
-    program defines an external identifier with the name setjmp, the behavior is undefined.
-<a name="7.13.1" href="#7.13.1"><b>    7.13.1 Save calling environment</b></a>
-<a name="7.13.1.1" href="#7.13.1.1"><b>    7.13.1.1 The setjmp macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.13">&lt;setjmp.h&gt;</a>
-            int setjmp(jmp_buf env);
-<b>    Description</b>
-2   The setjmp macro saves its calling environment in its jmp_buf argument for later use
-    by the longjmp function.
-<b>    Returns</b>
-3   If the return is from a direct invocation, the setjmp macro returns the value zero. If the
-    return is from a call to the longjmp function, the setjmp macro returns a nonzero
-    value.
-    Environmental limits
-4   An invocation of the setjmp macro shall appear only in one of the following contexts:
-    -- the entire controlling expression of a selection or iteration statement;
-    -- one operand of a relational or equality operator with the other operand an integer
-      constant expression, with the resulting expression being the entire controlling
-
-
-    <sup><a name="note244" href="#note244"><b>244)</b></a></sup> These functions are useful for dealing with unusual conditions encountered in a low-level function of
-         a program.
-
-[<a name="p261" href="#p261">page 261</a>] (<a href="#Contents">Contents</a>)
-
-        expression of a selection or iteration statement;
-    -- the operand of a unary ! operator with the resulting expression being the entire
-      controlling expression of a selection or iteration statement; or
-    -- the entire expression of an expression statement (possibly cast to void).
-5   If the invocation appears in any other context, the behavior is undefined.
-<a name="7.13.2" href="#7.13.2"><b>    7.13.2 Restore calling environment</b></a>
-<a name="7.13.2.1" href="#7.13.2.1"><b>    7.13.2.1 The longjmp function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.13">&lt;setjmp.h&gt;</a>
-             _Noreturn void longjmp(jmp_buf env, int val);
-<b>    Description</b>
-2   The longjmp function restores the environment saved by the most recent invocation of
-    the setjmp macro in the same invocation of the program with the corresponding
-    jmp_buf argument. If there has been no such invocation, or if the function containing
-    the invocation of the setjmp macro has terminated execution<sup><a href="#note245"><b>245)</b></a></sup> in the interim, or if the
-    invocation of the setjmp macro was within the scope of an identifier with variably
-    modified type and execution has left that scope in the interim, the behavior is undefined.
-3   All accessible objects have values, and all other components of the abstract machine<sup><a href="#note246"><b>246)</b></a></sup>
-    have state, as of the time the longjmp function was called, except that the values of
-    objects of automatic storage duration that are local to the function containing the
-    invocation of the corresponding setjmp macro that do not have volatile-qualified type
-    and have been changed between the setjmp invocation and longjmp call are
-    indeterminate.
-<b>    Returns</b>
-4   After longjmp is completed, program execution continues as if the corresponding
-    invocation of the setjmp macro had just returned the value specified by val. The
-    longjmp function cannot cause the setjmp macro to return the value 0; if val is 0,
-    the setjmp macro returns the value 1.
-5   EXAMPLE The longjmp function that returns control back to the point of the setjmp invocation
-    might cause memory associated with a variable length array object to be squandered.
-
-
-
-
-    <sup><a name="note245" href="#note245"><b>245)</b></a></sup> For example, by executing a return statement or because another longjmp call has caused a
-         transfer to a setjmp invocation in a function earlier in the set of nested calls.
-    <sup><a name="note246" href="#note246"><b>246)</b></a></sup> This includes, but is not limited to, the floating-point status flags and the state of open files.
-
-[<a name="p262" href="#p262">page 262</a>] (<a href="#Contents">Contents</a>)
-
-        #include <a href="#7.13">&lt;setjmp.h&gt;</a>
-        jmp_buf buf;
-        void g(int n);
-        void h(int n);
-        int n = 6;
-        void f(void)
-        {
-              int x[n];          // valid: f is not terminated
-              setjmp(buf);
-              g(n);
-        }
-        void g(int n)
-        {
-              int a[n];          // a may remain allocated
-              h(n);
-        }
-        void h(int n)
-        {
-              int b[n];          // b may remain allocated
-              longjmp(buf, 2);   // might cause memory loss
-        }
-
-[<a name="p263" href="#p263">page 263</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.14" href="#7.14"><b>    7.14 Signal handling &lt;signal.h&gt;</b></a>
-1   The header <a href="#7.14">&lt;signal.h&gt;</a> declares a type and two functions and defines several macros,
-    for handling various signals (conditions that may be reported during program execution).
-2   The type defined is
-             sig_atomic_t
-    which is the (possibly volatile-qualified) integer type of an object that can be accessed as
-    an atomic entity, even in the presence of asynchronous interrupts.
-3   The macros defined are
-             SIG_DFL
-             SIG_ERR
-             SIG_IGN
-    which expand to constant expressions with distinct values that have type compatible with
-    the second argument to, and the return value of, the signal function, and whose values
-    compare unequal to the address of any declarable function; and the following, which
-    expand to positive integer constant expressions with type int and distinct values that are
-    the signal numbers, each corresponding to the specified condition:
-             SIGABRT abnormal termination, such as is initiated by the abort function
-             SIGFPE        an erroneous arithmetic operation, such as zero divide or an operation
-                           resulting in overflow
-             SIGILL        detection of an invalid function image, such as an invalid instruction
-             SIGINT        receipt of an interactive attention signal
-             SIGSEGV an invalid access to storage
-             SIGTERM a termination request sent to the program
-4   An implementation need not generate any of these signals, except as a result of explicit
-    calls to the raise function. Additional signals and pointers to undeclarable functions,
-    with macro definitions beginning, respectively, with the letters SIG and an uppercase
-    letter or with SIG_ and an uppercase letter,<sup><a href="#note247"><b>247)</b></a></sup> may also be specified by the
-    implementation. The complete set of signals, their semantics, and their default handling
-    is implementation-defined; all signal numbers shall be positive.
-
-
-
-
-    <sup><a name="note247" href="#note247"><b>247)</b></a></sup> See ''future library directions'' (<a href="#7.30.6">7.30.6</a>). The names of the signal numbers reflect the following terms
-         (respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
-         and termination.
-
-[<a name="p264" href="#p264">page 264</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.14.1" href="#7.14.1"><b>    7.14.1 Specify signal handling</b></a>
-<a name="7.14.1.1" href="#7.14.1.1"><b>    7.14.1.1 The signal function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.14">&lt;signal.h&gt;</a>
-            void (*signal(int sig, void (*func)(int)))(int);
-<b>    Description</b>
-2   The signal function chooses one of three ways in which receipt of the signal number
-    sig is to be subsequently handled. If the value of func is SIG_DFL, default handling
-    for that signal will occur. If the value of func is SIG_IGN, the signal will be ignored.
-    Otherwise, func shall point to a function to be called when that signal occurs. An
-    invocation of such a function because of a signal, or (recursively) of any further functions
-    called by that invocation (other than functions in the standard library),<sup><a href="#note248"><b>248)</b></a></sup> is called a
-    signal handler.
-3   When a signal occurs and func points to a function, it is implementation-defined
-    whether the equivalent of signal(sig, SIG_DFL); is executed or the
-    implementation prevents some implementation-defined set of signals (at least including
-    sig) from occurring until the current signal handling has completed; in the case of
-    SIGILL, the implementation may alternatively define that no action is taken. Then the
-    equivalent of (*func)(sig); is executed. If and when the function returns, if the
-    value of sig is SIGFPE, SIGILL, SIGSEGV, or any other implementation-defined
-    value corresponding to a computational exception, the behavior is undefined; otherwise
-    the program will resume execution at the point it was interrupted.
-4   If the signal occurs as the result of calling the abort or raise function, the signal
-    handler shall not call the raise function.
-5   If the signal occurs other than as the result of calling the abort or raise function, the
-    behavior is undefined if the signal handler refers to any object with static or thread
-    storage duration that is not a lock-free atomic object other than by assigning a value to an
-    object declared as volatile sig_atomic_t, or the signal handler calls any function
-    in the standard library other than the abort function, the _Exit function, the
-    quick_exit function, or the signal function with the first argument equal to the
-    signal number corresponding to the signal that caused the invocation of the handler.
-    Furthermore, if such a call to the signal function results in a SIG_ERR return, the
-    value of errno is indeterminate.<sup><a href="#note249"><b>249)</b></a></sup>
-
-
-    <sup><a name="note248" href="#note248"><b>248)</b></a></sup> This includes functions called indirectly via standard library functions (e.g., a SIGABRT handler
-         called via the abort function).
-    <sup><a name="note249" href="#note249"><b>249)</b></a></sup> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
-
-[<a name="p265" href="#p265">page 265</a>] (<a href="#Contents">Contents</a>)
-
-6   At program startup, the equivalent of
-           signal(sig, SIG_IGN);
-    may be executed for some signals selected in an implementation-defined manner; the
-    equivalent of
-           signal(sig, SIG_DFL);
-    is executed for all other signals defined by the implementation.
-7   The implementation shall behave as if no library function calls the signal function.
-<b>    Returns</b>
-8   If the request can be honored, the signal function returns the value of func for the
-    most recent successful call to signal for the specified signal sig. Otherwise, a value of
-    SIG_ERR is returned and a positive value is stored in errno.
-    Forward references: the abort function (<a href="#7.22.4.1">7.22.4.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the
-    _Exit function (<a href="#7.22.4.5">7.22.4.5</a>), the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
-<a name="7.14.2" href="#7.14.2"><b>    7.14.2 Send signal</b></a>
-<a name="7.14.2.1" href="#7.14.2.1"><b>    7.14.2.1 The raise function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.14">&lt;signal.h&gt;</a>
-           int raise(int sig);
-<b>    Description</b>
-2   The raise function carries out the actions described in <a href="#7.14.1.1">7.14.1.1</a> for the signal sig. If a
-    signal handler is called, the raise function shall not return until after the signal handler
-    does.
-<b>    Returns</b>
-3   The raise function returns zero if successful, nonzero if unsuccessful.
-
-[<a name="p266" href="#p266">page 266</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.15" href="#7.15"><b>    7.15 Alignment &lt;stdalign.h&gt;</b></a>
-1   The header <a href="#7.15">&lt;stdalign.h&gt;</a> defines two macros.
-2   The macro
-            alignas
-    expands to _Alignas.
-3   The remaining macro is suitable for use in #if preprocessing directives. It is
-            __alignas_is_defined
-    which expands to the integer constant 1.
-
-[<a name="p267" href="#p267">page 267</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.16" href="#7.16"><b>    7.16 Variable arguments &lt;stdarg.h&gt;</b></a>
-1   The header <a href="#7.16">&lt;stdarg.h&gt;</a> declares a type and defines four macros, for advancing
-    through a list of arguments whose number and types are not known to the called function
-    when it is translated.
-2   A function may be called with a variable number of arguments of varying types. As
-    described in <a href="#6.9.1">6.9.1</a>, its parameter list contains one or more parameters. The rightmost
-    parameter plays a special role in the access mechanism, and will be designated parmN in
-    this description.
-3   The type declared is
-            va_list
-    which is a complete object type suitable for holding information needed by the macros
-    va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
-    desired, the called function shall declare an object (generally referred to as ap in this
-    subclause) having type va_list. The object ap may be passed as an argument to
-    another function; if that function invokes the va_arg macro with parameter ap, the
-    value of ap in the calling function is indeterminate and shall be passed to the va_end
-    macro prior to any further reference to ap.<sup><a href="#note250"><b>250)</b></a></sup>
-<a name="7.16.1" href="#7.16.1"><b>    7.16.1 Variable argument list access macros</b></a>
-1   The va_start and va_arg macros described in this subclause shall be implemented
-    as macros, not functions. It is unspecified whether va_copy and va_end are macros or
-    identifiers declared with external linkage. If a macro definition is suppressed in order to
-    access an actual function, or a program defines an external identifier with the same name,
-    the behavior is undefined. Each invocation of the va_start and va_copy macros
-    shall be matched by a corresponding invocation of the va_end macro in the same
-    function.
-<a name="7.16.1.1" href="#7.16.1.1"><b>    7.16.1.1 The va_arg macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            type va_arg(va_list ap, type);
-<b>    Description</b>
-2   The va_arg macro expands to an expression that has the specified type and the value of
-    the next argument in the call. The parameter ap shall have been initialized by the
-    va_start or va_copy macro (without an intervening invocation of the va_end
-
-    <sup><a name="note250" href="#note250"><b>250)</b></a></sup> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
-         case the original function may make further use of the original list after the other function returns.
-
-[<a name="p268" href="#p268">page 268</a>] (<a href="#Contents">Contents</a>)
-
-    macro for the same ap). Each invocation of the va_arg macro modifies ap so that the
-    values of successive arguments are returned in turn. The parameter type shall be a type
-    name specified such that the type of a pointer to an object that has the specified type can
-    be obtained simply by postfixing a * to type. If there is no actual next argument, or if
-    type is not compatible with the type of the actual next argument (as promoted according
-    to the default argument promotions), the behavior is undefined, except for the following
-    cases:
-    -- one type is a signed integer type, the other type is the corresponding unsigned integer
-      type, and the value is representable in both types;
-    -- one type is pointer to void and the other is a pointer to a character type.
-<b>    Returns</b>
-3   The first invocation of the va_arg macro after that of the va_start macro returns the
-    value of the argument after that specified by parmN . Successive invocations return the
-    values of the remaining arguments in succession.
-<a name="7.16.1.2" href="#7.16.1.2"><b>    7.16.1.2 The va_copy macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            void va_copy(va_list dest, va_list src);
-<b>    Description</b>
-2   The va_copy macro initializes dest as a copy of src, as if the va_start macro had
-    been applied to dest followed by the same sequence of uses of the va_arg macro as
-    had previously been used to reach the present state of src. Neither the va_copy nor
-    va_start macro shall be invoked to reinitialize dest without an intervening
-    invocation of the va_end macro for the same dest.
-<b>    Returns</b>
-3   The va_copy macro returns no value.
-<a name="7.16.1.3" href="#7.16.1.3"><b>    7.16.1.3 The va_end macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            void va_end(va_list ap);
-<b>    Description</b>
-2   The va_end macro facilitates a normal return from the function whose variable
-    argument list was referred to by the expansion of the va_start macro, or the function
-    containing the expansion of the va_copy macro, that initialized the va_list ap. The
-    va_end macro may modify ap so that it is no longer usable (without being reinitialized
-
-[<a name="p269" href="#p269">page 269</a>] (<a href="#Contents">Contents</a>)
-
-    by the va_start or va_copy macro). If there is no corresponding invocation of the
-    va_start or va_copy macro, or if the va_end macro is not invoked before the
-    return, the behavior is undefined.
-<b>    Returns</b>
-3   The va_end macro returns no value.
-<a name="7.16.1.4" href="#7.16.1.4"><b>    7.16.1.4 The va_start macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            void va_start(va_list ap, parmN);
-<b>    Description</b>
-2   The va_start macro shall be invoked before any access to the unnamed arguments.
-3   The va_start macro initializes ap for subsequent use by the va_arg and va_end
-    macros. Neither the va_start nor va_copy macro shall be invoked to reinitialize ap
-    without an intervening invocation of the va_end macro for the same ap.
-4   The parameter parmN is the identifier of the rightmost parameter in the variable
-    parameter list in the function definition (the one just before the , ...). If the parameter
-    parmN is declared with the register storage class, with a function or array type, or
-    with a type that is not compatible with the type that results after application of the default
-    argument promotions, the behavior is undefined.
-<b>    Returns</b>
-5   The va_start macro returns no value.
-6   EXAMPLE 1 The function f1 gathers into an array a list of arguments that are pointers to strings (but not
-    more than MAXARGS arguments), then passes the array as a single argument to function f2. The number of
-    pointers is specified by the first argument to f1.
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #define MAXARGS   31
-            void f1(int n_ptrs, ...)
-            {
-                  va_list ap;
-                  char *array[MAXARGS];
-                  int ptr_no = 0;
-
-[<a name="p270" href="#p270">page 270</a>] (<a href="#Contents">Contents</a>)
-
-                      if (n_ptrs &gt; MAXARGS)
-                            n_ptrs = MAXARGS;
-                      va_start(ap, n_ptrs);
-                      while (ptr_no &lt; n_ptrs)
-                            array[ptr_no++] = va_arg(ap, char *);
-                      va_end(ap);
-                      f2(n_ptrs, array);
-             }
-    Each call to f1 is required to have visible the definition of the function or a declaration such as
-             void f1(int, ...);
-
-7   EXAMPLE 2 The function f3 is similar, but saves the status of the variable argument list after the
-    indicated number of arguments; after f2 has been called once with the whole list, the trailing part of the list
-    is gathered again and passed to function f4.
-             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-             #define MAXARGS 31
-             void f3(int n_ptrs, int f4_after, ...)
-             {
-                   va_list ap, ap_save;
-                   char *array[MAXARGS];
-                   int ptr_no = 0;
-                   if (n_ptrs &gt; MAXARGS)
-                         n_ptrs = MAXARGS;
-                   va_start(ap, f4_after);
-                   while (ptr_no &lt; n_ptrs) {
-                         array[ptr_no++] = va_arg(ap, char *);
-                         if (ptr_no == f4_after)
-                               va_copy(ap_save, ap);
-                   }
-                   va_end(ap);
-                   f2(n_ptrs, array);
-                      // Now process the saved copy.
-                      n_ptrs -= f4_after;
-                      ptr_no = 0;
-                      while (ptr_no &lt; n_ptrs)
-                            array[ptr_no++] = va_arg(ap_save, char *);
-                      va_end(ap_save);
-                      f4(n_ptrs, array);
-             }
-
-[<a name="p271" href="#p271">page 271</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.17" href="#7.17"><b>    7.17 Atomics &lt;stdatomic.h&gt;</b></a>
-<a name="7.17.1" href="#7.17.1"><b>    7.17.1 Introduction</b></a>
-1   The header <a href="#7.17">&lt;stdatomic.h&gt;</a> defines several macros and declares several types and
-    functions for performing atomic operations on data shared between threads.
-2   Implementations that define the macro __STDC_NO_THREADS__ need not provide
-    this header nor support any of its facilities.
-3   The macros defined are the atomic lock-free macros
-           ATOMIC_CHAR_LOCK_FREE
-           ATOMIC_CHAR16_T_LOCK_FREE
-           ATOMIC_CHAR32_T_LOCK_FREE
-           ATOMIC_WCHAR_T_LOCK_FREE
-           ATOMIC_SHORT_LOCK_FREE
-           ATOMIC_INT_LOCK_FREE
-           ATOMIC_LONG_LOCK_FREE
-           ATOMIC_LLONG_LOCK_FREE
-           ATOMIC_ADDRESS_LOCK_FREE
-    which indicate the lock-free property of the corresponding atomic types (both signed and
-    unsigned); and
-           ATOMIC_FLAG_INIT
-    which expands to an initializer for an object of type atomic_flag.
-4   The types include
-           memory_order
-    which is an enumerated type whose enumerators identify memory ordering constraints;
-           atomic_flag
-    which is a structure type representing a lock-free, primitive atomic flag;
-           atomic_bool
-    which is a structure type representing the atomic analog of the type _Bool;
-           atomic_address
-    which is a structure type representing the atomic analog of a pointer type; and several
-    atomic analogs of integer types.
-5   In the following operation definitions:
-    -- An A refers to one of the atomic types.
-
-[<a name="p272" href="#p272">page 272</a>] (<a href="#Contents">Contents</a>)
-
-    -- A C refers to its corresponding non-atomic type. The atomic_address atomic
-      type corresponds to the void * non-atomic type.
-    -- An M refers to the type of the other argument for arithmetic operations. For atomic
-      integer types, M is C. For atomic address types, M is ptrdiff_t.
-    -- The functions not ending in _explicit have the same semantics as the
-      corresponding _explicit function with memory_order_seq_cst for the
-      memory_order argument.
-6   NOTE Many operations are volatile-qualified. The ''volatile as device register'' semantics have not
-    changed in the standard. This qualification means that volatility is preserved when applying these
-    operations to volatile objects.
-
-<a name="7.17.2" href="#7.17.2"><b>    7.17.2 Initialization</b></a>
-<a name="7.17.2.1" href="#7.17.2.1"><b>    7.17.2.1 The ATOMIC_VAR_INIT macro</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            #define ATOMIC_VAR_INIT(C value)
-<b>    Description</b>
-2   The ATOMIC_VAR_INIT macro expands to a token sequence suitable for initializing an
-    atomic object of a type that is initialization-compatible with value. An atomic object
-    with automatic storage duration that is not explicitly initialized using
-    ATOMIC_VAR_INIT is initially in an indeterminate state; however, the default (zero)
-    initialization for objects with static or thread-local storage duration is guaranteed to
-    produce a valid state.
-3   Concurrent access to the variable being initialized, even via an atomic operation,
-    constitutes a data race.
-4   EXAMPLE
-            atomic_int guide = ATOMIC_VAR_INIT(42);
-
-<a name="7.17.2.2" href="#7.17.2.2"><b>    7.17.2.2 The atomic_init generic function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            void atomic_init(volatile A *obj, C value);
-<b>    Description</b>
-2   The atomic_init generic function initializes the atomic object pointed to by obj to
-    the value value, while also initializing any additional state that the implementation
-    might need to carry for the atomic object.
-
-[<a name="p273" href="#p273">page 273</a>] (<a href="#Contents">Contents</a>)
-
-3   Although this function initializes an atomic object, it does not avoid data races;
-    concurrent access to the variable being initialized, even via an atomic operation,
-    constitutes a data race.
-<b>    Returns</b>
-4   The atomic_init generic function returns no value.
-5   EXAMPLE
-            atomic_int guide;
-            atomic_init(&amp;guide, 42);
-
-<a name="7.17.3" href="#7.17.3"><b>    7.17.3 Order and consistency</b></a>
-1   The enumerated type memory_order specifies the detailed regular (non-atomic)
-    memory synchronization operations as defined in <a href="#5.1.2.4">5.1.2.4</a> and may provide for operation
-    ordering. Its enumeration constants are as follows:
-            memory_order_relaxed
-            memory_order_consume
-            memory_order_acquire
-            memory_order_release
-            memory_order_acq_rel
-            memory_order_seq_cst
-2   For memory_order_relaxed, no operation orders memory.
-3   For       memory_order_release,       memory_order_acq_rel,             and
-    memory_order_seq_cst, a store operation performs a release operation on the
-    affected memory location.
-4   For       memory_order_acquire,       memory_order_acq_rel,             and
-    memory_order_seq_cst, a load operation performs an acquire operation on the
-    affected memory location.
-5   For memory_order_consume, a load operation performs a consume operation on the
-    affected memory location.
-6   For memory_order_seq_cst, there shall be a single total order S on all operations,
-    consistent with the ''happens before'' order and modification orders for all affected
-    locations, such that each memory_order_seq_cst operation that loads a value
-    observes either the last preceding modification according to this order S, or the result of
-    an operation that is not memory_order_seq_cst.
-7   NOTE 1 Although it is not explicitly required that S include lock operations, it can always be extended to
-    an order that does include lock and unlock operations, since the ordering between those is already included
-    in the ''happens before'' ordering.
-
-8   NOTE 2 Atomic operations specifying memory_order_relaxed are relaxed only with respect to
-    memory ordering. Implementations must still guarantee that any given atomic access to a particular atomic
-
-[<a name="p274" href="#p274">page 274</a>] (<a href="#Contents">Contents</a>)
-
-     object be indivisible with respect to all other atomic accesses to that object.
-
-9    For an atomic operation B that reads the value of an atomic object M, if there is a
-     memory_order_seq_cst fence X sequenced before B, then B observes either the
-     last memory_order_seq_cst modification of M preceding X in the total order S or
-     a later modification of M in its modification order.
-10   For atomic operations A and B on an atomic object M, where A modifies M and B takes
-     its value, if there is a memory_order_seq_cst fence X such that A is sequenced
-     before X and B follows X in S, then B observes either the effects of A or a later
-     modification of M in its modification order.
-11   For atomic operations A and B on an atomic object M, where A modifies M and B takes
-     its value, if there are memory_order_seq_cst fences X and Y such that A is
-     sequenced before X, Y is sequenced before B, and X precedes Y in S, then B observes
-     either the effects of A or a later modification of M in its modification order.
-12   Atomic read-modify-write operations shall always read the last value (in the modification
-     order) stored before the write associated with the read-modify-write operation.
-13   An atomic store shall only store a value that has been computed from constants and
-     program input values by a finite sequence of program evaluations, such that each
-     evaluation observes the values of variables as computed by the last prior assignment in
-     the sequence.<sup><a href="#note251"><b>251)</b></a></sup> The ordering of evaluations in this sequence shall be such that
-     -- If an evaluation B observes a value computed by A in a different thread, then B does
-       not happen before A.
-     -- If an evaluation A is included in the sequence, then all evaluations that assign to the
-       same variable and happen before A are also included.
-14   NOTE 3 The second requirement disallows ''out-of-thin-air'', or ''speculative'' stores of atomics when
-     relaxed atomics are used. Since unordered operations are involved, evaluations may appear in this
-     sequence out of thread order. For example, with x and y initially zero,
-              // Thread 1:
-              r1 = atomic_load_explicit(&amp;y, memory_order_relaxed);
-              atomic_store_explicit(&amp;x, r1, memory_order_relaxed);
-
-              // Thread 2:
-              r2 = atomic_load_explicit(&amp;x, memory_order_relaxed);
-              atomic_store_explicit(&amp;y, 42, memory_order_relaxed);
-     is allowed to produce r1 == 42 &amp;&amp; r2 == 42. The sequence of evaluations justifying this consists of:
-
-
-
-
-     <sup><a name="note251" href="#note251"><b>251)</b></a></sup> Among other implications, atomic variables shall not decay.
-
-[<a name="p275" href="#p275">page 275</a>] (<a href="#Contents">Contents</a>)
-
-             atomic_store_explicit(&amp;y, 42,               memory_order_relaxed);
-             r1 = atomic_load_explicit(&amp;y,               memory_order_relaxed);
-             atomic_store_explicit(&amp;x, r1,               memory_order_relaxed);
-             r2 = atomic_load_explicit(&amp;x,               memory_order_relaxed);
-     On the other hand,
-             // Thread 1:
-             r1 = atomic_load_explicit(&amp;y, memory_order_relaxed);
-             atomic_store_explicit(&amp;x, r1, memory_order_relaxed);
-
-             // Thread 2:
-             r2 = atomic_load_explicit(&amp;x, memory_order_relaxed);
-             atomic_store_explicit(&amp;y, r2, memory_order_relaxed);
-     is not allowed to produce r1 == 42 &amp;&amp; r2 = 42, since there is no sequence of evaluations that results
-     in the computation of 42. In the absence of ''relaxed'' operations and read-modify-write operations with
-     weaker than memory_order_acq_rel ordering, the second requirement has no impact.
-
-     Recommended practice
-15   The requirements do not forbid r1 == 42 &amp;&amp; r2 == 42 in the following example,
-     with x and y initially zero:
-             // Thread 1:
-             r1 = atomic_load_explicit(&amp;x, memory_order_relaxed);
-             if (r1 == 42)
-                  atomic_store_explicit(&amp;y, r1, memory_order_relaxed);
-
-             // Thread 2:
-             r2 = atomic_load_explicit(&amp;y, memory_order_relaxed);
-             if (r2 == 42)
-                  atomic_store_explicit(&amp;x, 42, memory_order_relaxed);
-     However, this is not useful behavior, and implementations should not allow it.
-16   Implementations should make atomic stores visible to atomic loads within a reasonable
-     amount of time.
-<a name="7.17.3.1" href="#7.17.3.1"><b>     7.17.3.1 The kill_dependency macro</b></a>
-<b>     Synopsis</b>
-1            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-             type kill_dependency(type y);
-<b>     Description</b>
-2    The kill_dependency macro terminates a dependency chain; the argument does not
-     carry a dependency to the return value.
-
-[<a name="p276" href="#p276">page 276</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The kill_dependency macro returns the value of y.
-<a name="7.17.4" href="#7.17.4"><b>    7.17.4 Fences</b></a>
-1   This subclause introduces synchronization primitives called fences. Fences can have
-    acquire semantics, release semantics, or both. A fence with acquire semantics is called
-    an acquire fence; a fence with release semantics is called a release fence.
-2   A release fence A synchronizes with an acquire fence B if there exist atomic operations
-    X and Y , both operating on some atomic object M, such that A is sequenced before X, X
-    modifies M, Y is sequenced before B, and Y reads the value written by X or a value
-    written by any side effect in the hypothetical release sequence X would head if it were a
-    release operation.
-3   A release fence A synchronizes with an atomic operation B that performs an acquire
-    operation on an atomic object M if there exists an atomic operation X such that A is
-    sequenced before X, X modifies M, and B reads the value written by X or a value written
-    by any side effect in the hypothetical release sequence X would head if it were a release
-    operation.
-4   An atomic operation A that is a release operation on an atomic object M synchronizes
-    with an acquire fence B if there exists some atomic operation X on M such that X is
-    sequenced before B and reads the value written by A or a value written by any side effect
-    in the release sequence headed by A.
-<a name="7.17.4.1" href="#7.17.4.1"><b>    7.17.4.1 The atomic_thread_fence function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            void atomic_thread_fence(memory_order order);
-<b>    Description</b>
-2   Depending on the value of order, this operation:
-    -- has no effects, if order == memory_order_relaxed;
-    -- is an acquire fence, if order == memory_order_acquire or order ==
-      memory_order_consume;
-    -- is a release fence, if order == memory_order_release;
-    -- is both an acquire fence              and   a    release   fence,    if   order     ==
-      memory_order_acq_rel;
-    -- is a sequentially consistent acquire and release fence, if order                    ==
-      memory_order_seq_cst.
-
-[<a name="p277" href="#p277">page 277</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The atomic_thread_fence function returns no value.
-<a name="7.17.4.2" href="#7.17.4.2"><b>    7.17.4.2 The atomic_signal_fence function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            void atomic_signal_fence(memory_order order);
-<b>    Description</b>
-2   Equivalent to atomic_thread_fence(order), except that ''synchronizes with''
-    relationships are established only between a thread and a signal handler executed in the
-    same thread.
-3   NOTE 1 The atomic_signal_fence function can be used to specify the order in which actions
-    performed by the thread become visible to the signal handler.
-
-4   NOTE 2 Compiler optimizations and reorderings of loads and stores are inhibited in the same way as with
-    atomic_thread_fence, but the hardware fence instructions that atomic_thread_fence would
-    have inserted are not emitted.
-
-<b>    Returns</b>
-5   The atomic_signal_fence function returns no value.
-<a name="7.17.5" href="#7.17.5"><b>    7.17.5 Lock-free property</b></a>
-1   The atomic lock-free macros indicate the lock-free property of integer and address atomic
-    types. A value of 0 indicates that the type is never lock-free; a value of 1 indicates that
-    the type is sometimes lock-free; a value of 2 indicates that the type is always lock-free.
-2   NOTE Operations that are lock-free should also be address-free. That is, atomic operations on the same
-    memory location via two different addresses will communicate atomically. The implementation should not
-    depend on any per-process state. This restriction enables communication via memory mapped into a
-    process more than once and memory shared between two processes.
-
-<a name="7.17.5.1" href="#7.17.5.1"><b>    7.17.5.1 The atomic_is_lock_free generic function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            _Bool atomic_is_lock_free(atomic_type const volatile *obj);
-<b>    Description</b>
-2   The atomic_is_lock_free generic function indicates whether or not the object
-    pointed to by obj is lock-free. atomic_type can be any atomic type.
-<b>    Returns</b>
-3   The atomic_is_lock_free generic function returns nonzero (true) if and only if the
-    object's operations are lock-free. The result of a lock-free query on one object cannot be
-
-[<a name="p278" href="#p278">page 278</a>] (<a href="#Contents">Contents</a>)
-
-    inferred from the result of a lock-free query on another object.
-<a name="7.17.6" href="#7.17.6"><b>    7.17.6 Atomic integer and address types</b></a>
-1   For each line in the following table, the atomic type name is declared as the
-    corresponding direct type.
-
-[<a name="p279" href="#p279">page 279</a>] (<a href="#Contents">Contents</a>)
-
-               Atomic type name                              Direct type
-           atomic_char                           _Atomic    char
-           atomic_schar                          _Atomic    signed char
-           atomic_uchar                          _Atomic    unsigned char
-           atomic_short                          _Atomic    short
-           atomic_ushort                         _Atomic    unsigned short
-           atomic_int                            _Atomic    int
-           atomic_uint                           _Atomic    unsigned int
-           atomic_long                           _Atomic    long
-           atomic_ulong                          _Atomic    unsigned long
-           atomic_llong                          _Atomic    long long
-           atomic_ullong                         _Atomic    unsigned long long
-           atomic_char16_t                       _Atomic    char16_t
-           atomic_char32_t                       _Atomic    char32_t
-           atomic_wchar_t                        _Atomic    wchar_t
-           atomic_int_least8_t                   _Atomic    int_least8_t
-           atomic_uint_least8_t                  _Atomic    uint_least8_t
-           atomic_int_least16_t                  _Atomic    int_least16_t
-           atomic_uint_least16_t                 _Atomic    uint_least16_t
-           atomic_int_least32_t                  _Atomic    int_least32_t
-           atomic_uint_least32_t                 _Atomic    uint_least32_t
-           atomic_int_least64_t                  _Atomic    int_least64_t
-           atomic_uint_least64_t                 _Atomic    uint_least64_t
-           atomic_int_fast8_t                    _Atomic    int_fast8_t
-           atomic_uint_fast8_t                   _Atomic    uint_fast8_t
-           atomic_int_fast16_t                   _Atomic    int_fast16_t
-           atomic_uint_fast16_t                  _Atomic    uint_fast16_t
-           atomic_int_fast32_t                   _Atomic    int_fast32_t
-           atomic_uint_fast32_t                  _Atomic    uint_fast32_t
-           atomic_int_fast64_t                   _Atomic    int_fast64_t
-           atomic_uint_fast64_t                  _Atomic    uint_fast64_t
-           atomic_intptr_t                       _Atomic    intptr_t
-           atomic_uintptr_t                      _Atomic    uintptr_t
-           atomic_size_t                         _Atomic    size_t
-           atomic_ptrdiff_t                      _Atomic    ptrdiff_t
-           atomic_intmax_t                       _Atomic    intmax_t
-           atomic_uintmax_t                      _Atomic    uintmax_t
-2   The semantics of the operations on these types are defined in <a href="#7.17.7">7.17.7</a>.
-3   The atomic_bool type provides an atomic boolean.
-
-[<a name="p280" href="#p280">page 280</a>] (<a href="#Contents">Contents</a>)
-
-4   The atomic_address type provides atomic void * operations. The unit of
-    addition/subtraction shall be one byte.
-5   NOTE The representation of atomic integer and address types need not have the same size as their
-    corresponding regular types. They should have the same size whenever possible, as it eases effort required
-    to port existing code.
-
-<a name="7.17.7" href="#7.17.7"><b>    7.17.7 Operations on atomic types</b></a>
-1   There are only a few kinds of operations on atomic types, though there are many
-    instances of those kinds. This subclause specifies each general kind.
-<a name="7.17.7.1" href="#7.17.7.1"><b>    7.17.7.1 The atomic_store generic functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            void atomic_store(volatile A *object, C desired);
-            void atomic_store_explicit(volatile A *object,
-                 C desired, memory_order order);
-<b>    Description</b>
-2   The      order      argument    shall    not    be    memory_order_acquire,
-    memory_order_consume, nor memory_order_acq_rel. Atomically replace the
-    value pointed to by object with the value of desired. Memory is affected according
-    to the value of order.
-<b>    Returns</b>
-3   The atomic_store generic functions return no value.
-<a name="7.17.7.2" href="#7.17.7.2"><b>    7.17.7.2 The atomic_load generic functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            C atomic_load(volatile A *object);
-            C atomic_load_explicit(volatile A *object,
-                 memory_order order);
-<b>    Description</b>
-2   The order argument shall not be memory_order_release nor
-    memory_order_acq_rel. Memory is affected according to the value of order.
-<b>    Returns</b>
-    Atomically returns the value pointed to by object.
-
-[<a name="p281" href="#p281">page 281</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.17.7.3" href="#7.17.7.3"><b>    7.17.7.3 The atomic_exchange generic functions</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-             C atomic_exchange(volatile A *object, C desired);
-             C atomic_exchange_explicit(volatile A *object,
-                  C desired, memory_order order);
-<b>    Description</b>
-2   Atomically replace the value pointed to by object with desired. Memory is affected
-    according to the value of order. These operations are read-modify-write operations
-    (<a href="#5.1.2.4">5.1.2.4</a>).
-<b>    Returns</b>
-3   Atomically returns the value pointed to by object immediately before the effects.
-<a name="7.17.7.4" href="#7.17.7.4"><b>    7.17.7.4 The atomic_compare_exchange generic functions</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-             _Bool atomic_compare_exchange_strong(volatile A *object,
-                  C *expected, C desired);
-             _Bool atomic_compare_exchange_strong_explicit(
-                  volatile A *object, C *expected, C desired,
-                  memory_order success, memory_order failure);
-             _Bool atomic_compare_exchange_weak(volatile A *object,
-                  C *expected, C desired);
-             _Bool atomic_compare_exchange_weak_explicit(
-                  volatile A *object, C *expected, C desired,
-                  memory_order success, memory_order failure);
-<b>    Description</b>
-2   The failure argument shall not be memory_order_release nor
-    memory_order_acq_rel. The failure argument shall be no stronger than the
-    success argument. Atomically, compares the value pointed to by object for equality
-    with that in expected, and if true, replaces the value pointed to by object with
-    desired, and if false, updates the value in expected with the value pointed to by
-    object. Further, if the comparison is true, memory is affected according to the value of
-    success, and if the comparison is false, memory is affected according to the value of
-    failure. These operations are atomic read-modify-write operations (<a href="#5.1.2.4">5.1.2.4</a>).
-3   NOTE 1    The effect of the compare-and-exchange operations is
-
-[<a name="p282" href="#p282">page 282</a>] (<a href="#Contents">Contents</a>)
-
-             if (*object == *expected)
-                   *object = desired;
-             else
-                   *expected = *object;
-
-4   The weak compare-and-exchange operations may fail spuriously, that is, return zero
-    while leaving the value pointed to by expected unchanged.
-5   NOTE 2 This spurious failure enables implementation of compare-and-exchange on a broader class of
-    machines, e.g. load-locked store-conditional machines.
-
-6   EXAMPLE         A consequence of spurious failure is that nearly all uses of weak compare-and-exchange will
-    be in a loop.
-             exp = atomic_load(&amp;cur);
-             do {
-                   des = function(exp);
-             } while (!atomic_compare_exchange_weak(&amp;cur, &amp;exp, des));
-    When a compare-and-exchange is in a loop, the weak version will yield better performance on some
-    platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
-    strong one is preferable.
-
-<b>    Returns</b>
-7   The result of the comparison.
-<a name="7.17.7.5" href="#7.17.7.5"><b>    7.17.7.5 The atomic_fetch and modify generic functions</b></a>
-1   The following operations perform arithmetic and bitwise computations. All of these
-    operations are applicable to an object of any atomic integer type. Only addition and
-    subtraction are applicable to atomic_address. None of these operations is applicable
-    to atomic_bool. The key, operator, and computation correspondence is:
-     key            op          computation
-     add            +       addition
-     sub            -       subtraction
-     or             |       bitwise inclusive or
-     xor            ^       bitwise exclusive or
-     and            &amp;       bitwise and
-<b>    Synopsis</b>
-2            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-             C atomic_fetch_key(volatile A *object, M operand);
-             C atomic_fetch_key_explicit(volatile A *object,
-                  M operand, memory_order order);
-<b>    Description</b>
-3   Atomically replaces the value pointed to by object with the result of the computation
-    applied to the value pointed to by object and the given operand. Memory is affected
-    according to the value of order. These operations are atomic read-modify-write
-
-[<a name="p283" href="#p283">page 283</a>] (<a href="#Contents">Contents</a>)
-
-    operations (<a href="#5.1.2.4">5.1.2.4</a>). For signed integer types, arithmetic is defined to use two's
-    complement representation with silent wrap-around on overflow; there are no undefined
-    results. For address types, the result may be an undefined address, but the operations
-    otherwise have no undefined behavior.
-<b>    Returns</b>
-4   Atomically, the value pointed to by object immediately before the effects.
-5   NOTE The operation of the atomic_fetch and modify generic functions are nearly equivalent to the
-    operation of the corresponding op= compound assignment operators. The only differences are that the
-    compound assignment operators are not guaranteed to operate atomically, and the value yielded by a
-    compound assignment operator is the updated value of the object, whereas the value returned by the
-    atomic_fetch and modify generic functions is the previous value of the atomic object.
-
-<a name="7.17.8" href="#7.17.8"><b>    7.17.8 Atomic flag type and operations</b></a>
-1   The atomic_flag type provides the classic test-and-set functionality. It has two
-    states, set and clear.
-2   Operations on an object of type atomic_flag shall be lock free.
-3   NOTE Hence the operations should also be address-free. No other type requires lock-free operations, so
-    the atomic_flag type is the minimum hardware-implemented type needed to conform to this
-    International standard. The remaining types can be emulated with atomic_flag, though with less than
-    ideal properties.
-
-4   The macro ATOMIC_FLAG_INIT may be used to initialize an atomic_flag to the
-    clear state. An atomic_flag that is not explicitly initialized with
-    ATOMIC_FLAG_INIT is initially in an indeterminate state.
-5   EXAMPLE
-            atomic_flag guard = ATOMIC_FLAG_INIT;
-
-<a name="7.17.8.1" href="#7.17.8.1"><b>    7.17.8.1 The atomic_flag_test_and_set functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            bool atomic_flag_test_and_set(
-                 volatile atomic_flag *object);
-            bool atomic_flag_test_and_set_explicit(
-                 volatile atomic_flag *object, memory_order order);
-<b>    Description</b>
-2   Atomically sets the value pointed to by object to true. Memory is affected according
-    to the value of order. These operations are atomic read-modify-write operations
-    (<a href="#5.1.2.4">5.1.2.4</a>).
-
-[<a name="p284" href="#p284">page 284</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   Atomically, the value of the object immediately before the effects.
-<a name="7.17.8.2" href="#7.17.8.2"><b>    7.17.8.2 The atomic_flag_clear functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
-            void atomic_flag_clear(volatile atomic_flag *object);
-            void atomic_flag_clear_explicit(
-                 volatile atomic_flag *object, memory_order order);
-<b>    Description</b>
-2   The order argument shall not be memory_order_acquire nor
-    memory_order_acq_rel. Atomically sets the value pointed to by object to false.
-    Memory is affected according to the value of order.
-<b>    Returns</b>
-3   The atomic_flag_clear functions return no value.
-
-[<a name="p285" href="#p285">page 285</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.18" href="#7.18"><b>    7.18 Boolean type and values &lt;stdbool.h&gt;</b></a>
-1   The header <a href="#7.18">&lt;stdbool.h&gt;</a> defines four macros.
-2   The macro
-             bool
-    expands to _Bool.
-3   The remaining three macros are suitable for use in #if preprocessing directives. They
-    are
-             true
-    which expands to the integer constant 1,
-             false
-    which expands to the integer constant 0, and
-             __bool_true_false_are_defined
-    which expands to the integer constant 1.
-4   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
-    redefine the macros bool, true, and false.<sup><a href="#note252"><b>252)</b></a></sup>
-
-
-
-
-    <sup><a name="note252" href="#note252"><b>252)</b></a></sup> See ''future library directions'' (<a href="#7.30.7">7.30.7</a>).
-
-[<a name="p286" href="#p286">page 286</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.19" href="#7.19"><b>    7.19 Common definitions &lt;stddef.h&gt;</b></a>
-1   The header <a href="#7.19">&lt;stddef.h&gt;</a> defines the following macros and declares the following types.
-    Some are also defined in other headers, as noted in their respective subclauses.
-2   The types are
-            ptrdiff_t
-    which is the signed integer type of the result of subtracting two pointers;
-            size_t
-    which is the unsigned integer type of the result of the sizeof operator;
-            max_align_t
-    which is an object type whose alignment is as great as is supported by the implementation
-    in all contexts; and
-            wchar_t
-    which is an integer type whose range of values can represent distinct codes for all
-    members of the largest extended character set specified among the supported locales; the
-    null character shall have the code value zero. Each member of the basic character set
-    shall have a code value equal to its value when used as the lone character in an integer
-    character      constant     if     an      implementation      does      not      define
-    __STDC_MB_MIGHT_NEQ_WC__.
-3   The macros are
-            NULL
-    which expands to an implementation-defined null pointer constant; and
-            offsetof(type, member-designator)
-    which expands to an integer constant expression that has type size_t, the value of
-    which is the offset in bytes, to the structure member (designated by member-designator),
-    from the beginning of its structure (designated by type). The type and member designator
-    shall be such that given
-            static type t;
-    then the expression &amp;(t.member-designator) evaluates to an address constant. (If the
-    specified member is a bit-field, the behavior is undefined.)
-    Recommended practice
-4   The types used for size_t and ptrdiff_t should not have an integer conversion rank
-    greater than that of signed long int unless the implementation supports objects
-    large enough to make this necessary.
-
-[<a name="p287" href="#p287">page 287</a>] (<a href="#Contents">Contents</a>)
-
-Forward references: localization (<a href="#7.11">7.11</a>).
-
-[<a name="p288" href="#p288">page 288</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20" href="#7.20"><b>    7.20 Integer types &lt;stdint.h&gt;</b></a>
-1   The header <a href="#7.20">&lt;stdint.h&gt;</a> declares sets of integer types having specified widths, and
-    defines corresponding sets of macros.<sup><a href="#note253"><b>253)</b></a></sup> It also defines macros that specify limits of
-    integer types corresponding to types defined in other standard headers.
-2   Types are defined in the following categories:
-    -- integer types having certain exact widths;
-    -- integer types having at least certain specified widths;
-    -- fastest integer types having at least certain specified widths;
-    -- integer types wide enough to hold pointers to objects;
-    -- integer types having greatest width.
-    (Some of these types may denote the same type.)
-3   Corresponding macros specify limits of the declared types and construct suitable
-    constants.
-4   For each type described herein that the implementation provides,<sup><a href="#note254"><b>254)</b></a></sup> <a href="#7.20">&lt;stdint.h&gt;</a> shall
-    declare that typedef name and define the associated macros. Conversely, for each type
-    described herein that the implementation does not provide, <a href="#7.20">&lt;stdint.h&gt;</a> shall not
-    declare that typedef name nor shall it define the associated macros. An implementation
-    shall provide those types described as ''required'', but need not provide any of the others
-    (described as ''optional'').
-<a name="7.20.1" href="#7.20.1"><b>    7.20.1 Integer types</b></a>
-1   When typedef names differing only in the absence or presence of the initial u are defined,
-    they shall denote corresponding signed and unsigned types as described in <a href="#6.2.5">6.2.5</a>; an
-    implementation providing one of these corresponding types shall also provide the other.
-2   In the following descriptions, the symbol N represents an unsigned decimal integer with
-    no leading zeros (e.g., 8 or 24, but not 04 or 048).
-
-
-
-
-    <sup><a name="note253" href="#note253"><b>253)</b></a></sup> See ''future library directions'' (<a href="#7.30.8">7.30.8</a>).
-    <sup><a name="note254" href="#note254"><b>254)</b></a></sup> Some of these types may denote implementation-defined extended integer types.
-
-[<a name="p289" href="#p289">page 289</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.1.1" href="#7.20.1.1"><b>    7.20.1.1 Exact-width integer types</b></a>
-1   The typedef name intN_t designates a signed integer type with width N , no padding
-    bits, and a two's complement representation. Thus, int8_t denotes such a signed
-    integer type with a width of exactly 8 bits.
-2   The typedef name uintN_t designates an unsigned integer type with width N and no
-    padding bits. Thus, uint24_t denotes such an unsigned integer type with a width of
-    exactly 24 bits.
-3   These types are optional. However, if an implementation provides integer types with
-    widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a
-    two's complement representation, it shall define the corresponding typedef names.
-<a name="7.20.1.2" href="#7.20.1.2"><b>    7.20.1.2 Minimum-width integer types</b></a>
-1   The typedef name int_leastN_t designates a signed integer type with a width of at
-    least N , such that no signed integer type with lesser size has at least the specified width.
-    Thus, int_least32_t denotes a signed integer type with a width of at least 32 bits.
-2   The typedef name uint_leastN_t designates an unsigned integer type with a width
-    of at least N , such that no unsigned integer type with lesser size has at least the specified
-    width. Thus, uint_least16_t denotes an unsigned integer type with a width of at
-    least 16 bits.
-3   The following types are required:
-             int_least8_t                                      uint_least8_t
-             int_least16_t                                     uint_least16_t
-             int_least32_t                                     uint_least32_t
-             int_least64_t                                     uint_least64_t
-    All other types of this form are optional.
-<a name="7.20.1.3" href="#7.20.1.3"><b>    7.20.1.3 Fastest minimum-width integer types</b></a>
-1   Each of the following types designates an integer type that is usually fastest<sup><a href="#note255"><b>255)</b></a></sup> to operate
-    with among all integer types that have at least the specified width.
-2   The typedef name int_fastN_t designates the fastest signed integer type with a width
-    of at least N . The typedef name uint_fastN_t designates the fastest unsigned integer
-    type with a width of at least N .
-
-
-
-
-    <sup><a name="note255" href="#note255"><b>255)</b></a></sup> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
-         grounds for choosing one type over another, it will simply pick some integer type satisfying the
-         signedness and width requirements.
-
-[<a name="p290" href="#p290">page 290</a>] (<a href="#Contents">Contents</a>)
-
-3   The following types are required:
-            int_fast8_t                                    uint_fast8_t
-            int_fast16_t                                   uint_fast16_t
-            int_fast32_t                                   uint_fast32_t
-            int_fast64_t                                   uint_fast64_t
-    All other types of this form are optional.
-<a name="7.20.1.4" href="#7.20.1.4"><b>    7.20.1.4 Integer types capable of holding object pointers</b></a>
-1   The following type designates a signed integer type with the property that any valid
-    pointer to void can be converted to this type, then converted back to pointer to void,
-    and the result will compare equal to the original pointer:
-            intptr_t
-    The following type designates an unsigned integer type with the property that any valid
-    pointer to void can be converted to this type, then converted back to pointer to void,
-    and the result will compare equal to the original pointer:
-            uintptr_t
-    These types are optional.
-<a name="7.20.1.5" href="#7.20.1.5"><b>    7.20.1.5 Greatest-width integer types</b></a>
-1   The following type designates a signed integer type capable of representing any value of
-    any signed integer type:
-            intmax_t
-    The following type designates an unsigned integer type capable of representing any value
-    of any unsigned integer type:
-            uintmax_t
-    These types are required.
-<a name="7.20.2" href="#7.20.2"><b>    7.20.2 Limits of specified-width integer types</b></a>
-1   The following object-like macros specify the minimum and maximum limits of the types *
-    declared in <a href="#7.20">&lt;stdint.h&gt;</a>. Each macro name corresponds to a similar type name in
-    <a href="#7.20.1">7.20.1</a>.
-2   Each instance of any defined macro shall be replaced by a constant expression suitable
-    for use in #if preprocessing directives, and this expression shall have the same type as
-    would an expression that is an object of the corresponding type converted according to
-    the integer promotions. Its implementation-defined value shall be equal to or greater in
-    magnitude (absolute value) than the corresponding value given below, with the same sign,
-    except where stated to be exactly the given value.
-
-[<a name="p291" href="#p291">page 291</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.2.1" href="#7.20.2.1"><b>    7.20.2.1 Limits of exact-width integer types</b></a>
-1   -- minimum values of exact-width signed integer types
-          INTN_MIN                                  exactly -(2 N -1 )
-    -- maximum values of exact-width signed integer types
-          INTN_MAX                                  exactly 2 N -1 - 1
-    -- maximum values of exact-width unsigned integer types
-       UINTN_MAX                                    exactly 2 N - 1
-<a name="7.20.2.2" href="#7.20.2.2"><b>    7.20.2.2 Limits of minimum-width integer types</b></a>
-1   -- minimum values of minimum-width signed integer types
-          INT_LEASTN_MIN                                    -(2 N -1 - 1)
-    -- maximum values of minimum-width signed integer types
-          INT_LEASTN_MAX                                    2 N -1 - 1
-    -- maximum values of minimum-width unsigned integer types
-       UINT_LEASTN_MAX                                      2N - 1
-<a name="7.20.2.3" href="#7.20.2.3"><b>    7.20.2.3 Limits of fastest minimum-width integer types</b></a>
-1   -- minimum values of fastest minimum-width signed integer types
-          INT_FASTN_MIN                                     -(2 N -1 - 1)
-    -- maximum values of fastest minimum-width signed integer types
-       INT_FASTN_MAX                                        2 N -1 - 1
-    -- maximum values of fastest minimum-width unsigned integer types
-       UINT_FASTN_MAX                                       2N - 1
-<a name="7.20.2.4" href="#7.20.2.4"><b>    7.20.2.4 Limits of integer types capable of holding object pointers</b></a>
-1   -- minimum value of pointer-holding signed integer type
-          INTPTR_MIN                                        -(215 - 1)
-    -- maximum value of pointer-holding signed integer type
-       INTPTR_MAX                                           215 - 1
-    -- maximum value of pointer-holding unsigned integer type
-       UINTPTR_MAX                                          216 - 1
-
-[<a name="p292" href="#p292">page 292</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.2.5" href="#7.20.2.5"><b>    7.20.2.5 Limits of greatest-width integer types</b></a>
-1   -- minimum value of greatest-width signed integer type
-        INTMAX_MIN                                                    -(263 - 1)
-    -- maximum value of greatest-width signed integer type
-        INTMAX_MAX                                                    263 - 1
-    -- maximum value of greatest-width unsigned integer type
-        UINTMAX_MAX                                                   264 - 1
-<a name="7.20.3" href="#7.20.3"><b>    7.20.3 Limits of other integer types</b></a>
-1   The following object-like macros specify the minimum and maximum limits of integer *
-    types corresponding to types defined in other standard headers.
-2   Each instance of these macros shall be replaced by a constant expression suitable for use
-    in #if preprocessing directives, and this expression shall have the same type as would an
-    expression that is an object of the corresponding type converted according to the integer
-    promotions. Its implementation-defined value shall be equal to or greater in magnitude
-    (absolute value) than the corresponding value given below, with the same sign. An
-    implementation shall define only the macros corresponding to those typedef names it
-    actually provides.<sup><a href="#note256"><b>256)</b></a></sup>
-    -- limits of ptrdiff_t
-        PTRDIFF_MIN                                                 -65535
-        PTRDIFF_MAX                                                 +65535
-    -- limits of sig_atomic_t
-        SIG_ATOMIC_MIN                                              see below
-        SIG_ATOMIC_MAX                                              see below
-    -- limit of size_t
-        SIZE_MAX                                                      65535
-    -- limits of wchar_t
-        WCHAR_MIN                                                   see below
-        WCHAR_MAX                                                   see below
-    -- limits of wint_t
-
-
-
-
-    <sup><a name="note256" href="#note256"><b>256)</b></a></sup> A freestanding implementation need not provide all of these types.
-
-[<a name="p293" href="#p293">page 293</a>] (<a href="#Contents">Contents</a>)
-
-        WINT_MIN                                              see below
-        WINT_MAX                                              see below
-3   If sig_atomic_t (see <a href="#7.14">7.14</a>) is defined as a signed integer type, the value of
-    SIG_ATOMIC_MIN shall be no greater than -127 and the value of SIG_ATOMIC_MAX
-    shall be no less than 127; otherwise, sig_atomic_t is defined as an unsigned integer
-    type, and the value of SIG_ATOMIC_MIN shall be 0 and the value of
-    SIG_ATOMIC_MAX shall be no less than 255.
-4   If wchar_t (see <a href="#7.19">7.19</a>) is defined as a signed integer type, the value of WCHAR_MIN
-    shall be no greater than -127 and the value of WCHAR_MAX shall be no less than 127;
-    otherwise, wchar_t is defined as an unsigned integer type, and the value of
-    WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.<sup><a href="#note257"><b>257)</b></a></sup>
-5   If wint_t (see <a href="#7.28">7.28</a>) is defined as a signed integer type, the value of WINT_MIN shall
-    be no greater than -32767 and the value of WINT_MAX shall be no less than 32767;
-    otherwise, wint_t is defined as an unsigned integer type, and the value of WINT_MIN
-    shall be 0 and the value of WINT_MAX shall be no less than 65535.
-<a name="7.20.4" href="#7.20.4"><b>    7.20.4 Macros for integer constants</b></a>
-1   The following function-like macros expand to integer constants suitable for initializing *
-    objects that have integer types corresponding to types defined in <a href="#7.20">&lt;stdint.h&gt;</a>. Each
-    macro name corresponds to a similar type name in <a href="#7.20.1.2">7.20.1.2</a> or <a href="#7.20.1.5">7.20.1.5</a>.
-2   The argument in any instance of these macros shall be an unsuffixed integer constant (as
-    defined in <a href="#6.4.4.1">6.4.4.1</a>) with a value that does not exceed the limits for the corresponding type.
-3   Each invocation of one of these macros shall expand to an integer constant expression
-    suitable for use in #if preprocessing directives. The type of the expression shall have
-    the same type as would an expression of the corresponding type converted according to
-    the integer promotions. The value of the expression shall be that of the argument.
-<a name="7.20.4.1" href="#7.20.4.1"><b>    7.20.4.1 Macros for minimum-width integer constants</b></a>
-1   The macro INTN_C(value) shall expand to an integer constant expression
-    corresponding to the type int_leastN_t. The macro UINTN_C(value) shall expand
-    to an integer constant expression corresponding to the type uint_leastN_t. For
-    example, if uint_least64_t is a name for the type unsigned long long int,
-    then UINT64_C(0x123) might expand to the integer constant 0x123ULL.
-
-
-
-
-    <sup><a name="note257" href="#note257"><b>257)</b></a></sup> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
-         character set.
-
-[<a name="p294" href="#p294">page 294</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.20.4.2" href="#7.20.4.2"><b>    7.20.4.2 Macros for greatest-width integer constants</b></a>
-1   The following macro expands to an integer constant expression having the value specified
-    by its argument and the type intmax_t:
-            INTMAX_C(value)
-    The following macro expands to an integer constant expression having the value specified
-    by its argument and the type uintmax_t:
-            UINTMAX_C(value)
-
-[<a name="p295" href="#p295">page 295</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21" href="#7.21"><b>    7.21 Input/output &lt;stdio.h&gt;</b></a>
-<a name="7.21.1" href="#7.21.1"><b>    7.21.1 Introduction</b></a>
-1   The header <a href="#7.21">&lt;stdio.h&gt;</a> defines several macros, and declares three types and many
-    functions for performing input and output.
-2   The types declared are size_t (described in <a href="#7.19">7.19</a>);
-           FILE
-    which is an object type capable of recording all the information needed to control a
-    stream, including its file position indicator, a pointer to its associated buffer (if any), an
-    error indicator that records whether a read/write error has occurred, and an end-of-file
-    indicator that records whether the end of the file has been reached; and
-           fpos_t
-    which is a complete object type other than an array type capable of recording all the
-    information needed to specify uniquely every position within a file.
-3   The macros are NULL (described in <a href="#7.19">7.19</a>);
-           _IOFBF
-           _IOLBF
-           _IONBF
-    which expand to integer constant expressions with distinct values, suitable for use as the
-    third argument to the setvbuf function;
-           BUFSIZ
-    which expands to an integer constant expression that is the size of the buffer used by the
-    setbuf function;
-           EOF
-    which expands to an integer constant expression, with type int and a negative value, that
-    is returned by several functions to indicate end-of-file, that is, no more input from a
-    stream;
-           FOPEN_MAX
-    which expands to an integer constant expression that is the minimum number of files that
-    the implementation guarantees can be open simultaneously;
-           FILENAME_MAX
-    which expands to an integer constant expression that is the size needed for an array of
-    char large enough to hold the longest file name string that the implementation
-
-[<a name="p296" href="#p296">page 296</a>] (<a href="#Contents">Contents</a>)
-
-    guarantees can be opened;<sup><a href="#note258"><b>258)</b></a></sup>
-            L_tmpnam
-    which expands to an integer constant expression that is the size needed for an array of
-    char large enough to hold a temporary file name string generated by the tmpnam
-    function;
-            SEEK_CUR
-            SEEK_END
-            SEEK_SET
-    which expand to integer constant expressions with distinct values, suitable for use as the
-    third argument to the fseek function;
-            TMP_MAX
-    which expands to an integer constant expression that is the minimum number of unique
-    file names that can be generated by the tmpnam function;
-            stderr
-            stdin
-            stdout
-    which are expressions of type ''pointer to FILE'' that point to the FILE objects
-    associated, respectively, with the standard error, input, and output streams.
-4   The header <a href="#7.28">&lt;wchar.h&gt;</a> declares a number of functions useful for wide character input
-    and output. The wide character input/output functions described in that subclause
-    provide operations analogous to most of those described here, except that the
-    fundamental units internal to the program are wide characters. The external
-    representation (in the file) is a sequence of ''generalized'' multibyte characters, as
-    described further in <a href="#7.21.3">7.21.3</a>.
-5   The input/output functions are given the following collective terms:
-    -- The wide character input functions -- those functions described in <a href="#7.28">7.28</a> that perform
-      input into wide characters and wide strings: fgetwc, fgetws, getwc, getwchar,
-      fwscanf, wscanf, vfwscanf, and vwscanf.
-    -- The wide character output functions -- those functions described in <a href="#7.28">7.28</a> that perform
-      output from wide characters and wide strings: fputwc, fputws, putwc,
-      putwchar, fwprintf, wprintf, vfwprintf, and vwprintf.
-
-
-    <sup><a name="note258" href="#note258"><b>258)</b></a></sup> If the implementation imposes no practical limit on the length of file name strings, the value of
-         FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
-         string. Of course, file name string contents are subject to other system-specific constraints; therefore
-         all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
-
-[<a name="p297" href="#p297">page 297</a>] (<a href="#Contents">Contents</a>)
-
-    -- The wide character input/output functions -- the union of the ungetwc function, the
-      wide character input functions, and the wide character output functions.
-    -- The byte input/output functions -- those functions described in this subclause that
-      perform input/output: fgetc, fgets, fprintf, fputc, fputs, fread,
-      fscanf, fwrite, getc, getchar, printf, putc, putchar, puts, scanf, *
-      ungetc, vfprintf, vfscanf, vprintf, and vscanf.
-    Forward references: files (<a href="#7.21.3">7.21.3</a>), the fseek function (<a href="#7.21.9.2">7.21.9.2</a>), streams (<a href="#7.21.2">7.21.2</a>), the
-    tmpnam function (<a href="#7.21.4.4">7.21.4.4</a>), <a href="#7.28">&lt;wchar.h&gt;</a> (<a href="#7.28">7.28</a>).
-<a name="7.21.2" href="#7.21.2"><b>    7.21.2 Streams</b></a>
-1   Input and output, whether to or from physical devices such as terminals and tape drives,
-    or whether to or from files supported on structured storage devices, are mapped into
-    logical data streams, whose properties are more uniform than their various inputs and
-    outputs. Two forms of mapping are supported, for text streams and for binary
-    streams.<sup><a href="#note259"><b>259)</b></a></sup>
-2   A text stream is an ordered sequence of characters composed into lines, each line
-    consisting of zero or more characters plus a terminating new-line character. Whether the
-    last line requires a terminating new-line character is implementation-defined. Characters
-    may have to be added, altered, or deleted on input and output to conform to differing
-    conventions for representing text in the host environment. Thus, there need not be a one-
-    to-one correspondence between the characters in a stream and those in the external
-    representation. Data read in from a text stream will necessarily compare equal to the data
-    that were earlier written out to that stream only if: the data consist only of printing
-    characters and the control characters horizontal tab and new-line; no new-line character is
-    immediately preceded by space characters; and the last character is a new-line character.
-    Whether space characters that are written out immediately before a new-line character
-    appear when read in is implementation-defined.
-3   A binary stream is an ordered sequence of characters that can transparently record
-    internal data. Data read in from a binary stream shall compare equal to the data that were
-    earlier written out to that stream, under the same implementation. Such a stream may,
-    however, have an implementation-defined number of null characters appended to the end
-    of the stream.
-4   Each stream has an orientation. After a stream is associated with an external file, but
-    before any operations are performed on it, the stream is without orientation. Once a wide
-    character input/output function has been applied to a stream without orientation, the
-
-
-    <sup><a name="note259" href="#note259"><b>259)</b></a></sup> An implementation need not distinguish between text streams and binary streams. In such an
-         implementation, there need be no new-line characters in a text stream nor any limit to the length of a
-         line.
-
-[<a name="p298" href="#p298">page 298</a>] (<a href="#Contents">Contents</a>)
-
-    stream becomes a wide-oriented stream. Similarly, once a byte input/output function has
-    been applied to a stream without orientation, the stream becomes a byte-oriented stream.
-    Only a call to the freopen function or the fwide function can otherwise alter the
-    orientation of a stream. (A successful call to freopen removes any orientation.)<sup><a href="#note260"><b>260)</b></a></sup>
-5   Byte input/output functions shall not be applied to a wide-oriented stream and wide
-    character input/output functions shall not be applied to a byte-oriented stream. The
-    remaining stream operations do not affect, and are not affected by, a stream's orientation,
-    except for the following additional restrictions:
-    -- Binary wide-oriented streams have the file-positioning restrictions ascribed to both
-      text and binary streams.
-    -- For wide-oriented streams, after a successful call to a file-positioning function that
-      leaves the file position indicator prior to the end-of-file, a wide character output
-      function can overwrite a partial multibyte character; any file contents beyond the
-      byte(s) written are henceforth indeterminate.
-6   Each wide-oriented stream has an associated mbstate_t object that stores the current
-    parse state of the stream. A successful call to fgetpos stores a representation of the
-    value of this mbstate_t object as part of the value of the fpos_t object. A later
-    successful call to fsetpos using the same stored fpos_t value restores the value of
-    the associated mbstate_t object as well as the position within the controlled stream.
-    Environmental limits
-7   An implementation shall support text files with lines containing at least 254 characters,
-    including the terminating new-line character. The value of the macro BUFSIZ shall be at
-    least 256.
-    Forward references: the freopen function (<a href="#7.21.5.4">7.21.5.4</a>), the fwide function (<a href="#7.28.3.5">7.28.3.5</a>),
-    mbstate_t (<a href="#7.29.1">7.29.1</a>), the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>), the fsetpos function
-    (<a href="#7.21.9.3">7.21.9.3</a>).
-
-
-
-
-    <sup><a name="note260" href="#note260"><b>260)</b></a></sup> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
-
-[<a name="p299" href="#p299">page 299</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.3" href="#7.21.3"><b>    7.21.3 Files</b></a>
-1   A stream is associated with an external file (which may be a physical device) by opening
-    a file, which may involve creating a new file. Creating an existing file causes its former
-    contents to be discarded, if necessary. If a file can support positioning requests (such as a
-    disk file, as opposed to a terminal), then a file position indicator associated with the
-    stream is positioned at the start (character number zero) of the file, unless the file is
-    opened with append mode in which case it is implementation-defined whether the file
-    position indicator is initially positioned at the beginning or the end of the file. The file
-    position indicator is maintained by subsequent reads, writes, and positioning requests, to
-    facilitate an orderly progression through the file.
-2   Binary files are not truncated, except as defined in <a href="#7.21.5.3">7.21.5.3</a>. Whether a write on a text
-    stream causes the associated file to be truncated beyond that point is implementation-
-    defined.
-3   When a stream is unbuffered, characters are intended to appear from the source or at the
-    destination as soon as possible. Otherwise characters may be accumulated and
-    transmitted to or from the host environment as a block. When a stream is fully buffered,
-    characters are intended to be transmitted to or from the host environment as a block when
-    a buffer is filled. When a stream is line buffered, characters are intended to be
-    transmitted to or from the host environment as a block when a new-line character is
-    encountered. Furthermore, characters are intended to be transmitted as a block to the host
-    environment when a buffer is filled, when input is requested on an unbuffered stream, or
-    when input is requested on a line buffered stream that requires the transmission of
-    characters from the host environment. Support for these characteristics is
-    implementation-defined, and may be affected via the setbuf and setvbuf functions.
-4   A file may be disassociated from a controlling stream by closing the file. Output streams
-    are flushed (any unwritten buffer contents are transmitted to the host environment) before
-    the stream is disassociated from the file. The value of a pointer to a FILE object is
-    indeterminate after the associated file is closed (including the standard text streams).
-    Whether a file of zero length (on which no characters have been written by an output
-    stream) actually exists is implementation-defined.
-5   The file may be subsequently reopened, by the same or another program execution, and
-    its contents reclaimed or modified (if it can be repositioned at its start). If the main
-    function returns to its original caller, or if the exit function is called, all open files are
-    closed (hence all output streams are flushed) before program termination. Other paths to
-    program termination, such as calling the abort function, need not close all files
-    properly.
-6   The address of the FILE object used to control a stream may be significant; a copy of a
-    FILE object need not serve in place of the original.
-
-[<a name="p300" href="#p300">page 300</a>] (<a href="#Contents">Contents</a>)
-
-7    At program startup, three text streams are predefined and need not be opened explicitly
-     -- standard input (for reading conventional input), standard output (for writing
-     conventional output), and standard error (for writing diagnostic output). As initially
-     opened, the standard error stream is not fully buffered; the standard input and standard
-     output streams are fully buffered if and only if the stream can be determined not to refer
-     to an interactive device.
-8    Functions that open additional (nontemporary) files require a file name, which is a string.
-     The rules for composing valid file names are implementation-defined. Whether the same
-     file can be simultaneously open multiple times is also implementation-defined.
-9    Although both text and binary wide-oriented streams are conceptually sequences of wide
-     characters, the external file associated with a wide-oriented stream is a sequence of
-     multibyte characters, generalized as follows:
-     -- Multibyte encodings within files may contain embedded null bytes (unlike multibyte
-       encodings valid for use internal to the program).
-     -- A file need not begin nor end in the initial shift state.<sup><a href="#note261"><b>261)</b></a></sup>
-10   Moreover, the encodings used for multibyte characters may differ among files. Both the
-     nature and choice of such encodings are implementation-defined.
-11   The wide character input functions read multibyte characters from the stream and convert
-     them to wide characters as if they were read by successive calls to the fgetwc function.
-     Each conversion occurs as if by a call to the mbrtowc function, with the conversion state
-     described by the stream's own mbstate_t object. The byte input functions read
-     characters from the stream as if by successive calls to the fgetc function.
-12   The wide character output functions convert wide characters to multibyte characters and
-     write them to the stream as if they were written by successive calls to the fputwc
-     function. Each conversion occurs as if by a call to the wcrtomb function, with the
-     conversion state described by the stream's own mbstate_t object. The byte output
-     functions write characters to the stream as if by successive calls to the fputc function.
-13   In some cases, some of the byte input/output functions also perform conversions between
-     multibyte characters and wide characters. These conversions also occur as if by calls to
-     the mbrtowc and wcrtomb functions.
-14   An encoding error occurs if the character sequence presented to the underlying
-     mbrtowc function does not form a valid (generalized) multibyte character, or if the code
-     value passed to the underlying wcrtomb does not correspond to a valid (generalized)
-
-
-     <sup><a name="note261" href="#note261"><b>261)</b></a></sup> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
-          undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
-          with state-dependent encoding that does not assuredly end in the initial shift state.
-
-[<a name="p301" href="#p301">page 301</a>] (<a href="#Contents">Contents</a>)
-
-     multibyte character. The wide character input/output functions and the byte input/output
-     functions store the value of the macro EILSEQ in errno if and only if an encoding error
-     occurs.
-     Environmental limits
-15   The value of FOPEN_MAX shall be at least eight, including the three standard text
-     streams.
-     Forward references: the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the fgetc function (<a href="#7.21.7.1">7.21.7.1</a>), the
-     fopen function (<a href="#7.21.5.3">7.21.5.3</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>), the setbuf function
-     (<a href="#7.21.5.5">7.21.5.5</a>), the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>), the fgetwc function (<a href="#7.28.3.1">7.28.3.1</a>), the
-     fputwc function (<a href="#7.28.3.3">7.28.3.3</a>), conversion state (<a href="#7.28.6">7.28.6</a>), the mbrtowc function
-     (<a href="#7.28.6.3.2">7.28.6.3.2</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
-<a name="7.21.4" href="#7.21.4"><b>     7.21.4 Operations on files</b></a>
-<a name="7.21.4.1" href="#7.21.4.1"><b>     7.21.4.1 The remove function</b></a>
-<b>     Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int remove(const char *filename);
-<b>     Description</b>
-2    The remove function causes the file whose name is the string pointed to by filename
-     to be no longer accessible by that name. A subsequent attempt to open that file using that
-     name will fail, unless it is created anew. If the file is open, the behavior of the remove
-     function is implementation-defined.
-<b>     Returns</b>
-3    The remove function returns zero if the operation succeeds, nonzero if it fails.
-<a name="7.21.4.2" href="#7.21.4.2"><b>     7.21.4.2 The rename function</b></a>
-<b>     Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int rename(const char *old, const char *new);
-<b>     Description</b>
-2    The rename function causes the file whose name is the string pointed to by old to be
-     henceforth known by the name given by the string pointed to by new. The file named
-     old is no longer accessible by that name. If a file named by the string pointed to by new
-     exists prior to the call to the rename function, the behavior is implementation-defined.
-
-[<a name="p302" href="#p302">page 302</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The rename function returns zero if the operation succeeds, nonzero if it fails,<sup><a href="#note262"><b>262)</b></a></sup> in
-    which case if the file existed previously it is still known by its original name.
-<a name="7.21.4.3" href="#7.21.4.3"><b>    7.21.4.3 The tmpfile function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            FILE *tmpfile(void);
-<b>    Description</b>
-2   The tmpfile function creates a temporary binary file that is different from any other
-    existing file and that will automatically be removed when it is closed or at program
-    termination. If the program terminates abnormally, whether an open temporary file is
-    removed is implementation-defined. The file is opened for update with "wb+" mode.
-    Recommended practice
-3   It should be possible to open at least TMP_MAX temporary files during the lifetime of the
-    program (this limit may be shared with tmpnam) and there should be no limit on the
-    number simultaneously open other than this limit and any limit on the number of open
-    files (FOPEN_MAX).
-<b>    Returns</b>
-4   The tmpfile function returns a pointer to the stream of the file that it created. If the file
-    cannot be created, the tmpfile function returns a null pointer.
-    Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
-<a name="7.21.4.4" href="#7.21.4.4"><b>    7.21.4.4 The tmpnam function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            char *tmpnam(char *s);
-<b>    Description</b>
-2   The tmpnam function generates a string that is a valid file name and that is not the same
-    as the name of an existing file.<sup><a href="#note263"><b>263)</b></a></sup> The function is potentially capable of generating at
-
-
-    <sup><a name="note262" href="#note262"><b>262)</b></a></sup> Among the reasons the implementation may cause the rename function to fail are that the file is open
-         or that it is necessary to copy its contents to effectuate its renaming.
-    <sup><a name="note263" href="#note263"><b>263)</b></a></sup> Files created using strings generated by the tmpnam function are temporary only in the sense that
-         their names should not collide with those generated by conventional naming rules for the
-         implementation. It is still necessary to use the remove function to remove such files when their use
-         is ended, and before program termination.
-
-[<a name="p303" href="#p303">page 303</a>] (<a href="#Contents">Contents</a>)
-
-    least TMP_MAX different strings, but any or all of them may already be in use by existing
-    files and thus not be suitable return values.
-3   The tmpnam function generates a different string each time it is called.
-4   Calls to the tmpnam function with a null pointer argument may introduce data races with
-    each other. The implementation shall behave as if no library function calls the tmpnam
-    function.
-<b>    Returns</b>
-5   If no suitable string can be generated, the tmpnam function returns a null pointer.
-    Otherwise, if the argument is a null pointer, the tmpnam function leaves its result in an
-    internal static object and returns a pointer to that object (subsequent calls to the tmpnam
-    function may modify the same object). If the argument is not a null pointer, it is assumed
-    to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
-    in that array and returns the argument as its value.
-    Environmental limits
-6   The value of the macro TMP_MAX shall be at least 25.
-<a name="7.21.5" href="#7.21.5"><b>    7.21.5 File access functions</b></a>
-<a name="7.21.5.1" href="#7.21.5.1"><b>    7.21.5.1 The fclose function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int fclose(FILE *stream);
-<b>    Description</b>
-2   A successful call to the fclose function causes the stream pointed to by stream to be
-    flushed and the associated file to be closed. Any unwritten buffered data for the stream
-    are delivered to the host environment to be written to the file; any unread buffered data
-    are discarded. Whether or not the call succeeds, the stream is disassociated from the file
-    and any buffer set by the setbuf or setvbuf function is disassociated from the stream
-    (and deallocated if it was automatically allocated).
-<b>    Returns</b>
-3   The fclose function returns zero if the stream was successfully closed, or EOF if any
-    errors were detected.
-
-[<a name="p304" href="#p304">page 304</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.5.2" href="#7.21.5.2"><b>    7.21.5.2 The fflush function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int fflush(FILE *stream);
-<b>    Description</b>
-2   If stream points to an output stream or an update stream in which the most recent
-    operation was not input, the fflush function causes any unwritten data for that stream
-    to be delivered to the host environment to be written to the file; otherwise, the behavior is
-    undefined.
-3   If stream is a null pointer, the fflush function performs this flushing action on all
-    streams for which the behavior is defined above.
-<b>    Returns</b>
-4   The fflush function sets the error indicator for the stream and returns EOF if a write
-    error occurs, otherwise it returns zero.
-    Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
-<a name="7.21.5.3" href="#7.21.5.3"><b>    7.21.5.3 The fopen function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            FILE *fopen(const char * restrict filename,
-                 const char * restrict mode);
-<b>    Description</b>
-2   The fopen function opens the file whose name is the string pointed to by filename,
-    and associates a stream with it.
-3   The argument mode points to a string. If the string is one of the following, the file is
-    open in the indicated mode. Otherwise, the behavior is undefined.<sup><a href="#note264"><b>264)</b></a></sup>
-    r                     open text file for reading
-    w                     truncate to zero length or create text file for writing
-    wx                    create text file for writing
-    a                     append; open or create text file for writing at end-of-file
-    rb                    open binary file for reading
-    wb                    truncate to zero length or create binary file for writing
-
-
-    <sup><a name="note264" href="#note264"><b>264)</b></a></sup> If the string begins with one of the above sequences, the implementation might choose to ignore the
-         remaining characters, or it might use them to select different kinds of a file (some of which might not
-         conform to the properties in <a href="#7.21.2">7.21.2</a>).
-
-[<a name="p305" href="#p305">page 305</a>] (<a href="#Contents">Contents</a>)
-
-    wbx               create binary file for writing
-    ab                append; open or create binary file for writing at end-of-file
-    r+                open text file for update (reading and writing)
-    w+                truncate to zero length or create text file for update
-    w+x               create text file for update
-    a+                append; open or create text file for update, writing at end-of-file
-    r+b or rb+        open binary file for update (reading and writing)
-    w+b or wb+        truncate to zero length or create binary file for update
-    w+bx or wb+x      create binary file for update
-    a+b or ab+        append; open or create binary file for update, writing at end-of-file
-4   Opening a file with read mode ('r' as the first character in the mode argument) fails if
-    the file does not exist or cannot be read.
-5   Opening a file with exclusive mode ('x' as the last character in the mode argument)
-    fails if the file already exists or cannot be created. Otherwise, the file is created with
-    exclusive (also known as non-shared) access to the extent that the underlying system
-    supports exclusive access.
-6   Opening a file with append mode ('a' as the first character in the mode argument)
-    causes all subsequent writes to the file to be forced to the then current end-of-file,
-    regardless of intervening calls to the fseek function. In some implementations, opening
-    a binary file with append mode ('b' as the second or third character in the above list of
-    mode argument values) may initially position the file position indicator for the stream
-    beyond the last data written, because of null character padding.
-7   When a file is opened with update mode ('+' as the second or third character in the
-    above list of mode argument values), both input and output may be performed on the
-    associated stream. However, output shall not be directly followed by input without an
-    intervening call to the fflush function or to a file positioning function (fseek,
-    fsetpos, or rewind), and input shall not be directly followed by output without an
-    intervening call to a file positioning function, unless the input operation encounters end-
-    of-file. Opening (or creating) a text file with update mode may instead open (or create) a
-    binary stream in some implementations.
-8   When opened, a stream is fully buffered if and only if it can be determined not to refer to
-    an interactive device. The error and end-of-file indicators for the stream are cleared.
-<b>    Returns</b>
-9   The fopen function returns a pointer to the object controlling the stream. If the open
-    operation fails, fopen returns a null pointer.
-    Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
-
-[<a name="p306" href="#p306">page 306</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.5.4" href="#7.21.5.4"><b>    7.21.5.4 The freopen function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            FILE *freopen(const char * restrict filename,
-                 const char * restrict mode,
-                 FILE * restrict stream);
-<b>    Description</b>
-2   The freopen function opens the file whose name is the string pointed to by filename
-    and associates the stream pointed to by stream with it. The mode argument is used just
-    as in the fopen function.<sup><a href="#note265"><b>265)</b></a></sup>
-3   If filename is a null pointer, the freopen function attempts to change the mode of
-    the stream to that specified by mode, as if the name of the file currently associated with
-    the stream had been used. It is implementation-defined which changes of mode are
-    permitted (if any), and under what circumstances.
-4   The freopen function first attempts to close any file that is associated with the specified
-    stream. Failure to close the file is ignored. The error and end-of-file indicators for the
-    stream are cleared.
-<b>    Returns</b>
-5   The freopen function returns a null pointer if the open operation fails. Otherwise,
-    freopen returns the value of stream.
-<a name="7.21.5.5" href="#7.21.5.5"><b>    7.21.5.5 The setbuf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            void setbuf(FILE * restrict stream,
-                 char * restrict buf);
-<b>    Description</b>
-2   Except that it returns no value, the setbuf function is equivalent to the setvbuf
-    function invoked with the values _IOFBF for mode and BUFSIZ for size, or (if buf
-    is a null pointer), with the value _IONBF for mode.
-
-
-
-
-    <sup><a name="note265" href="#note265"><b>265)</b></a></sup> The primary use of the freopen function is to change the file associated with a standard text stream
-         (stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
-         returned by the fopen function may be assigned.
-
-[<a name="p307" href="#p307">page 307</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The setbuf function returns no value.
-    Forward references: the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
-<a name="7.21.5.6" href="#7.21.5.6"><b>    7.21.5.6 The setvbuf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int setvbuf(FILE * restrict stream,
-                 char * restrict buf,
-                 int mode, size_t size);
-<b>    Description</b>
-2   The setvbuf function may be used only after the stream pointed to by stream has
-    been associated with an open file and before any other operation (other than an
-    unsuccessful call to setvbuf) is performed on the stream. The argument mode
-    determines how stream will be buffered, as follows: _IOFBF causes input/output to be
-    fully buffered; _IOLBF causes input/output to be line buffered; _IONBF causes
-    input/output to be unbuffered. If buf is not a null pointer, the array it points to may be
-    used instead of a buffer allocated by the setvbuf function<sup><a href="#note266"><b>266)</b></a></sup> and the argument size
-    specifies the size of the array; otherwise, size may determine the size of a buffer
-    allocated by the setvbuf function. The contents of the array at any time are
-    indeterminate.
-<b>    Returns</b>
-3   The setvbuf function returns zero on success, or nonzero if an invalid value is given
-    for mode or if the request cannot be honored.
-
-
-
-
-    <sup><a name="note266" href="#note266"><b>266)</b></a></sup> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
-         before a buffer that has automatic storage duration is deallocated upon block exit.
-
-[<a name="p308" href="#p308">page 308</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.6" href="#7.21.6"><b>    7.21.6 Formatted input/output functions</b></a>
-1   The formatted input/output functions shall behave as if there is a sequence point after the
-    actions associated with each specifier.<sup><a href="#note267"><b>267)</b></a></sup>
-<a name="7.21.6.1" href="#7.21.6.1"><b>    7.21.6.1 The fprintf function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int fprintf(FILE * restrict stream,
-                  const char * restrict format, ...);
-<b>    Description</b>
-2   The fprintf function writes output to the stream pointed to by stream, under control
-    of the string pointed to by format that specifies how subsequent arguments are
-    converted for output. If there are insufficient arguments for the format, the behavior is
-    undefined. If the format is exhausted while arguments remain, the excess arguments are
-    evaluated (as always) but are otherwise ignored. The fprintf function returns when
-    the end of the format string is encountered.
-3   The format shall be a multibyte character sequence, beginning and ending in its initial
-    shift state. The format is composed of zero or more directives: ordinary multibyte
-    characters (not %), which are copied unchanged to the output stream; and conversion
-    specifications, each of which results in fetching zero or more subsequent arguments,
-    converting them, if applicable, according to the corresponding conversion specifier, and
-    then writing the result to the output stream.
-4   Each conversion specification is introduced by the character %. After the %, the following
-    appear in sequence:
-    -- Zero or more flags (in any order) that modify the meaning of the conversion
-      specification.
-    -- An optional minimum field width. If the converted value has fewer characters than the
-      field width, it is padded with spaces (by default) on the left (or right, if the left
-      adjustment flag, described later, has been given) to the field width. The field width
-      takes the form of an asterisk * (described later) or a nonnegative decimal integer.<sup><a href="#note268"><b>268)</b></a></sup>
-    -- An optional precision that gives the minimum number of digits to appear for the d, i,
-      o, u, x, and X conversions, the number of digits to appear after the decimal-point
-      character for a, A, e, E, f, and F conversions, the maximum number of significant
-      digits for the g and G conversions, or the maximum number of bytes to be written for
-
-
-    <sup><a name="note267" href="#note267"><b>267)</b></a></sup> The fprintf functions perform writes to memory for the %n specifier.
-    <sup><a name="note268" href="#note268"><b>268)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
-
-[<a name="p309" href="#p309">page 309</a>] (<a href="#Contents">Contents</a>)
-
-        s conversions. The precision takes the form of a period (.) followed either by an
-        asterisk * (described later) or by an optional decimal integer; if only the period is
-        specified, the precision is taken as zero. If a precision appears with any other
-        conversion specifier, the behavior is undefined.
-    -- An optional length modifier that specifies the size of the argument.
-    -- A conversion specifier character that specifies the type of conversion to be applied.
-5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
-    this case, an int argument supplies the field width or precision. The arguments
-    specifying field width, or precision, or both, shall appear (in that order) before the
-    argument (if any) to be converted. A negative field width argument is taken as a - flag
-    followed by a positive field width. A negative precision argument is taken as if the
-    precision were omitted.
-6   The flag characters and their meanings are:
-    -       The result of the conversion is left-justified within the field. (It is right-justified if
-            this flag is not specified.)
-    +       The result of a signed conversion always begins with a plus or minus sign. (It
-            begins with a sign only when a negative value is converted if this flag is not
-            specified.)<sup><a href="#note269"><b>269)</b></a></sup>
-    space If the first character of a signed conversion is not a sign, or if a signed conversion
-          results in no characters, a space is prefixed to the result. If the space and + flags
-          both appear, the space flag is ignored.
-    #       The result is converted to an ''alternative form''. For o conversion, it increases
-            the precision, if and only if necessary, to force the first digit of the result to be a
-            zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
-            conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
-            and G conversions, the result of converting a floating-point number always
-            contains a decimal-point character, even if no digits follow it. (Normally, a
-            decimal-point character appears in the result of these conversions only if a digit
-            follows it.) For g and G conversions, trailing zeros are not removed from the
-            result. For other conversions, the behavior is undefined.
-    0       For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
-            (following any indication of sign or base) are used to pad to the field width rather
-            than performing space padding, except when converting an infinity or NaN. If the
-            0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
-
-
-    <sup><a name="note269" href="#note269"><b>269)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
-         include a minus sign.
-
-[<a name="p310" href="#p310">page 310</a>] (<a href="#Contents">Contents</a>)
-
-              conversions, if a precision is specified, the 0 flag is ignored. For other
-              conversions, the behavior is undefined.
-7   The length modifiers and their meanings are:
-    hh            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                  signed char or unsigned char argument (the argument will have
-                  been promoted according to the integer promotions, but its value shall be
-                  converted to signed char or unsigned char before printing); or that
-                  a following n conversion specifier applies to a pointer to a signed char
-                  argument.
-    h             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                  short int or unsigned short int argument (the argument will
-                  have been promoted according to the integer promotions, but its value shall
-                  be converted to short int or unsigned short int before printing);
-                  or that a following n conversion specifier applies to a pointer to a short
-                  int argument.
-    l (ell)       Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                  long int or unsigned long int argument; that a following n
-                  conversion specifier applies to a pointer to a long int argument; that a
-                  following c conversion specifier applies to a wint_t argument; that a
-                  following s conversion specifier applies to a pointer to a wchar_t
-                  argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
-                  specifier.
-    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 long long int or unsigned long long int argument; or that a
-                 following n conversion specifier applies to a pointer to a long long int
-                 argument.
-    j             Specifies that a following d, i, o, u, x, or X conversion specifier applies to
-                  an intmax_t or uintmax_t argument; or that a following n conversion
-                  specifier applies to a pointer to an intmax_t argument.
-    z             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                  size_t or the corresponding signed integer type argument; or that a
-                  following n conversion specifier applies to a pointer to a signed integer type
-                  corresponding to size_t argument.
-    t             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                  ptrdiff_t or the corresponding unsigned integer type argument; or that a
-                  following n conversion specifier applies to a pointer to a ptrdiff_t
-                  argument.
-
-[<a name="p311" href="#p311">page 311</a>] (<a href="#Contents">Contents</a>)
-
-    L              Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                   applies to a long double argument.
-    If a length modifier appears with any conversion specifier other than as specified above,
-    the behavior is undefined.
-8   The conversion specifiers and their meanings are:
-    d,i          The int argument is converted to signed decimal in the style [-]dddd. The
-                 precision specifies the minimum number of digits to appear; if the value
-                 being converted can be represented in fewer digits, it is expanded with
-                 leading zeros. The default precision is 1. The result of converting a zero
-                 value with a precision of zero is no characters.
-    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
-            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
-            letters abcdef are used for x conversion and the letters ABCDEF for X
-            conversion. The precision specifies the minimum number of digits to appear;
-            if the value being converted can be represented in fewer digits, it is expanded
-            with leading zeros. The default precision is 1. The result of converting a
-            zero value with a precision of zero is no characters.
-    f,F          A double argument representing a floating-point number is converted to
-                 decimal notation in the style [-]ddd.ddd, where the number of digits after
-                 the decimal-point character is equal to the precision specification. If the
-                 precision is missing, it is taken as 6; if the precision is zero and the # flag is
-                 not specified, no decimal-point character appears. If a decimal-point
-                 character appears, at least one digit appears before it. The value is rounded to
-                 the appropriate number of digits.
-                 A double argument representing an infinity is converted in one of the styles
-                 [-]inf or [-]infinity -- which style is implementation-defined. A
-                 double argument representing a NaN is converted in one of the styles
-                 [-]nan or [-]nan(n-char-sequence) -- which style, and the meaning of
-                 any n-char-sequence, is implementation-defined. The F conversion specifier
-                 produces INF, INFINITY, or NAN instead of inf, infinity, or nan,
-                 respectively.<sup><a href="#note270"><b>270)</b></a></sup>
-    e,E          A double argument representing a floating-point number is converted in the
-                 style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
-                 argument is nonzero) before the decimal-point character and the number of
-                 digits after it is equal to the precision; if the precision is missing, it is taken as
-
-
-    <sup><a name="note270" href="#note270"><b>270)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
-         the # and 0 flag characters have no effect.
-
-[<a name="p312" href="#p312">page 312</a>] (<a href="#Contents">Contents</a>)
-
-              6; if the precision is zero and the # flag is not specified, no decimal-point
-              character appears. The value is rounded to the appropriate number of digits.
-              The E conversion specifier produces a number with E instead of e
-              introducing the exponent. The exponent always contains at least two digits,
-              and only as many more digits as necessary to represent the exponent. If the
-              value is zero, the exponent is zero.
-              A double argument representing an infinity or NaN is converted in the style
-              of an f or F conversion specifier.
-g,G           A double argument representing a floating-point number is converted in
-              style f or e (or in style F or E in the case of a G conversion specifier),
-              depending on the value converted and the precision. Let P equal the
-              precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
-              Then, if a conversion with style E would have an exponent of X:
-              -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
-                P - (X + 1).
-              -- otherwise, the conversion is with style e (or E) and precision P - 1.
-              Finally, unless the # flag is used, any trailing zeros are removed from the
-              fractional portion of the result and the decimal-point character is removed if
-              there is no fractional portion remaining.
-              A double argument representing an infinity or NaN is converted in the style
-              of an f or F conversion specifier.
-a,A           A double argument representing a floating-point number is converted in the
-              style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
-              nonzero if the argument is a normalized floating-point number and is
-              otherwise unspecified) before the decimal-point character<sup><a href="#note271"><b>271)</b></a></sup> and the number
-              of hexadecimal digits after it is equal to the precision; if the precision is
-              missing and FLT_RADIX is a power of 2, then the precision is sufficient for
-              an exact representation of the value; if the precision is missing and
-              FLT_RADIX is not a power of 2, then the precision is sufficient to
-
-
-
-
-<sup><a name="note271" href="#note271"><b>271)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
-     that subsequent digits align to nibble (4-bit) boundaries.
-
-[<a name="p313" href="#p313">page 313</a>] (<a href="#Contents">Contents</a>)
-
-              distinguish<sup><a href="#note272"><b>272)</b></a></sup> values of type double, except that trailing zeros may be
-              omitted; if the precision is zero and the # flag is not specified, no decimal-
-              point character appears. The letters abcdef are used for a conversion and
-              the letters ABCDEF for A conversion. The A conversion specifier produces a
-              number with X and P instead of x and p. The exponent always contains at
-              least one digit, and only as many more digits as necessary to represent the
-              decimal exponent of 2. If the value is zero, the exponent is zero.
-              A double argument representing an infinity or NaN is converted in the style
-              of an f or F conversion specifier.
-c             If no l length modifier is present, the int argument is converted to an
-              unsigned char, and the resulting character is written.
-              If an l length modifier is present, the wint_t argument is converted as if by
-              an ls conversion specification with no precision and an argument that points
-              to the initial element of a two-element array of wchar_t, the first element
-              containing the wint_t argument to the lc conversion specification and the
-              second a null wide character.
-s             If no l length modifier is present, the argument shall be a pointer to the initial
-              element of an array of character type.<sup><a href="#note273"><b>273)</b></a></sup> Characters from the array are
-              written up to (but not including) the terminating null character. If the
-              precision is specified, no more than that many bytes are written. If the
-              precision is not specified or is greater than the size of the array, the array shall
-              contain a null character.
-              If an l length modifier is present, the argument shall be a pointer to the initial
-              element of an array of wchar_t type. Wide characters from the array are
-              converted to multibyte characters (each as if by a call to the wcrtomb
-              function, with the conversion state described by an mbstate_t object
-              initialized to zero before the first wide character is converted) up to and
-              including a terminating null wide character. The resulting multibyte
-              characters are written up to (but not including) the terminating null character
-              (byte). If no precision is specified, the array shall contain a null wide
-              character. If a precision is specified, no more than that many bytes are
-              written (including shift sequences, if any), and the array shall contain a null
-              wide character if, to equal the multibyte character sequence length given by
-
-<sup><a name="note272" href="#note272"><b>272)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
-     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
-     might suffice depending on the implementation's scheme for determining the digit to the left of the
-     decimal-point character.
-<sup><a name="note273" href="#note273"><b>273)</b></a></sup> No special provisions are made for multibyte characters.
-
-[<a name="p314" href="#p314">page 314</a>] (<a href="#Contents">Contents</a>)
-
-                    the precision, the function would need to access a wide character one past the
-                    end of the array. In no case is a partial multibyte character written.<sup><a href="#note274"><b>274)</b></a></sup>
-     p              The argument shall be a pointer to void. The value of the pointer is
-                    converted to a sequence of printing characters, in an implementation-defined
-                    manner.
-     n              The argument shall be a pointer to signed integer into which is written the
-                    number of characters written to the output stream so far by this call to
-                    fprintf. No argument is converted, but one is consumed. If the conversion
-                    specification includes any flags, a field width, or a precision, the behavior is
-                    undefined.
-     %              A % character is written. No argument is converted. The complete
-                    conversion specification shall be %%.
-9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note275"><b>275)</b></a></sup> If any argument is
-     not the correct type for the corresponding conversion specification, the behavior is
-     undefined.
-10   In no case does a nonexistent or small field width cause truncation of a field; if the result
-     of a conversion is wider than the field width, the field is expanded to contain the
-     conversion result.
-11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
-     to a hexadecimal floating number with the given precision.
-     Recommended practice
-12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
-     representable in the given precision, the result should be one of the two adjacent numbers
-     in hexadecimal floating style with the given precision, with the extra stipulation that the
-     error should have a correct sign for the current rounding direction.
-13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
-     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note276"><b>276)</b></a></sup> If the number of
-     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
-     representable with DECIMAL_DIG digits, then the result should be an exact
-     representation with trailing zeros. Otherwise, the source value is bounded by two
-     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
-
-
-     <sup><a name="note274" href="#note274"><b>274)</b></a></sup> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
-     <sup><a name="note275" href="#note275"><b>275)</b></a></sup> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
-     <sup><a name="note276" href="#note276"><b>276)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
-          given format specifier. The number of significant digits is determined by the format specifier, and in
-          the case of fixed-point conversion by the source value as well.
-
-[<a name="p315" href="#p315">page 315</a>] (<a href="#Contents">Contents</a>)
-
-     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
-     the error should have a correct sign for the current rounding direction.
-<b>     Returns</b>
-14   The fprintf function returns the number of characters transmitted, or a negative value
-     if an output or encoding error occurred.
-     Environmental limits
-15   The number of characters that can be produced by any single conversion shall be at least
-     4095.
-16   EXAMPLE 1         To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
-     places:
-              #include <a href="#7.12">&lt;math.h&gt;</a>
-              #include <a href="#7.21">&lt;stdio.h&gt;</a>
-              /* ... */
-              char *weekday, *month;      // pointers to strings
-              int day, hour, min;
-              fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
-                      weekday, month, day, hour, min);
-              fprintf(stdout, "pi = %.5f\n", 4 * atan(1.0));
-
-17   EXAMPLE 2 In this example, multibyte characters do not have a state-dependent encoding, and the
-     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
-     the first of which is denoted here by a and the second by an uppercase letter.
-18   Given the following wide string with length seven,
-              static wchar_t wstr[] = L" X Yabc Z W";
-     the seven calls
-              fprintf(stdout,          "|1234567890123|\n");
-              fprintf(stdout,          "|%13ls|\n", wstr);
-              fprintf(stdout,          "|%-13.9ls|\n", wstr);
-              fprintf(stdout,          "|%13.10ls|\n", wstr);
-              fprintf(stdout,          "|%13.11ls|\n", wstr);
-              fprintf(stdout,          "|%13.15ls|\n", &amp;wstr[2]);
-              fprintf(stdout,          "|%13lc|\n", (wint_t) wstr[5]);
-     will print the following seven lines:
-              |1234567890123|
-              |   X Yabc Z W|
-              | X Yabc Z    |
-              |     X Yabc Z|
-              |   X Yabc Z W|
-              |      abc Z W|
-              |            Z|
-
-     Forward references: conversion state (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
-
-[<a name="p316" href="#p316">page 316</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.6.2" href="#7.21.6.2"><b>    7.21.6.2 The fscanf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int fscanf(FILE * restrict stream,
-                 const char * restrict format, ...);
-<b>    Description</b>
-2   The fscanf function reads input from the stream pointed to by stream, under control
-    of the string pointed to by format that specifies the admissible input sequences and how
-    they are to be converted for assignment, using subsequent arguments as pointers to the
-    objects to receive the converted input. If there are insufficient arguments for the format,
-    the behavior is undefined. If the format is exhausted while arguments remain, the excess
-    arguments are evaluated (as always) but are otherwise ignored.
-3   The format shall be a multibyte character sequence, beginning and ending in its initial
-    shift state. The format is composed of zero or more directives: one or more white-space
-    characters, an ordinary multibyte character (neither % nor a white-space character), or a
-    conversion specification. Each conversion specification is introduced by the character %.
-    After the %, the following appear in sequence:
-    -- An optional assignment-suppressing character *.
-    -- An optional decimal integer greater than zero that specifies the maximum field width
-      (in characters).
-    -- An optional length modifier that specifies the size of the receiving object.
-    -- A conversion specifier character that specifies the type of conversion to be applied.
-4   The fscanf function executes each directive of the format in turn. When all directives
-    have been executed, or if a directive fails (as detailed below), the function returns.
-    Failures are described as input failures (due to the occurrence of an encoding error or the
-    unavailability of input characters), or matching failures (due to inappropriate input).
-5   A directive composed of white-space character(s) is executed by reading input up to the
-    first non-white-space character (which remains unread), or until no more characters can
-    be read.
-6   A directive that is an ordinary multibyte character is executed by reading the next
-    characters of the stream. If any of those characters differ from the ones composing the
-    directive, the directive fails and the differing and subsequent characters remain unread.
-    Similarly, if end-of-file, an encoding error, or a read error prevents a character from being
-    read, the directive fails.
-7   A directive that is a conversion specification defines a set of matching input sequences, as
-    described below for each specifier. A conversion specification is executed in the
-
-[<a name="p317" href="#p317">page 317</a>] (<a href="#Contents">Contents</a>)
-
-     following steps:
-8    Input white-space characters (as specified by the isspace function) are skipped, unless
-     the specification includes a [, c, or n specifier.<sup><a href="#note277"><b>277)</b></a></sup>
-9    An input item is read from the stream, unless the specification includes an n specifier. An
-     input item is defined as the longest sequence of input characters which does not exceed
-     any specified field width and which is, or is a prefix of, a matching input sequence.<sup><a href="#note278"><b>278)</b></a></sup>
-     The first character, if any, after the input item remains unread. If the length of the input
-     item is zero, the execution of the directive fails; this condition is a matching failure unless
-     end-of-file, an encoding error, or a read error prevented input from the stream, in which
-     case it is an input failure.
-10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
-     count of input characters) is converted to a type appropriate to the conversion specifier. If
-     the input item is not a matching sequence, the execution of the directive fails: this
-     condition is a matching failure. Unless assignment suppression was indicated by a *, the
-     result of the conversion is placed in the object pointed to by the first argument following
-     the format argument that has not already received a conversion result. If this object
-     does not have an appropriate type, or if the result of the conversion cannot be represented
-     in the object, the behavior is undefined.
-11   The length modifiers and their meanings are:
-     hh             Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                    to an argument with type pointer to signed char or unsigned char.
-     h              Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                    to an argument with type pointer to short int or unsigned short
-                    int.
-     l (ell)        Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                    to an argument with type pointer to long int or unsigned long
-                    int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
-                    an argument with type pointer to double; or that a following c, s, or [
-                    conversion specifier applies to an argument with type pointer to wchar_t.
-     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to long long int or unsigned
-                  long long int.
-
-
-
-     <sup><a name="note277" href="#note277"><b>277)</b></a></sup> These white-space characters are not counted against a specified field width.
-     <sup><a name="note278" href="#note278"><b>278)</b></a></sup> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
-          that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
-
-[<a name="p318" href="#p318">page 318</a>] (<a href="#Contents">Contents</a>)
-
-     j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to intmax_t or uintmax_t.
-     z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to size_t or the corresponding signed
-                  integer type.
-     t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to ptrdiff_t or the corresponding
-                  unsigned integer type.
-     L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                  applies to an argument with type pointer to long double.
-     If a length modifier appears with any conversion specifier other than as specified above,
-     the behavior is undefined.
-12   The conversion specifiers and their meanings are:
-     d           Matches an optionally signed decimal integer, whose format is the same as
-                 expected for the subject sequence of the strtol function with the value 10
-                 for the base argument. The corresponding argument shall be a pointer to
-                 signed integer.
-     i           Matches an optionally signed integer, whose format is the same as expected
-                 for the subject sequence of the strtol function with the value 0 for the
-                 base argument. The corresponding argument shall be a pointer to signed
-                 integer.
-     o           Matches an optionally signed octal integer, whose format is the same as
-                 expected for the subject sequence of the strtoul function with the value 8
-                 for the base argument. The corresponding argument shall be a pointer to
-                 unsigned integer.
-     u           Matches an optionally signed decimal integer, whose format is the same as
-                 expected for the subject sequence of the strtoul function with the value 10
-                 for the base argument. The corresponding argument shall be a pointer to
-                 unsigned integer.
-     x           Matches an optionally signed hexadecimal integer, whose format is the same
-                 as expected for the subject sequence of the strtoul function with the value
-                 16 for the base argument. The corresponding argument shall be a pointer to
-                 unsigned integer.
-     a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
-             format is the same as expected for the subject sequence of the strtod
-             function. The corresponding argument shall be a pointer to floating.
-
-[<a name="p319" href="#p319">page 319</a>] (<a href="#Contents">Contents</a>)
-
-c             Matches a sequence of characters of exactly the number specified by the field
-              width (1 if no field width is present in the directive).<sup><a href="#note279"><b>279)</b></a></sup>
-              If no l length modifier is present, the corresponding argument shall be a
-              pointer to the initial element of a character array large enough to accept the
-              sequence. No null character is added.
-              If an l length modifier is present, the input shall be a sequence of multibyte
-              characters that begins in the initial shift state. Each multibyte character in the
-              sequence is converted to a wide character as if by a call to the mbrtowc
-              function, with the conversion state described by an mbstate_t object
-              initialized to zero before the first multibyte character is converted. The
-              corresponding argument shall be a pointer to the initial element of an array of
-              wchar_t large enough to accept the resulting sequence of wide characters.
-              No null wide character is added.
-s             Matches a sequence of non-white-space characters.279)
-              If no l length modifier is present, the corresponding argument shall be a
-              pointer to the initial element of a character array large enough to accept the
-              sequence and a terminating null character, which will be added automatically.
-              If an l length modifier is present, the input shall be a sequence of multibyte
-              characters that begins in the initial shift state. Each multibyte character is
-              converted to a wide character as if by a call to the mbrtowc function, with
-              the conversion state described by an mbstate_t object initialized to zero
-              before the first multibyte character is converted. The corresponding argument
-              shall be a pointer to the initial element of an array of wchar_t large enough
-              to accept the sequence and the terminating null wide character, which will be
-              added automatically.
-[             Matches a nonempty sequence of characters from a set of expected characters
-              (the scanset).279)
-              If no l length modifier is present, the corresponding argument shall be a
-              pointer to the initial element of a character array large enough to accept the
-              sequence and a terminating null character, which will be added automatically.
-              If an l length modifier is present, the input shall be a sequence of multibyte
-              characters that begins in the initial shift state. Each multibyte character is
-              converted to a wide character as if by a call to the mbrtowc function, with
-              the conversion state described by an mbstate_t object initialized to zero
-
-<sup><a name="note279" href="#note279"><b>279)</b></a></sup> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
-     conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
-     resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
-
-[<a name="p320" href="#p320">page 320</a>] (<a href="#Contents">Contents</a>)
-
-                    before the first multibyte character is converted. The corresponding argument
-                    shall be a pointer to the initial element of an array of wchar_t large enough
-                    to accept the sequence and the terminating null wide character, which will be
-                    added automatically.
-                    The conversion specifier includes all subsequent characters in the format
-                    string, up to and including the matching right bracket (]). The characters
-                    between the brackets (the scanlist) compose the scanset, unless the character
-                    after the left bracket is a circumflex (^), in which case the scanset contains all
-                    characters that do not appear in the scanlist between the circumflex and the
-                    right bracket. If the conversion specifier begins with [] or [^], the right
-                    bracket character is in the scanlist and the next following right bracket
-                    character is the matching right bracket that ends the specification; otherwise
-                    the first following right bracket character is the one that ends the
-                    specification. If a - character is in the scanlist and is not the first, nor the
-                    second where the first character is a ^, nor the last character, the behavior is
-                    implementation-defined.
-     p              Matches an implementation-defined set of sequences, which should be the
-                    same as the set of sequences that may be produced by the %p conversion of
-                    the fprintf function. The corresponding argument shall be a pointer to a
-                    pointer to void. The input item is converted to a pointer value in an
-                    implementation-defined manner. If the input item is a value converted earlier
-                    during the same program execution, the pointer that results shall compare
-                    equal to that value; otherwise the behavior of the %p conversion is undefined.
-     n              No input is consumed. The corresponding argument shall be a pointer to
-                    signed integer into which is to be written the number of characters read from
-                    the input stream so far by this call to the fscanf function. Execution of a
-                    %n directive does not increment the assignment count returned at the
-                    completion of execution of the fscanf function. No argument is converted,
-                    but one is consumed. If the conversion specification includes an assignment-
-                    suppressing character or a field width, the behavior is undefined.
-     %              Matches a single % character; no conversion or assignment occurs. The
-                    complete conversion specification shall be %%.
-13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note280"><b>280)</b></a></sup>
-14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
-     respectively, a, e, f, g, and x.
-
-
-
-     <sup><a name="note280" href="#note280"><b>280)</b></a></sup> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
-
-[<a name="p321" href="#p321">page 321</a>] (<a href="#Contents">Contents</a>)
-
-15   Trailing white space (including new-line characters) is left unread unless matched by a
-     directive. The success of literal matches and suppressed assignments is not directly
-     determinable other than via the %n directive.
-<b>     Returns</b>
-16   The fscanf function returns the value of the macro EOF if an input failure occurs
-     before the first conversion (if any) has completed. Otherwise, the function returns the
-     number of input items assigned, which can be fewer than provided for, or even zero, in
-     the event of an early matching failure.
-17   EXAMPLE 1        The call:
-              #include <a href="#7.21">&lt;stdio.h&gt;</a>
-              /* ... */
-              int n, i; float x; char name[50];
-              n = fscanf(stdin, "%d%f%s", &amp;i, &amp;x, name);
-     with the input line:
-              25 54.32E-1 thompson
-     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
-     thompson\0.
-
-18   EXAMPLE 2        The call:
-              #include <a href="#7.21">&lt;stdio.h&gt;</a>
-              /* ... */
-              int i; float x; char name[50];
-              fscanf(stdin, "%2d%f%*d %[0123456789]", &amp;i, &amp;x, name);
-     with input:
-              56789 0123 56a72
-     will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
-     sequence 56\0. The next character read from the input stream will be a.
-
-19   EXAMPLE 3        To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
-              #include <a href="#7.21">&lt;stdio.h&gt;</a>
-              /* ... */
-              int count; float quant; char units[21], item[21];
-              do {
-                      count = fscanf(stdin, "%f%20s of %20s", &amp;quant, units, item);
-                      fscanf(stdin,"%*[^\n]");
-              } while (!feof(stdin) &amp;&amp; !ferror(stdin));
-20   If the stdin stream contains the following lines:
-              2 quarts of oil
-              -12.8degrees Celsius
-              lots of luck
-              10.0LBS     of
-              dirt
-              100ergs of energy
-
-[<a name="p322" href="#p322">page 322</a>] (<a href="#Contents">Contents</a>)
-
-     the execution of the above example will be analogous to the following assignments:
-               quant     =   2; strcpy(units, "quarts"); strcpy(item, "oil");
-               count     =   3;
-               quant     =   -12.8; strcpy(units, "degrees");
-               count     =   2; // "C" fails to match "o"
-               count     =   0; // "l" fails to match "%f"
-               quant     =   10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
-               count     =   3;
-               count     =   0; // "100e" fails to match "%f"
-               count     =   EOF;
-
-21   EXAMPLE 4         In:
-               #include <a href="#7.21">&lt;stdio.h&gt;</a>
-               /* ... */
-               int d1, d2, n1, n2, i;
-               i = sscanf("123", "%d%n%n%d", &amp;d1, &amp;n1, &amp;n2, &amp;d2);
-     the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
-     of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
-
-22   EXAMPLE 5 In these examples, multibyte characters do have a state-dependent encoding, and the
-     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
-     the first of which is denoted here by a and the second by an uppercase letter, but are only recognized as
-     such when in the alternate shift state. The shift sequences are denoted by (uparrow) and (downarrow), in which the first causes
-     entry into the alternate shift state.
-23   After the call:
-               #include <a href="#7.21">&lt;stdio.h&gt;</a>
-               /* ... */
-               char str[50];
-               fscanf(stdin, "a%s", str);
-     with the input line:
-               a(uparrow) X Y(downarrow) bc
-     str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
-     characters, in the more general case) appears to be a single-byte white-space character.
-24   In contrast, after the call:
-               #include <a href="#7.21">&lt;stdio.h&gt;</a>
-               #include <a href="#7.19">&lt;stddef.h&gt;</a>
-               /* ... */
-               wchar_t wstr[50];
-               fscanf(stdin, "a%ls", wstr);
-     with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
-     terminating null wide character.
-25   However, the call:
-
-[<a name="p323" href="#p323">page 323</a>] (<a href="#Contents">Contents</a>)
-
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             #include <a href="#7.19">&lt;stddef.h&gt;</a>
-             /* ... */
-             wchar_t wstr[50];
-             fscanf(stdin, "a(uparrow) X(downarrow)%ls", wstr);
-     with the same input line will return zero due to a matching failure against the (downarrow) sequence in the format
-     string.
-26   Assuming that the first byte of the multibyte character X is the same as the first byte of the multibyte
-     character Y, after the call:
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             #include <a href="#7.19">&lt;stddef.h&gt;</a>
-             /* ... */
-             wchar_t wstr[50];
-             fscanf(stdin, "a(uparrow) Y(downarrow)%ls", wstr);
-     with the same input line, zero will again be returned, but stdin will be left with a partially consumed
-     multibyte character.
-
-     Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>), the
-     strtol, strtoll, strtoul, and strtoull functions (<a href="#7.22.1.4">7.22.1.4</a>), conversion state
-     (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
-<a name="7.21.6.3" href="#7.21.6.3"><b>     7.21.6.3 The printf function</b></a>
-<b>     Synopsis</b>
-1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int printf(const char * restrict format, ...);
-<b>     Description</b>
-2    The printf function is equivalent to fprintf with the argument stdout interposed
-     before the arguments to printf.
-<b>     Returns</b>
-3    The printf function returns the number of characters transmitted, or a negative value if
-     an output or encoding error occurred.
-<a name="7.21.6.4" href="#7.21.6.4"><b>     7.21.6.4 The scanf function</b></a>
-<b>     Synopsis</b>
-1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int scanf(const char * restrict format, ...);
-<b>     Description</b>
-2    The scanf function is equivalent to fscanf with the argument stdin interposed
-     before the arguments to scanf.
-
-[<a name="p324" href="#p324">page 324</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The scanf function returns the value of the macro EOF if an input failure occurs before
-    the first conversion (if any) has completed. Otherwise, the scanf function returns the
-    number of input items assigned, which can be fewer than provided for, or even zero, in
-    the event of an early matching failure.
-<a name="7.21.6.5" href="#7.21.6.5"><b>    7.21.6.5 The snprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int snprintf(char * restrict s, size_t n,
-                 const char * restrict format, ...);
-<b>    Description</b>
-2   The snprintf function is equivalent to fprintf, except that the output is written into
-    an array (specified by argument s) rather than to a stream. If n is zero, nothing is written,
-    and s may be a null pointer. Otherwise, output characters beyond the n-1st are
-    discarded rather than being written to the array, and a null character is written at the end
-    of the characters actually written into the array. If copying takes place between objects
-    that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The snprintf function returns the number of characters that would have been written
-    had n been sufficiently large, not counting the terminating null character, or a negative
-    value if an encoding error occurred. Thus, the null-terminated output has been
-    completely written if and only if the returned value is nonnegative and less than n.
-<a name="7.21.6.6" href="#7.21.6.6"><b>    7.21.6.6 The sprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int sprintf(char * restrict s,
-                 const char * restrict format, ...);
-<b>    Description</b>
-2   The sprintf function is equivalent to fprintf, except that the output is written into
-    an array (specified by the argument s) rather than to a stream. A null character is written
-    at the end of the characters written; it is not counted as part of the returned value. If
-    copying takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The sprintf function returns the number of characters written in the array, not
-    counting the terminating null character, or a negative value if an encoding error occurred.
-
-[<a name="p325" href="#p325">page 325</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.6.7" href="#7.21.6.7"><b>    7.21.6.7 The sscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int sscanf(const char * restrict s,
-                const char * restrict format, ...);
-<b>    Description</b>
-2   The sscanf function is equivalent to fscanf, except that input is obtained from a
-    string (specified by the argument s) rather than from a stream. Reaching the end of the
-    string is equivalent to encountering end-of-file for the fscanf function. If copying
-    takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The sscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the sscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.21.6.8" href="#7.21.6.8"><b>    7.21.6.8 The vfprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int vfprintf(FILE * restrict stream,
-                const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vfprintf function is equivalent to fprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfprintf function does not invoke the
-    va_end macro.<sup><a href="#note281"><b>281)</b></a></sup>
-<b>    Returns</b>
-3   The vfprintf function returns the number of characters transmitted, or a negative
-    value if an output or encoding error occurred.
-4   EXAMPLE       The following shows the use of the vfprintf function in a general error-reporting routine.
-
-
-
-
-    <sup><a name="note281" href="#note281"><b>281)</b></a></sup> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
-         vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
-
-[<a name="p326" href="#p326">page 326</a>] (<a href="#Contents">Contents</a>)
-
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            void error(char *function_name, char *format, ...)
-            {
-                  va_list args;
-                  va_start(args, format);
-                  // print out name of function causing error
-                  fprintf(stderr, "ERROR in %s: ", function_name);
-                  // print out remainder of message
-                  vfprintf(stderr, format, args);
-                  va_end(args);
-            }
-
-<a name="7.21.6.9" href="#7.21.6.9"><b>    7.21.6.9 The vfscanf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int vfscanf(FILE * restrict stream,
-                 const char * restrict format,
-                 va_list arg);
-<b>    Description</b>
-2   The vfscanf function is equivalent to fscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfscanf function does not invoke the
-    va_end macro.281)
-<b>    Returns</b>
-3   The vfscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the vfscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.21.6.10" href="#7.21.6.10"><b>    7.21.6.10 The vprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int vprintf(const char * restrict format,
-                 va_list arg);
-<b>    Description</b>
-2   The vprintf function is equivalent to printf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-
-[<a name="p327" href="#p327">page 327</a>] (<a href="#Contents">Contents</a>)
-
-    possibly subsequent va_arg calls). The vprintf function does not invoke the
-    va_end macro.281)
-<b>    Returns</b>
-3   The vprintf function returns the number of characters transmitted, or a negative value
-    if an output or encoding error occurred.
-<a name="7.21.6.11" href="#7.21.6.11"><b>    7.21.6.11 The vscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int vscanf(const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vscanf function is equivalent to scanf, with the variable argument list replaced
-    by arg, which shall have been initialized by the va_start macro (and possibly
-    subsequent va_arg calls). The vscanf function does not invoke the va_end
-    macro.281)
-<b>    Returns</b>
-3   The vscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the vscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.21.6.12" href="#7.21.6.12"><b>    7.21.6.12 The vsnprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int vsnprintf(char * restrict s, size_t n,
-                const char * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vsnprintf function is equivalent to snprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vsnprintf function does not invoke the
-    va_end macro.281) If copying takes place between objects that overlap, the behavior is
-    undefined.
-
-[<a name="p328" href="#p328">page 328</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The vsnprintf function returns the number of characters that would have been written
-    had n been sufficiently large, not counting the terminating null character, or a negative
-    value if an encoding error occurred. Thus, the null-terminated output has been
-    completely written if and only if the returned value is nonnegative and less than n.
-<a name="7.21.6.13" href="#7.21.6.13"><b>    7.21.6.13 The vsprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int vsprintf(char * restrict s,
-                 const char * restrict format,
-                 va_list arg);
-<b>    Description</b>
-2   The vsprintf function is equivalent to sprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vsprintf function does not invoke the
-    va_end macro.281) If copying takes place between objects that overlap, the behavior is
-    undefined.
-<b>    Returns</b>
-3   The vsprintf function returns the number of characters written in the array, not
-    counting the terminating null character, or a negative value if an encoding error occurred.
-<a name="7.21.6.14" href="#7.21.6.14"><b>    7.21.6.14 The vsscanf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int vsscanf(const char * restrict s,
-                 const char * restrict format,
-                 va_list arg);
-<b>    Description</b>
-2   The vsscanf function is equivalent to sscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vsscanf function does not invoke the
-    va_end macro.281)
-<b>    Returns</b>
-3   The vsscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the vsscanf function
-
-[<a name="p329" href="#p329">page 329</a>] (<a href="#Contents">Contents</a>)
-
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.21.7" href="#7.21.7"><b>    7.21.7 Character input/output functions</b></a>
-<a name="7.21.7.1" href="#7.21.7.1"><b>    7.21.7.1 The fgetc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int fgetc(FILE *stream);
-<b>    Description</b>
-2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
-    next character is present, the fgetc function obtains that character as an unsigned
-    char converted to an int and advances the associated file position indicator for the
-    stream (if defined).
-<b>    Returns</b>
-3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
-    of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the
-    fgetc function returns the next character from the input stream pointed to by stream.
-    If a read error occurs, the error indicator for the stream is set and the fgetc function
-    returns EOF.<sup><a href="#note282"><b>282)</b></a></sup>
-<a name="7.21.7.2" href="#7.21.7.2"><b>    7.21.7.2 The fgets function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            char *fgets(char * restrict s, int n,
-                 FILE * restrict stream);
-<b>    Description</b>
-2   The fgets function reads at most one less than the number of characters specified by n
-    from the stream pointed to by stream into the array pointed to by s. No additional
-    characters are read after a new-line character (which is retained) or after end-of-file. A
-    null character is written immediately after the last character read into the array.
-<b>    Returns</b>
-3   The fgets function returns s if successful. If end-of-file is encountered and no
-    characters have been read into the array, the contents of the array remain unchanged and a
-    null pointer is returned. If a read error occurs during the operation, the array contents are
-    indeterminate and a null pointer is returned.
-
-    <sup><a name="note282" href="#note282"><b>282)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
-
-[<a name="p330" href="#p330">page 330</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.7.3" href="#7.21.7.3"><b>    7.21.7.3 The fputc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int fputc(int c, FILE *stream);
-<b>    Description</b>
-2   The fputc function writes the character specified by c (converted to an unsigned
-    char) to the output stream pointed to by stream, at the position indicated by the
-    associated file position indicator for the stream (if defined), and advances the indicator
-    appropriately. If the file cannot support positioning requests, or if the stream was opened
-    with append mode, the character is appended to the output stream.
-<b>    Returns</b>
-3   The fputc function returns the character written. If a write error occurs, the error
-    indicator for the stream is set and fputc returns EOF.
-<a name="7.21.7.4" href="#7.21.7.4"><b>    7.21.7.4 The fputs function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int fputs(const char * restrict s,
-                 FILE * restrict stream);
-<b>    Description</b>
-2   The fputs function writes the string pointed to by s to the stream pointed to by
-    stream. The terminating null character is not written.
-<b>    Returns</b>
-3   The fputs function returns EOF if a write error occurs; otherwise it returns a
-    nonnegative value.
-<a name="7.21.7.5" href="#7.21.7.5"><b>    7.21.7.5 The getc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int getc(FILE *stream);
-<b>    Description</b>
-2   The getc function is equivalent to fgetc, except that if it is implemented as a macro, it
-    may evaluate stream more than once, so the argument should never be an expression
-    with side effects.
-
-[<a name="p331" href="#p331">page 331</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The getc function returns the next character from the input stream pointed to by
-    stream. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
-    getc returns EOF. If a read error occurs, the error indicator for the stream is set and
-    getc returns EOF.
-<a name="7.21.7.6" href="#7.21.7.6"><b>    7.21.7.6 The getchar function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int getchar(void);
-<b>    Description</b>
-2   The getchar function is equivalent to getc with the argument stdin.
-<b>    Returns</b>
-3   The getchar function returns the next character from the input stream pointed to by
-    stdin. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
-    getchar returns EOF. If a read error occurs, the error indicator for the stream is set and
-    getchar returns EOF.                                                                       *
-<a name="7.21.7.7" href="#7.21.7.7"><b>    7.21.7.7 The putc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int putc(int c, FILE *stream);
-<b>    Description</b>
-2   The putc function is equivalent to fputc, except that if it is implemented as a macro, it
-    may evaluate stream more than once, so that argument should never be an expression
-    with side effects.
-<b>    Returns</b>
-3   The putc function returns the character written. If a write error occurs, the error
-    indicator for the stream is set and putc returns EOF.
-<a name="7.21.7.8" href="#7.21.7.8"><b>    7.21.7.8 The putchar function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int putchar(int c);
-<b>    Description</b>
-2   The putchar function is equivalent to putc with the second argument stdout.
-
-[<a name="p332" href="#p332">page 332</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The putchar function returns the character written. If a write error occurs, the error
-    indicator for the stream is set and putchar returns EOF.
-<a name="7.21.7.9" href="#7.21.7.9"><b>    7.21.7.9 The puts function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int puts(const char *s);
-<b>    Description</b>
-2   The puts function writes the string pointed to by s to the stream pointed to by stdout,
-    and appends a new-line character to the output. The terminating null character is not
-    written.
-<b>    Returns</b>
-3   The puts function returns EOF if a write error occurs; otherwise it returns a nonnegative
-    value.
-<a name="7.21.7.10" href="#7.21.7.10"><b>    7.21.7.10 The ungetc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int ungetc(int c, FILE *stream);
-<b>    Description</b>
-2   The ungetc function pushes the character specified by c (converted to an unsigned
-    char) back onto the input stream pointed to by stream. Pushed-back characters will be
-    returned by subsequent reads on that stream in the reverse order of their pushing. A
-    successful intervening call (with the stream pointed to by stream) to a file positioning
-    function (fseek, fsetpos, or rewind) discards any pushed-back characters for the
-    stream. The external storage corresponding to the stream is unchanged.
-3   One character of pushback is guaranteed. If the ungetc function is called too many
-    times on the same stream without an intervening read or file positioning operation on that
-    stream, the operation may fail.
-4   If the value of c equals that of the macro EOF, the operation fails and the input stream is
-    unchanged.
-5   A successful call to the ungetc function clears the end-of-file indicator for the stream.
-    The value of the file position indicator for the stream after reading or discarding all
-    pushed-back characters shall be the same as it was before the characters were pushed
-    back. For a text stream, the value of its file position indicator after a successful call to the
-    ungetc function is unspecified until all pushed-back characters are read or discarded.
-
-[<a name="p333" href="#p333">page 333</a>] (<a href="#Contents">Contents</a>)
-
-    For a binary stream, its file position indicator is decremented by each successful call to
-    the ungetc function; if its value was zero before a call, it is indeterminate after the
-    call.<sup><a href="#note283"><b>283)</b></a></sup>
-<b>    Returns</b>
-6   The ungetc function returns the character pushed back after conversion, or EOF if the
-    operation fails.
-    Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
-<a name="7.21.8" href="#7.21.8"><b>    7.21.8 Direct input/output functions</b></a>
-<a name="7.21.8.1" href="#7.21.8.1"><b>    7.21.8.1 The fread function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             size_t fread(void * restrict ptr,
-                  size_t size, size_t nmemb,
-                  FILE * restrict stream);
-<b>    Description</b>
-2   The fread function reads, into the array pointed to by ptr, up to nmemb elements
-    whose size is specified by size, from the stream pointed to by stream. For each
-    object, size calls are made to the fgetc function and the results stored, in the order
-    read, in an array of unsigned char exactly overlaying the object. The file position
-    indicator for the stream (if defined) is advanced by the number of characters successfully
-    read. If an error occurs, the resulting value of the file position indicator for the stream is
-    indeterminate. If a partial element is read, its value is indeterminate.
-<b>    Returns</b>
-3   The fread function returns the number of elements successfully read, which may be
-    less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero,
-    fread returns zero and the contents of the array and the state of the stream remain
-    unchanged.
-
-
-
-
-    <sup><a name="note283" href="#note283"><b>283)</b></a></sup> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
-
-[<a name="p334" href="#p334">page 334</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.8.2" href="#7.21.8.2"><b>    7.21.8.2 The fwrite function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            size_t fwrite(const void * restrict ptr,
-                 size_t size, size_t nmemb,
-                 FILE * restrict stream);
-<b>    Description</b>
-2   The fwrite function writes, from the array pointed to by ptr, up to nmemb elements
-    whose size is specified by size, to the stream pointed to by stream. For each object,
-    size calls are made to the fputc function, taking the values (in order) from an array of
-    unsigned char exactly overlaying the object. The file position indicator for the
-    stream (if defined) is advanced by the number of characters successfully written. If an
-    error occurs, the resulting value of the file position indicator for the stream is
-    indeterminate.
-<b>    Returns</b>
-3   The fwrite function returns the number of elements successfully written, which will be
-    less than nmemb only if a write error is encountered. If size or nmemb is zero,
-    fwrite returns zero and the state of the stream remains unchanged.
-<a name="7.21.9" href="#7.21.9"><b>    7.21.9 File positioning functions</b></a>
-<a name="7.21.9.1" href="#7.21.9.1"><b>    7.21.9.1 The fgetpos function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int fgetpos(FILE * restrict stream,
-                 fpos_t * restrict pos);
-<b>    Description</b>
-2   The fgetpos function stores the current values of the parse state (if any) and file
-    position indicator for the stream pointed to by stream in the object pointed to by pos.
-    The values stored contain unspecified information usable by the fsetpos function for
-    repositioning the stream to its position at the time of the call to the fgetpos function.
-<b>    Returns</b>
-3   If successful, the fgetpos function returns zero; on failure, the fgetpos function
-    returns nonzero and stores an implementation-defined positive value in errno.
-    Forward references: the fsetpos function (<a href="#7.21.9.3">7.21.9.3</a>).
-
-[<a name="p335" href="#p335">page 335</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.9.2" href="#7.21.9.2"><b>    7.21.9.2 The fseek function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int fseek(FILE *stream, long int offset, int whence);
-<b>    Description</b>
-2   The fseek function sets the file position indicator for the stream pointed to by stream.
-    If a read or write error occurs, the error indicator for the stream is set and fseek fails.
-3   For a binary stream, the new position, measured in characters from the beginning of the
-    file, is obtained by adding offset to the position specified by whence. The specified
-    position is the beginning of the file if whence is SEEK_SET, the current value of the file
-    position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
-    meaningfully support fseek calls with a whence value of SEEK_END.
-4   For a text stream, either offset shall be zero, or offset shall be a value returned by
-    an earlier successful call to the ftell function on a stream associated with the same file
-    and whence shall be SEEK_SET.
-5   After determining the new position, a successful call to the fseek function undoes any
-    effects of the ungetc function on the stream, clears the end-of-file indicator for the
-    stream, and then establishes the new position. After a successful fseek call, the next
-    operation on an update stream may be either input or output.
-<b>    Returns</b>
-6   The fseek function returns nonzero only for a request that cannot be satisfied.
-    Forward references: the ftell function (<a href="#7.21.9.4">7.21.9.4</a>).
-<a name="7.21.9.3" href="#7.21.9.3"><b>    7.21.9.3 The fsetpos function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int fsetpos(FILE *stream, const fpos_t *pos);
-<b>    Description</b>
-2   The fsetpos function sets the mbstate_t object (if any) and file position indicator
-    for the stream pointed to by stream according to the value of the object pointed to by
-    pos, which shall be a value obtained from an earlier successful call to the fgetpos
-    function on a stream associated with the same file. If a read or write error occurs, the
-    error indicator for the stream is set and fsetpos fails.
-3   A successful call to the fsetpos function undoes any effects of the ungetc function
-    on the stream, clears the end-of-file indicator for the stream, and then establishes the new
-    parse state and position. After a successful fsetpos call, the next operation on an
-
-[<a name="p336" href="#p336">page 336</a>] (<a href="#Contents">Contents</a>)
-
-    update stream may be either input or output.
-<b>    Returns</b>
-4   If successful, the fsetpos function returns zero; on failure, the fsetpos function
-    returns nonzero and stores an implementation-defined positive value in errno.
-<a name="7.21.9.4" href="#7.21.9.4"><b>    7.21.9.4 The ftell function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            long int ftell(FILE *stream);
-<b>    Description</b>
-2   The ftell function obtains the current value of the file position indicator for the stream
-    pointed to by stream. For a binary stream, the value is the number of characters from
-    the beginning of the file. For a text stream, its file position indicator contains unspecified
-    information, usable by the fseek function for returning the file position indicator for the
-    stream to its position at the time of the ftell call; the difference between two such
-    return values is not necessarily a meaningful measure of the number of characters written
-    or read.
-<b>    Returns</b>
-3   If successful, the ftell function returns the current value of the file position indicator
-    for the stream. On failure, the ftell function returns -1L and stores an
-    implementation-defined positive value in errno.
-<a name="7.21.9.5" href="#7.21.9.5"><b>    7.21.9.5 The rewind function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            void rewind(FILE *stream);
-<b>    Description</b>
-2   The rewind function sets the file position indicator for the stream pointed to by
-    stream to the beginning of the file. It is equivalent to
-            (void)fseek(stream, 0L, SEEK_SET)
-    except that the error indicator for the stream is also cleared.
-<b>    Returns</b>
-3   The rewind function returns no value.
-
-[<a name="p337" href="#p337">page 337</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.10" href="#7.21.10"><b>    7.21.10 Error-handling functions</b></a>
-<a name="7.21.10.1" href="#7.21.10.1"><b>    7.21.10.1 The clearerr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           void clearerr(FILE *stream);
-<b>    Description</b>
-2   The clearerr function clears the end-of-file and error indicators for the stream pointed
-    to by stream.
-<b>    Returns</b>
-3   The clearerr function returns no value.
-<a name="7.21.10.2" href="#7.21.10.2"><b>    7.21.10.2 The feof function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int feof(FILE *stream);
-<b>    Description</b>
-2   The feof function tests the end-of-file indicator for the stream pointed to by stream.
-<b>    Returns</b>
-3   The feof function returns nonzero if and only if the end-of-file indicator is set for
-    stream.
-<a name="7.21.10.3" href="#7.21.10.3"><b>    7.21.10.3 The ferror function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int ferror(FILE *stream);
-<b>    Description</b>
-2   The ferror function tests the error indicator for the stream pointed to by stream.
-<b>    Returns</b>
-3   The ferror function returns nonzero if and only if the error indicator is set for
-    stream.
-
-[<a name="p338" href="#p338">page 338</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.21.10.4" href="#7.21.10.4"><b>    7.21.10.4 The perror function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            void perror(const char *s);
-<b>    Description</b>
-2   The perror function maps the error number in the integer expression errno to an
-    error message. It writes a sequence of characters to the standard error stream thus: first
-    (if s is not a null pointer and the character pointed to by s is not the null character), the
-    string pointed to by s followed by a colon (:) and a space; then an appropriate error
-    message string followed by a new-line character. The contents of the error message
-    strings are the same as those returned by the strerror function with argument errno.
-<b>    Returns</b>
-3   The perror function returns no value.
-    Forward references: the strerror function (<a href="#7.23.6.2">7.23.6.2</a>).
-
-[<a name="p339" href="#p339">page 339</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22" href="#7.22"><b>    7.22 General utilities &lt;stdlib.h&gt;</b></a>
-1   The header <a href="#7.22">&lt;stdlib.h&gt;</a> declares five types and several functions of general utility, and
-    defines several macros.<sup><a href="#note284"><b>284)</b></a></sup>
-2   The types declared are size_t and wchar_t (both described in <a href="#7.19">7.19</a>),
-             div_t
-    which is a structure type that is the type of the value returned by the div function,
-             ldiv_t
-    which is a structure type that is the type of the value returned by the ldiv function, and
-             lldiv_t
-    which is a structure type that is the type of the value returned by the lldiv function.
-3   The macros defined are NULL (described in <a href="#7.19">7.19</a>);
-             EXIT_FAILURE
-    and
-             EXIT_SUCCESS
-    which expand to integer constant expressions that can be used as the argument to the
-    exit function to return unsuccessful or successful termination status, respectively, to the
-    host environment;
-             RAND_MAX
-    which expands to an integer constant expression that is the maximum value returned by
-    the rand function; and
-             MB_CUR_MAX
-    which expands to a positive integer expression with type size_t that is the maximum
-    number of bytes in a multibyte character for the extended character set specified by the
-    current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
-
-
-
-
-    <sup><a name="note284" href="#note284"><b>284)</b></a></sup> See ''future library directions'' (<a href="#7.30.10">7.30.10</a>).
-
-[<a name="p340" href="#p340">page 340</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22.1" href="#7.22.1"><b>    7.22.1 Numeric conversion functions</b></a>
-1   The functions atof, atoi, atol, and atoll need not affect the value of the integer
-    expression errno on an error. If the value of the result cannot be represented, the
-    behavior is undefined.
-<a name="7.22.1.1" href="#7.22.1.1"><b>    7.22.1.1 The atof function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            double atof(const char *nptr);
-<b>    Description</b>
-2   The atof function converts the initial portion of the string pointed to by nptr to
-    double representation. Except for the behavior on error, it is equivalent to
-            strtod(nptr, (char **)NULL)
-<b>    Returns</b>
-3   The atof function returns the converted value.
-    Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
-<a name="7.22.1.2" href="#7.22.1.2"><b>    7.22.1.2 The atoi, atol, and atoll functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            int atoi(const char *nptr);
-            long int atol(const char *nptr);
-            long long int atoll(const char *nptr);
-<b>    Description</b>
-2   The atoi, atol, and atoll functions convert the initial portion of the string pointed
-    to by nptr to int, long int, and long long int representation, respectively.
-    Except for the behavior on error, they are equivalent to
-            atoi: (int)strtol(nptr, (char **)NULL, 10)
-            atol: strtol(nptr, (char **)NULL, 10)
-            atoll: strtoll(nptr, (char **)NULL, 10)
-<b>    Returns</b>
-3   The atoi, atol, and atoll functions return the converted value.
-    Forward references: the strtol, strtoll, strtoul, and strtoull functions
-    (<a href="#7.22.1.4">7.22.1.4</a>).
-
-[<a name="p341" href="#p341">page 341</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22.1.3" href="#7.22.1.3"><b>    7.22.1.3 The strtod, strtof, and strtold functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-           double strtod(const char * restrict nptr,
-                char ** restrict endptr);
-           float strtof(const char * restrict nptr,
-                char ** restrict endptr);
-           long double strtold(const char * restrict nptr,
-                char ** restrict endptr);
-<b>    Description</b>
-2   The strtod, strtof, and strtold functions convert the initial portion of the string
-    pointed to by nptr to double, float, and long double representation,
-    respectively. First, they decompose the input string into three parts: an initial, possibly
-    empty, sequence of white-space characters (as specified by the isspace function), a
-    subject sequence resembling a floating-point constant or representing an infinity or NaN;
-    and a final string of one or more unrecognized characters, including the terminating null
-    character of the input string. Then, they attempt to convert the subject sequence to a
-    floating-point number, and return the result.
-3   The expected form of the subject sequence is an optional plus or minus sign, then one of
-    the following:
-    -- a nonempty sequence of decimal digits optionally containing a decimal-point
-      character, then an optional exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
-    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
-      decimal-point character, then an optional binary exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
-    -- INF or INFINITY, ignoring case
-    -- NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part, where:
-               n-char-sequence:
-                      digit
-                      nondigit
-                      n-char-sequence digit
-                      n-char-sequence nondigit
-    The subject sequence is defined as the longest initial subsequence of the input string,
-    starting with the first non-white-space character, that is of the expected form. The subject
-    sequence contains no characters if the input string is not of the expected form.
-4   If the subject sequence has the expected form for a floating-point number, the sequence of
-    characters starting with the first digit or the decimal-point character (whichever occurs
-    first) is interpreted as a floating constant according to the rules of <a href="#6.4.4.2">6.4.4.2</a>, except that the
-
-[<a name="p342" href="#p342">page 342</a>] (<a href="#Contents">Contents</a>)
-
-    decimal-point character is used in place of a period, and that if neither an exponent part
-    nor a decimal-point character appears in a decimal floating point number, or if a binary
-    exponent part does not appear in a hexadecimal floating point number, an exponent part
-    of the appropriate type with value zero is assumed to follow the last digit in the string. If
-    the subject sequence begins with a minus sign, the sequence is interpreted as negated.<sup><a href="#note285"><b>285)</b></a></sup>
-    A character sequence INF or INFINITY is interpreted as an infinity, if representable in
-    the return type, else like a floating constant that is too large for the range of the return
-    type. A character sequence NAN or NAN(n-char-sequenceopt), is interpreted as a quiet
-    NaN, if supported in the return type, else like a subject sequence part that does not have
-    the expected form; the meaning of the n-char sequences is implementation-defined.<sup><a href="#note286"><b>286)</b></a></sup> A
-    pointer to the final string is stored in the object pointed to by endptr, provided that
-    endptr is not a null pointer.
-5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
-    value resulting from the conversion is correctly rounded.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-    Recommended practice
-8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
-    the result is not exactly representable, the result should be one of the two numbers in the
-    appropriate internal format that are adjacent to the hexadecimal floating source value,
-    with the extra stipulation that the error should have a correct sign for the current rounding
-    direction.
-9   If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
-    <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
-    sequence D has the decimal form and more than DECIMAL_DIG significant digits,
-    consider the two bounding, adjacent decimal strings L and U, both having
-    DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
-    The result should be one of the (equal or adjacent) values that would be obtained by
-    correctly rounding L and U according to the current rounding direction, with the extra
-
-    <sup><a name="note285" href="#note285"><b>285)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
-         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
-         methods may yield different results if rounding is toward positive or negative infinity. In either case,
-         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
-    <sup><a name="note286" href="#note286"><b>286)</b></a></sup> An implementation may use the n-char sequence to determine extra information to be represented in
-         the NaN's significand.
-
-[<a name="p343" href="#p343">page 343</a>] (<a href="#Contents">Contents</a>)
-
-     stipulation that the error with respect to D should have a correct sign for the current
-     rounding direction.<sup><a href="#note287"><b>287)</b></a></sup>
-<b>     Returns</b>
-10   The functions return the converted value, if any. If no conversion could be performed,
-     zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
-     plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
-     return type and sign of the value), and the value of the macro ERANGE is stored in
-     errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
-     no greater than the smallest normalized positive number in the return type; whether
-     errno acquires the value ERANGE is implementation-defined.
-<a name="7.22.1.4" href="#7.22.1.4"><b>     7.22.1.4 The strtol, strtoll, strtoul, and strtoull functions</b></a>
-<b>     Synopsis</b>
-1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             long int strtol(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-             long long int strtoll(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-             unsigned long int strtoul(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-             unsigned long long int strtoull(
-                  const char * restrict nptr,
-                  char ** restrict endptr,
-                  int base);
-<b>     Description</b>
-2    The strtol, strtoll, strtoul, and strtoull functions convert the initial
-     portion of the string pointed to by nptr to long int, long long int, unsigned
-     long int, and unsigned long long int representation, respectively. First,
-     they decompose the input string into three parts: an initial, possibly empty, sequence of
-     white-space characters (as specified by the isspace function), a subject sequence
-
-
-     <sup><a name="note287" href="#note287"><b>287)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
-          to the same internal floating value, but if not will round to adjacent values.
-
-[<a name="p344" href="#p344">page 344</a>] (<a href="#Contents">Contents</a>)
-
-    resembling an integer represented in some radix determined by the value of base, and a
-    final string of one or more unrecognized characters, including the terminating null
-    character of the input string. Then, they attempt to convert the subject sequence to an
-    integer, and return the result.
-3   If the value of base is zero, the expected form of the subject sequence is that of an
-    integer constant as described in <a href="#6.4.4.1">6.4.4.1</a>, optionally preceded by a plus or minus sign, but
-    not including an integer suffix. If the value of base is between 2 and 36 (inclusive), the
-    expected form of the subject sequence is a sequence of letters and digits representing an
-    integer with the radix specified by base, optionally preceded by a plus or minus sign,
-    but not including an integer suffix. The letters from a (or A) through z (or Z) are
-    ascribed the values 10 through 35; only letters and digits whose ascribed values are less
-    than that of base are permitted. If the value of base is 16, the characters 0x or 0X may
-    optionally precede the sequence of letters and digits, following the sign if present.
-4   The subject sequence is defined as the longest initial subsequence of the input string,
-    starting with the first non-white-space character, that is of the expected form. The subject
-    sequence contains no characters if the input string is empty or consists entirely of white
-    space, or if the first non-white-space character is other than a sign or a permissible letter
-    or digit.
-5   If the subject sequence has the expected form and the value of base is zero, the sequence
-    of characters starting with the first digit is interpreted as an integer constant according to
-    the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the value of base
-    is between 2 and 36, it is used as the base for conversion, ascribing to each letter its value
-    as given above. If the subject sequence begins with a minus sign, the value resulting from
-    the conversion is negated (in the return type). A pointer to the final string is stored in the
-    object pointed to by endptr, provided that endptr is not a null pointer.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-<b>    Returns</b>
-8   The strtol, strtoll, strtoul, and strtoull functions return the converted
-    value, if any. If no conversion could be performed, zero is returned. If the correct value
-    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
-    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
-    and sign of the value, if any), and the value of the macro ERANGE is stored in errno.
-
-[<a name="p345" href="#p345">page 345</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22.2" href="#7.22.2"><b>    7.22.2 Pseudo-random sequence generation functions</b></a>
-<a name="7.22.2.1" href="#7.22.2.1"><b>    7.22.2.1 The rand function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            int rand(void);
-<b>    Description</b>
-2   The rand function computes a sequence of pseudo-random integers in the range 0 to
-    RAND_MAX.<sup><a href="#note288"><b>288)</b></a></sup>
-3   The rand function is not required to avoid data races. The implementation shall behave
-    as if no library function calls the rand function.
-<b>    Returns</b>
-4   The rand function returns a pseudo-random integer.
-    Environmental limits
-5   The value of the RAND_MAX macro shall be at least 32767.
-<a name="7.22.2.2" href="#7.22.2.2"><b>    7.22.2.2 The srand function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void srand(unsigned int seed);
-<b>    Description</b>
-2   The srand function uses the argument as a seed for a new sequence of pseudo-random
-    numbers to be returned by subsequent calls to rand. If srand is then called with the
-    same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is
-    called before any calls to srand have been made, the same sequence shall be generated
-    as when srand is first called with a seed value of 1.
-3   The implementation shall behave as if no library function calls the srand function.
-<b>    Returns</b>
-4   The srand function returns no value.
-
-
-
-
-    <sup><a name="note288" href="#note288"><b>288)</b></a></sup> There are no guarantees as to the quality of the random sequence produced and some implementations
-         are known to produce sequences with distressingly non-random low-order bits. Applications with
-         particular requirements should use a generator that is known to be sufficient for their needs.
-
-[<a name="p346" href="#p346">page 346</a>] (<a href="#Contents">Contents</a>)
-
-5   EXAMPLE       The following functions define a portable implementation of rand and srand.
-            static unsigned long int next = 1;
-            int rand(void)   // RAND_MAX assumed to be 32767
-            {
-                  next = next * 1103515245 + 12345;
-                  return (unsigned int)(next/65536) % 32768;
-            }
-            void srand(unsigned int seed)
-            {
-                  next = seed;
-            }
-
-<a name="7.22.3" href="#7.22.3"><b>    7.22.3 Memory management functions</b></a>
-1   The order and contiguity of storage allocated by successive calls to the
-    aligned_alloc, calloc, malloc, and realloc functions is unspecified. The
-    pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to
-    a pointer to any type of object with a fundamental alignment requirement and then used
-    to access such an object or an array of such objects in the space allocated (until the space
-    is explicitly deallocated). The lifetime of an allocated object extends from the allocation
-    until the deallocation. Each such allocation shall yield a pointer to an object disjoint from
-    any other object. The pointer returned points to the start (lowest byte address) of the
-    allocated space. If the space cannot be allocated, a null pointer is returned. If the size of
-    the space requested is zero, the behavior is implementation-defined: either a null pointer
-    is returned, or the behavior is as if the size were some nonzero value, except that the
-    returned pointer shall not be used to access an object.
-<a name="7.22.3.1" href="#7.22.3.1"><b>    7.22.3.1 The aligned_alloc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void *aligned_alloc(size_t alignment, size_t size);
-<b>    Description</b>
-2   The aligned_alloc function allocates space for an object whose alignment is
-    specified by alignment, whose size is specified by size, and whose value is
-    indeterminate. The value of alignment shall be a valid alignment supported by the
-    implementation and the value of size shall be an integral multiple of alignment.
-<b>    Returns</b>
-3   The aligned_alloc function returns either a null pointer or a pointer to the allocated
-    space.
-
-[<a name="p347" href="#p347">page 347</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22.3.2" href="#7.22.3.2"><b>    7.22.3.2 The calloc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void *calloc(size_t nmemb, size_t size);
-<b>    Description</b>
-2   The calloc function allocates space for an array of nmemb objects, each of whose size
-    is size. The space is initialized to all bits zero.<sup><a href="#note289"><b>289)</b></a></sup>
-<b>    Returns</b>
-3   The calloc function returns either a null pointer or a pointer to the allocated space.
-<a name="7.22.3.3" href="#7.22.3.3"><b>    7.22.3.3 The free function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void free(void *ptr);
-<b>    Description</b>
-2   The free function causes the space pointed to by ptr to be deallocated, that is, made
-    available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if
-    the argument does not match a pointer earlier returned by a memory management
-    function, or if the space has been deallocated by a call to free or realloc, the
-    behavior is undefined.
-<b>    Returns</b>
-3   The free function returns no value.
-<a name="7.22.3.4" href="#7.22.3.4"><b>    7.22.3.4 The malloc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void *malloc(size_t size);
-<b>    Description</b>
-2   The malloc function allocates space for an object whose size is specified by size and
-    whose value is indeterminate.
-
-
-
-
-    <sup><a name="note289" href="#note289"><b>289)</b></a></sup> Note that this need not be the same as the representation of floating-point zero or a null pointer
-         constant.
-
-[<a name="p348" href="#p348">page 348</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The malloc function returns either a null pointer or a pointer to the allocated space.
-<a name="7.22.3.5" href="#7.22.3.5"><b>    7.22.3.5 The realloc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void *realloc(void *ptr, size_t size);
-<b>    Description</b>
-2   The realloc function deallocates the old object pointed to by ptr and returns a
-    pointer to a new object that has the size specified by size. The contents of the new
-    object shall be the same as that of the old object prior to deallocation, up to the lesser of
-    the new and old sizes. Any bytes in the new object beyond the size of the old object have
-    indeterminate values.
-3   If ptr is a null pointer, the realloc function behaves like the malloc function for the
-    specified size. Otherwise, if ptr does not match a pointer earlier returned by a memory
-    management function, or if the space has been deallocated by a call to the free or
-    realloc function, the behavior is undefined. If memory for the new object cannot be
-    allocated, the old object is not deallocated and its value is unchanged.
-<b>    Returns</b>
-4   The realloc function returns a pointer to the new object (which may have the same
-    value as a pointer to the old object), or a null pointer if the new object could not be
-    allocated.
-<a name="7.22.4" href="#7.22.4"><b>    7.22.4 Communication with the environment</b></a>
-<a name="7.22.4.1" href="#7.22.4.1"><b>    7.22.4.1 The abort function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            _Noreturn void abort(void);
-<b>    Description</b>
-2   The abort function causes abnormal program termination to occur, unless the signal
-    SIGABRT is being caught and the signal handler does not return. Whether open streams
-    with unwritten buffered data are flushed, open streams are closed, or temporary files are
-    removed is implementation-defined. An implementation-defined form of the status
-    unsuccessful termination is returned to the host environment by means of the function
-    call raise(SIGABRT).
-
-[<a name="p349" href="#p349">page 349</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The abort function does not return to its caller.
-<a name="7.22.4.2" href="#7.22.4.2"><b>    7.22.4.2 The atexit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-           int atexit(void (*func)(void));
-<b>    Description</b>
-2   The atexit function registers the function pointed to by func, to be called without
-    arguments at normal program termination.<sup><a href="#note290"><b>290)</b></a></sup>
-    Environmental limits
-3   The implementation shall support the registration of at least 32 functions.
-<b>    Returns</b>
-4   The atexit function returns zero if the registration succeeds, nonzero if it fails.
-    Forward references: the at_quick_exit function (<a href="#7.22.4.3">7.22.4.3</a>), the exit function
-    (<a href="#7.22.4.4">7.22.4.4</a>).
-<a name="7.22.4.3" href="#7.22.4.3"><b>    7.22.4.3 The at_quick_exit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-           int at_quick_exit(void (*func)(void));
-<b>    Description</b>
-2   The at_quick_exit function registers the function pointed to by func, to be called
-    without arguments should quick_exit be called.<sup><a href="#note291"><b>291)</b></a></sup>
-    Environmental limits
-3   The implementation shall support the registration of at least 32 functions.
-<b>    Returns</b>
-4   The at_quick_exit function returns zero if the registration succeeds, nonzero if it
-    fails.
-    Forward references: the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
-
-
-    <sup><a name="note290" href="#note290"><b>290)</b></a></sup> The atexit function registrations are distinct from the at_quick_exit registrations, so
-         applications may need to call both registration functions with the same argument.
-    <sup><a name="note291" href="#note291"><b>291)</b></a></sup> The at_quick_exit function registrations are distinct from the atexit registrations, so
-         applications may need to call both registration functions with the same argument.
-
-[<a name="p350" href="#p350">page 350</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22.4.4" href="#7.22.4.4"><b>    7.22.4.4 The exit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            _Noreturn void exit(int status);
-<b>    Description</b>
-2   The exit function causes normal program termination to occur. No functions registered
-    by the at_quick_exit function are called. If a program calls the exit function
-    more than once, or calls the quick_exit function in addition to the exit function, the
-    behavior is undefined.
-3   First, all functions registered by the atexit function are called, in the reverse order of
-    their registration,<sup><a href="#note292"><b>292)</b></a></sup> except that a function is called after any previously registered
-    functions that had already been called at the time it was registered. If, during the call to
-    any such function, a call to the longjmp function is made that would terminate the call
-    to the registered function, the behavior is undefined.
-4   Next, all open streams with unwritten buffered data are flushed, all open streams are
-    closed, and all files created by the tmpfile function are removed.
-5   Finally, control is returned to the host environment. If the value of status is zero or
-    EXIT_SUCCESS, an implementation-defined form of the status successful termination is
-    returned. If the value of status is EXIT_FAILURE, an implementation-defined form
-    of the status unsuccessful termination is returned. Otherwise the status returned is
-    implementation-defined.
-<b>    Returns</b>
-6   The exit function cannot return to its caller.
-<a name="7.22.4.5" href="#7.22.4.5"><b>    7.22.4.5 The _Exit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            _Noreturn void _Exit(int status);
-<b>    Description</b>
-2   The _Exit function causes normal program termination to occur and control to be
-    returned to the host environment. No functions registered by the atexit function, the
-    at_quick_exit function, or signal handlers registered by the signal function are
-    called. The status returned to the host environment is determined in the same way as for
-
-
-    <sup><a name="note292" href="#note292"><b>292)</b></a></sup> Each function is called as many times as it was registered, and in the correct order with respect to
-         other registered functions.
-
-[<a name="p351" href="#p351">page 351</a>] (<a href="#Contents">Contents</a>)
-
-    the exit function (<a href="#7.22.4.4">7.22.4.4</a>). Whether open streams with unwritten buffered data are
-    flushed, open streams are closed, or temporary files are removed is implementation-
-    defined.
-<b>    Returns</b>
-3   The _Exit function cannot return to its caller.
-<a name="7.22.4.6" href="#7.22.4.6"><b>    7.22.4.6 The getenv function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            char *getenv(const char *name);
-<b>    Description</b>
-2   The getenv function searches an environment list, provided by the host environment,
-    for a string that matches the string pointed to by name. The set of environment names
-    and the method for altering the environment list are implementation-defined. The
-    getenv function need not avoid data races with other threads of execution that modify
-    the environment list.<sup><a href="#note293"><b>293)</b></a></sup>
-3   The implementation shall behave as if no library function calls the getenv function.
-<b>    Returns</b>
-4   The getenv function returns a pointer to a string associated with the matched list
-    member. The string pointed to shall not be modified by the program, but may be
-    overwritten by a subsequent call to the getenv function. If the specified name cannot
-    be found, a null pointer is returned.
-<a name="7.22.4.7" href="#7.22.4.7"><b>    7.22.4.7 The quick_exit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            _Noreturn void quick_exit(int status);
-<b>    Description</b>
-2   The quick_exit function causes normal program termination to occur. No functions
-    registered by the atexit function or signal handlers registered by the signal function
-    are called. If a program calls the quick_exit function more than once, or calls the
-    exit function in addition to the quick_exit function, the behavior is undefined.
-3   The quick_exit function first calls all functions registered by the at_quick_exit
-    function, in the reverse order of their registration,<sup><a href="#note294"><b>294)</b></a></sup> except that a function is called after
-
-
-    <sup><a name="note293" href="#note293"><b>293)</b></a></sup> Many implementations provide non-standard functions that modify the environment list.
-
-[<a name="p352" href="#p352">page 352</a>] (<a href="#Contents">Contents</a>)
-
-    any previously registered functions that had already been called at the time it was
-    registered. If, during the call to any such function, a call to the longjmp function is
-    made that would terminate the call to the registered function, the behavior is undefined.
-4   Then control is returned to the host environment by means of the function call
-    _Exit(status).
-<b>    Returns</b>
-5   The quick_exit function cannot return to its caller.
-<a name="7.22.4.8" href="#7.22.4.8"><b>    7.22.4.8 The system function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            int system(const char *string);
-<b>    Description</b>
-2   If string is a null pointer, the system function determines whether the host
-    environment has a command processor. If string is not a null pointer, the system
-    function passes the string pointed to by string to that command processor to be
-    executed in a manner which the implementation shall document; this might then cause the
-    program calling system to behave in a non-conforming manner or to terminate.
-<b>    Returns</b>
-3   If the argument is a null pointer, the system function returns nonzero only if a
-    command processor is available. If the argument is not a null pointer, and the system
-    function does return, it returns an implementation-defined value.
-<a name="7.22.5" href="#7.22.5"><b>    7.22.5 Searching and sorting utilities</b></a>
-1   These utilities make use of a comparison function to search or sort arrays of unspecified
-    type. Where an argument declared as size_t nmemb specifies the length of the array
-    for a function, nmemb can have the value zero on a call to that function; the comparison
-    function is not called, a search finds no matching element, and sorting performs no
-    rearrangement. Pointer arguments on such a call shall still have valid values, as described
-    in <a href="#7.1.4">7.1.4</a>.
-2   The implementation shall ensure that the second argument of the comparison function
-    (when called from bsearch), or both arguments (when called from qsort), are
-    pointers to elements of the array.<sup><a href="#note295"><b>295)</b></a></sup> The first argument when called from bsearch
-    shall equal key.
-
-
-
-    <sup><a name="note294" href="#note294"><b>294)</b></a></sup> Each function is called as many times as it was registered, and in the correct order with respect to
-         other registered functions.
-
-[<a name="p353" href="#p353">page 353</a>] (<a href="#Contents">Contents</a>)
-
-3   The comparison function shall not alter the contents of the array. The implementation
-    may reorder elements of the array between calls to the comparison function, but shall not
-    alter the contents of any individual element.
-4   When the same objects (consisting of size bytes, irrespective of their current positions
-    in the array) are passed more than once to the comparison function, the results shall be
-    consistent with one another. That is, for qsort they shall define a total ordering on the
-    array, and for bsearch the same object shall always compare the same way with the
-    key.
-5   A sequence point occurs immediately before and immediately after each call to the
-    comparison function, and also between any call to the comparison function and any
-    movement of the objects passed as arguments to that call.
-<a name="7.22.5.1" href="#7.22.5.1"><b>    7.22.5.1 The bsearch function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             void *bsearch(const void *key, const void *base,
-                  size_t nmemb, size_t size,
-                  int (*compar)(const void *, const void *));
-<b>    Description</b>
-2   The bsearch function searches an array of nmemb objects, the initial element of which
-    is pointed to by base, for an element that matches the object pointed to by key. The
-    size of each element of the array is specified by size.
-3   The comparison function pointed to by compar is called with two arguments that point
-    to the key object and to an array element, in that order. The function shall return an
-    integer less than, equal to, or greater than zero if the key object is considered,
-    respectively, to be less than, to match, or to be greater than the array element. The array
-    shall consist of: all the elements that compare less than, all the elements that compare
-    equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note296"><b>296)</b></a></sup>
-<b>    Returns</b>
-4   The bsearch function returns a pointer to a matching element of the array, or a null
-    pointer if no match is found. If two elements compare as equal, which element is
-
-
-    <sup><a name="note295" href="#note295"><b>295)</b></a></sup> That is, if the value passed is p, then the following expressions are always nonzero:
-                  ((char *)p - (char *)base) % size == 0
-                  (char *)p &gt;= (char *)base
-                  (char *)p &lt; (char *)base + nmemb * size
-
-    <sup><a name="note296" href="#note296"><b>296)</b></a></sup> In practice, the entire array is sorted according to the comparison function.
-
-[<a name="p354" href="#p354">page 354</a>] (<a href="#Contents">Contents</a>)
-
-    matched is unspecified.
-<a name="7.22.5.2" href="#7.22.5.2"><b>    7.22.5.2 The qsort function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void qsort(void *base, size_t nmemb, size_t size,
-                 int (*compar)(const void *, const void *));
-<b>    Description</b>
-2   The qsort function sorts an array of nmemb objects, the initial element of which is
-    pointed to by base. The size of each object is specified by size.
-3   The contents of the array are sorted into ascending order according to a comparison
-    function pointed to by compar, which is called with two arguments that point to the
-    objects being compared. The function shall return an integer less than, equal to, or
-    greater than zero if the first argument is considered to be respectively less than, equal to,
-    or greater than the second.
-4   If two elements compare as equal, their order in the resulting sorted array is unspecified.
-<b>    Returns</b>
-5   The qsort function returns no value.
-<a name="7.22.6" href="#7.22.6"><b>    7.22.6 Integer arithmetic functions</b></a>
-<a name="7.22.6.1" href="#7.22.6.1"><b>    7.22.6.1 The abs, labs and llabs functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            int abs(int j);
-            long int labs(long int j);
-            long long int llabs(long long int j);
-<b>    Description</b>
-2   The abs, labs, and llabs functions compute the absolute value of an integer j. If the
-    result cannot be represented, the behavior is undefined.<sup><a href="#note297"><b>297)</b></a></sup>
-<b>    Returns</b>
-3   The abs, labs, and llabs, functions return the absolute value.
-
-
-
-
-    <sup><a name="note297" href="#note297"><b>297)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
-
-[<a name="p355" href="#p355">page 355</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22.6.2" href="#7.22.6.2"><b>    7.22.6.2 The div, ldiv, and lldiv functions</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             div_t div(int numer, int denom);
-             ldiv_t ldiv(long int numer, long int denom);
-             lldiv_t lldiv(long long int numer, long long int denom);
-<b>    Description</b>
-2   The div, ldiv, and lldiv, functions compute numer / denom and numer %
-    denom in a single operation.
-<b>    Returns</b>
-3   The div, ldiv, and lldiv functions return a structure of type div_t, ldiv_t, and
-    lldiv_t, respectively, comprising both the quotient and the remainder. The structures
-    shall contain (in either order) the members quot (the quotient) and rem (the remainder),
-    each of which has the same type as the arguments numer and denom. If either part of
-    the result cannot be represented, the behavior is undefined.
-<a name="7.22.7" href="#7.22.7"><b>    7.22.7 Multibyte/wide character conversion functions</b></a>
-1   The behavior of the multibyte character functions is affected by the LC_CTYPE category
-    of the current locale. For a state-dependent encoding, each function is placed into its
-    initial conversion state at program startup and can be returned to that state by a call for
-    which its character pointer argument, s, is a null pointer. Subsequent calls with s as
-    other than a null pointer cause the internal conversion state of the function to be altered as
-    necessary. A call with s as a null pointer causes these functions to return a nonzero value
-    if encodings have state dependency, and zero otherwise.<sup><a href="#note298"><b>298)</b></a></sup> Changing the LC_CTYPE
-    category causes the conversion state of these functions to be indeterminate.
-<a name="7.22.7.1" href="#7.22.7.1"><b>    7.22.7.1 The mblen function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             int mblen(const char *s, size_t n);
-<b>    Description</b>
-2   If s is not a null pointer, the mblen function determines the number of bytes contained
-    in the multibyte character pointed to by s. Except that the conversion state of the
-    mbtowc function is not affected, it is equivalent to
-
-
-
-    <sup><a name="note298" href="#note298"><b>298)</b></a></sup> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
-         character codes, but are grouped with an adjacent multibyte character.
-
-[<a name="p356" href="#p356">page 356</a>] (<a href="#Contents">Contents</a>)
-
-            mbtowc((wchar_t *)0, (const char *)0, 0);
-            mbtowc((wchar_t *)0, s, n);
-3   The implementation shall behave as if no library function calls the mblen function.
-<b>    Returns</b>
-4   If s is a null pointer, the mblen function returns a nonzero or zero value, if multibyte
-    character encodings, respectively, do or do not have state-dependent encodings. If s is
-    not a null pointer, the mblen function either returns 0 (if s points to the null character),
-    or returns the number of bytes that are contained in the multibyte character (if the next n
-    or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
-    multibyte character).
-    Forward references: the mbtowc function (<a href="#7.22.7.2">7.22.7.2</a>).
-<a name="7.22.7.2" href="#7.22.7.2"><b>    7.22.7.2 The mbtowc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            int mbtowc(wchar_t * restrict pwc,
-                 const char * restrict s,
-                 size_t n);
-<b>    Description</b>
-2   If s is not a null pointer, the mbtowc function inspects at most n bytes beginning with
-    the byte pointed to by s to determine the number of bytes needed to complete the next
-    multibyte character (including any shift sequences). If the function determines that the
-    next multibyte character is complete and valid, it determines the value of the
-    corresponding wide character and then, if pwc is not a null pointer, stores that value in
-    the object pointed to by pwc. If the corresponding wide character is the null wide
-    character, the function is left in the initial conversion state.
-3   The implementation shall behave as if no library function calls the mbtowc function.
-<b>    Returns</b>
-4   If s is a null pointer, the mbtowc function returns a nonzero or zero value, if multibyte
-    character encodings, respectively, do or do not have state-dependent encodings. If s is
-    not a null pointer, the mbtowc function either returns 0 (if s points to the null character),
-    or returns the number of bytes that are contained in the converted multibyte character (if
-    the next n or fewer bytes form a valid multibyte character), or returns -1 (if they do not
-    form a valid multibyte character).
-5   In no case will the value returned be greater than n or the value of the MB_CUR_MAX
-    macro.
-
-[<a name="p357" href="#p357">page 357</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.22.7.3" href="#7.22.7.3"><b>    7.22.7.3 The wctomb function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-           int wctomb(char *s, wchar_t wc);
-<b>    Description</b>
-2   The wctomb function determines the number of bytes needed to represent the multibyte
-    character corresponding to the wide character given by wc (including any shift
-    sequences), and stores the multibyte character representation in the array whose first
-    element is pointed to by s (if s is not a null pointer). At most MB_CUR_MAX characters
-    are stored. If wc is a null wide character, a null byte is stored, preceded by any shift
-    sequence needed to restore the initial shift state, and the function is left in the initial
-    conversion state.
-3   The implementation shall behave as if no library function calls the wctomb function.
-<b>    Returns</b>
-4   If s is a null pointer, the wctomb function returns a nonzero or zero value, if multibyte
-    character encodings, respectively, do or do not have state-dependent encodings. If s is
-    not a null pointer, the wctomb function returns -1 if the value of wc does not correspond
-    to a valid multibyte character, or returns the number of bytes that are contained in the
-    multibyte character corresponding to the value of wc.
-5   In no case will the value returned be greater than the value of the MB_CUR_MAX macro.
-<a name="7.22.8" href="#7.22.8"><b>    7.22.8 Multibyte/wide string conversion functions</b></a>
-1   The behavior of the multibyte string functions is affected by the LC_CTYPE category of
-    the current locale.
-<a name="7.22.8.1" href="#7.22.8.1"><b>    7.22.8.1 The mbstowcs function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-           size_t mbstowcs(wchar_t * restrict pwcs,
-                const char * restrict s,
-                size_t n);
-<b>    Description</b>
-2   The mbstowcs function converts a sequence of multibyte characters that begins in the
-    initial shift state from the array pointed to by s into a sequence of corresponding wide
-    characters and stores not more than n wide characters into the array pointed to by pwcs.
-    No multibyte characters that follow a null character (which is converted into a null wide
-    character) will be examined or converted. Each multibyte character is converted as if by
-    a call to the mbtowc function, except that the conversion state of the mbtowc function is
-
-[<a name="p358" href="#p358">page 358</a>] (<a href="#Contents">Contents</a>)
-
-    not affected.
-3   No more than n elements will be modified in the array pointed to by pwcs. If copying
-    takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-4   If an invalid multibyte character is encountered, the mbstowcs function returns
-    (size_t)(-1). Otherwise, the mbstowcs function returns the number of array
-    elements modified, not including a terminating null wide character, if any.<sup><a href="#note299"><b>299)</b></a></sup>
-<a name="7.22.8.2" href="#7.22.8.2"><b>    7.22.8.2 The wcstombs function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             size_t wcstombs(char * restrict s,
-                  const wchar_t * restrict pwcs,
-                  size_t n);
-<b>    Description</b>
-2   The wcstombs function converts a sequence of wide characters from the array pointed
-    to by pwcs into a sequence of corresponding multibyte characters that begins in the
-    initial shift state, and stores these multibyte characters into the array pointed to by s,
-    stopping if a multibyte character would exceed the limit of n total bytes or if a null
-    character is stored. Each wide character is converted as if by a call to the wctomb
-    function, except that the conversion state of the wctomb function is not affected.
-3   No more than n bytes will be modified in the array pointed to by s. If copying takes place
-    between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-4   If a wide character is encountered that does not correspond to a valid multibyte character,
-    the wcstombs function returns (size_t)(-1). Otherwise, the wcstombs function
-    returns the number of bytes modified, not including a terminating null character, if
-    any.299)
-
-
-
-
-    <sup><a name="note299" href="#note299"><b>299)</b></a></sup> The array will not be null-terminated if the value returned is n.
-
-[<a name="p359" href="#p359">page 359</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.23" href="#7.23"><b>    7.23 String handling &lt;string.h&gt;</b></a>
-<a name="7.23.1" href="#7.23.1"><b>    7.23.1 String function conventions</b></a>
-1   The header <a href="#7.23">&lt;string.h&gt;</a> declares one type and several functions, and defines one
-    macro useful for manipulating arrays of character type and other objects treated as arrays
-    of character type.<sup><a href="#note300"><b>300)</b></a></sup> The type is size_t and the macro is NULL (both described in
-<a name="7.19)" href="#7.19)"><b>    7.19). Various methods are used for determining the lengths of the arrays, but in all cases</b></a>
-    a char * or void * argument points to the initial (lowest addressed) character of the
-    array. If an array is accessed beyond the end of an object, the behavior is undefined.
-2   Where an argument declared as size_t n specifies the length of the array for a
-    function, n can have the value zero on a call to that function. Unless explicitly stated
-    otherwise in the description of a particular function in this subclause, pointer arguments
-    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
-    function that locates a character finds no occurrence, a function that compares two
-    character sequences returns zero, and a function that copies characters copies zero
-    characters.
-3   For all functions in this subclause, each character shall be interpreted as if it had the type
-    unsigned char (and therefore every possible object representation is valid and has a
-    different value).
-<a name="7.23.2" href="#7.23.2"><b>    7.23.2 Copying functions</b></a>
-<a name="7.23.2.1" href="#7.23.2.1"><b>    7.23.2.1 The memcpy function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.23">&lt;string.h&gt;</a>
-             void *memcpy(void * restrict s1,
-                  const void * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The memcpy function copies n characters from the object pointed to by s2 into the
-    object pointed to by s1. If copying takes place between objects that overlap, the behavior
-    is undefined.
-<b>    Returns</b>
-3   The memcpy function returns the value of s1.
-
-
-
-
-    <sup><a name="note300" href="#note300"><b>300)</b></a></sup> See ''future library directions'' (<a href="#7.30.11">7.30.11</a>).
-
-[<a name="p360" href="#p360">page 360</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.23.2.2" href="#7.23.2.2"><b>    7.23.2.2 The memmove function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            void *memmove(void *s1, const void *s2, size_t n);
-<b>    Description</b>
-2   The memmove function copies n characters from the object pointed to by s2 into the
-    object pointed to by s1. Copying takes place as if the n characters from the object
-    pointed to by s2 are first copied into a temporary array of n characters that does not
-    overlap the objects pointed to by s1 and s2, and then the n characters from the
-    temporary array are copied into the object pointed to by s1.
-<b>    Returns</b>
-3   The memmove function returns the value of s1.
-<a name="7.23.2.3" href="#7.23.2.3"><b>    7.23.2.3 The strcpy function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            char *strcpy(char * restrict s1,
-                 const char * restrict s2);
-<b>    Description</b>
-2   The strcpy function copies the string pointed to by s2 (including the terminating null
-    character) into the array pointed to by s1. If copying takes place between objects that
-    overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The strcpy function returns the value of s1.
-<a name="7.23.2.4" href="#7.23.2.4"><b>    7.23.2.4 The strncpy function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            char *strncpy(char * restrict s1,
-                 const char * restrict s2,
-                 size_t n);
-<b>    Description</b>
-2   The strncpy function copies not more than n characters (characters that follow a null
-    character are not copied) from the array pointed to by s2 to the array pointed to by
-
-[<a name="p361" href="#p361">page 361</a>] (<a href="#Contents">Contents</a>)
-
-    s1.<sup><a href="#note301"><b>301)</b></a></sup> If copying takes place between objects that overlap, the behavior is undefined.
-3   If the array pointed to by s2 is a string that is shorter than n characters, null characters
-    are appended to the copy in the array pointed to by s1, until n characters in all have been
-    written.
-<b>    Returns</b>
-4   The strncpy function returns the value of s1.
-<a name="7.23.3" href="#7.23.3"><b>    7.23.3 Concatenation functions</b></a>
-<a name="7.23.3.1" href="#7.23.3.1"><b>    7.23.3.1 The strcat function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.23">&lt;string.h&gt;</a>
-             char *strcat(char * restrict s1,
-                  const char * restrict s2);
-<b>    Description</b>
-2   The strcat function appends a copy of the string pointed to by s2 (including the
-    terminating null character) to the end of the string pointed to by s1. The initial character
-    of s2 overwrites the null character at the end of s1. If copying takes place between
-    objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The strcat function returns the value of s1.
-<a name="7.23.3.2" href="#7.23.3.2"><b>    7.23.3.2 The strncat function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.23">&lt;string.h&gt;</a>
-             char *strncat(char * restrict s1,
-                  const char * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The strncat function appends not more than n characters (a null character and
-    characters that follow it are not appended) from the array pointed to by s2 to the end of
-    the string pointed to by s1. The initial character of s2 overwrites the null character at the
-    end of s1. A terminating null character is always appended to the result.<sup><a href="#note302"><b>302)</b></a></sup> If copying
-
-    <sup><a name="note301" href="#note301"><b>301)</b></a></sup> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
-         not be null-terminated.
-    <sup><a name="note302" href="#note302"><b>302)</b></a></sup> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
-         strlen(s1)+n+1.
-
-[<a name="p362" href="#p362">page 362</a>] (<a href="#Contents">Contents</a>)
-
-    takes place between objects that overlap, the behavior is undefined.
-<b>    Returns</b>
-3   The strncat function returns the value of s1.
-    Forward references: the strlen function (<a href="#7.23.6.3">7.23.6.3</a>).
-<a name="7.23.4" href="#7.23.4"><b>    7.23.4 Comparison functions</b></a>
-1   The sign of a nonzero value returned by the comparison functions memcmp, strcmp,
-    and strncmp is determined by the sign of the difference between the values of the first
-    pair of characters (both interpreted as unsigned char) that differ in the objects being
-    compared.
-<a name="7.23.4.1" href="#7.23.4.1"><b>    7.23.4.1 The memcmp function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            int memcmp(const void *s1, const void *s2, size_t n);
-<b>    Description</b>
-2   The memcmp function compares the first n characters of the object pointed to by s1 to
-    the first n characters of the object pointed to by s2.<sup><a href="#note303"><b>303)</b></a></sup>
-<b>    Returns</b>
-3   The memcmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
-    pointed to by s2.
-<a name="7.23.4.2" href="#7.23.4.2"><b>    7.23.4.2 The strcmp function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            int strcmp(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strcmp function compares the string pointed to by s1 to the string pointed to by
-    s2.
-<b>    Returns</b>
-3   The strcmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
-
-    <sup><a name="note303" href="#note303"><b>303)</b></a></sup> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
-         indeterminate. Strings shorter than their allocated space and unions may also cause problems in
-         comparison.
-
-[<a name="p363" href="#p363">page 363</a>] (<a href="#Contents">Contents</a>)
-
-    pointed to by s2.
-<a name="7.23.4.3" href="#7.23.4.3"><b>    7.23.4.3 The strcoll function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;string.h&gt;</a>
-           int strcoll(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strcoll function compares the string pointed to by s1 to the string pointed to by
-    s2, both interpreted as appropriate to the LC_COLLATE category of the current locale.
-<b>    Returns</b>
-3   The strcoll function returns an integer greater than, equal to, or less than zero,
-    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
-    pointed to by s2 when both are interpreted as appropriate to the current locale.
-<a name="7.23.4.4" href="#7.23.4.4"><b>    7.23.4.4 The strncmp function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;string.h&gt;</a>
-           int strncmp(const char *s1, const char *s2, size_t n);
-<b>    Description</b>
-2   The strncmp function compares not more than n characters (characters that follow a
-    null character are not compared) from the array pointed to by s1 to the array pointed to
-    by s2.
-<b>    Returns</b>
-3   The strncmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
-    to, or less than the possibly null-terminated array pointed to by s2.
-<a name="7.23.4.5" href="#7.23.4.5"><b>    7.23.4.5 The strxfrm function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;string.h&gt;</a>
-           size_t strxfrm(char * restrict s1,
-                const char * restrict s2,
-                size_t n);
-<b>    Description</b>
-2   The strxfrm function transforms the string pointed to by s2 and places the resulting
-    string into the array pointed to by s1. The transformation is such that if the strcmp
-    function is applied to two transformed strings, it returns a value greater than, equal to, or
-
-[<a name="p364" href="#p364">page 364</a>] (<a href="#Contents">Contents</a>)
-
-    less than zero, corresponding to the result of the strcoll function applied to the same
-    two original strings. No more than n characters are placed into the resulting array
-    pointed to by s1, including the terminating null character. If n is zero, s1 is permitted to
-    be a null pointer. If copying takes place between objects that overlap, the behavior is
-    undefined.
-<b>    Returns</b>
-3   The strxfrm function returns the length of the transformed string (not including the
-    terminating null character). If the value returned is n or more, the contents of the array
-    pointed to by s1 are indeterminate.
-4   EXAMPLE The value of the following expression is the size of the array needed to hold the
-    transformation of the string pointed to by s.
-            1 + strxfrm(NULL, s, 0)
-
-<a name="7.23.5" href="#7.23.5"><b>    7.23.5 Search functions</b></a>
-<a name="7.23.5.1" href="#7.23.5.1"><b>    7.23.5.1 The memchr function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            void *memchr(const void *s, int c, size_t n);
-<b>    Description</b>
-2   The memchr function locates the first occurrence of c (converted to an unsigned
-    char) in the initial n characters (each interpreted as unsigned char) of the object
-    pointed to by s. The implementation shall behave as if it reads the characters sequentially
-    and stops as soon as a matching character is found.
-<b>    Returns</b>
-3   The memchr function returns a pointer to the located character, or a null pointer if the
-    character does not occur in the object.
-<a name="7.23.5.2" href="#7.23.5.2"><b>    7.23.5.2 The strchr function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            char *strchr(const char *s, int c);
-<b>    Description</b>
-2   The strchr function locates the first occurrence of c (converted to a char) in the
-    string pointed to by s. The terminating null character is considered to be part of the
-    string.
-
-[<a name="p365" href="#p365">page 365</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The strchr function returns a pointer to the located character, or a null pointer if the
-    character does not occur in the string.
-<a name="7.23.5.3" href="#7.23.5.3"><b>    7.23.5.3 The strcspn function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;string.h&gt;</a>
-           size_t strcspn(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strcspn function computes the length of the maximum initial segment of the string
-    pointed to by s1 which consists entirely of characters not from the string pointed to by
-    s2.
-<b>    Returns</b>
-3   The strcspn function returns the length of the segment.
-<a name="7.23.5.4" href="#7.23.5.4"><b>    7.23.5.4 The strpbrk function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;string.h&gt;</a>
-           char *strpbrk(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strpbrk function locates the first occurrence in the string pointed to by s1 of any
-    character from the string pointed to by s2.
-<b>    Returns</b>
-3   The strpbrk function returns a pointer to the character, or a null pointer if no character
-    from s2 occurs in s1.
-<a name="7.23.5.5" href="#7.23.5.5"><b>    7.23.5.5 The strrchr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;string.h&gt;</a>
-           char *strrchr(const char *s, int c);
-<b>    Description</b>
-2   The strrchr function locates the last occurrence of c (converted to a char) in the
-    string pointed to by s. The terminating null character is considered to be part of the
-    string.
-
-[<a name="p366" href="#p366">page 366</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The strrchr function returns a pointer to the character, or a null pointer if c does not
-    occur in the string.
-<a name="7.23.5.6" href="#7.23.5.6"><b>    7.23.5.6 The strspn function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            size_t strspn(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strspn function computes the length of the maximum initial segment of the string
-    pointed to by s1 which consists entirely of characters from the string pointed to by s2.
-<b>    Returns</b>
-3   The strspn function returns the length of the segment.
-<a name="7.23.5.7" href="#7.23.5.7"><b>    7.23.5.7 The strstr function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            char *strstr(const char *s1, const char *s2);
-<b>    Description</b>
-2   The strstr function locates the first occurrence in the string pointed to by s1 of the
-    sequence of characters (excluding the terminating null character) in the string pointed to
-    by s2.
-<b>    Returns</b>
-3   The strstr function returns a pointer to the located string, or a null pointer if the string
-    is not found. If s2 points to a string with zero length, the function returns s1.
-<a name="7.23.5.8" href="#7.23.5.8"><b>    7.23.5.8 The strtok function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            char *strtok(char * restrict s1,
-                 const char * restrict s2);
-<b>    Description</b>
-2   A sequence of calls to the strtok function breaks the string pointed to by s1 into a
-    sequence of tokens, each of which is delimited by a character from the string pointed to
-    by s2. The first call in the sequence has a non-null first argument; subsequent calls in the
-    sequence have a null first argument. The separator string pointed to by s2 may be
-    different from call to call.
-
-[<a name="p367" href="#p367">page 367</a>] (<a href="#Contents">Contents</a>)
-
-3   The first call in the sequence searches the string pointed to by s1 for the first character
-    that is not contained in the current separator string pointed to by s2. If no such character
-    is found, then there are no tokens in the string pointed to by s1 and the strtok function
-    returns a null pointer. If such a character is found, it is the start of the first token.
-4   The strtok function then searches from there for a character that is contained in the
-    current separator string. If no such character is found, the current token extends to the
-    end of the string pointed to by s1, and subsequent searches for a token will return a null
-    pointer. If such a character is found, it is overwritten by a null character, which
-    terminates the current token. The strtok function saves a pointer to the following
-    character, from which the next search for a token will start.
-5   Each subsequent call, with a null pointer as the value of the first argument, starts
-    searching from the saved pointer and behaves as described above.
-6   The strtok function is not required to avoid data races. The implementation shall
-    behave as if no library function calls the strtok function.
-<b>    Returns</b>
-7   The strtok function returns a pointer to the first character of a token, or a null pointer
-    if there is no token.
-8   EXAMPLE
-           #include <a href="#7.23">&lt;string.h&gt;</a>
-           static char str[] = "?a???b,,,#c";
-           char *t;
-           t   =   strtok(str, "?");      //   t   points to the token "a"
-           t   =   strtok(NULL, ",");     //   t   points to the token "??b"
-           t   =   strtok(NULL, "#,");    //   t   points to the token "c"
-           t   =   strtok(NULL, "?");     //   t   is a null pointer
-
-<a name="7.23.6" href="#7.23.6"><b>    7.23.6 Miscellaneous functions</b></a>
-<a name="7.23.6.1" href="#7.23.6.1"><b>    7.23.6.1 The memset function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.23">&lt;string.h&gt;</a>
-           void *memset(void *s, int c, size_t n);
-<b>    Description</b>
-2   The memset function copies the value of c (converted to an unsigned char) into
-    each of the first n characters of the object pointed to by s.
-<b>    Returns</b>
-3   The memset function returns the value of s.
-
-[<a name="p368" href="#p368">page 368</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.23.6.2" href="#7.23.6.2"><b>    7.23.6.2 The strerror function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            char *strerror(int errnum);
-<b>    Description</b>
-2   The strerror function maps the number in errnum to a message string. Typically,
-    the values for errnum come from errno, but strerror shall map any value of type
-    int to a message.
-3   The strerror function is not required to avoid data races. The implementation shall
-    behave as if no library function calls the strerror function.
-<b>    Returns</b>
-4   The strerror function returns a pointer to the string, the contents of which are locale-
-    specific. The array pointed to shall not be modified by the program, but may be
-    overwritten by a subsequent call to the strerror function.
-<a name="7.23.6.3" href="#7.23.6.3"><b>    7.23.6.3 The strlen function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.23">&lt;string.h&gt;</a>
-            size_t strlen(const char *s);
-<b>    Description</b>
-2   The strlen function computes the length of the string pointed to by s.
-<b>    Returns</b>
-3   The strlen function returns the number of characters that precede the terminating null
-    character.
-
-[<a name="p369" href="#p369">page 369</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.24" href="#7.24"><b>    7.24 Type-generic math &lt;tgmath.h&gt;</b></a>
-1   The header <a href="#7.24">&lt;tgmath.h&gt;</a> includes the headers <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> and
-    defines several type-generic macros.
-2   Of the <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> functions without an f (float) or l (long
-    double) suffix, several have one or more parameters whose corresponding real type is
-    double. For each such function, except modf, there is a corresponding type-generic
-    macro.<sup><a href="#note304"><b>304)</b></a></sup> The parameters whose corresponding real type is double in the function
-    synopsis are generic parameters. Use of the macro invokes a function whose
-    corresponding real type and type domain are determined by the arguments for the generic
-    parameters.<sup><a href="#note305"><b>305)</b></a></sup>
-3   Use of the macro invokes a function whose generic parameters have the corresponding
-    real type determined as follows:
-    -- First, if any argument for generic parameters has type long double, the type
-      determined is long double.
-    -- Otherwise, if any argument for generic parameters has type double or is of integer
-      type, the type determined is double.
-    -- Otherwise, the type determined is float.
-4   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> for which there is a function in
-    <a href="#7.3">&lt;complex.h&gt;</a> with the same name except for a c prefix, the corresponding type-
-    generic macro (for both functions) has the same name as the function in <a href="#7.12">&lt;math.h&gt;</a>. The
-    corresponding type-generic macro for fabs and cabs is fabs.
-
-
-
-
-    <sup><a name="note304" href="#note304"><b>304)</b></a></sup> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
-         make available the corresponding ordinary function.
-    <sup><a name="note305" href="#note305"><b>305)</b></a></sup> If the type of the argument is not compatible with the type of the parameter for the selected function,
-         the behavior is undefined.
-
-[<a name="p370" href="#p370">page 370</a>] (<a href="#Contents">Contents</a>)
-
-             <a href="#7.12">&lt;math.h&gt;</a>         <a href="#7.3">&lt;complex.h&gt;</a>              type-generic
-              function           function                 macro
-               acos              cacos                   acos
-               asin              casin                   asin
-               atan              catan                   atan
-               acosh             cacosh                  acosh
-               asinh             casinh                  asinh
-               atanh             catanh                  atanh
-               cos               ccos                    cos
-               sin               csin                    sin
-               tan               ctan                    tan
-               cosh              ccosh                   cosh
-               sinh              csinh                   sinh
-               tanh              ctanh                   tanh
-               exp               cexp                    exp
-               log               clog                    log
-               pow               cpow                    pow
-               sqrt              csqrt                   sqrt
-               fabs              cabs                    fabs
-    If at least one argument for a generic parameter is complex, then use of the macro invokes
-    a complex function; otherwise, use of the macro invokes a real function.
-5   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> without a c-prefixed counterpart in
-    <a href="#7.3">&lt;complex.h&gt;</a> (except modf), the corresponding type-generic macro has the same
-    name as the function. These type-generic macros are:
-            atan2              fma                  llround              remainder
-            cbrt               fmax                 log10                remquo
-            ceil               fmin                 log1p                rint
-            copysign           fmod                 log2                 round
-            erf                frexp                logb                 scalbn
-            erfc               hypot                lrint                scalbln
-            exp2               ilogb                lround               tgamma
-            expm1              ldexp                nearbyint            trunc
-            fdim               lgamma               nextafter
-            floor              llrint               nexttoward
-    If all arguments for generic parameters are real, then use of the macro invokes a real
-    function; otherwise, use of the macro results in undefined behavior.
-
-[<a name="p371" href="#p371">page 371</a>] (<a href="#Contents">Contents</a>)
-
-6   For each unsuffixed function in <a href="#7.3">&lt;complex.h&gt;</a> that is not a c-prefixed counterpart to a
-    function in <a href="#7.12">&lt;math.h&gt;</a>, the corresponding type-generic macro has the same name as the
-    function. These type-generic macros are:
-           carg                     conj                     creal
-           cimag                    cproj
-    Use of the macro with any real or complex argument invokes a complex function.
-7   EXAMPLE       With the declarations
-            #include <a href="#7.24">&lt;tgmath.h&gt;</a>
-            int n;
-            float f;
-            double d;
-            long double ld;
-            float complex fc;
-            double complex dc;
-            long double complex ldc;
-    functions invoked by use of type-generic macros are shown in the following table:
-                     macro use                                  invokes
-                exp(n)                              exp(n), the function
-                acosh(f)                            acoshf(f)
-                sin(d)                              sin(d), the function
-                atan(ld)                            atanl(ld)
-                log(fc)                             clogf(fc)
-                sqrt(dc)                            csqrt(dc)
-                pow(ldc, f)                         cpowl(ldc, f)
-                remainder(n, n)                     remainder(n, n), the function
-                nextafter(d, f)                     nextafter(d, f), the function
-                nexttoward(f, ld)                   nexttowardf(f, ld)
-                copysign(n, ld)                     copysignl(n, ld)
-                ceil(fc)                            undefined behavior
-                rint(dc)                            undefined behavior
-                fmax(ldc, ld)                       undefined behavior
-                carg(n)                             carg(n), the function
-                cproj(f)                            cprojf(f)
-                creal(d)                            creal(d), the function
-                cimag(ld)                           cimagl(ld)
-                fabs(fc)                            cabsf(fc)
-                carg(dc)                            carg(dc), the function
-                cproj(ldc)                          cprojl(ldc)
-
-[<a name="p372" href="#p372">page 372</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.25" href="#7.25"><b>    7.25 Threads &lt;threads.h&gt;</b></a>
-<a name="7.25.1" href="#7.25.1"><b>    7.25.1 Introduction</b></a>
-1   The header <a href="#7.25">&lt;threads.h&gt;</a> defines macros, and declares types, enumeration constants,
-    and functions that support multiple threads of execution.
-2   Implementations that define the macro __STDC_NO_THREADS__ need not provide
-    this header nor support any of its facilities.
-3   The macros are
-            ONCE_FLAG_INIT
-    which expands to a value that can be used to initialize an object of type once_flag;
-    and
-            TSS_DTOR_ITERATIONS
-    which expands to an integer constant expression representing the maximum number of
-    times that destructors will be called when a thread terminates.
-4   The types are
-            cnd_t
-    which is a complete object type that holds an identifier for a condition variable;
-            thrd_t
-    which is a complete object type that holds an identifier for a thread;
-            tss_t
-    which is a complete object type that holds an identifier for a thread-specific storage
-    pointer;
-            mtx_t
-    which is a complete object type that holds an identifier for a mutex;
-            tss_dtor_t
-    which is the function pointer type void (*)(void*), used for a destructor for a
-    thread-specific storage pointer;
-            thrd_start_t
-    which is the function pointer type int (*)(void*) that is passed to thrd_create
-    to create a new thread;
-            once_flag
-    which is a complete object type that holds a flag for use by call_once; and
-
-[<a name="p373" href="#p373">page 373</a>] (<a href="#Contents">Contents</a>)
-
-           xtime
-    which is a structure type that holds a time specified in seconds and nanoseconds. The
-    structure shall contain at least the following members, in any order.
-           time_t sec;
-           long nsec;
-5   The enumeration constants are
-           mtx_plain
-    which is passed to mtx_init to create a mutex object that supports neither timeout nor
-    test and return;
-           mtx_recursive
-    which is passed to mtx_init to create a mutex object that supports recursive locking;
-           mtx_timed
-    which is passed to mtx_init to create a mutex object that supports timeout;
-           mtx_try
-    which is passed to mtx_init to create a mutex object that supports test and return;
-           thrd_timeout
-    which is returned by a timed wait function to indicate that the time specified in the call
-    was reached without acquiring the requested resource;
-           thrd_success
-    which is returned by a function to indicate that the requested operation succeeded;
-           thrd_busy
-    which is returned by a function to indicate that the requested operation failed because a
-    resource requested by a test and return function is already in use;
-           thrd_error
-    which is returned by a function to indicate that the requested operation failed; and
-           thrd_nomem
-    which is returned by a function to indicate that the requested operation failed because it
-    was unable to allocate memory.
-
-[<a name="p374" href="#p374">page 374</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.25.2" href="#7.25.2"><b>    7.25.2 Initialization functions</b></a>
-<a name="7.25.2.1" href="#7.25.2.1"><b>    7.25.2.1 The call_once function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            void call_once(once_flag *flag, void (*func)(void));
-<b>    Description</b>
-2   The call_once function uses the once_flag pointed to by flag to ensure that
-    func is called exactly once, the first time the call_once function is called with that
-    value of flag. Completion of an effective call to the call_once function synchronizes
-    with all subsequent calls to the call_once function with the same value of flag.
-<b>    Returns</b>
-3   The call_once function returns no value.
-<a name="7.25.3" href="#7.25.3"><b>    7.25.3 Condition variable functions</b></a>
-<a name="7.25.3.1" href="#7.25.3.1"><b>    7.25.3.1 The cnd_broadcast function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int cnd_broadcast(cnd_t *cond);
-<b>    Description</b>
-2   The cnd_broadcast function unblocks all of the threads that are blocked on the
-    condition variable pointed to by cond at the time of the call. If no threads are blocked
-    on the condition variable pointed to by cond at the time of the call, the function does
-    nothing.
-<b>    Returns</b>
-3   The cnd_broadcast function returns thrd_success on success, or thrd_error
-    if the request could not be honored.
-<a name="7.25.3.2" href="#7.25.3.2"><b>    7.25.3.2 The cnd_destroy function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            void cnd_destroy(cnd_t *cond);
-<b>    Description</b>
-2   The cnd_destroy function releases all resources used by the condition variable
-    pointed to by cond. The cnd_destroy function requires that no threads be blocked
-    waiting for the condition variable pointed to by cond.
-
-[<a name="p375" href="#p375">page 375</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The cnd_destroy function returns no value.
-<a name="7.25.3.3" href="#7.25.3.3"><b>    7.25.3.3 The cnd_init function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int cnd_init(cnd_t *cond);
-<b>    Description</b>
-2   The cnd_init function creates a condition variable. If it succeeds it sets the variable
-    pointed to by cond to a value that uniquely identifies the newly created condition
-    variable. A thread that calls cnd_wait on a newly created condition variable will
-    block.
-<b>    Returns</b>
-3   The cnd_init function returns thrd_success on success, or thrd_nomem if no
-    memory could be allocated for the newly created condition, or thrd_error if the
-    request could not be honored.
-<a name="7.25.3.4" href="#7.25.3.4"><b>    7.25.3.4 The cnd_signal function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int cnd_signal(cnd_t *cond);
-<b>    Description</b>
-2   The cnd_signal function unblocks one of the threads that are blocked on the
-    condition variable pointed to by cond at the time of the call. If no threads are blocked
-    on the condition variable at the time of the call, the function does nothing and return
-    success.
-<b>    Returns</b>
-3   The cnd_signal function returns thrd_success on success or thrd_error if
-    the request could not be honored.
-<a name="7.25.3.5" href="#7.25.3.5"><b>    7.25.3.5 The cnd_timedwait function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int cnd_timedwait(cnd_t *cond, mtx_t *mtx,
-                const xtime *xt);
-
-[<a name="p376" href="#p376">page 376</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The cnd_timedwait function atomically unlocks the mutex pointed to by mtx and
-    endeavors to block until the condition variable pointed to by cond is signaled by a call to
-    cnd_signal or to cnd_broadcast, or until after the time specified by the xtime
-    object pointed to by xt. When the calling thread becomes unblocked it locks the variable
-    pointed to by mtx before it returns. The cnd_timedwait function requires that the
-    mutex pointed to by mtx be locked by the calling thread.
-<b>    Returns</b>
-3   The cnd_timedwait function returns thrd_success upon success, or
-    thrd_timeout if the time specified in the call was reached without acquiring the
-    requested resource, or thrd_error if the request could not be honored.
-<a name="7.25.3.6" href="#7.25.3.6"><b>    7.25.3.6 The cnd_wait function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int cnd_wait(cnd_t *cond, mtx_t *mtx);
-<b>    Description</b>
-2   The cnd_wait function atomically unlocks the mutex pointed to by mtx and endeavors
-    to block until the condition variable pointed to by cond is signaled by a call to
-    cnd_signal or to cnd_broadcast. When the calling thread becomes unblocked it
-    locks the mutex pointed to by mtx before it returns. If the mutex pointed to by mtx is
-    not locked by the calling thread, the cnd_wait function will act as if the abort
-    function is called.
-<b>    Returns</b>
-3   The cnd_wait function returns thrd_success on success or thrd_error if the
-    request could not be honored.
-<a name="7.25.4" href="#7.25.4"><b>    7.25.4 Mutex functions</b></a>
-<a name="7.25.4.1" href="#7.25.4.1"><b>    7.25.4.1 The mtx_destroy function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            void mtx_destroy(mtx_t *mtx);
-<b>    Description</b>
-2   The mtx_destroy function releases any resources used by the mutex pointed to by
-    mtx. No threads can be blocked waiting for the mutex pointed to by mtx.
-
-[<a name="p377" href="#p377">page 377</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The mtx_destroy function returns no value.
-<a name="7.25.4.2" href="#7.25.4.2"><b>    7.25.4.2 The mtx_init function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int mtx_init(mtx_t *mtx, int type);
-<b>    Description</b>
-2   The mtx_init function creates a mutex object with properties indicated by type,
-    which must have one of the six values:
-    mtx_plain for a simple non-recursive mutex,
-    mtx_timed for a non-recursive mutex that supports timeout,
-    mtx_try      for a non-recursive mutex that supports test and return,
-    mtx_plain | mtx_recursive for a simple recursive mutex,
-    mtx_timed | mtx_recursive for a recursive mutex that supports timeout, or
-    mtx_try | mtx_recursive for a recursive mutex that supports test and return.
-3   If the mtx_init function succeeds, it sets the mutex pointed to by mtx to a value that
-    uniquely identifies the newly created mutex.
-<b>    Returns</b>
-4   The mtx_init function returns thrd_success on success, or thrd_error if the
-    request could not be honored.
-<a name="7.25.4.3" href="#7.25.4.3"><b>    7.25.4.3 The mtx_lock function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int mtx_lock(mtx_t *mtx);
-<b>    Description</b>
-2   The mtx_lock function blocks until it locks the mutex pointed to by mtx. If the mutex
-    is non-recursive, it shall not be locked by the calling thread. Prior calls to mtx_unlock
-    on the same mutex shall synchronize with this operation.
-<b>    Returns</b>
-3   The mtx_lock function returns thrd_success on success, or thrd_busy if the
-    resource requested is already in use, or thrd_error if the request could not be
-    honored.
-
-[<a name="p378" href="#p378">page 378</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.25.4.4" href="#7.25.4.4"><b>    7.25.4.4 The mtx_timedlock function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int mtx_timedlock(mtx_t *mtx, const xtime *xt);
-<b>    Description</b>
-2   The mtx_timedlock function endeavors to block until it locks the mutex pointed to by
-    mtx or until the time specified by the xtime object xt has passed. The specified mutex
-    shall support timeout. If the operation succeeds, prior calls to mtx_unlock on the same
-    mutex shall synchronize with this operation.
-<b>    Returns</b>
-3   The mtx_timedlock function returns thrd_success on success, or thrd_busy
-    if the resource requested is already in use, or thrd_timeout if the time specified was
-    reached without acquiring the requested resource, or thrd_error if the request could
-    not be honored.
-<a name="7.25.4.5" href="#7.25.4.5"><b>    7.25.4.5 The mtx_trylock function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int mtx_trylock(mtx_t *mtx);
-<b>    Description</b>
-2   The mtx_trylock function endeavors to lock the mutex pointed to by mtx. The
-    specified mutex shall support either test and return or timeout. If the mutex is already
-    locked, the function returns without blocking. If the operation succeeds, prior calls to
-    mtx_unlock on the same mutex shall synchronize with this operation.
-<b>    Returns</b>
-3   The mtx_trylock function returns thrd_success on success, or thrd_busy if
-    the resource requested is already in use, or thrd_error if the request could not be
-    honored.
-<a name="7.25.4.6" href="#7.25.4.6"><b>    7.25.4.6 The mtx_unlock function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int mtx_unlock(mtx_t *mtx);
-<b>    Description</b>
-2   The mtx_unlock function unlocks the mutex pointed to by mtx. The mutex pointed to
-    by mtx shall be locked by the calling thread.
-
-[<a name="p379" href="#p379">page 379</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The mtx_unlock function returns thrd_success on success or thrd_error if
-    the request could not be honored.
-<a name="7.25.5" href="#7.25.5"><b>    7.25.5 Thread functions</b></a>
-<a name="7.25.5.1" href="#7.25.5.1"><b>    7.25.5.1 The thrd_create function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int thrd_create(thrd_t *thr, thrd_start_t func,
-                void *arg);
-<b>    Description</b>
-2   The thrd_create function creates a new thread executing func(arg). If the
-    thrd_create function succeeds, it sets the object pointed to by thr to the identifier of
-    the newly created thread. (A thread's identifier may be reused for a different thread once
-    the original thread has exited and either been detached or joined to another thread.) The
-    completion of the thrd_create function synchronizes with the beginning of the
-    execution of the new thread.
-<b>    Returns</b>
-3   The thrd_create function returns thrd_success on success, or thrd_nomem if
-    no memory could be allocated for the thread requested, or thrd_error if the request
-    could not be honored.
-<a name="7.25.5.2" href="#7.25.5.2"><b>    7.25.5.2 The thrd_current function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           thrd_t thrd_current(void);
-<b>    Description</b>
-2   The thrd_current function identifies the thread that called it.
-<b>    Returns</b>
-3   The thrd_current function returns the identifier of the thread that called it.
-<a name="7.25.5.3" href="#7.25.5.3"><b>    7.25.5.3 The thrd_detach function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int thrd_detach(thrd_t thr);
-
-[<a name="p380" href="#p380">page 380</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The thrd_detach function tells the operating system to dispose of any resources
-    allocated to the thread identified by thr when that thread terminates. The thread
-    identified by thr shall not have been previously detached or joined with another thread.
-<b>    Returns</b>
-3   The thrd_detach function returns thrd_success on success or thrd_error if
-    the request could not be honored.
-<a name="7.25.5.4" href="#7.25.5.4"><b>    7.25.5.4 The thrd_equal function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int thrd_equal(thrd_t thr0, thrd_t thr1);
-<b>    Description</b>
-2   The thrd_equal function will determine whether the thread identified by thr0 refers
-    to the thread identified by thr1.
-<b>    Returns</b>
-3   The thrd_equal function returns zero if the thread thr0 and the thread thr1 refer to
-    different threads. Otherwise the thrd_equal function returns a nonzero value.
-<a name="7.25.5.5" href="#7.25.5.5"><b>    7.25.5.5 The thrd_exit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            void thrd_exit(int res);
-<b>    Description</b>
-2   The thrd_exit function terminates execution of the calling thread and sets its result
-    code to res.
-<b>    Returns</b>
-3   The thrd_exit function returns no value.
-<a name="7.25.5.6" href="#7.25.5.6"><b>    7.25.5.6 The thrd_join function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int thrd_join(thrd_t thr, int *res);
-<b>    Description</b>
-2   The thrd_join function joins the thread identified by thr with the current thread by
-    blocking until the other thread has terminated. If the parameter res is not a null pointer,
-
-[<a name="p381" href="#p381">page 381</a>] (<a href="#Contents">Contents</a>)
-
-    it stores the thread's result code in the integer pointed to by res. The termination of the
-    other thread synchronizes with the completion of the thrd_join function. The thread
-    identified by thr shall not have been previously detached or joined with another thread.
-<b>    Returns</b>
-3   The thrd_join function returns thrd_success on success or thrd_error if the
-    request could not be honored.
-<a name="7.25.5.7" href="#7.25.5.7"><b>    7.25.5.7 The thrd_sleep function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           void thrd_sleep(const xtime *xt);
-<b>    Description</b>
-2   The thrd_sleep function suspends execution of the calling thread until after the time
-    specified by the xtime object pointed to by xt.
-<b>    Returns</b>
-3   The thrd_sleep function returns no value.
-<a name="7.25.5.8" href="#7.25.5.8"><b>    7.25.5.8 The thrd_yield function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           void thrd_yield(void);
-<b>    Description</b>
-2   The thrd_yield function endeavors to permit other threads to run, even if the current
-    thread would ordinarily continue to run.
-<b>    Returns</b>
-3   The thrd_yield function returns no value.
-<a name="7.25.6" href="#7.25.6"><b>    7.25.6 Thread-specific storage functions</b></a>
-<a name="7.25.6.1" href="#7.25.6.1"><b>    7.25.6.1 The tss_create function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.25">&lt;threads.h&gt;</a>
-           int tss_create(tss_t *key, tss_dtor_t dtor);
-<b>    Description</b>
-2   The tss_create function creates a thread-specific storage pointer with destructor
-    dtor, which may be null.
-
-[<a name="p382" href="#p382">page 382</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   If the tss_create function is successful, it sets the thread-specific storage pointed to
-    by key to a value that uniquely identifies the newly created pointer and returns
-    thrd_success; otherwise, thrd_error is returned and the thread-specific storage
-    pointed to by key is set to an undefined value.
-<a name="7.25.6.2" href="#7.25.6.2"><b>    7.25.6.2 The tss_delete function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            void tss_delete(tss_t key);
-<b>    Description</b>
-2   The tss_delete function releases any resources used by the thread-specific storage
-    identified by key.
-<b>    Returns</b>
-3   The tss_delete function returns no value.
-<a name="7.25.6.3" href="#7.25.6.3"><b>    7.25.6.3 The tss_get function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            void *tss_get(tss_t key);
-<b>    Description</b>
-2   The tss_get function returns the value for the current thread held in the thread-specific
-    storage identified by key.
-<b>    Returns</b>
-3   The tss_get function returns the value for the current thread if successful, or zero if
-    unsuccessful.
-<a name="7.25.6.4" href="#7.25.6.4"><b>    7.25.6.4 The tss_set function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int tss_set(tss_t key, void *val);
-<b>    Description</b>
-2   The tss_set function sets the value for the current thread held in the thread-specific
-    storage identified by key to val.
-
-[<a name="p383" href="#p383">page 383</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The tss_set function returns thrd_success on success or thrd_error if the
-    request could not be honored.
-<a name="7.25.7" href="#7.25.7"><b>    7.25.7 Time functions</b></a>
-<a name="7.25.7.1" href="#7.25.7.1"><b>    7.25.7.1 The xtime_get function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.25">&lt;threads.h&gt;</a>
-            int xtime_get(xtime *xt, int base);
-<b>    Description</b>
-2   The xtime_get function sets the xtime object pointed to by xt to hold the current
-    time based on the time base base.
-<b>    Returns</b>
-3   If the xtime_get function is successful it returns the nonzero value base, which must
-    be TIME_UTC; otherwise, it returns zero.<sup><a href="#note306"><b>306)</b></a></sup>
-
-
-
-
-    <sup><a name="note306" href="#note306"><b>306)</b></a></sup> Although an xtime object describes times with nanosecond resolution, the actual resolution in an
-         xtime object is system dependent.
-
-[<a name="p384" href="#p384">page 384</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.26" href="#7.26"><b>    7.26 Date and time &lt;time.h&gt;</b></a>
-<a name="7.26.1" href="#7.26.1"><b>    7.26.1 Components of time</b></a>
-1   The header <a href="#7.26">&lt;time.h&gt;</a> defines two macros, and declares several types and functions for
-    manipulating time. Many functions deal with a calendar time that represents the current
-    date (according to the Gregorian calendar) and time. Some functions deal with local
-    time, which is the calendar time expressed for some specific time zone, and with Daylight
-    Saving Time, which is a temporary change in the algorithm for determining local time.
-    The local time zone and Daylight Saving Time are implementation-defined.
-2   The macros defined are NULL (described in <a href="#7.19">7.19</a>); and
-            CLOCKS_PER_SEC
-    which expands to an expression with type clock_t (described below) that is the
-    number per second of the value returned by the clock function.
-3   The types declared are size_t (described in <a href="#7.19">7.19</a>);
-            clock_t
-    and
-            time_t
-    which are arithmetic types capable of representing times; and
-            struct tm
-    which holds the components of a calendar time, called the broken-down time.
-4   The range and precision of times representable in clock_t and time_t are
-    implementation-defined. The tm structure shall contain at least the following members,
-    in any order. The semantics of the members and their normal ranges are expressed in the
-    comments.<sup><a href="#note307"><b>307)</b></a></sup>
-            int    tm_sec;           //   seconds after the minute -- [0, 60]
-            int    tm_min;           //   minutes after the hour -- [0, 59]
-            int    tm_hour;          //   hours since midnight -- [0, 23]
-            int    tm_mday;          //   day of the month -- [1, 31]
-            int    tm_mon;           //   months since January -- [0, 11]
-            int    tm_year;          //   years since 1900
-            int    tm_wday;          //   days since Sunday -- [0, 6]
-            int    tm_yday;          //   days since January 1 -- [0, 365]
-            int    tm_isdst;         //   Daylight Saving Time flag
-
-
-
-    <sup><a name="note307" href="#note307"><b>307)</b></a></sup> The range [0, 60] for tm_sec allows for a positive leap second.
-
-[<a name="p385" href="#p385">page 385</a>] (<a href="#Contents">Contents</a>)
-
-    The value of tm_isdst is positive if Daylight Saving Time is in effect, zero if Daylight
-    Saving Time is not in effect, and negative if the information is not available.
-<a name="7.26.2" href="#7.26.2"><b>    7.26.2 Time manipulation functions</b></a>
-<a name="7.26.2.1" href="#7.26.2.1"><b>    7.26.2.1 The clock function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.26">&lt;time.h&gt;</a>
-            clock_t clock(void);
-<b>    Description</b>
-2   The clock function determines the processor time used.
-<b>    Returns</b>
-3   The clock function returns the implementation's best approximation to the processor
-    time used by the program since the beginning of an implementation-defined era related
-    only to the program invocation. To determine the time in seconds, the value returned by
-    the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
-    the processor time used is not available or its value cannot be represented, the function
-    returns the value (clock_t)(-1).<sup><a href="#note308"><b>308)</b></a></sup>
-<a name="7.26.2.2" href="#7.26.2.2"><b>    7.26.2.2 The difftime function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.26">&lt;time.h&gt;</a>
-            double difftime(time_t time1, time_t time0);
-<b>    Description</b>
-2   The difftime function computes the difference between two calendar times: time1 -
-    time0.
-<b>    Returns</b>
-3   The difftime function returns the difference expressed in seconds as a double.
-
-
-
-
-    <sup><a name="note308" href="#note308"><b>308)</b></a></sup> In order to measure the time spent in a program, the clock function should be called at the start of
-         the program and its return value subtracted from the value returned by subsequent calls.
-
-[<a name="p386" href="#p386">page 386</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.26.2.3" href="#7.26.2.3"><b>    7.26.2.3 The mktime function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.26">&lt;time.h&gt;</a>
-            time_t mktime(struct tm *timeptr);
-<b>    Description</b>
-2   The mktime function converts the broken-down time, expressed as local time, in the
-    structure pointed to by timeptr into a calendar time value with the same encoding as
-    that of the values returned by the time function. The original values of the tm_wday
-    and tm_yday components of the structure are ignored, and the original values of the
-    other components are not restricted to the ranges indicated above.<sup><a href="#note309"><b>309)</b></a></sup> On successful
-    completion, the values of the tm_wday and tm_yday components of the structure are
-    set appropriately, and the other components are set to represent the specified calendar
-    time, but with their values forced to the ranges indicated above; the final value of
-    tm_mday is not set until tm_mon and tm_year are determined.
-<b>    Returns</b>
-3   The mktime function returns the specified calendar time encoded as a value of type
-    time_t. If the calendar time cannot be represented, the function returns the value
-    (time_t)(-1).
-4   EXAMPLE       What day of the week is July 4, 2001?
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.26">&lt;time.h&gt;</a>
-            static const char *const wday[] = {
-                    "Sunday", "Monday", "Tuesday", "Wednesday",
-                    "Thursday", "Friday", "Saturday", "-unknown-"
-            };
-            struct tm time_str;
+                return a &gt; b ? a : b;
+          }</pre>
+ Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
+ that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
+ to the function, whereas the second form does not.
+ 
+<p><!--para 14-->
+ EXAMPLE 2           To pass one function to another, one might say
+<pre>
+                      int f(void);
+                      /* ... */
+                      g(f);</pre>
+ Then the definition of g might read
+<pre>
+          void g(int (*funcp)(void))
+          {
+                /* ... */
+                (*funcp)(); /* or funcp(); ...                    */
+          }</pre>
+ or, equivalently,
+<pre>
+          void g(int func(void))
+          {
+                /* ... */
+                func(); /* or (*func)(); ...                   */
+          }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note162">162)</a> The intent is that the type category in a function definition cannot be inherited from a typedef:
+
+<pre>
+          typedef int F(void);                          //   type F is ''function with no parameters
+                                                        //                  returning int''
+          F f, g;                                       //   f and g both have type compatible with F
+          F f { /* ... */ }                             //   WRONG: syntax/constraint error
+          F g() { /* ... */ }                           //   WRONG: declares that g returns a function
+          int f(void) { /* ... */ }                     //   RIGHT: f has type compatible with F
+          int g() { /* ... */ }                         //   RIGHT: g has type compatible with F
+          F *e(void) { /* ... */ }                      //   e returns a pointer to a function
+          F *((e))(void) { /* ... */ }                  //   same: parentheses irrelevant
+          int (*fp)(void);                              //   fp points to a function that has type F
+          F *Fp;                                        //   Fp points to a function that has type F</pre>
+
+<p><a name="note163">163)</a> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
+
+<p><a name="note164">164)</a> A parameter identifier cannot be redeclared in the function body except in an enclosed block.
+
+
+<a name="6.9.2" href="#6.9.2"><h4>6.9.2 External object definitions</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If the declaration of an identifier for an object has file scope and an initializer, the
+ declaration is an external definition for the identifier.
+<p><!--para 2-->
+ A declaration of an identifier for an object that has file scope without an initializer, and
+ without a storage-class specifier or with the storage-class specifier static, constitutes a
+ tentative definition. If a translation unit contains one or more tentative definitions for an
+ identifier, and the translation unit contains no external definition for that identifier, then
+ the behavior is exactly as if the translation unit contains a file scope declaration of that
+ identifier, with the composite type as of the end of the translation unit, with an initializer
+ equal to 0.
+<p><!--para 3-->
+ If the declaration of an identifier for an object is a tentative definition and has internal
+ linkage, the declared type shall not be an incomplete type.
+<!--page 176 indent 4-->
+<p><!--para 4-->
+ EXAMPLE 1
+<pre>
+          int i1 = 1;                    // definition, external linkage
+          static int i2 = 2;             // definition, internal linkage
+          extern int i3 = 3;             // definition, external linkage
+          int i4;                        // tentative definition, external linkage
+          static int i5;                 // tentative definition, internal linkage
+          int   i1;                      // valid tentative definition, refers to previous
+          int   i2;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+          int   i3;                      // valid tentative definition, refers to previous
+          int   i4;                      // valid tentative definition, refers to previous
+          int   i5;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+          extern    int   i1;            // refers to previous, whose linkage is external
+          extern    int   i2;            // refers to previous, whose linkage is internal
+          extern    int   i3;            // refers to previous, whose linkage is external
+          extern    int   i4;            // refers to previous, whose linkage is external
+          extern    int   i5;            // refers to previous, whose linkage is internal</pre>
+ 
+<p><!--para 5-->
+ EXAMPLE 2       If at the end of the translation unit containing
+<pre>
+          int i[];</pre>
+ the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
+ zero on program startup.
+<!--page 177 indent 4-->
+
+<a name="6.10" href="#6.10"><h3>6.10 Preprocessing directives</h3></a>
+<h6>Syntax</h6>
+<p><!--para 1-->
+<!--page 178 indent 4-->
+<pre>
+          preprocessing-file:
+                 groupopt
+          group:
+                   group-part
+                   group group-part
+          group-part:
+                 if-section
+                 control-line
+                 text-line
+                 # non-directive
+          if-section:
+                   if-group elif-groupsopt else-groupopt endif-line
+          if-group:
+                  # if     constant-expression new-line groupopt
+                  # ifdef identifier new-line groupopt
+                  # ifndef identifier new-line groupopt
+          elif-groups:
+                  elif-group
+                  elif-groups elif-group
+          elif-group:
+                  # elif       constant-expression new-line groupopt
+          else-group:
+                  # else       new-line groupopt
+          endif-line:
+                  # endif      new-line
+          control-line:
+                 # include pp-tokens new-line
+                 # define identifier replacement-list new-line
+                 # define identifier lparen identifier-listopt )
+                                                 replacement-list new-line
+                 # define identifier lparen ... ) replacement-list new-line
+                 # define identifier lparen identifier-list , ... )
+                                                 replacement-list new-line
+                 # undef   identifier new-line
+                 # line    pp-tokens new-line
+                 # error   pp-tokensopt new-line
+                 # pragma pp-tokensopt new-line
+                 #         new-line
+          text-line:
+                  pp-tokensopt new-line
+          non-directive:
+                 pp-tokens new-line
+          lparen:
+                    a ( character not immediately preceded by white-space
+          replacement-list:
+                 pp-tokensopt
+          pp-tokens:
+                 preprocessing-token
+                 pp-tokens preprocessing-token
+          new-line:
+                 the new-line character</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
+ following constraints: The first token in the sequence is a # preprocessing token that (at
+ the start of translation phase 4) is either the first character in the source file (optionally
+ after white space containing no new-line characters) or that follows white space
+ containing at least one new-line character. The last token in the sequence is the first new-
+ line character that follows the first token in the sequence.<sup><a href="#note165"><b>165)</b></a></sup> A new-line character ends
+ the preprocessing directive even if it occurs within what would otherwise be an
+ 
+<!--page 179 indent 4-->
+ invocation of a function-like macro.
+<p><!--para 3-->
+ A text line shall not begin with a # preprocessing token. A non-directive shall not begin
+ with any of the directive names appearing in the syntax.
+<p><!--para 4-->
+ When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
+ sequence of preprocessing tokens to occur between the directive name and the following
+ new-line character.
+<h6>Constraints</h6>
+<p><!--para 5-->
+ The only white-space characters that shall appear between preprocessing tokens within a
+ preprocessing directive (from just after the introducing # preprocessing token through
+ just before the terminating new-line character) are space and horizontal-tab (including
+ spaces that have replaced comments or possibly other white-space characters in
+ translation phase 3).
+<h6>Semantics</h6>
+<p><!--para 6-->
+ The implementation can process and skip sections of source files conditionally, include
+ other source files, and replace macros. These capabilities are called preprocessing,
+ because conceptually they occur before translation of the resulting translation unit.
+<p><!--para 7-->
+ The preprocessing tokens within a preprocessing directive are not subject to macro
+ expansion unless otherwise stated.
+<p><!--para 8-->
+ EXAMPLE        In:
+<pre>
+           #define EMPTY
+           EMPTY # include &lt;file.h&gt;</pre>
+ the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
+ begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
+ replaced.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note165">165)</a> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
+ significance, as all white space is equivalent except in certain situations during preprocessing (see the
+ # character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
+
+
+<a name="6.10.1" href="#6.10.1"><h4>6.10.1 Conditional inclusion</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The expression that controls conditional inclusion shall be an integer constant expression
+ except that: identifiers (including those lexically identical to keywords) are interpreted as *
+ described below;<sup><a href="#note166"><b>166)</b></a></sup> and it may contain unary operator expressions of the form
+<pre>
+      defined identifier</pre>
+ or
+<pre>
+      defined ( identifier )</pre>
+ which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
+ 
+ 
+<!--page 180 indent 4-->
+ predefined or if it has been the subject of a #define preprocessing directive without an
+ intervening #undef directive with the same subject identifier), 0 if it is not.
+<p><!--para 2-->
+ Each preprocessing token that remains (in the list of preprocessing tokens that will
+ become the controlling expression) after all macro replacements have occurred shall be in
+ the lexical form of a token (<a href="#6.4">6.4</a>).
+<h6>Semantics</h6>
+<p><!--para 3-->
+ Preprocessing directives of the forms
+<pre>
+    # if   constant-expression new-line groupopt
+    # elif constant-expression new-line groupopt</pre>
+ check whether the controlling constant expression evaluates to nonzero.
+<p><!--para 4-->
+ Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
+ the controlling constant expression are replaced (except for those macro names modified
+ by the defined unary operator), just as in normal text. If the token defined is
+ generated as a result of this replacement process or use of the defined unary operator
+ does not match one of the two specified forms prior to macro replacement, the behavior is
+ undefined. After all replacements due to macro expansion and the defined unary
+ operator have been performed, all remaining identifiers (including those lexically
+ identical to keywords) are replaced with the pp-number 0, and then each preprocessing
+ token is converted into a token. The resulting tokens compose the controlling constant
+ expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
+ token conversion and evaluation, all signed integer types and all unsigned integer types
+ act as if they have the same representation as, respectively, the types intmax_t and
+ uintmax_t defined in the header &lt;stdint.h&gt;.<sup><a href="#note167"><b>167)</b></a></sup> This includes interpreting
+ character constants, which may involve converting escape sequences into execution
+ character set members. Whether the numeric value for these character constants matches
+ the value obtained when an identical character constant occurs in an expression (other
+ than within a #if or #elif directive) is implementation-defined.<sup><a href="#note168"><b>168)</b></a></sup> Also, whether a
+ single-character character constant may have a negative value is implementation-defined.
+ 
+ 
+ 
+ 
+<!--page 181 indent 4-->
+<p><!--para 5-->
+ Preprocessing directives of the forms
+<pre>
+    # ifdef identifier new-line groupopt
+    # ifndef identifier new-line groupopt</pre>
+ check whether the identifier is or is not currently defined as a macro name. Their
+ conditions are equivalent to #if defined identifier and #if !defined identifier
+ respectively.
+<p><!--para 6-->
+ Each directive's condition is checked in order. If it evaluates to false (zero), the group
+ that it controls is skipped: directives are processed only through the name that determines
+ the directive in order to keep track of the level of nested conditionals; the rest of the
+ directives' preprocessing tokens are ignored, as are the other preprocessing tokens in the
+ group. Only the first group whose control condition evaluates to true (nonzero) is
+ processed. If none of the conditions evaluates to true, and there is a #else directive, the
+ group controlled by the #else is processed; lacking a #else directive, all the groups
+ until the #endif are skipped.<sup><a href="#note169"><b>169)</b></a></sup>
+ Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
+ integer types (<a href="#7.20.1.5">7.20.1.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note166">166)</a> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
+ either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
+
+<p><a name="note167">167)</a> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
+ 0x8000 is signed and positive within a #if expression even though it would be unsigned in
+ translation phase 7.
+
+<p><a name="note168">168)</a> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
+ evaluate to the same value in these two contexts.
+   #if 'z' - 'a' == 25
+   if ('z' - 'a' == 25)
+
+<p><a name="note169">169)</a> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
+ before the terminating new-line character. However, comments may appear anywhere in a source file,
+ including within a preprocessing directive.
+
+
+<a name="6.10.2" href="#6.10.2"><h4>6.10.2 Source file inclusion</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A #include directive shall identify a header or source file that can be processed by the
+ implementation.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ A preprocessing directive of the form
+<pre>
+    # include &lt;h-char-sequence&gt; new-line</pre>
+ searches a sequence of implementation-defined places for a header identified uniquely by
+ the specified sequence between the &lt; and &gt; delimiters, and causes the replacement of that
+ directive by the entire contents of the header. How the places are specified or the header
+ identified is implementation-defined.
+<p><!--para 3-->
+ A preprocessing directive of the form
+<pre>
+    # include "q-char-sequence" new-line</pre>
+ causes the replacement of that directive by the entire contents of the source file identified
+ by the specified sequence between the " delimiters. The named source file is searched
+ 
+ 
+<!--page 182 indent 4-->
+ for in an implementation-defined manner. If this search is not supported, or if the search
+ fails, the directive is reprocessed as if it read
+<pre>
+    # include &lt;h-char-sequence&gt; new-line</pre>
+ with the identical contained sequence (including &gt; characters, if any) from the original
+ directive.
+<p><!--para 4-->
+ A preprocessing directive of the form
+<pre>
+    # include pp-tokens new-line</pre>
+ (that does not match one of the two previous forms) is permitted. The preprocessing
+ tokens after include in the directive are processed just as in normal text. (Each
+ identifier currently defined as a macro name is replaced by its replacement list of
+ preprocessing tokens.) The directive resulting after all replacements shall match one of
+ the two previous forms.<sup><a href="#note170"><b>170)</b></a></sup> The method by which a sequence of preprocessing tokens
+ between a &lt; and a &gt; preprocessing token pair or a pair of " characters is combined into a
+ single header name preprocessing token is implementation-defined.
+<p><!--para 5-->
+ The implementation shall provide unique mappings for sequences consisting of one or
+ more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
+ first character shall not be a digit. The implementation may ignore distinctions of
+ alphabetical case and restrict the mapping to eight significant characters before the
+ period.
+<p><!--para 6-->
+ A #include preprocessing directive may appear in a source file that has been read
+ because of a #include directive in another file, up to an implementation-defined
+ nesting limit (see <a href="#5.2.4.1">5.2.4.1</a>).
+<p><!--para 7-->
+ EXAMPLE 1       The most common uses of #include preprocessing directives are as in the following:
+<pre>
+          #include &lt;stdio.h&gt;
+          #include "myprog.h"</pre>
+ 
+ 
+ 
+ 
+<!--page 183 indent 4-->
+<p><!--para 8-->
+ EXAMPLE 2      This illustrates macro-replaced #include directives:
+<pre>
+           #if VERSION == 1
+                 #define INCFILE          "vers1.h"
+           #elif VERSION == 2
+                 #define INCFILE          "vers2.h"        // and so on
+           #else
+                  #define INCFILE         "versN.h"
+           #endif
+           #include INCFILE</pre>
+ 
+ Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note170">170)</a> Note that adjacent string literals are not concatenated into a single string literal (see the translation
+ phases in <a href="#5.1.1.2">5.1.1.2</a>); thus, an expansion that results in two string literals is an invalid directive.
+
+
+<a name="6.10.3" href="#6.10.3"><h4>6.10.3 Macro replacement</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ Two replacement lists are identical if and only if the preprocessing tokens in both have
+ the same number, ordering, spelling, and white-space separation, where all white-space
+ separations are considered identical.
+<p><!--para 2-->
+ An identifier currently defined as an object-like macro shall not be redefined by another
+ #define preprocessing directive unless the second definition is an object-like macro
+ definition and the two replacement lists are identical. Likewise, an identifier currently
+ defined as a function-like macro shall not be redefined by another #define
+ preprocessing directive unless the second definition is a function-like macro definition
+ that has the same number and spelling of parameters, and the two replacement lists are
+ identical.
+<p><!--para 3-->
+ There shall be white-space between the identifier and the replacement list in the definition
+ of an object-like macro.
+<p><!--para 4-->
+ If the identifier-list in the macro definition does not end with an ellipsis, the number of
+ arguments (including those arguments consisting of no preprocessing tokens) in an
+ invocation of a function-like macro shall equal the number of parameters in the macro
+ definition. Otherwise, there shall be more arguments in the invocation than there are
+ parameters in the macro definition (excluding the ...). There shall exist a )
+ preprocessing token that terminates the invocation.
+<p><!--para 5-->
+ The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
+ macro that uses the ellipsis notation in the parameters.
+<p><!--para 6-->
+ A parameter identifier in a function-like macro shall be uniquely declared within its
+ scope.
+<h6>Semantics</h6>
+<p><!--para 7-->
+ The identifier immediately following the define is called the macro name. There is one
+ name space for macro names. Any white-space characters preceding or following the
+ replacement list of preprocessing tokens are not considered part of the replacement list
+<!--page 184 indent 5-->
+ for either form of macro.
+<p><!--para 8-->
+ If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
+ a preprocessing directive could begin, the identifier is not subject to macro replacement.
+<p><!--para 9-->
+ A preprocessing directive of the form
+<pre>
+    # define identifier replacement-list new-line</pre>
+ defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note171"><b>171)</b></a></sup>
+ to be replaced by the replacement list of preprocessing tokens that constitute the
+ remainder of the directive. The replacement list is then rescanned for more macro names
+ as specified below.
+<p><!--para 10-->
+ A preprocessing directive of the form
+<pre>
+    # define identifier lparen identifier-listopt ) replacement-list new-line
+    # define identifier lparen ... ) replacement-list new-line
+    # define identifier lparen identifier-list , ... ) replacement-list new-line</pre>
+ defines a function-like macro with parameters, whose use is similar syntactically to a
+ function call. The parameters are specified by the optional list of identifiers, whose scope
+ extends from their declaration in the identifier list until the new-line character that
+ terminates the #define preprocessing directive. Each subsequent instance of the
+ function-like macro name followed by a ( as the next preprocessing token introduces the
+ sequence of preprocessing tokens that is replaced by the replacement list in the definition
+ (an invocation of the macro). The replaced sequence of preprocessing tokens is
+ terminated by the matching ) preprocessing token, skipping intervening matched pairs of
+ left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
+ tokens making up an invocation of a function-like macro, new-line is considered a normal
+ white-space character.
+<p><!--para 11-->
+ The sequence of preprocessing tokens bounded by the outside-most matching parentheses
+ forms the list of arguments for the function-like macro. The individual arguments within
+ the list are separated by comma preprocessing tokens, but comma preprocessing tokens
+ between matching inner parentheses do not separate arguments. If there are sequences of
+ preprocessing tokens within the list of arguments that would otherwise act as
+ preprocessing directives,<sup><a href="#note172"><b>172)</b></a></sup> the behavior is undefined.
+<p><!--para 12-->
+ If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
+ including any separating comma preprocessing tokens, are merged to form a single item:
+ 
+ 
+<!--page 185 indent 4-->
+ the variable arguments. The number of arguments so combined is such that, following
+ merger, the number of arguments is one more than the number of parameters in the macro
+ definition (excluding the ...).
+
+<h6>footnotes</h6>
+<p><a name="note171">171)</a> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
+ not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
+ are never scanned for macro names or parameters.
+
+<p><a name="note172">172)</a> Despite the name, a non-directive is a preprocessing directive.
+
+
+<a name="6.10.3.1" href="#6.10.3.1"><h5>6.10.3.1 Argument substitution</h5></a>
+<p><!--para 1-->
+ After the arguments for the invocation of a function-like macro have been identified,
+ argument substitution takes place. A parameter in the replacement list, unless preceded
+ by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
+ replaced by the corresponding argument after all macros contained therein have been
+ expanded. Before being substituted, each argument's preprocessing tokens are
+ completely macro replaced as if they formed the rest of the preprocessing file; no other
+ preprocessing tokens are available.
+<p><!--para 2-->
+ An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
+ were a parameter, and the variable arguments shall form the preprocessing tokens used to
+ replace it.
+
+<a name="6.10.3.2" href="#6.10.3.2"><h5>6.10.3.2 The # operator</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ Each # preprocessing token in the replacement list for a function-like macro shall be
+ followed by a parameter as the next preprocessing token in the replacement list.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ If, in the replacement list, a parameter is immediately preceded by a # preprocessing
+ token, both are replaced by a single character string literal preprocessing token that
+ contains the spelling of the preprocessing token sequence for the corresponding
+ argument. Each occurrence of white space between the argument's preprocessing tokens
+ becomes a single space character in the character string literal. White space before the
+ first preprocessing token and after the last preprocessing token composing the argument
+ is deleted. Otherwise, the original spelling of each preprocessing token in the argument
+ is retained in the character string literal, except for special handling for producing the
+ spelling of string literals and character constants: a \ character is inserted before each "
+ and \ character of a character constant or string literal (including the delimiting "
+ characters), except that it is implementation-defined whether a \ character is inserted
+ before the \ character beginning a universal character name. If the replacement that
+ results is not a valid character string literal, the behavior is undefined. The character
+ string literal corresponding to an empty argument is "". The order of evaluation of # and
+ ## operators is unspecified.
+<!--page 186 indent 4-->
+
+<a name="6.10.3.3" href="#6.10.3.3"><h5>6.10.3.3 The ## operator</h5></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ A ## preprocessing token shall not occur at the beginning or at the end of a replacement
+ list for either form of macro definition.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ If, in the replacement list of a function-like macro, a parameter is immediately preceded
+ or followed by a ## preprocessing token, the parameter is replaced by the corresponding
+ argument's preprocessing token sequence; however, if an argument consists of no
+ preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
+ instead.<sup><a href="#note173"><b>173)</b></a></sup>
+<p><!--para 3-->
+ For both object-like and function-like macro invocations, before the replacement list is
+ reexamined for more macro names to replace, each instance of a ## preprocessing token
+ in the replacement list (not from an argument) is deleted and the preceding preprocessing
+ token is concatenated with the following preprocessing token. Placemarker
+ preprocessing tokens are handled specially: concatenation of two placemarkers results in
+ a single placemarker preprocessing token, and concatenation of a placemarker with a
+ non-placemarker preprocessing token results in the non-placemarker preprocessing token.
+ If the result is not a valid preprocessing token, the behavior is undefined. The resulting
+ token is available for further macro replacement. The order of evaluation of ## operators
+ is unspecified.
+<p><!--para 4-->
+ EXAMPLE       In the following fragment:
+<pre>
+         #define     hash_hash # ## #
+         #define     mkstr(a) # a
+         #define     in_between(a) mkstr(a)
+         #define     join(c, d) in_between(c hash_hash d)
+         char p[] = join(x, y); // equivalent to
+                                // char p[] = "x ## y";</pre>
+ The expansion produces, at various stages:
+<pre>
+         join(x, y)
+         in_between(x hash_hash y)
+         in_between(x ## y)
+         mkstr(x ## y)
+         "x ## y"</pre>
+ In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
+ this new token is not the ## operator.
+ 
+ 
+<!--page 187 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note173">173)</a> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
+ exist only within translation phase 4.
+
+
+<a name="6.10.3.4" href="#6.10.3.4"><h5>6.10.3.4 Rescanning and further replacement</h5></a>
+<p><!--para 1-->
+ After all parameters in the replacement list have been substituted and # and ##
+ processing has taken place, all placemarker preprocessing tokens are removed. The
+ resulting preprocessing token sequence is then rescanned, along with all subsequent
+ preprocessing tokens of the source file, for more macro names to replace.
+<p><!--para 2-->
+ If the name of the macro being replaced is found during this scan of the replacement list
+ (not including the rest of the source file's preprocessing tokens), it is not replaced.
+ Furthermore, if any nested replacements encounter the name of the macro being replaced,
+ it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
+ available for further replacement even if they are later (re)examined in contexts in which
+ that macro name preprocessing token would otherwise have been replaced.
+<p><!--para 3-->
+ The resulting completely macro-replaced preprocessing token sequence is not processed
+ as a preprocessing directive even if it resembles one, but all pragma unary operator
+ expressions within it are then processed as specified in <a href="#6.10.9">6.10.9</a> below.
+
+<a name="6.10.3.5" href="#6.10.3.5"><h5>6.10.3.5 Scope of macro definitions</h5></a>
+<p><!--para 1-->
+ A macro definition lasts (independent of block structure) until a corresponding #undef
+ directive is encountered or (if none is encountered) until the end of the preprocessing
+ translation unit. Macro definitions have no significance after translation phase 4.
+<p><!--para 2-->
+ A preprocessing directive of the form
+<pre>
+    # undef identifier new-line</pre>
+ causes the specified identifier no longer to be defined as a macro name. It is ignored if
+ the specified identifier is not currently defined as a macro name.
+<p><!--para 3-->
+ EXAMPLE 1      The simplest use of this facility is to define a ''manifest constant'', as in
+<pre>
+         #define TABSIZE 100
+         int table[TABSIZE];</pre>
+ 
+<p><!--para 4-->
+ EXAMPLE 2 The following defines a function-like macro whose value is the maximum of its arguments.
+ It has the advantages of working for any compatible types of the arguments and of generating in-line code
+ without the overhead of function calling. It has the disadvantages of evaluating one or the other of its
+ arguments a second time (including side effects) and generating more code than a function if invoked
+ several times. It also cannot have its address taken, as it has none.
+<pre>
+         #define max(a, b) ((a) &gt; (b) ? (a) : (b))</pre>
+ The parentheses ensure that the arguments and the resulting expression are bound properly.
+<!--page 188 indent 4-->
+<p><!--para 5-->
+ EXAMPLE 3     To illustrate the rules for redefinition and reexamination, the sequence
+<pre>
+          #define   x         3
+          #define   f(a)      f(x * (a))
+          #undef    x
+          #define   x         2
+          #define   g         f
+          #define   z         z[0]
+          #define   h         g(~
+          #define   m(a)      a(w)
+          #define   w         0,1
+          #define   t(a)      a
+          #define   p()       int
+          #define   q(x)      x
+          #define   r(x,y)    x ## y
+          #define   str(x)    # x
+          f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);
+          g(x+(3,4)-w) | h 5) &amp; m
+                (f)^m(m);
+          p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
+          char c[2][6] = { str(hello), str() };</pre>
+ results in
+<pre>
+          f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
+          f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) &amp; f(2 * (0,1))^m(0,1);
+          int i[] = { 1, 23, 4, 5, };
+          char c[2][6] = { "hello", "" };</pre>
+ 
+<p><!--para 6-->
+ EXAMPLE 4     To illustrate the rules for creating character string literals and concatenating tokens, the
+ sequence
+<pre>
+          #define str(s)      # s
+          #define xstr(s)     str(s)
+          #define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
+                                  x ## s, x ## t)
+          #define INCFILE(n) vers ## n
+          #define glue(a, b) a ## b
+          #define xglue(a, b) glue(a, b)
+          #define HIGHLOW     "hello"
+          #define LOW         LOW ", world"
+          debug(1, 2);
+          fputs(str(strncmp("abc\0d", "abc", '\4') // this goes away
+                == 0) str(: @\n), s);
+          #include xstr(INCFILE(2).h)
+          glue(HIGH, LOW);
+          xglue(HIGH, LOW)</pre>
+ results in
+<!--page 189 indent 4-->
+<pre>
+          printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
+          fputs(
+            "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0" ": @\n",
+            s);
+          #include "vers2.h"    (after macro replacement, before file access)
+          "hello";
+          "hello" ", world"</pre>
+ or, after concatenation of the character string literals,
+<pre>
+          printf("x1= %d, x2= %s", x1, x2);
+          fputs(
+            "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: @\n",
+            s);
+          #include "vers2.h"    (after macro replacement, before file access)
+          "hello";
+          "hello, world"</pre>
+ Space around the # and ## tokens in the macro definition is optional.
+ 
+<p><!--para 7-->
+ EXAMPLE 5        To illustrate the rules for placemarker preprocessing tokens, the sequence
+<pre>
+          #define t(x,y,z) x ## y ## z
+          int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
+                     t(10,,), t(,11,), t(,,12), t(,,) };</pre>
+ results in
+<pre>
+          int j[] = { 123, 45, 67, 89,
+                      10, 11, 12, };</pre>
+ 
+<p><!--para 8-->
+ EXAMPLE 6        To demonstrate the redefinition rules, the following sequence is valid.
+<pre>
+          #define      OBJ_LIKE      (1-1)
+          #define      OBJ_LIKE      /* white space */ (1-1) /* other */
+          #define      FUNC_LIKE(a)   ( a )
+          #define      FUNC_LIKE( a )( /* note the white space */ \
+                                       a /* other stuff on this line
+                                           */ )</pre>
+ But the following redefinitions are invalid:
+<pre>
+          #define      OBJ_LIKE    (0)     // different token sequence
+          #define      OBJ_LIKE    (1 - 1) // different white space
+          #define      FUNC_LIKE(b) ( a ) // different parameter usage
+          #define      FUNC_LIKE(b) ( b ) // different parameter spelling</pre>
+ 
+<p><!--para 9-->
+ EXAMPLE 7        Finally, to show the variable argument list macro facilities:
+<!--page 190 indent 4-->
+<pre>
+          #define debug(...)       fprintf(stderr, __VA_ARGS__)
+          #define showlist(...)    puts(#__VA_ARGS__)
+          #define report(test, ...) ((test)?puts(#test):\
+                      printf(__VA_ARGS__))
+          debug("Flag");
+          debug("X = %d\n", x);
+          showlist(The first, second, and third items.);
+          report(x&gt;y, "x is %d but y is %d", x, y);</pre>
+ results in
+<pre>
+          fprintf(stderr, "Flag" );
+          fprintf(stderr, "X = %d\n", x );
+          puts( "The first, second, and third items." );
+          ((x&gt;y)?puts("x&gt;y"):
+                      printf("x is %d but y is %d", x, y));</pre>
+ 
+
+<a name="6.10.4" href="#6.10.4"><h4>6.10.4 Line control</h4></a>
+<h6>Constraints</h6>
+<p><!--para 1-->
+ The string literal of a #line directive, if present, shall be a character string literal.
+<h6>Semantics</h6>
+<p><!--para 2-->
+ The line number of the current source line is one greater than the number of new-line
+ characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
+ file to the current token.
+<p><!--para 3-->
+ A preprocessing directive of the form
+<pre>
+    # line digit-sequence new-line</pre>
+ causes the implementation to behave as if the following sequence of source lines begins
+ with a source line that has a line number as specified by the digit sequence (interpreted as
+ a decimal integer). The digit sequence shall not specify zero, nor a number greater than
+ 2147483647.
+<p><!--para 4-->
+ A preprocessing directive of the form
+<pre>
+    # line digit-sequence "s-char-sequenceopt" new-line</pre>
+ sets the presumed line number similarly and changes the presumed name of the source
+ file to be the contents of the character string literal.
+<p><!--para 5-->
+ A preprocessing directive of the form
+<pre>
+    # line pp-tokens new-line</pre>
+ (that does not match one of the two previous forms) is permitted. The preprocessing
+ tokens after line on the directive are processed just as in normal text (each identifier
+ currently defined as a macro name is replaced by its replacement list of preprocessing
+ tokens). The directive resulting after all replacements shall match one of the two
+ previous forms and is then processed as appropriate.
+<!--page 191 indent 4-->
+
+<a name="6.10.5" href="#6.10.5"><h4>6.10.5 Error directive</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A preprocessing directive of the form
+<pre>
+    # error pp-tokensopt new-line</pre>
+ causes the implementation to produce a diagnostic message that includes the specified
+ sequence of preprocessing tokens.
+
+<a name="6.10.6" href="#6.10.6"><h4>6.10.6 Pragma directive</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A preprocessing directive of the form
+<pre>
+    # pragma pp-tokensopt new-line</pre>
+ where the preprocessing token STDC does not immediately follow pragma in the
+ directive (prior to any macro replacement)<sup><a href="#note174"><b>174)</b></a></sup> causes the implementation to behave in an
+ implementation-defined manner. The behavior might cause translation to fail or cause the
+ translator or the resulting program to behave in a non-conforming manner. Any such
+ pragma that is not recognized by the implementation is ignored.
+<p><!--para 2-->
+ If the preprocessing token STDC does immediately follow pragma in the directive (prior
+ to any macro replacement), then no macro replacement is performed on the directive, and
+ the directive shall have one of the following forms<sup><a href="#note175"><b>175)</b></a></sup> whose meanings are described
+ elsewhere:
+<pre>
+    #pragma STDC FP_CONTRACT on-off-switch
+    #pragma STDC FENV_ACCESS on-off-switch
+    #pragma STDC CX_LIMITED_RANGE on-off-switch
+    on-off-switch: one of
+                ON     OFF           DEFAULT</pre>
+ Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
+ (<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
+ 
+ 
+ 
+ 
+<!--page 192 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note174">174)</a> An implementation is not required to perform macro replacement in pragmas, but it is permitted
+ except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
+ replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
+ implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
+ but is not required to.
+
+<p><a name="note175">175)</a> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
+
+
+<a name="6.10.7" href="#6.10.7"><h4>6.10.7 Null directive</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A preprocessing directive of the form
+<pre>
+    # new-line</pre>
+ has no effect.
+
+<a name="6.10.8" href="#6.10.8"><h4>6.10.8 Predefined macro names</h4></a>
+<p><!--para 1-->
+ The values of the predefined macros listed in the following subclauses<sup><a href="#note176"><b>176)</b></a></sup> (except for
+ __FILE__ and __LINE__) remain constant throughout the translation unit.
+<p><!--para 2-->
+ None of these macro names, nor the identifier defined, shall be the subject of a
+ #define or a #undef preprocessing directive. Any other predefined macro names
+ shall begin with a leading underscore followed by an uppercase letter or a second
+ underscore.
+<p><!--para 3-->
+ The implementation shall not predefine the macro __cplusplus, nor shall it define it
+ in any standard header.
+ Forward references: standard headers (<a href="#7.1.2">7.1.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note176">176)</a> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
+
+
+<a name="6.10.8.1" href="#6.10.8.1"><h5>6.10.8.1 Mandatory macros</h5></a>
+<p><!--para 1-->
+ The following macro names shall be defined by the implementation:
+ __DATE__ The date of translation of the preprocessing translation unit: a character
+<pre>
+            string literal of the form "Mmm dd yyyy", where the names of the
+            months are the same as those generated by the asctime function, and the
+            first character of dd is a space character if the value is less than 10. If the
+            date of translation is not available, an implementation-defined valid date
+            shall be supplied.</pre>
+ __FILE__ The presumed name of the current source file (a character string literal).<sup><a href="#note177"><b>177)</b></a></sup>
+ __LINE__ The presumed line number (within the current source file) of the current
+<pre>
+            source line (an integer constant).177)</pre>
+ __STDC__ The integer constant 1, intended to indicate a conforming implementation.
+ __STDC_HOSTED__ The integer constant 1 if the implementation is a hosted
+<pre>
+           implementation or the integer constant 0 if it is not.</pre>
+ 
+ 
+ 
+ 
+<!--page 193 indent 4-->
+ __STDC_VERSION__ The integer constant 201ymmL.<sup><a href="#note178"><b>178)</b></a></sup>
+ __TIME__ The time of translation of the preprocessing translation unit: a character
+<pre>
+            string literal of the form "hh:mm:ss" as in the time generated by the
+            asctime function. If the time of translation is not available, an
+            implementation-defined valid time shall be supplied.</pre>
+ Forward references: the asctime function (<a href="#7.26.3.1">7.26.3.1</a>).
+
+<h6>footnotes</h6>
+<p><a name="note177">177)</a> The presumed source file name and line number can be changed by the #line directive.
+
+<p><a name="note178">178)</a> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
+ ISO/IEC 9899/AMD1:1995 and as 199901L in ISO/IEC 9899:1999. The intention is that this will
+ remain an integer constant of type long int that is increased with each revision of this International
+ Standard.
+
+
+<a name="6.10.8.2" href="#6.10.8.2"><h5>6.10.8.2 Environment macros</h5></a>
+<p><!--para 1-->
+ The following macro names are conditionally defined by the implementation:
+ __STDC_ISO_10646__ An integer constant of the form yyyymmL (for example,
+<pre>
+           199712L). If this symbol is defined, then every character in the Unicode
+           required set, when stored in an object of type wchar_t, has the same
+           value as the short identifier of that character. The Unicode required set
+           consists of all the characters that are defined by ISO/IEC 10646, along with
+           all amendments and technical corrigenda, as of the specified year and
+           month. If some other encoding is used, the macro shall not be defined and
+           the actual encoding used is implementation-defined.</pre>
+ __STDC_MB_MIGHT_NEQ_WC__ The integer constant 1, intended to indicate that, in
+<pre>
+           the encoding for wchar_t, a member of the basic character set need not
+           have a code value equal to its value when used as the lone character in an
+           integer character constant.</pre>
+ __STDC_UTF_16__ The integer constant 1, intended to indicate that values of type
+<pre>
+           char16_t are UTF-16 encoded. If some other encoding is used, the
+           macro shall not be defined and the actual encoding used is implementation-
+           defined.</pre>
+ __STDC_UTF_32__ The integer constant 1, intended to indicate that values of type
+<pre>
+           char32_t are UTF-32 encoded. If some other encoding is used, the
+           macro shall not be defined and the actual encoding used is implementation-
+           defined.</pre>
+ Forward references: common definitions (<a href="#7.19">7.19</a>), unicode utilities (<a href="#7.27">7.27</a>).
+ 
+ 
+ 
+ 
+<!--page 194 indent 4-->
+
+<a name="6.10.8.3" href="#6.10.8.3"><h5>6.10.8.3 Conditional feature macros</h5></a>
+<p><!--para 1-->
+ The following macro names are conditionally defined by the implementation:
+ __STDC_ANALYZABLE__ The integer constant 1, intended to indicate conformance to
+<pre>
+           the specifications in <a href="#L">annex L</a> (Analyzability).</pre>
+ __STDC_IEC_559__ The integer constant 1, intended to indicate conformance to the
+<pre>
+           specifications in <a href="#F">annex F</a> (IEC 60559 floating-point arithmetic).</pre>
+ __STDC_IEC_559_COMPLEX__ The integer constant 1, intended to indicate
+<pre>
+           adherence to the specifications in <a href="#G">annex G</a> (IEC 60559 compatible complex
+           arithmetic).</pre>
+ __STDC_LIB_EXT1__ The integer constant 201ymmL, intended to indicate support
+<pre>
+           for the extensions defined in <a href="#K">annex K</a> (Bounds-checking interfaces).<sup><a href="#note179"><b>179)</b></a></sup></pre>
+ __STDC_NO_COMPLEX__ The integer constant 1, intended to indicate that the
+<pre>
+           implementation does not support complex types or the &lt;complex.h&gt;
+           header.</pre>
+ __STDC_NO_THREADS__ The integer constant 1, intended to indicate that the
+<pre>
+           implementation does not support atomic types (including the _Atomic
+           type qualifier and the &lt;stdatomic.h&gt; header) or the &lt;threads.h&gt;
+           header.</pre>
+ __STDC_NO_VLA__ The integer constant 1, intended to indicate that the
+<p><!--para 2-->
+<pre>
+           implementation does not support variable length arrays or variably
+           modified types.</pre>
+ An implementation that defines __STDC_NO_COMPLEX__ shall not define
+ __STDC_IEC_559_COMPLEX__.
+
+<h6>footnotes</h6>
+<p><a name="note179">179)</a> The intention is that this will remain an integer constant of type long int that is increased with
+ each revision of this International Standard.
+
+
+<a name="6.10.9" href="#6.10.9"><h4>6.10.9 Pragma operator</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ A unary operator expression of the form:
+<pre>
+    _Pragma ( string-literal )</pre>
+ is processed as follows: The string literal is destringized by deleting the L prefix, if
+ present, deleting the leading and trailing double-quotes, replacing each escape sequence
+ \" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
+ resulting sequence of characters is processed through translation phase 3 to produce
+ preprocessing tokens that are executed as if they were the pp-tokens in a pragma
+ 
+ 
+<!--page 195 indent 4-->
+ directive. The original four preprocessing tokens in the unary operator expression are
+ removed.
+<p><!--para 2-->
+ EXAMPLE       A directive of the form:
+<pre>
+           #pragma listing on "..\listing.dir"</pre>
+ can also be expressed as:
+<pre>
+           _Pragma ( "listing on \"..\\listing.dir\"" )</pre>
+ The latter form is processed in the same way whether it appears literally as shown, or results from macro
+ replacement, as in:
+<!--page 196 indent 4-->
+<pre>
+           #define LISTING(x) PRAGMA(listing on #x)
+           #define PRAGMA(x) _Pragma(#x)
+           LISTING ( ..\listing.dir )</pre>
+
+<a name="6.11" href="#6.11"><h3>6.11 Future language directions</h3></a>
+
+<a name="6.11.1" href="#6.11.1"><h4>6.11.1 Floating types</h4></a>
+<p><!--para 1-->
+ Future standardization may include additional floating-point types, including those with
+ greater range, precision, or both than long double.
+
+<a name="6.11.2" href="#6.11.2"><h4>6.11.2 Linkages of identifiers</h4></a>
+<p><!--para 1-->
+ Declaring an identifier with internal linkage at file scope without the static storage-
+ class specifier is an obsolescent feature.
+
+<a name="6.11.3" href="#6.11.3"><h4>6.11.3 External names</h4></a>
+<p><!--para 1-->
+ Restriction of the significance of an external name to fewer than 255 characters
+ (considering each universal character name or extended source character as a single
+ character) is an obsolescent feature that is a concession to existing implementations.
+
+<a name="6.11.4" href="#6.11.4"><h4>6.11.4 Character escape sequences</h4></a>
+<p><!--para 1-->
+ Lowercase letters as escape sequences are reserved for future standardization. Other
+ characters may be used in extensions.
+
+<a name="6.11.5" href="#6.11.5"><h4>6.11.5 Storage-class specifiers</h4></a>
+<p><!--para 1-->
+ The placement of a storage-class specifier other than at the beginning of the declaration
+ specifiers in a declaration is an obsolescent feature.
+
+<a name="6.11.6" href="#6.11.6"><h4>6.11.6 Function declarators</h4></a>
+<p><!--para 1-->
+ The use of function declarators with empty parentheses (not prototype-format parameter
+ type declarators) is an obsolescent feature.
+
+<a name="6.11.7" href="#6.11.7"><h4>6.11.7 Function definitions</h4></a>
+<p><!--para 1-->
+ The use of function definitions with separate parameter identifier and declaration lists
+ (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
+
+<a name="6.11.8" href="#6.11.8"><h4>6.11.8 Pragma directives</h4></a>
+<p><!--para 1-->
+ Pragmas whose first preprocessing token is STDC are reserved for future standardization.
+
+<a name="6.11.9" href="#6.11.9"><h4>6.11.9 Predefined macro names</h4></a>
+<p><!--para 1-->
+ Macro names beginning with __STDC_ are reserved for future standardization.
+<!--page 197 indent 4-->
+
+<a name="7" href="#7"><h2>7. Library</h2></a>
+
+<a name="7.1" href="#7.1"><h3>7.1 Introduction</h3></a>
+
+<a name="7.1.1" href="#7.1.1"><h4>7.1.1 Definitions of terms</h4></a>
+<p><!--para 1-->
+ A string is a contiguous sequence of characters terminated by and including the first null
+ character. The term multibyte string is sometimes used instead to emphasize special
+ processing given to multibyte characters contained in the string or to avoid confusion
+ with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
+ character. The length of a string is the number of bytes preceding the null character and
+ the value of a string is the sequence of the values of the contained characters, in order.
+<p><!--para 2-->
+ The decimal-point character is the character used by functions that convert floating-point
+ numbers to or from character sequences to denote the beginning of the fractional part of
+ such character sequences.<sup><a href="#note180"><b>180)</b></a></sup> It is represented in the text and examples by a period, but
+ may be changed by the setlocale function.
+<p><!--para 3-->
+ A null wide character is a wide character with code value zero.
+<p><!--para 4-->
+ A wide string is a contiguous sequence of wide characters terminated by and including
+ the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
+ addressed) wide character. The length of a wide string is the number of wide characters
+ preceding the null wide character and the value of a wide string is the sequence of code
+ values of the contained wide characters, in order.
+<p><!--para 5-->
+ A shift sequence is a contiguous sequence of bytes within a multibyte string that
+ (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
+ corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
+ character.<sup><a href="#note181"><b>181)</b></a></sup>
+ Forward references: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+ 
+ 
+ 
+ 
+<!--page 198 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note180">180)</a> The functions that make use of the decimal-point character are the numeric conversion functions
+ (<a href="#7.22.1">7.22.1</a>, <a href="#7.28.4.1">7.28.4.1</a>) and the formatted input/output functions (<a href="#7.21.6">7.21.6</a>, <a href="#7.28.2">7.28.2</a>).
+
+<p><a name="note181">181)</a> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
+ enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
+ sequence of maximum length. Whether these counts provide for more than one shift sequence is the
+ implementation's choice.
+
+
+<a name="7.1.2" href="#7.1.2"><h4>7.1.2 Standard headers</h4></a>
+<p><!--para 1-->
+ Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note182"><b>182)</b></a></sup>
+ whose contents are made available by the #include preprocessing directive. The
+ header declares a set of related functions, plus any necessary types and additional macros
+ needed to facilitate their use. Declarations of types described in this clause shall not
+ include type qualifiers, unless explicitly stated otherwise.
+<p><!--para 2-->
+ The standard headers are<sup><a href="#note183"><b>183)</b></a></sup>
+<p><!--para 3-->
+<pre>
+        &lt;assert.h&gt;             &lt;iso646.h&gt;              &lt;stdarg.h&gt;              &lt;string.h&gt;
+        &lt;complex.h&gt;            &lt;limits.h&gt;              &lt;stdatomic.h&gt;           &lt;tgmath.h&gt;
+        &lt;ctype.h&gt;              &lt;locale.h&gt;              &lt;stdbool.h&gt;             &lt;threads.h&gt;
+        &lt;errno.h&gt;              &lt;math.h&gt;                &lt;stddef.h&gt;              &lt;time.h&gt;
+        &lt;fenv.h&gt;               &lt;setjmp.h&gt;              &lt;stdint.h&gt;              &lt;uchar.h&gt;
+        &lt;float.h&gt;              &lt;signal.h&gt;              &lt;stdio.h&gt;               &lt;wchar.h&gt;
+        &lt;inttypes.h&gt;           &lt;stdalign.h&gt;            &lt;stdlib.h&gt;              &lt;wctype.h&gt;</pre>
+ If a file with the same name as one of the above &lt; and &gt; delimited sequences, not
+ provided as part of the implementation, is placed in any of the standard places that are
+ searched for included source files, the behavior is undefined.
+<p><!--para 4-->
+ Standard headers may be included in any order; each may be included more than once in
+ a given scope, with no effect different from being included only once, except that the
+ effect of including &lt;assert.h&gt; depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
+ used, a header shall be included outside of any external declaration or definition, and it
+ shall first be included before the first reference to any of the functions or objects it
+ declares, or to any of the types or macros it defines. However, if an identifier is declared
+ or defined in more than one header, the second and subsequent associated headers may be
+ included after the initial reference to the identifier. The program shall not have any
+ macros with names lexically identical to keywords currently defined prior to the
+ inclusion.
+<p><!--para 5-->
+ Any definition of an object-like macro described in this clause shall expand to code that is
+ fully protected by parentheses where necessary, so that it groups in an arbitrary
+ expression as if it were a single identifier.
+<p><!--para 6-->
+ Any declaration of a library function shall have external linkage.
+ 
+ 
+ 
+ 
+<!--page 199 indent 4-->
+<p><!--para 7-->
+ A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
+ Forward references: diagnostics (<a href="#7.2">7.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note182">182)</a> A header is not necessarily a source file, nor are the &lt; and &gt; delimited sequences in header names
+ necessarily valid source file names.
+
+<p><a name="note183">183)</a> The headers &lt;complex.h&gt;, &lt;stdatomic.h&gt;, and &lt;threads.h&gt; are conditional features that
+ implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.
+
+
+<a name="7.1.3" href="#7.1.3"><h4>7.1.3 Reserved identifiers</h4></a>
+<p><!--para 1-->
+ Each header declares or defines all identifiers listed in its associated subclause, and
+ optionally declares or defines identifiers listed in its associated future library directions
+ subclause and identifiers which are always reserved either for any use or for use as file
+ scope identifiers.
+<ul>
+<li>  All identifiers that begin with an underscore and either an uppercase letter or another
+ underscore are always reserved for any use.
+<li>  All identifiers that begin with an underscore are always reserved for use as identifiers
+ with file scope in both the ordinary and tag name spaces.
+<li>  Each macro name in any of the following subclauses (including the future library
+ directions) is reserved for use as specified if any of its associated headers is included;
+ unless explicitly stated otherwise (see <a href="#7.1.4">7.1.4</a>).
+<li>  All identifiers with external linkage in any of the following subclauses (including the
+ future library directions) and errno are always reserved for use as identifiers with
+ external linkage.<sup><a href="#note184"><b>184)</b></a></sup>
+<li>  Each identifier with file scope listed in any of the following subclauses (including the
+ future library directions) is reserved for use as a macro name and as an identifier with
+ file scope in the same name space if any of its associated headers is included.
+</ul>
+<p><!--para 2-->
+ No other identifiers are reserved. If the program declares or defines an identifier in a
+ context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
+ identifier as a macro name, the behavior is undefined.
+<p><!--para 3-->
+ If the program removes (with #undef) any macro definition of an identifier in the first
+ group listed above, the behavior is undefined.
+ 
+ 
+ 
+ 
+<!--page 200 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note184">184)</a> The list of reserved identifiers with external linkage includes math_errhandling, setjmp,
+ va_copy, and va_end.
+
+
+<a name="7.1.4" href="#7.1.4"><h4>7.1.4 Use of library functions</h4></a>
+<p><!--para 1-->
+ Each of the following statements applies unless explicitly stated otherwise in the detailed
+ descriptions that follow: If an argument to a function has an invalid value (such as a value
+ outside the domain of the function, or a pointer outside the address space of the program,
+ or a null pointer, or a pointer to non-modifiable storage when the corresponding
+ parameter is not const-qualified) or a type (after promotion) not expected by a function
+ with variable number of arguments, the behavior is undefined. If a function argument is
+ described as being an array, the pointer actually passed to the function shall have a value
+ such that all address computations and accesses to objects (that would be valid if the
+ pointer did point to the first element of such an array) are in fact valid. Any function
+ declared in a header may be additionally implemented as a function-like macro defined in
+ the header, so if a library function is declared explicitly when its header is included, one
+ of the techniques shown below can be used to ensure the declaration is not affected by
+ such a macro. Any macro definition of a function can be suppressed locally by enclosing
+ the name of the function in parentheses, because the name is then not followed by the left
+ parenthesis that indicates expansion of a macro function name. For the same syntactic
+ reason, it is permitted to take the address of a library function even if it is also defined as
+ a macro.<sup><a href="#note185"><b>185)</b></a></sup> The use of #undef to remove any macro definition will also ensure that an
+ actual function is referred to. Any invocation of a library function that is implemented as
+ a macro shall expand to code that evaluates each of its arguments exactly once, fully
+ protected by parentheses where necessary, so it is generally safe to use arbitrary
+ expressions as arguments.<sup><a href="#note186"><b>186)</b></a></sup> Likewise, those function-like macros described in the
+ following subclauses may be invoked in an expression anywhere a function with a
+ compatible return type could be called.<sup><a href="#note187"><b>187)</b></a></sup> All object-like macros listed as expanding to
+ 
+ 
+<!--page 201 indent 4-->
+ integer constant expressions shall additionally be suitable for use in #if preprocessing
+ directives.
+<p><!--para 2-->
+ Provided that a library function can be declared without reference to any type defined in a
+ header, it is also permissible to declare the function and use it without including its
+ associated header.
+<p><!--para 3-->
+ There is a sequence point immediately before a library function returns.
+<p><!--para 4-->
+ The functions in the standard library are not guaranteed to be reentrant and may modify
+ objects with static or thread storage duration.<sup><a href="#note188"><b>188)</b></a></sup>
+<p><!--para 5-->
+ Unless explicitly stated otherwise in the detailed descriptions that follow, library
+ functions shall prevent data races as follows: A library function shall not directly or
+ indirectly access objects accessible by threads other than the current thread unless the
+ objects are accessed directly or indirectly via the function's arguments. A library
+ function shall not directly or indirectly modify objects accessible by threads other than
+ the current thread unless the objects are accessed directly or indirectly via the function's
+ non-const arguments.<sup><a href="#note189"><b>189)</b></a></sup> Implementations may share their own internal objects between
+ threads if the objects are not visible to users and are protected against data races.
+<p><!--para 6-->
+ Unless otherwise specified, library functions shall perform all operations solely within the
+ current thread if those operations have effects that are visible to users.<sup><a href="#note190"><b>190)</b></a></sup>
+<p><!--para 7-->
+ EXAMPLE        The function atoi may be used in any of several ways:
+<ul>
+<li>  by use of its associated header (possibly generating a macro expansion)
+<pre>
+            #include &lt;stdlib.h&gt;
+            const char *str;
             /* ... */
-
-
-
-
-    <sup><a name="note309" href="#note309"><b>309)</b></a></sup> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
-         Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
-         causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
-
-[<a name="p387" href="#p387">page 387</a>] (<a href="#Contents">Contents</a>)
-
-           time_str.tm_year   = 2001 - 1900;
-           time_str.tm_mon    = 7 - 1;
-           time_str.tm_mday   = 4;
-           time_str.tm_hour   = 0;
-           time_str.tm_min    = 0;
-           time_str.tm_sec    = 1;
-           time_str.tm_isdst = -1;
-           if (mktime(&amp;time_str) == (time_t)(-1))
-                 time_str.tm_wday = 7;
-           printf("%s\n", wday[time_str.tm_wday]);
-
-<a name="7.26.2.4" href="#7.26.2.4"><b>    7.26.2.4 The time function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.26">&lt;time.h&gt;</a>
-           time_t time(time_t *timer);
-<b>    Description</b>
-2   The time function determines the current calendar time. The encoding of the value is
-    unspecified.
-<b>    Returns</b>
-3   The time function returns the implementation's best approximation to the current
-    calendar time. The value (time_t)(-1) is returned if the calendar time is not
-    available. If timer is not a null pointer, the return value is also assigned to the object it
-    points to.
-<a name="7.26.3" href="#7.26.3"><b>    7.26.3 Time conversion functions</b></a>
-1   Except for the strftime function, these functions each return a pointer to one of two
-    types of static objects: a broken-down time structure or an array of char. Execution of
-    any of the functions that return a pointer to one of these object types may overwrite the
-    information in any object of the same type pointed to by the value returned from any
-    previous call to any of them and the functions are not required to avoid data races. The
-    implementation shall behave as if no other library functions call these functions.
-<a name="7.26.3.1" href="#7.26.3.1"><b>    7.26.3.1 The asctime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.26">&lt;time.h&gt;</a>
-           char *asctime(const struct tm *timeptr);
-<b>    Description</b>
-2   The asctime function converts the broken-down time in the structure pointed to by
-    timeptr into a string in the form
-           Sun Sep 16 01:03:52 1973\n\0
-
-[<a name="p388" href="#p388">page 388</a>] (<a href="#Contents">Contents</a>)
-
-    using the equivalent of the following algorithm.
-    char *asctime(const struct tm *timeptr)
-    {
-         static const char wday_name[7][3] = {
-              "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-         };
-         static const char mon_name[12][3] = {
-              "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-         };
-         static char result[26];
-            sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
-                 wday_name[timeptr-&gt;tm_wday],
-                 mon_name[timeptr-&gt;tm_mon],
-                 timeptr-&gt;tm_mday, timeptr-&gt;tm_hour,
-                 timeptr-&gt;tm_min, timeptr-&gt;tm_sec,
-                 1900 + timeptr-&gt;tm_year);
-            return result;
-    }
-3   If any of the fields of the broken-down time contain values that are outside their normal
-    ranges,<sup><a href="#note310"><b>310)</b></a></sup> the behavior of the asctime function is undefined. Likewise, if the
-    calculated year exceeds four digits or is less than the year 1000, the behavior is
-    undefined.
-<b>    Returns</b>
-4   The asctime function returns a pointer to the string.
-<a name="7.26.3.2" href="#7.26.3.2"><b>    7.26.3.2 The ctime function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.26">&lt;time.h&gt;</a>
-            char *ctime(const time_t *timer);
-<b>    Description</b>
-2   The ctime function converts the calendar time pointed to by timer to local time in the
-    form of a string. It is equivalent to
-            asctime(localtime(timer))
-
-
-
-    <sup><a name="note310" href="#note310"><b>310)</b></a></sup> See <a href="#7.26.1">7.26.1</a>.
-
-[<a name="p389" href="#p389">page 389</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The ctime function returns the pointer returned by the asctime function with that
-    broken-down time as argument.
-    Forward references: the localtime function (<a href="#7.26.3.4">7.26.3.4</a>).
-<a name="7.26.3.3" href="#7.26.3.3"><b>    7.26.3.3 The gmtime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.26">&lt;time.h&gt;</a>
-           struct tm *gmtime(const time_t *timer);
-<b>    Description</b>
-2   The gmtime function converts the calendar time pointed to by timer into a broken-
-    down time, expressed as UTC.
-<b>    Returns</b>
-3   The gmtime function returns a pointer to the broken-down time, or a null pointer if the
-    specified time cannot be converted to UTC.
-<a name="7.26.3.4" href="#7.26.3.4"><b>    7.26.3.4 The localtime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.26">&lt;time.h&gt;</a>
-           struct tm *localtime(const time_t *timer);
-<b>    Description</b>
-2   The localtime function converts the calendar time pointed to by timer into a
-    broken-down time, expressed as local time.
-<b>    Returns</b>
-3   The localtime function returns a pointer to the broken-down time, or a null pointer if
-    the specified time cannot be converted to local time.
-<a name="7.26.3.5" href="#7.26.3.5"><b>    7.26.3.5 The strftime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.26">&lt;time.h&gt;</a>
-           size_t strftime(char * restrict s,
-                size_t maxsize,
-                const char * restrict format,
-                const struct tm * restrict timeptr);
-
-[<a name="p390" href="#p390">page 390</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The strftime function places characters into the array pointed to by s as controlled by
-    the string pointed to by format. The format shall be a multibyte character sequence,
-    beginning and ending in its initial shift state. The format string consists of zero or
-    more conversion specifiers and ordinary multibyte characters. A conversion specifier
-    consists of a % character, possibly followed by an E or O modifier character (described
-    below), followed by a character that determines the behavior of the conversion specifier.
-    All ordinary multibyte characters (including the terminating null character) are copied
-    unchanged into the array. If copying takes place between objects that overlap, the
-    behavior is undefined. No more than maxsize characters are placed into the array.
-3   Each conversion specifier is replaced by appropriate characters as described in the
-    following list. The appropriate characters are determined using the LC_TIME category
-    of the current locale and by the values of zero or more members of the broken-down time
-    structure pointed to by timeptr, as specified in brackets in the description. If any of
-    the specified values is outside the normal range, the characters stored are unspecified.
-    %a   is replaced by the locale's abbreviated weekday name. [tm_wday]
-    %A   is replaced by the locale's full weekday name. [tm_wday]
-    %b   is replaced by the locale's abbreviated month name. [tm_mon]
-    %B   is replaced by the locale's full month name. [tm_mon]
-    %c   is replaced by the locale's appropriate date and time representation. [all specified
-         in <a href="#7.26.1">7.26.1</a>]
-    %C   is replaced by the year divided by 100 and truncated to an integer, as a decimal
-         number (00-99). [tm_year]
-    %d   is replaced by the day of the month as a decimal number (01-31). [tm_mday]
-    %D   is equivalent to ''%m/%d/%y''. [tm_mon, tm_mday, tm_year]
-    %e   is replaced by the day of the month as a decimal number (1-31); a single digit is
-         preceded by a space. [tm_mday]
-    %F   is equivalent to ''%Y-%m-%d'' (the ISO 8601 date format). [tm_year, tm_mon,
-         tm_mday]
-    %g   is replaced by the last 2 digits of the week-based year (see below) as a decimal
-         number (00-99). [tm_year, tm_wday, tm_yday]
-    %G   is replaced by the week-based year (see below) as a decimal number (e.g., 1997).
-         [tm_year, tm_wday, tm_yday]
-    %h   is equivalent to ''%b''. [tm_mon]
-    %H   is replaced by the hour (24-hour clock) as a decimal number (00-23). [tm_hour]
-    %I   is replaced by the hour (12-hour clock) as a decimal number (01-12). [tm_hour]
-    %j   is replaced by the day of the year as a decimal number (001-366). [tm_yday]
-    %m   is replaced by the month as a decimal number (01-12). [tm_mon]
-    %M   is replaced by the minute as a decimal number (00-59). [tm_min]
-    %n   is replaced by a new-line character.
-
-[<a name="p391" href="#p391">page 391</a>] (<a href="#Contents">Contents</a>)
-
-    %p    is replaced by the locale's equivalent of the AM/PM designations associated with a
-          12-hour clock. [tm_hour]
-    %r    is replaced by the locale's 12-hour clock time. [tm_hour, tm_min, tm_sec]
-    %R    is equivalent to ''%H:%M''. [tm_hour, tm_min]
-    %S    is replaced by the second as a decimal number (00-60). [tm_sec]
-    %t    is replaced by a horizontal-tab character.
-    %T    is equivalent to ''%H:%M:%S'' (the ISO 8601 time format). [tm_hour, tm_min,
-          tm_sec]
-    %u    is replaced by the ISO 8601 weekday as a decimal number (1-7), where Monday
-          is 1. [tm_wday]
-    %U    is replaced by the week number of the year (the first Sunday as the first day of week
-          <sup><a name="note1" href="#note1"><b>1)</b></a></sup> as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
-    %V    is replaced by the ISO 8601 week number (see below) as a decimal number
-          (01-53). [tm_year, tm_wday, tm_yday]
-    %w    is replaced by the weekday as a decimal number (0-6), where Sunday is 0.
-          [tm_wday]
-    %W    is replaced by the week number of the year (the first Monday as the first day of
-          week 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
-    %x    is replaced by the locale's appropriate date representation. [all specified in <a href="#7.26.1">7.26.1</a>]
-    %X    is replaced by the locale's appropriate time representation. [all specified in <a href="#7.26.1">7.26.1</a>]
-    %y    is replaced by the last 2 digits of the year as a decimal number (00-99).
-          [tm_year]
-    %Y    is replaced by the year as a decimal number (e.g., 1997). [tm_year]
-    %z    is replaced by the offset from UTC in the ISO 8601 format ''-0430'' (meaning 4
-          hours 30 minutes behind UTC, west of Greenwich), or by no characters if no time
-          zone is determinable. [tm_isdst]
-    %Z    is replaced by the locale's time zone name or abbreviation, or by no characters if no
-          time zone is determinable. [tm_isdst]
-    %%    is replaced by %.
-4   Some conversion specifiers can be modified by the inclusion of an E or O modifier
-    character to indicate an alternative format or specification. If the alternative format or
-    specification does not exist for the current locale, the modifier is ignored.
-    %Ec is replaced by the locale's alternative date and time representation.
-    %EC is replaced by the name of the base year (period) in the locale's alternative
-        representation.
-    %Ex is replaced by the locale's alternative date representation.
-    %EX is replaced by the locale's alternative time representation.
-    %Ey is replaced by the offset from %EC (year only) in the locale's alternative
-        representation.
-    %EY is replaced by the locale's full alternative year representation.
-
-[<a name="p392" href="#p392">page 392</a>] (<a href="#Contents">Contents</a>)
-
-    %Od is replaced by the day of the month, using the locale's alternative numeric symbols
-        (filled as needed with leading zeros, or with leading spaces if there is no alternative
-        symbol for zero).
-    %Oe is replaced by the day of the month, using the locale's alternative numeric symbols
-        (filled as needed with leading spaces).
-    %OH is replaced by the hour (24-hour clock), using the locale's alternative numeric
-        symbols.
-    %OI is replaced by the hour (12-hour clock), using the locale's alternative numeric
-        symbols.
-    %Om is replaced by the month, using the locale's alternative numeric symbols.
-    %OM is replaced by the minutes, using the locale's alternative numeric symbols.
-    %OS is replaced by the seconds, using the locale's alternative numeric symbols.
-    %Ou is replaced by the ISO 8601 weekday as a number in the locale's alternative
-        representation, where Monday is 1.
-    %OU is replaced by the week number, using the locale's alternative numeric symbols.
-    %OV is replaced by the ISO 8601 week number, using the locale's alternative numeric
-        symbols.
-    %Ow is replaced by the weekday as a number, using the locale's alternative numeric
-        symbols.
-    %OW is replaced by the week number of the year, using the locale's alternative numeric
-        symbols.
-    %Oy is replaced by the last 2 digits of the year, using the locale's alternative numeric
-        symbols.
-5   %g, %G, and %V give values according to the ISO 8601 week-based year. In this system,
-    weeks begin on a Monday and week 1 of the year is the week that includes January 4th,
-    which is also the week that includes the first Thursday of the year, and is also the first
-    week that contains at least four days in the year. If the first Monday of January is the
-    2nd, 3rd, or 4th, the preceding days are part of the last week of the preceding year; thus,
-    for Saturday 2nd January 1999, %G is replaced by 1998 and %V is replaced by 53. If
-    December 29th, 30th, or 31st is a Monday, it and any following days are part of week 1 of
-    the following year. Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and
-    %V is replaced by 01.
-6   If a conversion specifier is not one of the above, the behavior is undefined.
-7   In the "C" locale, the E and O modifiers are ignored and the replacement strings for the
-    following specifiers are:
-    %a the first three characters of %A.
-    %A one of ''Sunday'', ''Monday'', ... , ''Saturday''.
-    %b the first three characters of %B.
-    %B one of ''January'', ''February'', ... , ''December''.
-    %c equivalent to ''%a %b %e %T %Y''.
-
-[<a name="p393" href="#p393">page 393</a>] (<a href="#Contents">Contents</a>)
-
-    %p    one of ''AM'' or ''PM''.
-    %r    equivalent to ''%I:%M:%S %p''.
-    %x    equivalent to ''%m/%d/%y''.
-    %X    equivalent to %T.
-    %Z    implementation-defined.
-<b>    Returns</b>
-8   If the total number of resulting characters including the terminating null character is not
-    more than maxsize, the strftime function returns the number of characters placed
-    into the array pointed to by s not including the terminating null character. Otherwise,
-    zero is returned and the contents of the array are indeterminate.
-
-[<a name="p394" href="#p394">page 394</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.27" href="#7.27"><b>    7.27 Unicode utilities &lt;uchar.h&gt;</b></a>
-1   The header <a href="#7.27">&lt;uchar.h&gt;</a> declares types and functions for manipulating Unicode
-    characters.
-2   The types declared are mbstate_t (described in <a href="#7.29.1">7.29.1</a>) and size_t (described in
-<a name="7.19);" href="#7.19);"><b>    7.19);</b></a>
-            char16_t
-    which is an unsigned integer type used for 16-bit characters and is the same type as
-    uint_least16_t (described in <a href="#7.20.1.2">7.20.1.2</a>); and
-            char32_t
-    which is an unsigned integer type used for 32-bit characters and is the same type as
-    uint_least32_t (also described in <a href="#7.20.1.2">7.20.1.2</a>).
-<a name="7.27.1" href="#7.27.1"><b>    7.27.1 Restartable multibyte/wide character conversion functions</b></a>
-1   These functions have a parameter, ps, of type pointer to mbstate_t that points to an
-    object that can completely describe the current conversion state of the associated
-    multibyte character sequence, which the functions alter as necessary. If ps is a null
-    pointer, each function uses its own internal mbstate_t object instead, which is
-    initialized at program startup to the initial conversion state; the functions are not required
-    to avoid data races in this case. The implementation behaves as if no library function
-    calls these functions with a null pointer for ps.
-<a name="7.27.1.1" href="#7.27.1.1"><b>    7.27.1.1 The mbrtoc16 function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
-            size_t mbrtoc16(char16_t * restrict pc16,
-                 const char * restrict s, size_t n,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the mbrtoc16 function is equivalent to the call:
-                   mbrtoc16(NULL, "", 1, ps)
-    In this case, the values of the parameters pc16 and n are ignored.
-3   If s is not a null pointer, the mbrtoc16 function inspects at most n bytes beginning with
-    the byte pointed to by s to determine the number of bytes needed to complete the next
-    multibyte character (including any shift sequences). If the function determines that the
-    next multibyte character is complete and valid, it determines the values of the
-    corresponding wide characters and then, if pc16 is not a null pointer, stores the value of
-    the first (or only) such character in the object pointed to by pc16. Subsequent calls will
-
-[<a name="p395" href="#p395">page 395</a>] (<a href="#Contents">Contents</a>)
-
-    store successive wide characters without consuming any additional input until all the
-    characters have been stored. If the corresponding wide character is the null wide
-    character, the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The mbrtoc16 function returns the first of the following that applies (given the current
-    conversion state):
-    0                     if the next n or fewer bytes complete the multibyte character that
-                          corresponds to the null wide character (which is the value stored).
-    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
-                       character (which is the value stored); the value returned is the number
-                       of bytes that complete the multibyte character.
-    (size_t)(-3) if the next character resulting from a previous call has been stored (no
-                 bytes from the input have been consumed by this call).
-    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
-                 multibyte character, and all n bytes have been processed (no value is
-                 stored).<sup><a href="#note311"><b>311)</b></a></sup>
-    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
-                 do not contribute to a complete and valid multibyte character (no
-                 value is stored); the value of the macro EILSEQ is stored in errno,
-                 and the conversion state is unspecified.
-<a name="7.27.1.2" href="#7.27.1.2"><b>    7.27.1.2 The c16rtomb function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
-            size_t c16rtomb(char * restrict s, char16_t c16,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the c16rtomb function is equivalent to the call
-                    c16rtomb(buf, L'\0', ps)
-    where buf is an internal buffer.
-3   If s is not a null pointer, the c16rtomb function determines the number of bytes needed
-    to represent the multibyte character that corresponds to the wide character given by c16
-    (including any shift sequences), and stores the multibyte character representation in the
-
-
-    <sup><a name="note311" href="#note311"><b>311)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
-         sequence of redundant shift sequences (for implementations with state-dependent encodings).
-
-[<a name="p396" href="#p396">page 396</a>] (<a href="#Contents">Contents</a>)
-
-    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
-    c16 is a null wide character, a null byte is stored, preceded by any shift sequence needed
-    to restore the initial shift state; the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The c16rtomb function returns the number of bytes stored in the array object (including
-    any shift sequences). When c16 is not a valid wide character, an encoding error occurs:
-    the function stores the value of the macro EILSEQ in errno and returns
-    (size_t)(-1); the conversion state is unspecified.
-<a name="7.27.1.3" href="#7.27.1.3"><b>    7.27.1.3 The mbrtoc32 function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
-            size_t mbrtoc32(char32_t * restrict pc32,
-                 const char * restrict s, size_t n,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the mbrtoc32 function is equivalent to the call:
-                    mbrtoc32(NULL, "", 1, ps)
-    In this case, the values of the parameters pc32 and n are ignored.
-3   If s is not a null pointer, the mbrtoc32 function inspects at most n bytes beginning with
-    the byte pointed to by s to determine the number of bytes needed to complete the next
-    multibyte character (including any shift sequences). If the function determines that the
-    next multibyte character is complete and valid, it determines the values of the
-    corresponding wide characters and then, if pc32 is not a null pointer, stores the value of
-    the first (or only) such character in the object pointed to by pc32. Subsequent calls will
-    store successive wide characters without consuming any additional input until all the
-    characters have been stored. If the corresponding wide character is the null wide
-    character, the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The mbrtoc32 function returns the first of the following that applies (given the current
-    conversion state):
-    0                    if the next n or fewer bytes complete the multibyte character that
-                         corresponds to the null wide character (which is the value stored).
-    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
-                       character (which is the value stored); the value returned is the number
-                       of bytes that complete the multibyte character.
-
-[<a name="p397" href="#p397">page 397</a>] (<a href="#Contents">Contents</a>)
-
-    (size_t)(-3) if the next character resulting from a previous call has been stored (no
-                 bytes from the input have been consumed by this call).
-    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
-                 multibyte character, and all n bytes have been processed (no value is
-                 stored).<sup><a href="#note312"><b>312)</b></a></sup>
-    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
-                 do not contribute to a complete and valid multibyte character (no
-                 value is stored); the value of the macro EILSEQ is stored in errno,
-                 and the conversion state is unspecified.
-<a name="7.27.1.4" href="#7.27.1.4"><b>    7.27.1.4 The c32rtomb function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
-            size_t c32rtomb(char * restrict s, char32_t c32,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the c32rtomb function is equivalent to the call
-                    c32rtomb(buf, L'\0', ps)
-    where buf is an internal buffer.
-3   If s is not a null pointer, the c32rtomb function determines the number of bytes needed
-    to represent the multibyte character that corresponds to the wide character given by c32
-    (including any shift sequences), and stores the multibyte character representation in the
-    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
-    c32 is a null wide character, a null byte is stored, preceded by any shift sequence needed
-    to restore the initial shift state; the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The c32rtomb function returns the number of bytes stored in the array object (including
-    any shift sequences). When c32 is not a valid wide character, an encoding error occurs:
-    the function stores the value of the macro EILSEQ in errno and returns
-    (size_t)(-1); the conversion state is unspecified.
-
-
-
-
-    <sup><a name="note312" href="#note312"><b>312)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
-         sequence of redundant shift sequences (for implementations with state-dependent encodings).
-
-[<a name="p398" href="#p398">page 398</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28" href="#7.28"><b>    7.28 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
-<a name="7.28.1" href="#7.28.1"><b>    7.28.1 Introduction</b></a>
-1   The header <a href="#7.28">&lt;wchar.h&gt;</a> defines four macros, and declares four data types, one tag, and
-    many functions.<sup><a href="#note313"><b>313)</b></a></sup>
-2   The types declared are wchar_t and size_t (both described in <a href="#7.19">7.19</a>);
-              mbstate_t
-    which is a complete object type other than an array type that can hold the conversion state
-    information necessary to convert between sequences of multibyte characters and wide
-    characters;
-             wint_t
-    which is an integer type unchanged by default argument promotions that can hold any
-    value corresponding to members of the extended character set, as well as at least one
-    value that does not correspond to any member of the extended character set (see WEOF
-    below);<sup><a href="#note314"><b>314)</b></a></sup> and
-             struct tm
-    which is declared as an incomplete structure type (the contents are described in <a href="#7.26.1">7.26.1</a>).
-3   The macros defined are NULL (described in <a href="#7.19">7.19</a>); WCHAR_MIN and WCHAR_MAX
-    (described in <a href="#7.20.3">7.20.3</a>); and
-             WEOF
-    which expands to a constant expression of type wint_t whose value does not
-    correspond to any member of the extended character set.<sup><a href="#note315"><b>315)</b></a></sup> It is accepted (and returned)
-    by several functions in this subclause to indicate end-of-file, that is, no more input from a
-    stream. It is also used as a wide character value that does not correspond to any member
-    of the extended character set.
-4   The functions declared are grouped as follows:
-    -- Functions that perform input and output of wide characters, or multibyte characters,
-      or both;
-    -- Functions that provide wide string numeric conversion;
-    -- Functions that perform general wide string manipulation;
-
-
-    <sup><a name="note313" href="#note313"><b>313)</b></a></sup> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
-    <sup><a name="note314" href="#note314"><b>314)</b></a></sup> wchar_t and wint_t can be the same integer type.
-    <sup><a name="note315" href="#note315"><b>315)</b></a></sup> The value of the macro WEOF may differ from that of EOF and need not be negative.
-
-[<a name="p399" href="#p399">page 399</a>] (<a href="#Contents">Contents</a>)
-
-    -- Functions for wide string date and time conversion; and
-    -- Functions that provide extended capabilities for conversion between multibyte and
-      wide character sequences.
-5   Unless explicitly stated otherwise, if the execution of a function described in this
-    subclause causes copying to take place between objects that overlap, the behavior is
-    undefined.
-<a name="7.28.2" href="#7.28.2"><b>    7.28.2 Formatted wide character input/output functions</b></a>
-1   The formatted wide character input/output functions shall behave as if there is a sequence
-    point after the actions associated with each specifier.<sup><a href="#note316"><b>316)</b></a></sup>
-<a name="7.28.2.1" href="#7.28.2.1"><b>    7.28.2.1 The fwprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int fwprintf(FILE * restrict stream,
-                 const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The fwprintf function writes output to the stream pointed to by stream, under
-    control of the wide string pointed to by format that specifies how subsequent arguments
-    are converted for output. If there are insufficient arguments for the format, the behavior
-    is undefined. If the format is exhausted while arguments remain, the excess arguments
-    are evaluated (as always) but are otherwise ignored. The fwprintf function returns
-    when the end of the format string is encountered.
-3   The format is composed of zero or more directives: ordinary wide characters (not %),
-    which are copied unchanged to the output stream; and conversion specifications, each of
-    which results in fetching zero or more subsequent arguments, converting them, if
-    applicable, according to the corresponding conversion specifier, and then writing the
-    result to the output stream.
-4   Each conversion specification is introduced by the wide character %. After the %, the
-    following appear in sequence:
-    -- Zero or more flags (in any order) that modify the meaning of the conversion
-      specification.
-    -- An optional minimum field width. If the converted value has fewer wide characters
-      than the field width, it is padded with spaces (by default) on the left (or right, if the
-
-
-    <sup><a name="note316" href="#note316"><b>316)</b></a></sup> The fwprintf functions perform writes to memory for the %n specifier.
-
-[<a name="p400" href="#p400">page 400</a>] (<a href="#Contents">Contents</a>)
-
-        left adjustment flag, described later, has been given) to the field width. The field
-        width takes the form of an asterisk * (described later) or a nonnegative decimal
-        integer.<sup><a href="#note317"><b>317)</b></a></sup>
-    -- An optional precision that gives the minimum number of digits to appear for the d, i,
-      o, u, x, and X conversions, the number of digits to appear after the decimal-point
-      wide character for a, A, e, E, f, and F conversions, the maximum number of
-      significant digits for the g and G conversions, or the maximum number of wide
-      characters to be written for s conversions. The precision takes the form of a period
-      (.) followed either by an asterisk * (described later) or by an optional decimal
-      integer; if only the period is specified, the precision is taken as zero. If a precision
-      appears with any other conversion specifier, the behavior is undefined.
-    -- An optional length modifier that specifies the size of the argument.
-    -- A conversion specifier wide character that specifies the type of conversion to be
-      applied.
-5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
-    this case, an int argument supplies the field width or precision. The arguments
-    specifying field width, or precision, or both, shall appear (in that order) before the
-    argument (if any) to be converted. A negative field width argument is taken as a - flag
-    followed by a positive field width. A negative precision argument is taken as if the
-    precision were omitted.
-6   The flag wide characters and their meanings are:
-    -        The result of the conversion is left-justified within the field. (It is right-justified if
-             this flag is not specified.)
-    +        The result of a signed conversion always begins with a plus or minus sign. (It
-             begins with a sign only when a negative value is converted if this flag is not
-             specified.)<sup><a href="#note318"><b>318)</b></a></sup>
-    space If the first wide character of a signed conversion is not a sign, or if a signed
-          conversion results in no wide characters, a space is prefixed to the result. If the
-          space and + flags both appear, the space flag is ignored.
-    #        The result is converted to an ''alternative form''. For o conversion, it increases
-             the precision, if and only if necessary, to force the first digit of the result to be a
-             zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
-             conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
-
-
-    <sup><a name="note317" href="#note317"><b>317)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
-    <sup><a name="note318" href="#note318"><b>318)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
-         include a minus sign.
-
-[<a name="p401" href="#p401">page 401</a>] (<a href="#Contents">Contents</a>)
-
-              and G conversions, the result of converting a floating-point number always
-              contains a decimal-point wide character, even if no digits follow it. (Normally, a
-              decimal-point wide character appears in the result of these conversions only if a
-              digit follows it.) For g and G conversions, trailing zeros are not removed from the
-              result. For other conversions, the behavior is undefined.
-    0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
-              (following any indication of sign or base) are used to pad to the field width rather
-              than performing space padding, except when converting an infinity or NaN. If the
-              0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
-              conversions, if a precision is specified, the 0 flag is ignored. For other
-              conversions, the behavior is undefined.
-7   The length modifiers and their meanings are:
-    hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   signed char or unsigned char argument (the argument will have
-                   been promoted according to the integer promotions, but its value shall be
-                   converted to signed char or unsigned char before printing); or that
-                   a following n conversion specifier applies to a pointer to a signed char
-                   argument.
-    h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   short int or unsigned short int argument (the argument will
-                   have been promoted according to the integer promotions, but its value shall
-                   be converted to short int or unsigned short int before printing);
-                   or that a following n conversion specifier applies to a pointer to a short
-                   int argument.
-    l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                   long int or unsigned long int argument; that a following n
-                   conversion specifier applies to a pointer to a long int argument; that a
-                   following c conversion specifier applies to a wint_t argument; that a
-                   following s conversion specifier applies to a pointer to a wchar_t
-                   argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
-                   specifier.
-    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 long long int or unsigned long long int argument; or that a
-                 following n conversion specifier applies to a pointer to a long long int
-                 argument.
-    j              Specifies that a following d, i, o, u, x, or X conversion specifier applies to
-                   an intmax_t or uintmax_t argument; or that a following n conversion
-                   specifier applies to a pointer to an intmax_t argument.
-
-[<a name="p402" href="#p402">page 402</a>] (<a href="#Contents">Contents</a>)
-
-    z            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 size_t or the corresponding signed integer type argument; or that a
-                 following n conversion specifier applies to a pointer to a signed integer type
-                 corresponding to size_t argument.
-    t            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
-                 ptrdiff_t or the corresponding unsigned integer type argument; or that a
-                 following n conversion specifier applies to a pointer to a ptrdiff_t
-                 argument.
-    L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                 applies to a long double argument.
-    If a length modifier appears with any conversion specifier other than as specified above,
-    the behavior is undefined.
-8   The conversion specifiers and their meanings are:
-    d,i         The int argument is converted to signed decimal in the style [-]dddd. The
-                precision specifies the minimum number of digits to appear; if the value
-                being converted can be represented in fewer digits, it is expanded with
-                leading zeros. The default precision is 1. The result of converting a zero
-                value with a precision of zero is no wide characters.
-    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
-            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
-            letters abcdef are used for x conversion and the letters ABCDEF for X
-            conversion. The precision specifies the minimum number of digits to appear;
-            if the value being converted can be represented in fewer digits, it is expanded
-            with leading zeros. The default precision is 1. The result of converting a
-            zero value with a precision of zero is no wide characters.
-    f,F         A double argument representing a floating-point number is converted to
-                decimal notation in the style [-]ddd.ddd, where the number of digits after
-                the decimal-point wide character is equal to the precision specification. If the
-                precision is missing, it is taken as 6; if the precision is zero and the # flag is
-                not specified, no decimal-point wide character appears. If a decimal-point
-                wide character appears, at least one digit appears before it. The value is
-                rounded to the appropriate number of digits.
-                A double argument representing an infinity is converted in one of the styles
-                [-]inf or [-]infinity -- which style is implementation-defined. A
-                double argument representing a NaN is converted in one of the styles
-                [-]nan or [-]nan(n-wchar-sequence) -- which style, and the meaning of
-                any n-wchar-sequence, is implementation-defined. The F conversion
-                specifier produces INF, INFINITY, or NAN instead of inf, infinity, or
-
-[<a name="p403" href="#p403">page 403</a>] (<a href="#Contents">Contents</a>)
-
-             nan, respectively.<sup><a href="#note319"><b>319)</b></a></sup>
-e,E          A double argument representing a floating-point number is converted in the
-             style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
-             argument is nonzero) before the decimal-point wide character and the number
-             of digits after it is equal to the precision; if the precision is missing, it is taken
-             as 6; if the precision is zero and the # flag is not specified, no decimal-point
-             wide character appears. The value is rounded to the appropriate number of
-             digits. The E conversion specifier produces a number with E instead of e
-             introducing the exponent. The exponent always contains at least two digits,
-             and only as many more digits as necessary to represent the exponent. If the
-             value is zero, the exponent is zero.
-             A double argument representing an infinity or NaN is converted in the style
-             of an f or F conversion specifier.
-g,G          A double argument representing a floating-point number is converted in
-             style f or e (or in style F or E in the case of a G conversion specifier),
-             depending on the value converted and the precision. Let P equal the
-             precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
-             Then, if a conversion with style E would have an exponent of X:
-             -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
-               P - (X + 1).
-             -- otherwise, the conversion is with style e (or E) and precision P - 1.
-             Finally, unless the # flag is used, any trailing zeros are removed from the
-             fractional portion of the result and the decimal-point wide character is
-             removed if there is no fractional portion remaining.
-             A double argument representing an infinity or NaN is converted in the style
-             of an f or F conversion specifier.
-a,A          A double argument representing a floating-point number is converted in the
-             style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
-             nonzero if the argument is a normalized floating-point number and is
-             otherwise unspecified) before the decimal-point wide character<sup><a href="#note320"><b>320)</b></a></sup> and the
-             number of hexadecimal digits after it is equal to the precision; if the precision
-             is missing and FLT_RADIX is a power of 2, then the precision is sufficient
-
-
-<sup><a name="note319" href="#note319"><b>319)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
-     meaning; the # and 0 flag wide characters have no effect.
-<sup><a name="note320" href="#note320"><b>320)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
-     character so that subsequent digits align to nibble (4-bit) boundaries.
-
-[<a name="p404" href="#p404">page 404</a>] (<a href="#Contents">Contents</a>)
-
-             for an exact representation of the value; if the precision is missing and
-             FLT_RADIX is not a power of 2, then the precision is sufficient to
-             distinguish<sup><a href="#note321"><b>321)</b></a></sup> values of type double, except that trailing zeros may be
-             omitted; if the precision is zero and the # flag is not specified, no decimal-
-             point wide character appears. The letters abcdef are used for a conversion
-             and the letters ABCDEF for A conversion. The A conversion specifier
-             produces a number with X and P instead of x and p. The exponent always
-             contains at least one digit, and only as many more digits as necessary to
-             represent the decimal exponent of 2. If the value is zero, the exponent is
-             zero.
-             A double argument representing an infinity or NaN is converted in the style
-             of an f or F conversion specifier.
-c            If no l length modifier is present, the int argument is converted to a wide
-             character as if by calling btowc and the resulting wide character is written.
-             If an l length modifier is present, the wint_t argument is converted to
-             wchar_t and written.
-s            If no l length modifier is present, the argument shall be a pointer to the initial
-             element of a character array containing a multibyte character sequence
-             beginning in the initial shift state. Characters from the array are converted as
-             if by repeated calls to the mbrtowc function, with the conversion state
-             described by an mbstate_t object initialized to zero before the first
-             multibyte character is converted, and written up to (but not including) the
-             terminating null wide character. If the precision is specified, no more than
-             that many wide characters are written. If the precision is not specified or is
-             greater than the size of the converted array, the converted array shall contain a
-             null wide character.
-             If an l length modifier is present, the argument shall be a pointer to the initial
-             element of an array of wchar_t type. Wide characters from the array are
-             written up to (but not including) a terminating null wide character. If the
-             precision is specified, no more than that many wide characters are written. If
-             the precision is not specified or is greater than the size of the array, the array
-             shall contain a null wide character.
-p            The argument shall be a pointer to void. The value of the pointer is
-             converted to a sequence of printing wide characters, in an implementation-
-
-<sup><a name="note321" href="#note321"><b>321)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
-     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
-     might suffice depending on the implementation's scheme for determining the digit to the left of the
-     decimal-point wide character.
-
-[<a name="p405" href="#p405">page 405</a>] (<a href="#Contents">Contents</a>)
-
-                    defined manner.
-     n              The argument shall be a pointer to signed integer into which is written the
-                    number of wide characters written to the output stream so far by this call to
-                    fwprintf. No argument is converted, but one is consumed. If the
-                    conversion specification includes any flags, a field width, or a precision, the
-                    behavior is undefined.
-     %              A % wide character is written. No argument is converted. The complete
-                    conversion specification shall be %%.
-9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note322"><b>322)</b></a></sup> If any argument is
-     not the correct type for the corresponding conversion specification, the behavior is
-     undefined.
-10   In no case does a nonexistent or small field width cause truncation of a field; if the result
-     of a conversion is wider than the field width, the field is expanded to contain the
-     conversion result.
-11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
-     to a hexadecimal floating number with the given precision.
-     Recommended practice
-12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
-     representable in the given precision, the result should be one of the two adjacent numbers
-     in hexadecimal floating style with the given precision, with the extra stipulation that the
-     error should have a correct sign for the current rounding direction.
-13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
-     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note323"><b>323)</b></a></sup> If the number of
-     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
-     representable with DECIMAL_DIG digits, then the result should be an exact
-     representation with trailing zeros. Otherwise, the source value is bounded by two
-     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
-     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
-     the error should have a correct sign for the current rounding direction.
-<b>     Returns</b>
-14   The fwprintf function returns the number of wide characters transmitted, or a negative
-     value if an output or encoding error occurred.
-
-     <sup><a name="note322" href="#note322"><b>322)</b></a></sup> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
-     <sup><a name="note323" href="#note323"><b>323)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
-          given format specifier. The number of significant digits is determined by the format specifier, and in
-          the case of fixed-point conversion by the source value as well.
-
-[<a name="p406" href="#p406">page 406</a>] (<a href="#Contents">Contents</a>)
-
-     Environmental limits
-15   The number of wide characters that can be produced by any single conversion shall be at
-     least 4095.
-16   EXAMPLE       To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
-     places:
-             #include <a href="#7.12">&lt;math.h&gt;</a>
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             /* ... */
-             wchar_t *weekday, *month; // pointers to wide strings
-             int day, hour, min;
-             fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
-                     weekday, month, day, hour, min);
-             fwprintf(stdout, L"pi = %.5f\n", 4 * atan(1.0));
-
-     Forward references:          the btowc function (<a href="#7.28.6.1.1">7.28.6.1.1</a>), the mbrtowc function
-     (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
-<a name="7.28.2.2" href="#7.28.2.2"><b>     7.28.2.2 The fwscanf function</b></a>
-<b>     Synopsis</b>
-1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             int fwscanf(FILE * restrict stream,
-                  const wchar_t * restrict format, ...);
-<b>     Description</b>
-2    The fwscanf function reads input from the stream pointed to by stream, under
-     control of the wide string pointed to by format that specifies the admissible input
-     sequences and how they are to be converted for assignment, using subsequent arguments
-     as pointers to the objects to receive the converted input. If there are insufficient
-     arguments for the format, the behavior is undefined. If the format is exhausted while
-     arguments remain, the excess arguments are evaluated (as always) but are otherwise
-     ignored.
-3    The format is composed of zero or more directives: one or more white-space wide
-     characters, an ordinary wide character (neither % nor a white-space wide character), or a
-     conversion specification. Each conversion specification is introduced by the wide
-     character %. After the %, the following appear in sequence:
-     -- An optional assignment-suppressing wide character *.
-     -- An optional decimal integer greater than zero that specifies the maximum field width
-       (in wide characters).
-
-[<a name="p407" href="#p407">page 407</a>] (<a href="#Contents">Contents</a>)
-
-     -- An optional length modifier that specifies the size of the receiving object.
-     -- A conversion specifier wide character that specifies the type of conversion to be
-       applied.
-4    The fwscanf function executes each directive of the format in turn. When all directives
-     have been executed, or if a directive fails (as detailed below), the function returns.
-     Failures are described as input failures (due to the occurrence of an encoding error or the
-     unavailability of input characters), or matching failures (due to inappropriate input).
-5    A directive composed of white-space wide character(s) is executed by reading input up to
-     the first non-white-space wide character (which remains unread), or until no more wide
-     characters can be read.
-6    A directive that is an ordinary wide character is executed by reading the next wide
-     character of the stream. If that wide character differs from the directive, the directive
-     fails and the differing and subsequent wide characters remain unread. Similarly, if end-
-     of-file, an encoding error, or a read error prevents a wide character from being read, the
-     directive fails.
-7    A directive that is a conversion specification defines a set of matching input sequences, as
-     described below for each specifier. A conversion specification is executed in the
-     following steps:
-8    Input white-space wide characters (as specified by the iswspace function) are skipped,
-     unless the specification includes a [, c, or n specifier.<sup><a href="#note324"><b>324)</b></a></sup>
-9    An input item is read from the stream, unless the specification includes an n specifier. An
-     input item is defined as the longest sequence of input wide characters which does not
-     exceed any specified field width and which is, or is a prefix of, a matching input
-     sequence.<sup><a href="#note325"><b>325)</b></a></sup> The first wide character, if any, after the input item remains unread. If the
-     length of the input item is zero, the execution of the directive fails; this condition is a
-     matching failure unless end-of-file, an encoding error, or a read error prevented input
-     from the stream, in which case it is an input failure.
-10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
-     count of input wide characters) is converted to a type appropriate to the conversion
-     specifier. If the input item is not a matching sequence, the execution of the directive fails:
-     this condition is a matching failure. Unless assignment suppression was indicated by a *,
-     the result of the conversion is placed in the object pointed to by the first argument
-     following the format argument that has not already received a conversion result. If this
-
-
-     <sup><a name="note324" href="#note324"><b>324)</b></a></sup> These white-space wide characters are not counted against a specified field width.
-     <sup><a name="note325" href="#note325"><b>325)</b></a></sup> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
-          sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
-
-[<a name="p408" href="#p408">page 408</a>] (<a href="#Contents">Contents</a>)
-
-     object does not have an appropriate type, or if the result of the conversion cannot be
-     represented in the object, the behavior is undefined.
-11   The length modifiers and their meanings are:
-     hh           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to signed char or unsigned char.
-     h            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to short int or unsigned short
-                  int.
-     l (ell)      Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to long int or unsigned long
-                  int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
-                  an argument with type pointer to double; or that a following c, s, or [
-                  conversion specifier applies to an argument with type pointer to wchar_t.
-     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to long long int or unsigned
-                  long long int.
-     j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to intmax_t or uintmax_t.
-     z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to size_t or the corresponding signed
-                  integer type.
-     t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
-                  to an argument with type pointer to ptrdiff_t or the corresponding
-                  unsigned integer type.
-     L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
-                  applies to an argument with type pointer to long double.
-     If a length modifier appears with any conversion specifier other than as specified above,
-     the behavior is undefined.
-12   The conversion specifiers and their meanings are:
-     d           Matches an optionally signed decimal integer, whose format is the same as
-                 expected for the subject sequence of the wcstol function with the value 10
-                 for the base argument. The corresponding argument shall be a pointer to
-                 signed integer.
-     i           Matches an optionally signed integer, whose format is the same as expected
-                 for the subject sequence of the wcstol function with the value 0 for the
-                 base argument. The corresponding argument shall be a pointer to signed
-
-[<a name="p409" href="#p409">page 409</a>] (<a href="#Contents">Contents</a>)
-
-          integer.
-o         Matches an optionally signed octal integer, whose format is the same as
-          expected for the subject sequence of the wcstoul function with the value 8
-          for the base argument. The corresponding argument shall be a pointer to
-          unsigned integer.
-u         Matches an optionally signed decimal integer, whose format is the same as
-          expected for the subject sequence of the wcstoul function with the value 10
-          for the base argument. The corresponding argument shall be a pointer to
-          unsigned integer.
-x         Matches an optionally signed hexadecimal integer, whose format is the same
-          as expected for the subject sequence of the wcstoul function with the value
-          16 for the base argument. The corresponding argument shall be a pointer to
-          unsigned integer.
-a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
-        format is the same as expected for the subject sequence of the wcstod
-        function. The corresponding argument shall be a pointer to floating.
-c         Matches a sequence of wide characters of exactly the number specified by the
-          field width (1 if no field width is present in the directive).
-          If no l length modifier is present, characters from the input field are
-          converted as if by repeated calls to the wcrtomb function, with the
-          conversion state described by an mbstate_t object initialized to zero
-          before the first wide character is converted. The corresponding argument
-          shall be a pointer to the initial element of a character array large enough to
-          accept the sequence. No null character is added.
-          If an l length modifier is present, the corresponding argument shall be a
-          pointer to the initial element of an array of wchar_t large enough to accept
-          the sequence. No null wide character is added.
-s         Matches a sequence of non-white-space wide characters.
-          If no l length modifier is present, characters from the input field are
-          converted as if by repeated calls to the wcrtomb function, with the
-          conversion state described by an mbstate_t object initialized to zero
-          before the first wide character is converted. The corresponding argument
-          shall be a pointer to the initial element of a character array large enough to
-          accept the sequence and a terminating null character, which will be added
-          automatically.
-          If an l length modifier is present, the corresponding argument shall be a
-          pointer to the initial element of an array of wchar_t large enough to accept
-
-[<a name="p410" href="#p410">page 410</a>] (<a href="#Contents">Contents</a>)
-
-            the sequence and the terminating null wide character, which will be added
-            automatically.
-[           Matches a nonempty sequence of wide characters from a set of expected
-            characters (the scanset).
-            If no l length modifier is present, characters from the input field are
-            converted as if by repeated calls to the wcrtomb function, with the
-            conversion state described by an mbstate_t object initialized to zero
-            before the first wide character is converted. The corresponding argument
-            shall be a pointer to the initial element of a character array large enough to
-            accept the sequence and a terminating null character, which will be added
-            automatically.
-            If an l length modifier is present, the corresponding argument shall be a
-            pointer to the initial element of an array of wchar_t large enough to accept
-            the sequence and the terminating null wide character, which will be added
-            automatically.
-            The conversion specifier includes all subsequent wide characters in the
-            format string, up to and including the matching right bracket (]). The wide
-            characters between the brackets (the scanlist) compose the scanset, unless the
-            wide character after the left bracket is a circumflex (^), in which case the
-            scanset contains all wide characters that do not appear in the scanlist between
-            the circumflex and the right bracket. If the conversion specifier begins with
-            [] or [^], the right bracket wide character is in the scanlist and the next
-            following right bracket wide character is the matching right bracket that ends
-            the specification; otherwise the first following right bracket wide character is
-            the one that ends the specification. If a - wide character is in the scanlist and
-            is not the first, nor the second where the first wide character is a ^, nor the
-            last character, the behavior is implementation-defined.
-p           Matches an implementation-defined set of sequences, which should be the
-            same as the set of sequences that may be produced by the %p conversion of
-            the fwprintf function. The corresponding argument shall be a pointer to a
-            pointer to void. The input item is converted to a pointer value in an
-            implementation-defined manner. If the input item is a value converted earlier
-            during the same program execution, the pointer that results shall compare
-            equal to that value; otherwise the behavior of the %p conversion is undefined.
-n           No input is consumed. The corresponding argument shall be a pointer to
-            signed integer into which is to be written the number of wide characters read
-            from the input stream so far by this call to the fwscanf function. Execution
-            of a %n directive does not increment the assignment count returned at the
-            completion of execution of the fwscanf function. No argument is
-
-[<a name="p411" href="#p411">page 411</a>] (<a href="#Contents">Contents</a>)
-
-                    converted, but one is consumed. If the conversion specification includes an
-                    assignment-suppressing wide character or a field width, the behavior is
-                    undefined.
-     %              Matches a single % wide character; no conversion or assignment occurs. The
-                    complete conversion specification shall be %%.
-13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note326"><b>326)</b></a></sup>
-14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
-     respectively, a, e, f, g, and x.
-15   Trailing white space (including new-line wide characters) is left unread unless matched
-     by a directive. The success of literal matches and suppressed assignments is not directly
-     determinable other than via the %n directive.
-<b>     Returns</b>
-16   The fwscanf function returns the value of the macro EOF if an input failure occurs
-     before the first conversion (if any) has completed. Otherwise, the function returns the
-     number of input items assigned, which can be fewer than provided for, or even zero, in
-     the event of an early matching failure.
-17   EXAMPLE 1        The call:
-              #include <a href="#7.21">&lt;stdio.h&gt;</a>
-              #include <a href="#7.28">&lt;wchar.h&gt;</a>
-              /* ... */
-              int n, i; float x; wchar_t name[50];
-              n = fwscanf(stdin, L"%d%f%ls", &amp;i, &amp;x, name);
-     with the input line:
-              25 54.32E-1 thompson
-     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
-     thompson\0.
-
-18   EXAMPLE 2        The call:
-              #include <a href="#7.21">&lt;stdio.h&gt;</a>
-              #include <a href="#7.28">&lt;wchar.h&gt;</a>
-              /* ... */
-              int i; float x; double y;
-              fwscanf(stdin, L"%2d%f%*d %lf", &amp;i, &amp;x, &amp;y);
-     with input:
-              56789 0123 56a72
-     will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
-     56.0. The next wide character read from the input stream will be a.
-
-
-     <sup><a name="note326" href="#note326"><b>326)</b></a></sup> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
-
-[<a name="p412" href="#p412">page 412</a>] (<a href="#Contents">Contents</a>)
-
-    Forward references: the wcstod, wcstof, and wcstold functions (<a href="#7.28.4.1.1">7.28.4.1.1</a>), the
-    wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.28.4.1.2">7.28.4.1.2</a>), the wcrtomb
-    function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
-<a name="7.28.2.3" href="#7.28.2.3"><b>    7.28.2.3 The swprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int swprintf(wchar_t * restrict s,
-                 size_t n,
-                 const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The swprintf function is equivalent to fwprintf, except that the argument s
-    specifies an array of wide characters into which the generated output is to be written,
-    rather than written to a stream. No more than n wide characters are written, including a
-    terminating null wide character, which is always added (unless n is zero).
-<b>    Returns</b>
-3   The swprintf function returns the number of wide characters written in the array, not
-    counting the terminating null wide character, or a negative value if an encoding error
-    occurred or if n or more wide characters were requested to be written.
-<a name="7.28.2.4" href="#7.28.2.4"><b>    7.28.2.4 The swscanf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int swscanf(const wchar_t * restrict s,
-                 const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The swscanf function is equivalent to fwscanf, except that the argument s specifies a
-    wide string from which the input is to be obtained, rather than from a stream. Reaching
-    the end of the wide string is equivalent to encountering end-of-file for the fwscanf
-    function.
-<b>    Returns</b>
-3   The swscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the swscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-
-[<a name="p413" href="#p413">page 413</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.2.5" href="#7.28.2.5"><b>    7.28.2.5 The vfwprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           int vfwprintf(FILE * restrict stream,
-                const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vfwprintf function is equivalent to fwprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfwprintf function does not invoke the
-    va_end macro.<sup><a href="#note327"><b>327)</b></a></sup>
-<b>    Returns</b>
-3   The vfwprintf function returns the number of wide characters transmitted, or a
-    negative value if an output or encoding error occurred.
-4   EXAMPLE       The following shows the use of the vfwprintf function in a general error-reporting
-    routine.
-           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           void error(char *function_name, wchar_t *format, ...)
-           {
-                 va_list args;
-                    va_start(args, format);
-                    // print out name of function causing error
-                    fwprintf(stderr, L"ERROR in %s: ", function_name);
-                    // print out remainder of message
-                    vfwprintf(stderr, format, args);
-                    va_end(args);
-           }
-
-
-
-
-    <sup><a name="note327" href="#note327"><b>327)</b></a></sup> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
-         invoke the va_arg macro, the value of arg after the return is indeterminate.
-
-[<a name="p414" href="#p414">page 414</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.2.6" href="#7.28.2.6"><b>    7.28.2.6 The vfwscanf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vfwscanf(FILE * restrict stream,
-                 const wchar_t * restrict format,
-                 va_list arg);
-<b>    Description</b>
-2   The vfwscanf function is equivalent to fwscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfwscanf function does not invoke the
-    va_end macro.327)
-<b>    Returns</b>
-3   The vfwscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the vfwscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.28.2.7" href="#7.28.2.7"><b>    7.28.2.7 The vswprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vswprintf(wchar_t * restrict s,
-                 size_t n,
-                 const wchar_t * restrict format,
-                 va_list arg);
-<b>    Description</b>
-2   The vswprintf function is equivalent to swprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vswprintf function does not invoke the
-    va_end macro.327)
-<b>    Returns</b>
-3   The vswprintf function returns the number of wide characters written in the array, not
-    counting the terminating null wide character, or a negative value if an encoding error
-    occurred or if n or more wide characters were requested to be generated.
-
-[<a name="p415" href="#p415">page 415</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.2.8" href="#7.28.2.8"><b>    7.28.2.8 The vswscanf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           int vswscanf(const wchar_t * restrict s,
-                const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vswscanf function is equivalent to swscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vswscanf function does not invoke the
-    va_end macro.327)
-<b>    Returns</b>
-3   The vswscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the vswscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.28.2.9" href="#7.28.2.9"><b>    7.28.2.9 The vwprintf function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           int vwprintf(const wchar_t * restrict format,
-                va_list arg);
-<b>    Description</b>
-2   The vwprintf function is equivalent to wprintf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vwprintf function does not invoke the
-    va_end macro.327)
-<b>    Returns</b>
-3   The vwprintf function returns the number of wide characters transmitted, or a negative
-    value if an output or encoding error occurred.
-
-[<a name="p416" href="#p416">page 416</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.2.10" href="#7.28.2.10"><b>    7.28.2.10 The vwscanf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vwscanf(const wchar_t * restrict format,
-                 va_list arg);
-<b>    Description</b>
-2   The vwscanf function is equivalent to wscanf, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vwscanf function does not invoke the
-    va_end macro.327)
-<b>    Returns</b>
-3   The vwscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the vwscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.28.2.11" href="#7.28.2.11"><b>    7.28.2.11 The wprintf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int wprintf(const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The wprintf function is equivalent to fwprintf with the argument stdout
-    interposed before the arguments to wprintf.
-<b>    Returns</b>
-3   The wprintf function returns the number of wide characters transmitted, or a negative
-    value if an output or encoding error occurred.
-<a name="7.28.2.12" href="#7.28.2.12"><b>    7.28.2.12 The wscanf function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int wscanf(const wchar_t * restrict format, ...);
-<b>    Description</b>
-2   The wscanf function is equivalent to fwscanf with the argument stdin interposed
-    before the arguments to wscanf.
-
-[<a name="p417" href="#p417">page 417</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The wscanf function returns the value of the macro EOF if an input failure occurs
-    before the first conversion (if any) has completed. Otherwise, the wscanf function
-    returns the number of input items assigned, which can be fewer than provided for, or even
-    zero, in the event of an early matching failure.
-<a name="7.28.3" href="#7.28.3"><b>    7.28.3 Wide character input/output functions</b></a>
-<a name="7.28.3.1" href="#7.28.3.1"><b>    7.28.3.1 The fgetwc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wint_t fgetwc(FILE *stream);
-<b>    Description</b>
-2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
-    next wide character is present, the fgetwc function obtains that wide character as a
-    wchar_t converted to a wint_t and advances the associated file position indicator for
-    the stream (if defined).
-<b>    Returns</b>
-3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
-    of-file indicator for the stream is set and the fgetwc function returns WEOF. Otherwise,
-    the fgetwc function returns the next wide character from the input stream pointed to by
-    stream. If a read error occurs, the error indicator for the stream is set and the fgetwc
-    function returns WEOF. If an encoding error occurs (including too few bytes), the value of
-    the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note328"><b>328)</b></a></sup>
-<a name="7.28.3.2" href="#7.28.3.2"><b>    7.28.3.2 The fgetws function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *fgetws(wchar_t * restrict s,
-                 int n, FILE * restrict stream);
-<b>    Description</b>
-2   The fgetws function reads at most one less than the number of wide characters
-    specified by n from the stream pointed to by stream into the array pointed to by s. No
-
-
-    <sup><a name="note328" href="#note328"><b>328)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
-         Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
-
-[<a name="p418" href="#p418">page 418</a>] (<a href="#Contents">Contents</a>)
-
-    additional wide characters are read after a new-line wide character (which is retained) or
-    after end-of-file. A null wide character is written immediately after the last wide
-    character read into the array.
-<b>    Returns</b>
-3   The fgetws function returns s if successful. If end-of-file is encountered and no
-    characters have been read into the array, the contents of the array remain unchanged and a
-    null pointer is returned. If a read or encoding error occurs during the operation, the array
-    contents are indeterminate and a null pointer is returned.
-<a name="7.28.3.3" href="#7.28.3.3"><b>    7.28.3.3 The fputwc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wint_t fputwc(wchar_t c, FILE *stream);
-<b>    Description</b>
-2   The fputwc function writes the wide character specified by c to the output stream
-    pointed to by stream, at the position indicated by the associated file position indicator
-    for the stream (if defined), and advances the indicator appropriately. If the file cannot
-    support positioning requests, or if the stream was opened with append mode, the
-    character is appended to the output stream.
-<b>    Returns</b>
-3   The fputwc function returns the wide character written. If a write error occurs, the
-    error indicator for the stream is set and fputwc returns WEOF. If an encoding error
-    occurs, the value of the macro EILSEQ is stored in errno and fputwc returns WEOF.
-<a name="7.28.3.4" href="#7.28.3.4"><b>    7.28.3.4 The fputws function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int fputws(const wchar_t * restrict s,
-                 FILE * restrict stream);
-<b>    Description</b>
-2   The fputws function writes the wide string pointed to by s to the stream pointed to by
-    stream. The terminating null wide character is not written.
-<b>    Returns</b>
-3   The fputws function returns EOF if a write or encoding error occurs; otherwise, it
-    returns a nonnegative value.
-
-[<a name="p419" href="#p419">page 419</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.3.5" href="#7.28.3.5"><b>    7.28.3.5 The fwide function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int fwide(FILE *stream, int mode);
-<b>    Description</b>
-2   The fwide function determines the orientation of the stream pointed to by stream. If
-    mode is greater than zero, the function first attempts to make the stream wide oriented. If
-    mode is less than zero, the function first attempts to make the stream byte oriented.<sup><a href="#note329"><b>329)</b></a></sup>
-    Otherwise, mode is zero and the function does not alter the orientation of the stream.
-<b>    Returns</b>
-3   The fwide function returns a value greater than zero if, after the call, the stream has
-    wide orientation, a value less than zero if the stream has byte orientation, or zero if the
-    stream has no orientation.
-<a name="7.28.3.6" href="#7.28.3.6"><b>    7.28.3.6 The getwc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wint_t getwc(FILE *stream);
-<b>    Description</b>
-2   The getwc function is equivalent to fgetwc, except that if it is implemented as a
-    macro, it may evaluate stream more than once, so the argument should never be an
-    expression with side effects.
-<b>    Returns</b>
-3   The getwc function returns the next wide character from the input stream pointed to by
-    stream, or WEOF.
-<a name="7.28.3.7" href="#7.28.3.7"><b>    7.28.3.7 The getwchar function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wint_t getwchar(void);
-
-
-
-
-    <sup><a name="note329" href="#note329"><b>329)</b></a></sup> If the orientation of the stream has already been determined, fwide does not change it.
-
-[<a name="p420" href="#p420">page 420</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The getwchar function is equivalent to getwc with the argument stdin.
-<b>    Returns</b>
-3   The getwchar function returns the next wide character from the input stream pointed to
-    by stdin, or WEOF.
-<a name="7.28.3.8" href="#7.28.3.8"><b>    7.28.3.8 The putwc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wint_t putwc(wchar_t c, FILE *stream);
-<b>    Description</b>
-2   The putwc function is equivalent to fputwc, except that if it is implemented as a
-    macro, it may evaluate stream more than once, so that argument should never be an
-    expression with side effects.
-<b>    Returns</b>
-3   The putwc function returns the wide character written, or WEOF.
-<a name="7.28.3.9" href="#7.28.3.9"><b>    7.28.3.9 The putwchar function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wint_t putwchar(wchar_t c);
-<b>    Description</b>
-2   The putwchar function is equivalent to putwc with the second argument stdout.
-<b>    Returns</b>
-3   The putwchar function returns the character written, or WEOF.
-<a name="7.28.3.10" href="#7.28.3.10"><b>    7.28.3.10 The ungetwc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wint_t ungetwc(wint_t c, FILE *stream);
-<b>    Description</b>
-2   The ungetwc function pushes the wide character specified by c back onto the input
-    stream pointed to by stream. Pushed-back wide characters will be returned by
-    subsequent reads on that stream in the reverse order of their pushing. A successful
-
-[<a name="p421" href="#p421">page 421</a>] (<a href="#Contents">Contents</a>)
-
-    intervening call (with the stream pointed to by stream) to a file positioning function
-    (fseek, fsetpos, or rewind) discards any pushed-back wide characters for the
-    stream. The external storage corresponding to the stream is unchanged.
-3   One wide character of pushback is guaranteed, even if the call to the ungetwc function
-    follows just after a call to a formatted wide character input function fwscanf,
-    vfwscanf, vwscanf, or wscanf. If the ungetwc function is called too many times
-    on the same stream without an intervening read or file positioning operation on that
-    stream, the operation may fail.
-4   If the value of c equals that of the macro WEOF, the operation fails and the input stream is
-    unchanged.
-5   A successful call to the ungetwc function clears the end-of-file indicator for the stream.
-    The value of the file position indicator for the stream after reading or discarding all
-    pushed-back wide characters is the same as it was before the wide characters were pushed
-    back. For a text or binary stream, the value of its file position indicator after a successful
-    call to the ungetwc function is unspecified until all pushed-back wide characters are
-    read or discarded.
-<b>    Returns</b>
-6   The ungetwc function returns the wide character pushed back, or WEOF if the operation
-    fails.
-<a name="7.28.4" href="#7.28.4"><b>    7.28.4 General wide string utilities</b></a>
-1   The header <a href="#7.28">&lt;wchar.h&gt;</a> declares a number of functions useful for wide string
-    manipulation. Various methods are used for determining the lengths of the arrays, but in
-    all cases a wchar_t * argument points to the initial (lowest addressed) element of the
-    array. If an array is accessed beyond the end of an object, the behavior is undefined.
-2   Where an argument declared as size_t n determines the length of the array for a
-    function, n can have the value zero on a call to that function. Unless explicitly stated
-    otherwise in the description of a particular function in this subclause, pointer arguments
-    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
-    function that locates a wide character finds no occurrence, a function that compares two
-    wide character sequences returns zero, and a function that copies wide characters copies
-    zero wide characters.
-
-[<a name="p422" href="#p422">page 422</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.4.1" href="#7.28.4.1"><b>    7.28.4.1 Wide string numeric conversion functions</b></a>
-<a name="7.28.4.1.1" href="#7.28.4.1.1"><b>    7.28.4.1.1 The wcstod, wcstof, and wcstold functions</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            double wcstod(const wchar_t * restrict nptr,
-                 wchar_t ** restrict endptr);
-            float wcstof(const wchar_t * restrict nptr,
-                 wchar_t ** restrict endptr);
-            long double wcstold(const wchar_t * restrict nptr,
-                 wchar_t ** restrict endptr);
-<b>    Description</b>
-2   The wcstod, wcstof, and wcstold functions convert the initial portion of the wide
-    string pointed to by nptr to double, float, and long double representation,
-    respectively. First, they decompose the input string into three parts: an initial, possibly
-    empty, sequence of white-space wide characters (as specified by the iswspace
-    function), a subject sequence resembling a floating-point constant or representing an
-    infinity or NaN; and a final wide string of one or more unrecognized wide characters,
-    including the terminating null wide character of the input wide string. Then, they attempt
-    to convert the subject sequence to a floating-point number, and return the result.
-3   The expected form of the subject sequence is an optional plus or minus sign, then one of
-    the following:
-    -- a nonempty sequence of decimal digits optionally containing a decimal-point wide
-      character, then an optional exponent part as defined for the corresponding single-byte
-      characters in <a href="#6.4.4.2">6.4.4.2</a>;
-    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
-      decimal-point wide character, then an optional binary exponent part as defined in
-      <a href="#6.4.4.2">6.4.4.2</a>;
-    -- INF or INFINITY, or any other wide string equivalent except for case
-    -- NAN or NAN(n-wchar-sequenceopt), or any other wide string equivalent except for
-      case in the NAN part, where:
-               n-wchar-sequence:
-                     digit
-                     nondigit
-                     n-wchar-sequence digit
-                     n-wchar-sequence nondigit
-    The subject sequence is defined as the longest initial subsequence of the input wide
-    string, starting with the first non-white-space wide character, that is of the expected form.
-
-[<a name="p423" href="#p423">page 423</a>] (<a href="#Contents">Contents</a>)
-
-    The subject sequence contains no wide characters if the input wide string is not of the
-    expected form.
-4   If the subject sequence has the expected form for a floating-point number, the sequence of
-    wide characters starting with the first digit or the decimal-point wide character
-    (whichever occurs first) is interpreted as a floating constant according to the rules of
-    <a href="#6.4.4.2">6.4.4.2</a>, except that the decimal-point wide character is used in place of a period, and that
-    if neither an exponent part nor a decimal-point wide character appears in a decimal
-    floating point number, or if a binary exponent part does not appear in a hexadecimal
-    floating point number, an exponent part of the appropriate type with value zero is
-    assumed to follow the last digit in the string. If the subject sequence begins with a minus
-    sign, the sequence is interpreted as negated.<sup><a href="#note330"><b>330)</b></a></sup> A wide character sequence INF or
-    INFINITY is interpreted as an infinity, if representable in the return type, else like a
-    floating constant that is too large for the range of the return type. A wide character
-    sequence NAN or NAN(n-wchar-sequenceopt) is interpreted as a quiet NaN, if supported
-    in the return type, else like a subject sequence part that does not have the expected form;
-    the meaning of the n-wchar sequences is implementation-defined.<sup><a href="#note331"><b>331)</b></a></sup> A pointer to the
-    final wide string is stored in the object pointed to by endptr, provided that endptr is
-    not a null pointer.
-5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
-    value resulting from the conversion is correctly rounded.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-    Recommended practice
-8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
-    the result is not exactly representable, the result should be one of the two numbers in the
-    appropriate internal format that are adjacent to the hexadecimal floating source value,
-    with the extra stipulation that the error should have a correct sign for the current rounding
-    direction.
-
-
-
-    <sup><a name="note330" href="#note330"><b>330)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
-         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
-         methods may yield different results if rounding is toward positive or negative infinity. In either case,
-         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
-    <sup><a name="note331" href="#note331"><b>331)</b></a></sup> An implementation may use the n-wchar sequence to determine extra information to be represented in
-         the NaN's significand.
-
-[<a name="p424" href="#p424">page 424</a>] (<a href="#Contents">Contents</a>)
-
-9    If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
-     <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
-     sequence D has the decimal form and more than DECIMAL_DIG significant digits,
-     consider the two bounding, adjacent decimal strings L and U, both having
-     DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
-     The result should be one of the (equal or adjacent) values that would be obtained by
-     correctly rounding L and U according to the current rounding direction, with the extra
-     stipulation that the error with respect to D should have a correct sign for the current
-     rounding direction.<sup><a href="#note332"><b>332)</b></a></sup>
-<b>     Returns</b>
-10   The functions return the converted value, if any. If no conversion could be performed,
-     zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
-     plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
-     return type and sign of the value), and the value of the macro ERANGE is stored in
-     errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
-     no greater than the smallest normalized positive number in the return type; whether
-     errno acquires the value ERANGE is implementation-defined.
-
-
-
-
-     <sup><a name="note332" href="#note332"><b>332)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
-          to the same internal floating value, but if not will round to adjacent values.
-
-[<a name="p425" href="#p425">page 425</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.4.1.2" href="#7.28.4.1.2"><b>    7.28.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           long int wcstol(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-           long long int wcstoll(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-           unsigned long int wcstoul(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-           unsigned long long int wcstoull(
-                const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr,
-                int base);
-<b>    Description</b>
-2   The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
-    portion of the wide string pointed to by nptr to long int, long long int,
-    unsigned long int, and unsigned long long int representation,
-    respectively. First, they decompose the input string into three parts: an initial, possibly
-    empty, sequence of white-space wide characters (as specified by the iswspace
-    function), a subject sequence resembling an integer represented in some radix determined
-    by the value of base, and a final wide string of one or more unrecognized wide
-    characters, including the terminating null wide character of the input wide string. Then,
-    they attempt to convert the subject sequence to an integer, and return the result.
-3   If the value of base is zero, the expected form of the subject sequence is that of an
-    integer constant as described for the corresponding single-byte characters in <a href="#6.4.4.1">6.4.4.1</a>,
-    optionally preceded by a plus or minus sign, but not including an integer suffix. If the
-    value of base is between 2 and 36 (inclusive), the expected form of the subject sequence
-    is a sequence of letters and digits representing an integer with the radix specified by
-    base, optionally preceded by a plus or minus sign, but not including an integer suffix.
-    The letters from a (or A) through z (or Z) are ascribed the values 10 through 35; only
-    letters and digits whose ascribed values are less than that of base are permitted. If the
-    value of base is 16, the wide characters 0x or 0X may optionally precede the sequence
-    of letters and digits, following the sign if present.
-
-[<a name="p426" href="#p426">page 426</a>] (<a href="#Contents">Contents</a>)
-
-4   The subject sequence is defined as the longest initial subsequence of the input wide
-    string, starting with the first non-white-space wide character, that is of the expected form.
-    The subject sequence contains no wide characters if the input wide string is empty or
-    consists entirely of white space, or if the first non-white-space wide character is other
-    than a sign or a permissible letter or digit.
-5   If the subject sequence has the expected form and the value of base is zero, the sequence
-    of wide characters starting with the first digit is interpreted as an integer constant
-    according to the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the
-    value of base is between 2 and 36, it is used as the base for conversion, ascribing to each
-    letter its value as given above. If the subject sequence begins with a minus sign, the value
-    resulting from the conversion is negated (in the return type). A pointer to the final wide
-    string is stored in the object pointed to by endptr, provided that endptr is not a null
-    pointer.
-6   In other than the "C" locale, additional locale-specific subject sequence forms may be
-    accepted.
-7   If the subject sequence is empty or does not have the expected form, no conversion is
-    performed; the value of nptr is stored in the object pointed to by endptr, provided
-    that endptr is not a null pointer.
-<b>    Returns</b>
-8   The wcstol, wcstoll, wcstoul, and wcstoull functions return the converted
-    value, if any. If no conversion could be performed, zero is returned. If the correct value
-    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
-    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
-    sign of the value, if any), and the value of the macro ERANGE is stored in errno.
-<a name="7.28.4.2" href="#7.28.4.2"><b>    7.28.4.2 Wide string copying functions</b></a>
-<a name="7.28.4.2.1" href="#7.28.4.2.1"><b>    7.28.4.2.1 The wcscpy function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wcscpy(wchar_t * restrict s1,
-                 const wchar_t * restrict s2);
-<b>    Description</b>
-2   The wcscpy function copies the wide string pointed to by s2 (including the terminating
-    null wide character) into the array pointed to by s1.
-<b>    Returns</b>
-3   The wcscpy function returns the value of s1.
-
-[<a name="p427" href="#p427">page 427</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.4.2.2" href="#7.28.4.2.2"><b>    7.28.4.2.2 The wcsncpy function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             wchar_t *wcsncpy(wchar_t * restrict s1,
-                  const wchar_t * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The wcsncpy function copies not more than n wide characters (those that follow a null
-    wide character are not copied) from the array pointed to by s2 to the array pointed to by
-    s1.<sup><a href="#note333"><b>333)</b></a></sup>
-3   If the array pointed to by s2 is a wide string that is shorter than n wide characters, null
-    wide characters are appended to the copy in the array pointed to by s1, until n wide
-    characters in all have been written.
-<b>    Returns</b>
-4   The wcsncpy function returns the value of s1.
-<a name="7.28.4.2.3" href="#7.28.4.2.3"><b>    7.28.4.2.3 The wmemcpy function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             wchar_t *wmemcpy(wchar_t * restrict s1,
-                  const wchar_t * restrict s2,
-                  size_t n);
-<b>    Description</b>
-2   The wmemcpy function copies n wide characters from the object pointed to by s2 to the
-    object pointed to by s1.
-<b>    Returns</b>
-3   The wmemcpy function returns the value of s1.
-
-
-
-
-    <sup><a name="note333" href="#note333"><b>333)</b></a></sup> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
-         result will not be null-terminated.
-
-[<a name="p428" href="#p428">page 428</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.4.2.4" href="#7.28.4.2.4"><b>    7.28.4.2.4 The wmemmove function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
-                 size_t n);
-<b>    Description</b>
-2   The wmemmove function copies n wide characters from the object pointed to by s2 to
-    the object pointed to by s1. Copying takes place as if the n wide characters from the
-    object pointed to by s2 are first copied into a temporary array of n wide characters that
-    does not overlap the objects pointed to by s1 or s2, and then the n wide characters from
-    the temporary array are copied into the object pointed to by s1.
-<b>    Returns</b>
-3   The wmemmove function returns the value of s1.
-<a name="7.28.4.3" href="#7.28.4.3"><b>    7.28.4.3 Wide string concatenation functions</b></a>
-<a name="7.28.4.3.1" href="#7.28.4.3.1"><b>    7.28.4.3.1 The wcscat function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wcscat(wchar_t * restrict s1,
-                 const wchar_t * restrict s2);
-<b>    Description</b>
-2   The wcscat function appends a copy of the wide string pointed to by s2 (including the
-    terminating null wide character) to the end of the wide string pointed to by s1. The initial
-    wide character of s2 overwrites the null wide character at the end of s1.
-<b>    Returns</b>
-3   The wcscat function returns the value of s1.
-<a name="7.28.4.3.2" href="#7.28.4.3.2"><b>    7.28.4.3.2 The wcsncat function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wcsncat(wchar_t * restrict s1,
-                 const wchar_t * restrict s2,
-                 size_t n);
-<b>    Description</b>
-2   The wcsncat function appends not more than n wide characters (a null wide character
-    and those that follow it are not appended) from the array pointed to by s2 to the end of
-
-[<a name="p429" href="#p429">page 429</a>] (<a href="#Contents">Contents</a>)
-
-    the wide string pointed to by s1. The initial wide character of s2 overwrites the null
-    wide character at the end of s1. A terminating null wide character is always appended to
-    the result.<sup><a href="#note334"><b>334)</b></a></sup>
-<b>    Returns</b>
-3   The wcsncat function returns the value of s1.
-<a name="7.28.4.4" href="#7.28.4.4"><b>    7.28.4.4 Wide string comparison functions</b></a>
-1   Unless explicitly stated otherwise, the functions described in this subclause order two
-    wide characters the same way as two integers of the underlying integer type designated
-    by wchar_t.
-<a name="7.28.4.4.1" href="#7.28.4.4.1"><b>    7.28.4.4.1 The wcscmp function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int wcscmp(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcscmp function compares the wide string pointed to by s1 to the wide string
-    pointed to by s2.
-<b>    Returns</b>
-3   The wcscmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
-    wide string pointed to by s2.
-<a name="7.28.4.4.2" href="#7.28.4.4.2"><b>    7.28.4.4.2 The wcscoll function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int wcscoll(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcscoll function compares the wide string pointed to by s1 to the wide string
-    pointed to by s2, both interpreted as appropriate to the LC_COLLATE category of the
-    current locale.
-<b>    Returns</b>
-3   The wcscoll function returns an integer greater than, equal to, or less than zero,
-    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
-
-
-    <sup><a name="note334" href="#note334"><b>334)</b></a></sup> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
-         wcslen(s1)+n+1.
-
-[<a name="p430" href="#p430">page 430</a>] (<a href="#Contents">Contents</a>)
-
-    wide string pointed to by s2 when both are interpreted as appropriate to the current
-    locale.
-<a name="7.28.4.4.3" href="#7.28.4.4.3"><b>    7.28.4.4.3 The wcsncmp function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int wcsncmp(const wchar_t *s1, const wchar_t *s2,
-                 size_t n);
-<b>    Description</b>
-2   The wcsncmp function compares not more than n wide characters (those that follow a
-    null wide character are not compared) from the array pointed to by s1 to the array
-    pointed to by s2.
-<b>    Returns</b>
-3   The wcsncmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
-    to, or less than the possibly null-terminated array pointed to by s2.
-<a name="7.28.4.4.4" href="#7.28.4.4.4"><b>    7.28.4.4.4 The wcsxfrm function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            size_t wcsxfrm(wchar_t * restrict s1,
-                 const wchar_t * restrict s2,
-                 size_t n);
-<b>    Description</b>
-2   The wcsxfrm function transforms the wide string pointed to by s2 and places the
-    resulting wide string into the array pointed to by s1. The transformation is such that if
-    the wcscmp function is applied to two transformed wide strings, it returns a value greater
-    than, equal to, or less than zero, corresponding to the result of the wcscoll function
-    applied to the same two original wide strings. No more than n wide characters are placed
-    into the resulting array pointed to by s1, including the terminating null wide character. If
-    n is zero, s1 is permitted to be a null pointer.
-<b>    Returns</b>
-3   The wcsxfrm function returns the length of the transformed wide string (not including
-    the terminating null wide character). If the value returned is n or greater, the contents of
-    the array pointed to by s1 are indeterminate.
-4   EXAMPLE The value of the following expression is the length of the array needed to hold the
-    transformation of the wide string pointed to by s:
-
-[<a name="p431" href="#p431">page 431</a>] (<a href="#Contents">Contents</a>)
-
-           1 + wcsxfrm(NULL, s, 0)
-
-<a name="7.28.4.4.5" href="#7.28.4.4.5"><b>    7.28.4.4.5 The wmemcmp function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           int wmemcmp(const wchar_t *s1, const wchar_t *s2,
-                size_t n);
-<b>    Description</b>
-2   The wmemcmp function compares the first n wide characters of the object pointed to by
-    s1 to the first n wide characters of the object pointed to by s2.
-<b>    Returns</b>
-3   The wmemcmp function returns an integer greater than, equal to, or less than zero,
-    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
-    pointed to by s2.
-<a name="7.28.4.5" href="#7.28.4.5"><b>    7.28.4.5 Wide string search functions</b></a>
-<a name="7.28.4.5.1" href="#7.28.4.5.1"><b>    7.28.4.5.1 The wcschr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           wchar_t *wcschr(const wchar_t *s, wchar_t c);
-<b>    Description</b>
-2   The wcschr function locates the first occurrence of c in the wide string pointed to by s.
-    The terminating null wide character is considered to be part of the wide string.
-<b>    Returns</b>
-3   The wcschr function returns a pointer to the located wide character, or a null pointer if
-    the wide character does not occur in the wide string.
-<a name="7.28.4.5.2" href="#7.28.4.5.2"><b>    7.28.4.5.2 The wcscspn function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcscspn function computes the length of the maximum initial segment of the wide
-    string pointed to by s1 which consists entirely of wide characters not from the wide
-    string pointed to by s2.
-
-[<a name="p432" href="#p432">page 432</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The wcscspn function returns the length of the segment.
-<a name="7.28.4.5.3" href="#7.28.4.5.3"><b>    7.28.4.5.3 The wcspbrk function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcspbrk function locates the first occurrence in the wide string pointed to by s1 of
-    any wide character from the wide string pointed to by s2.
-<b>    Returns</b>
-3   The wcspbrk function returns a pointer to the wide character in s1, or a null pointer if
-    no wide character from s2 occurs in s1.
-<a name="7.28.4.5.4" href="#7.28.4.5.4"><b>    7.28.4.5.4 The wcsrchr function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
-<b>    Description</b>
-2   The wcsrchr function locates the last occurrence of c in the wide string pointed to by
-    s. The terminating null wide character is considered to be part of the wide string.
-<b>    Returns</b>
-3   The wcsrchr function returns a pointer to the wide character, or a null pointer if c does
-    not occur in the wide string.
-<a name="7.28.4.5.5" href="#7.28.4.5.5"><b>    7.28.4.5.5 The wcsspn function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcsspn function computes the length of the maximum initial segment of the wide
-    string pointed to by s1 which consists entirely of wide characters from the wide string
-    pointed to by s2.
-<b>    Returns</b>
-3   The wcsspn function returns the length of the segment.
-
-[<a name="p433" href="#p433">page 433</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.4.5.6" href="#7.28.4.5.6"><b>    7.28.4.5.6 The wcsstr function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
-<b>    Description</b>
-2   The wcsstr function locates the first occurrence in the wide string pointed to by s1 of
-    the sequence of wide characters (excluding the terminating null wide character) in the
-    wide string pointed to by s2.
-<b>    Returns</b>
-3   The wcsstr function returns a pointer to the located wide string, or a null pointer if the
-    wide string is not found. If s2 points to a wide string with zero length, the function
-    returns s1.
-<a name="7.28.4.5.7" href="#7.28.4.5.7"><b>    7.28.4.5.7 The wcstok function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           wchar_t *wcstok(wchar_t * restrict s1,
-                const wchar_t * restrict s2,
-                wchar_t ** restrict ptr);
-<b>    Description</b>
-2   A sequence of calls to the wcstok function breaks the wide string pointed to by s1 into
-    a sequence of tokens, each of which is delimited by a wide character from the wide string
-    pointed to by s2. The third argument points to a caller-provided wchar_t pointer into
-    which the wcstok function stores information necessary for it to continue scanning the
-    same wide string.
-3   The first call in a sequence has a non-null first argument and stores an initial value in the
-    object pointed to by ptr. Subsequent calls in the sequence have a null first argument and
-    the object pointed to by ptr is required to have the value stored by the previous call in
-    the sequence, which is then updated. The separator wide string pointed to by s2 may be
-    different from call to call.
-4   The first call in the sequence searches the wide string pointed to by s1 for the first wide
-    character that is not contained in the current separator wide string pointed to by s2. If no
-    such wide character is found, then there are no tokens in the wide string pointed to by s1
-    and the wcstok function returns a null pointer. If such a wide character is found, it is
-    the start of the first token.
-5   The wcstok function then searches from there for a wide character that is contained in
-    the current separator wide string. If no such wide character is found, the current token
-
-[<a name="p434" href="#p434">page 434</a>] (<a href="#Contents">Contents</a>)
-
-    extends to the end of the wide string pointed to by s1, and subsequent searches in the
-    same wide string for a token return a null pointer. If such a wide character is found, it is
-    overwritten by a null wide character, which terminates the current token.
-6   In all cases, the wcstok function stores sufficient information in the pointer pointed to
-    by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
-    value for ptr, shall start searching just past the element overwritten by a null wide
-    character (if any).
-<b>    Returns</b>
-7   The wcstok function returns a pointer to the first wide character of a token, or a null
-    pointer if there is no token.
-8   EXAMPLE
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            static wchar_t str1[] = L"?a???b,,,#c";
-            static wchar_t str2[] = L"\t \t";
-            wchar_t *t, *ptr1, *ptr2;
-            t   =   wcstok(str1,   L"?", &amp;ptr1);         //   t   points to the token L"a"
-            t   =   wcstok(NULL,   L",", &amp;ptr1);         //   t   points to the token L"??b"
-            t   =   wcstok(str2,   L" \t", &amp;ptr2);       //   t   is a null pointer
-            t   =   wcstok(NULL,   L"#,", &amp;ptr1);        //   t   points to the token L"c"
-            t   =   wcstok(NULL,   L"?", &amp;ptr1);         //   t   is a null pointer
-
-<a name="7.28.4.5.8" href="#7.28.4.5.8"><b>    7.28.4.5.8 The wmemchr function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wmemchr(const wchar_t *s, wchar_t c,
-                 size_t n);
-<b>    Description</b>
-2   The wmemchr function locates the first occurrence of c in the initial n wide characters of
-    the object pointed to by s.
-<b>    Returns</b>
-3   The wmemchr function returns a pointer to the located wide character, or a null pointer if
-    the wide character does not occur in the object.
-
-[<a name="p435" href="#p435">page 435</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.4.6" href="#7.28.4.6"><b>    7.28.4.6 Miscellaneous functions</b></a>
-<a name="7.28.4.6.1" href="#7.28.4.6.1"><b>    7.28.4.6.1 The wcslen function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           size_t wcslen(const wchar_t *s);
-<b>    Description</b>
-2   The wcslen function computes the length of the wide string pointed to by s.
-<b>    Returns</b>
-3   The wcslen function returns the number of wide characters that precede the terminating
-    null wide character.
-<a name="7.28.4.6.2" href="#7.28.4.6.2"><b>    7.28.4.6.2 The wmemset function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
-<b>    Description</b>
-2   The wmemset function copies the value of c into each of the first n wide characters of
-    the object pointed to by s.
-<b>    Returns</b>
-3   The wmemset function returns the value of s.
-<a name="7.28.5" href="#7.28.5"><b>    7.28.5 Wide character time conversion functions</b></a>
-<a name="7.28.5.1" href="#7.28.5.1"><b>    7.28.5.1 The wcsftime function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.26">&lt;time.h&gt;</a>
-           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           size_t wcsftime(wchar_t * restrict s,
-                size_t maxsize,
-                const wchar_t * restrict format,
-                const struct tm * restrict timeptr);
-<b>    Description</b>
-2   The wcsftime function is equivalent to the strftime function, except that:
-    -- The argument s points to the initial element of an array of wide characters into which
-      the generated output is to be placed.
-
-[<a name="p436" href="#p436">page 436</a>] (<a href="#Contents">Contents</a>)
-
-    -- The argument maxsize indicates the limiting number of wide characters.
-    -- The argument format is a wide string and the conversion specifiers are replaced by
-      corresponding sequences of wide characters.
-    -- The return value indicates the number of wide characters.
-<b>    Returns</b>
-3   If the total number of resulting wide characters including the terminating null wide
-    character is not more than maxsize, the wcsftime function returns the number of
-    wide characters placed into the array pointed to by s not including the terminating null
-    wide character. Otherwise, zero is returned and the contents of the array are
-    indeterminate.
-<a name="7.28.6" href="#7.28.6"><b>    7.28.6 Extended multibyte/wide character conversion utilities</b></a>
-1   The header <a href="#7.28">&lt;wchar.h&gt;</a> declares an extended set of functions useful for conversion
-    between multibyte characters and wide characters.
-2   Most of the following functions -- those that are listed as ''restartable'', <a href="#7.28.6.3">7.28.6.3</a> and
-    <a href="#7.28.6.4">7.28.6.4</a> -- take as a last argument a pointer to an object of type mbstate_t that is used
-    to describe the current conversion state from a particular multibyte character sequence to
-    a wide character sequence (or the reverse) under the rules of a particular setting for the
-    LC_CTYPE category of the current locale.
-3   The initial conversion state corresponds, for a conversion in either direction, to the
-    beginning of a new multibyte character in the initial shift state. A zero-valued
-    mbstate_t object is (at least) one way to describe an initial conversion state. A zero-
-    valued mbstate_t object can be used to initiate conversion involving any multibyte
-    character sequence, in any LC_CTYPE category setting. If an mbstate_t object has
-    been altered by any of the functions described in this subclause, and is then used with a
-    different multibyte character sequence, or in the other conversion direction, or with a
-    different LC_CTYPE category setting than on earlier function calls, the behavior is
-    undefined.<sup><a href="#note335"><b>335)</b></a></sup>
-4   On entry, each function takes the described conversion state (either internal or pointed to
-    by an argument) as current. The conversion state described by the referenced object is
-    altered as needed to track the shift state, and the position within a multibyte character, for
-    the associated multibyte character sequence.
-
-
-
-
-    <sup><a name="note335" href="#note335"><b>335)</b></a></sup> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
-         mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
-         character string.
-
-[<a name="p437" href="#p437">page 437</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.6.1" href="#7.28.6.1"><b>    7.28.6.1 Single-byte/wide character conversion functions</b></a>
-<a name="7.28.6.1.1" href="#7.28.6.1.1"><b>    7.28.6.1.1 The btowc function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>                                                                        *
-           wint_t btowc(int c);
-<b>    Description</b>
-2   The btowc function determines whether c constitutes a valid single-byte character in the
-    initial shift state.
-<b>    Returns</b>
-3   The btowc function returns WEOF if c has the value EOF or if (unsigned char)c
-    does not constitute a valid single-byte character in the initial shift state. Otherwise, it
-    returns the wide character representation of that character.
-<a name="7.28.6.1.2" href="#7.28.6.1.2"><b>    7.28.6.1.2 The wctob function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>                                                                        *
-           int wctob(wint_t c);
-<b>    Description</b>
-2   The wctob function determines whether c corresponds to a member of the extended
-    character set whose multibyte character representation is a single byte when in the initial
-    shift state.
-<b>    Returns</b>
-3   The wctob function returns EOF if c does not correspond to a multibyte character with
-    length one in the initial shift state. Otherwise, it returns the single-byte representation of
-    that character as an unsigned char converted to an int.
-<a name="7.28.6.2" href="#7.28.6.2"><b>    7.28.6.2 Conversion state functions</b></a>
-<a name="7.28.6.2.1" href="#7.28.6.2.1"><b>    7.28.6.2.1 The mbsinit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           int mbsinit(const mbstate_t *ps);
-<b>    Description</b>
-2   If ps is not a null pointer, the mbsinit function determines whether the referenced
-    mbstate_t object describes an initial conversion state.
-
-[<a name="p438" href="#p438">page 438</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-3   The mbsinit function returns nonzero if ps is a null pointer or if the referenced object
-    describes an initial conversion state; otherwise, it returns zero.
-<a name="7.28.6.3" href="#7.28.6.3"><b>    7.28.6.3 Restartable multibyte/wide character conversion functions</b></a>
-1   These functions differ from the corresponding multibyte character functions of <a href="#7.22.7">7.22.7</a>
-    (mblen, mbtowc, and wctomb) in that they have an extra parameter, ps, of type
-    pointer to mbstate_t that points to an object that can completely describe the current
-    conversion state of the associated multibyte character sequence. If ps is a null pointer,
-    each function uses its own internal mbstate_t object instead, which is initialized at
-    program startup to the initial conversion state; the functions are not required to avoid data
-    races in this case. The implementation behaves as if no library function calls these
-    functions with a null pointer for ps.
-2   Also unlike their corresponding functions, the return value does not represent whether the
-    encoding is state-dependent.
-<a name="7.28.6.3.1" href="#7.28.6.3.1"><b>    7.28.6.3.1 The mbrlen function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            size_t mbrlen(const char * restrict s,
-                 size_t n,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   The mbrlen function is equivalent to the call:
-            mbrtowc(NULL, s, n, ps != NULL ? ps : &amp;internal)
-    where internal is the mbstate_t object for the mbrlen function, except that the
-    expression designated by ps is evaluated only once.
-<b>    Returns</b>
-3   The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
-    or (size_t)(-1).
-    Forward references: the mbrtowc function (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
-
-[<a name="p439" href="#p439">page 439</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.6.3.2" href="#7.28.6.3.2"><b>    7.28.6.3.2 The mbrtowc function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            size_t mbrtowc(wchar_t * restrict pwc,
-                 const char * restrict s,
-                 size_t n,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the mbrtowc function is equivalent to the call:
-                    mbrtowc(NULL, "", 1, ps)
-    In this case, the values of the parameters pwc and n are ignored.
-3   If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
-    the byte pointed to by s to determine the number of bytes needed to complete the next
-    multibyte character (including any shift sequences). If the function determines that the
-    next multibyte character is complete and valid, it determines the value of the
-    corresponding wide character and then, if pwc is not a null pointer, stores that value in
-    the object pointed to by pwc. If the corresponding wide character is the null wide
-    character, the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The mbrtowc function returns the first of the following that applies (given the current
-    conversion state):
-    0                     if the next n or fewer bytes complete the multibyte character that
-                          corresponds to the null wide character (which is the value stored).
-    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
-                       character (which is the value stored); the value returned is the number
-                       of bytes that complete the multibyte character.
-    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
-                 multibyte character, and all n bytes have been processed (no value is
-                 stored).<sup><a href="#note336"><b>336)</b></a></sup>
-    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
-                 do not contribute to a complete and valid multibyte character (no
-                 value is stored); the value of the macro EILSEQ is stored in errno,
-                 and the conversion state is unspecified.
-
-    <sup><a name="note336" href="#note336"><b>336)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
-         sequence of redundant shift sequences (for implementations with state-dependent encodings).
-
-[<a name="p440" href="#p440">page 440</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.6.3.3" href="#7.28.6.3.3"><b>    7.28.6.3.3 The wcrtomb function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            size_t wcrtomb(char * restrict s,
-                 wchar_t wc,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   If s is a null pointer, the wcrtomb function is equivalent to the call
-                    wcrtomb(buf, L'\0', ps)
-    where buf is an internal buffer.
-3   If s is not a null pointer, the wcrtomb function determines the number of bytes needed
-    to represent the multibyte character that corresponds to the wide character given by wc
-    (including any shift sequences), and stores the multibyte character representation in the
-    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
-    wc is a null wide character, a null byte is stored, preceded by any shift sequence needed
-    to restore the initial shift state; the resulting state described is the initial conversion state.
-<b>    Returns</b>
-4   The wcrtomb function returns the number of bytes stored in the array object (including
-    any shift sequences). When wc is not a valid wide character, an encoding error occurs:
-    the function stores the value of the macro EILSEQ in errno and returns
-    (size_t)(-1); the conversion state is unspecified.
-<a name="7.28.6.4" href="#7.28.6.4"><b>    7.28.6.4 Restartable multibyte/wide string conversion functions</b></a>
-1   These functions differ from the corresponding multibyte string functions of <a href="#7.22.8">7.22.8</a>
-    (mbstowcs and wcstombs) in that they have an extra parameter, ps, of type pointer to
-    mbstate_t that points to an object that can completely describe the current conversion
-    state of the associated multibyte character sequence. If ps is a null pointer, each function
-    uses its own internal mbstate_t object instead, which is initialized at program startup
-    to the initial conversion state; the functions are not required to avoid data races in this
-    case. The implementation behaves as if no library function calls these functions with a
-    null pointer for ps.
-2   Also unlike their corresponding functions, the conversion source parameter, src, has a
-    pointer-to-pointer type. When the function is storing the results of conversions (that is,
-    when dst is not a null pointer), the pointer object pointed to by this parameter is updated
-    to reflect the amount of the source processed by that invocation.
-
-[<a name="p441" href="#p441">page 441</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.6.4.1" href="#7.28.6.4.1"><b>    7.28.6.4.1 The mbsrtowcs function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             size_t mbsrtowcs(wchar_t * restrict dst,
-                  const char ** restrict src,
-                  size_t len,
-                  mbstate_t * restrict ps);
-<b>    Description</b>
-2   The mbsrtowcs function converts a sequence of multibyte characters that begins in the
-    conversion state described by the object pointed to by ps, from the array indirectly
-    pointed to by src into a sequence of corresponding wide characters. If dst is not a null
-    pointer, the converted characters are stored into the array pointed to by dst. Conversion
-    continues up to and including a terminating null character, which is also stored.
-    Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
-    not form a valid multibyte character, or (if dst is not a null pointer) when len wide
-    characters have been stored into the array pointed to by dst.<sup><a href="#note337"><b>337)</b></a></sup> Each conversion takes
-    place as if by a call to the mbrtowc function.
-3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
-    pointer (if conversion stopped due to reaching a terminating null character) or the address
-    just past the last multibyte character converted (if any). If conversion stopped due to
-    reaching a terminating null character and if dst is not a null pointer, the resulting state
-    described is the initial conversion state.
-<b>    Returns</b>
-4   If the input conversion encounters a sequence of bytes that do not form a valid multibyte
-    character, an encoding error occurs: the mbsrtowcs function stores the value of the
-    macro EILSEQ in errno and returns (size_t)(-1); the conversion state is
-    unspecified. Otherwise, it returns the number of multibyte characters successfully
-    converted, not including the terminating null character (if any).
-
-
-
-
-    <sup><a name="note337" href="#note337"><b>337)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
-
-[<a name="p442" href="#p442">page 442</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.28.6.4.2" href="#7.28.6.4.2"><b>    7.28.6.4.2 The wcsrtombs function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            size_t wcsrtombs(char * restrict dst,
-                 const wchar_t ** restrict src,
-                 size_t len,
-                 mbstate_t * restrict ps);
-<b>    Description</b>
-2   The wcsrtombs function converts a sequence of wide characters from the array
-    indirectly pointed to by src into a sequence of corresponding multibyte characters that
-    begins in the conversion state described by the object pointed to by ps. If dst is not a
-    null pointer, the converted characters are then stored into the array pointed to by dst.
-    Conversion continues up to and including a terminating null wide character, which is also
-    stored. Conversion stops earlier in two cases: when a wide character is reached that does
-    not correspond to a valid multibyte character, or (if dst is not a null pointer) when the
-    next multibyte character would exceed the limit of len total bytes to be stored into the
-    array pointed to by dst. Each conversion takes place as if by a call to the wcrtomb
-    function.<sup><a href="#note338"><b>338)</b></a></sup>
-3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
-    pointer (if conversion stopped due to reaching a terminating null wide character) or the
-    address just past the last wide character converted (if any). If conversion stopped due to
-    reaching a terminating null wide character, the resulting state described is the initial
-    conversion state.
-<b>    Returns</b>
-4   If conversion stops because a wide character is reached that does not correspond to a
-    valid multibyte character, an encoding error occurs: the wcsrtombs function stores the
-    value of the macro EILSEQ in errno and returns (size_t)(-1); the conversion
-    state is unspecified. Otherwise, it returns the number of bytes in the resulting multibyte
-    character sequence, not including the terminating null character (if any).
-
-
-
-
-    <sup><a name="note338" href="#note338"><b>338)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
-         include those necessary to reach the initial shift state immediately before the null byte.
-
-[<a name="p443" href="#p443">page 443</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.29" href="#7.29"><b>    7.29 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
-<a name="7.29.1" href="#7.29.1"><b>    7.29.1 Introduction</b></a>
-1   The header <a href="#7.29">&lt;wctype.h&gt;</a> defines one macro, and declares three data types and many
-    functions.<sup><a href="#note339"><b>339)</b></a></sup>
-2   The types declared are
-             wint_t
-    described in <a href="#7.28.1">7.28.1</a>;
-             wctrans_t
-    which is a scalar type that can hold values which represent locale-specific character
-    mappings; and
-             wctype_t
-    which is a scalar type that can hold values which represent locale-specific character
-    classifications.
-3   The macro defined is WEOF (described in <a href="#7.28.1">7.28.1</a>).
-4   The functions declared are grouped as follows:
-    -- Functions that provide wide character classification;
-    -- Extensible functions that provide wide character classification;
-    -- Functions that provide wide character case mapping;
-    -- Extensible functions that provide wide character mapping.
-5   For all functions described in this subclause that accept an argument of type wint_t, the
-    value shall be representable as a wchar_t or shall equal the value of the macro WEOF. If
-    this argument has any other value, the behavior is undefined.
-6   The behavior of these functions is affected by the LC_CTYPE category of the current
-    locale.
-
-
-
-
-    <sup><a name="note339" href="#note339"><b>339)</b></a></sup> See ''future library directions'' (<a href="#7.30.13">7.30.13</a>).
-
-[<a name="p444" href="#p444">page 444</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.29.2" href="#7.29.2"><b>    7.29.2 Wide character classification utilities</b></a>
-1   The header <a href="#7.29">&lt;wctype.h&gt;</a> declares several functions useful for classifying wide
-    characters.
-2   The term printing wide character refers to a member of a locale-specific set of wide
-    characters, each of which occupies at least one printing position on a display device. The
-    term control wide character refers to a member of a locale-specific set of wide characters
-    that are not printing wide characters.
-<a name="7.29.2.1" href="#7.29.2.1"><b>    7.29.2.1 Wide character classification functions</b></a>
-1   The functions in this subclause return nonzero (true) if and only if the value of the
-    argument wc conforms to that in the description of the function.
-2   Each of the following functions returns true for each wide character that corresponds (as
-    if by a call to the wctob function) to a single-byte character for which the corresponding
-    character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
-    iswpunct functions may differ with respect to wide characters other than L' ' that are
-    both printing and white-space wide characters.<sup><a href="#note340"><b>340)</b></a></sup>
-    Forward references: the wctob function (<a href="#7.28.6.1.2">7.28.6.1.2</a>).
-<a name="7.29.2.1.1" href="#7.29.2.1.1"><b>    7.29.2.1.1 The iswalnum function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswalnum(wint_t wc);
-<b>    Description</b>
-2   The iswalnum function tests for any wide character for which iswalpha or
-    iswdigit is true.
-<a name="7.29.2.1.2" href="#7.29.2.1.2"><b>    7.29.2.1.2 The iswalpha function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswalpha(wint_t wc);
-<b>    Description</b>
-2   The iswalpha function tests for any wide character for which iswupper or
-    iswlower is true, or any wide character that is one of a locale-specific set of alphabetic
-
-    <sup><a name="note340" href="#note340"><b>340)</b></a></sup> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
-         iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
-         (which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
-         &amp;&amp; iswspace(wc) is true, but not both.
-
-[<a name="p445" href="#p445">page 445</a>] (<a href="#Contents">Contents</a>)
-
-    wide characters for which none of iswcntrl, iswdigit, iswpunct, or iswspace
-    is true.<sup><a href="#note341"><b>341)</b></a></sup>
-<a name="7.29.2.1.3" href="#7.29.2.1.3"><b>    7.29.2.1.3 The iswblank function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswblank(wint_t wc);
-<b>    Description</b>
-2   The iswblank function tests for any wide character that is a standard blank wide
-    character or is one of a locale-specific set of wide characters for which iswspace is true
-    and that is used to separate words within a line of text. The standard blank wide
-    characters are the following: space (L' '), and horizontal tab (L'\t'). In the "C"
-    locale, iswblank returns true only for the standard blank characters.
-<a name="7.29.2.1.4" href="#7.29.2.1.4"><b>    7.29.2.1.4 The iswcntrl function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswcntrl(wint_t wc);
-<b>    Description</b>
-2   The iswcntrl function tests for any control wide character.
-<a name="7.29.2.1.5" href="#7.29.2.1.5"><b>    7.29.2.1.5 The iswdigit function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswdigit(wint_t wc);
-<b>    Description</b>
-2   The iswdigit function tests for any wide character that corresponds to a decimal-digit
-    character (as defined in <a href="#5.2.1">5.2.1</a>).
-<a name="7.29.2.1.6" href="#7.29.2.1.6"><b>    7.29.2.1.6 The iswgraph function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswgraph(wint_t wc);
-
-
-
-
-    <sup><a name="note341" href="#note341"><b>341)</b></a></sup> The functions iswlower and iswupper test true or false separately for each of these additional
-         wide characters; all four combinations are possible.
-
-[<a name="p446" href="#p446">page 446</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The iswgraph function tests for any wide character for which iswprint is true and
-    iswspace is false.<sup><a href="#note342"><b>342)</b></a></sup>
-<a name="7.29.2.1.7" href="#7.29.2.1.7"><b>    7.29.2.1.7 The iswlower function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswlower(wint_t wc);
-<b>    Description</b>
-2   The iswlower function tests for any wide character that corresponds to a lowercase
-    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
-    iswdigit, iswpunct, or iswspace is true.
-<a name="7.29.2.1.8" href="#7.29.2.1.8"><b>    7.29.2.1.8 The iswprint function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswprint(wint_t wc);
-<b>    Description</b>
-2   The iswprint function tests for any printing wide character.
-<a name="7.29.2.1.9" href="#7.29.2.1.9"><b>    7.29.2.1.9 The iswpunct function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswpunct(wint_t wc);
-<b>    Description</b>
-2   The iswpunct function tests for any printing wide character that is one of a locale-
-    specific set of punctuation wide characters for which neither iswspace nor iswalnum
-    is true.342)
-<a name="7.29.2.1.10" href="#7.29.2.1.10"><b>    7.29.2.1.10 The iswspace function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            int iswspace(wint_t wc);
-
-
-
-    <sup><a name="note342" href="#note342"><b>342)</b></a></sup> Note that the behavior of the iswgraph and iswpunct functions may differ from their
-         corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
-         characters other than ' '.
-
-[<a name="p447" href="#p447">page 447</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-2   The iswspace function tests for any wide character that corresponds to a locale-specific
-    set of white-space wide characters for which none of iswalnum, iswgraph, or
-    iswpunct is true.
-<a name="7.29.2.1.11" href="#7.29.2.1.11"><b>    7.29.2.1.11 The iswupper function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
-           int iswupper(wint_t wc);
-<b>    Description</b>
-2   The iswupper function tests for any wide character that corresponds to an uppercase
-    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
-    iswdigit, iswpunct, or iswspace is true.
-<a name="7.29.2.1.12" href="#7.29.2.1.12"><b>    7.29.2.1.12 The iswxdigit function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
-           int iswxdigit(wint_t wc);
-<b>    Description</b>
-2   The iswxdigit function tests for any wide character that corresponds to a
-    hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
-<a name="7.29.2.2" href="#7.29.2.2"><b>    7.29.2.2 Extensible wide character classification functions</b></a>
-1   The functions wctype and iswctype provide extensible wide character classification
-    as well as testing equivalent to that performed by the functions described in the previous
-    subclause (<a href="#7.29.2.1">7.29.2.1</a>).
-<a name="7.29.2.2.1" href="#7.29.2.2.1"><b>    7.29.2.2.1 The iswctype function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
-           int iswctype(wint_t wc, wctype_t desc);
-<b>    Description</b>
-2   The iswctype function determines whether the wide character wc has the property
-    described by desc. The current setting of the LC_CTYPE category shall be the same as
-    during the call to wctype that returned the value desc.
-3   Each of the following expressions has a truth-value equivalent to the call to the wide
-    character classification function (<a href="#7.29.2.1">7.29.2.1</a>) in the comment that follows the expression:
-
-[<a name="p448" href="#p448">page 448</a>] (<a href="#Contents">Contents</a>)
-
-            iswctype(wc,      wctype("alnum"))              //   iswalnum(wc)
-            iswctype(wc,      wctype("alpha"))              //   iswalpha(wc)
-            iswctype(wc,      wctype("blank"))              //   iswblank(wc)
-            iswctype(wc,      wctype("cntrl"))              //   iswcntrl(wc)
-            iswctype(wc,      wctype("digit"))              //   iswdigit(wc)
-            iswctype(wc,      wctype("graph"))              //   iswgraph(wc)
-            iswctype(wc,      wctype("lower"))              //   iswlower(wc)
-            iswctype(wc,      wctype("print"))              //   iswprint(wc)
-            iswctype(wc,      wctype("punct"))              //   iswpunct(wc)
-            iswctype(wc,      wctype("space"))              //   iswspace(wc)
-            iswctype(wc,      wctype("upper"))              //   iswupper(wc)
-            iswctype(wc,      wctype("xdigit"))             //   iswxdigit(wc)
-<b>    Returns</b>
-4   The iswctype function returns nonzero (true) if and only if the value of the wide
-    character wc has the property described by desc. If desc is zero, the iswctype
-    function returns zero (false).
-    Forward references: the wctype function (<a href="#7.29.2.2.2">7.29.2.2.2</a>).
-<a name="7.29.2.2.2" href="#7.29.2.2.2"><b>    7.29.2.2.2 The wctype function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            wctype_t wctype(const char *property);
-<b>    Description</b>
-2   The wctype function constructs a value with type wctype_t that describes a class of
-    wide characters identified by the string argument property.
-3   The strings listed in the description of the iswctype function shall be valid in all
-    locales as property arguments to the wctype function.
-<b>    Returns</b>
-4   If property identifies a valid class of wide characters according to the LC_CTYPE
-    category of the current locale, the wctype function returns a nonzero value that is valid
-    as the second argument to the iswctype function; otherwise, it returns zero.
-
-[<a name="p449" href="#p449">page 449</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.29.3" href="#7.29.3"><b>    7.29.3 Wide character case mapping utilities</b></a>
-1   The header <a href="#7.29">&lt;wctype.h&gt;</a> declares several functions useful for mapping wide characters.
-<a name="7.29.3.1" href="#7.29.3.1"><b>    7.29.3.1 Wide character case mapping functions</b></a>
-<a name="7.29.3.1.1" href="#7.29.3.1.1"><b>    7.29.3.1.1 The towlower function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
-           wint_t towlower(wint_t wc);
-<b>    Description</b>
-2   The towlower function converts an uppercase letter to a corresponding lowercase letter.
-<b>    Returns</b>
-3   If the argument is a wide character for which iswupper is true and there are one or
-    more corresponding wide characters, as specified by the current locale, for which
-    iswlower is true, the towlower function returns one of the corresponding wide
-    characters (always the same one for any given locale); otherwise, the argument is
-    returned unchanged.
-<a name="7.29.3.1.2" href="#7.29.3.1.2"><b>    7.29.3.1.2 The towupper function</b></a>
-<b>    Synopsis</b>
-1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
-           wint_t towupper(wint_t wc);
-<b>    Description</b>
-2   The towupper function converts a lowercase letter to a corresponding uppercase letter.
-<b>    Returns</b>
-3   If the argument is a wide character for which iswlower is true and there are one or
-    more corresponding wide characters, as specified by the current locale, for which
-    iswupper is true, the towupper function returns one of the corresponding wide
-    characters (always the same one for any given locale); otherwise, the argument is
-    returned unchanged.
-<a name="7.29.3.2" href="#7.29.3.2"><b>    7.29.3.2 Extensible wide character case mapping functions</b></a>
-1   The functions wctrans and towctrans provide extensible wide character mapping as
-    well as case mapping equivalent to that performed by the functions described in the
-    previous subclause (<a href="#7.29.3.1">7.29.3.1</a>).
-
-[<a name="p450" href="#p450">page 450</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.29.3.2.1" href="#7.29.3.2.1"><b>    7.29.3.2.1 The towctrans function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            wint_t towctrans(wint_t wc, wctrans_t desc);
-<b>    Description</b>
-2   The towctrans function maps the wide character wc using the mapping described by
-    desc. The current setting of the LC_CTYPE category shall be the same as during the call
-    to wctrans that returned the value desc.
-3   Each of the following expressions behaves the same as the call to the wide character case
-    mapping function (<a href="#7.29.3.1">7.29.3.1</a>) in the comment that follows the expression:
-            towctrans(wc, wctrans("tolower"))                     // towlower(wc)
-            towctrans(wc, wctrans("toupper"))                     // towupper(wc)
-<b>    Returns</b>
-4   The towctrans function returns the mapped value of wc using the mapping described
-    by desc. If desc is zero, the towctrans function returns the value of wc.
-<a name="7.29.3.2.2" href="#7.29.3.2.2"><b>    7.29.3.2.2 The wctrans function</b></a>
-<b>    Synopsis</b>
-1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
-            wctrans_t wctrans(const char *property);
-<b>    Description</b>
-2   The wctrans function constructs a value with type wctrans_t that describes a
-    mapping between wide characters identified by the string argument property.
-3   The strings listed in the description of the towctrans function shall be valid in all
-    locales as property arguments to the wctrans function.
-<b>    Returns</b>
-4   If property identifies a valid mapping of wide characters according to the LC_CTYPE
-    category of the current locale, the wctrans function returns a nonzero value that is valid
-    as the second argument to the towctrans function; otherwise, it returns zero.
-
-[<a name="p451" href="#p451">page 451</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.30" href="#7.30"><b>    7.30 Future library directions</b></a>
-1   The following names are grouped under individual headers for convenience. All external
-    names described below are reserved no matter what headers are included by the program.
-<a name="7.30.1" href="#7.30.1"><b>    7.30.1 Complex arithmetic &lt;complex.h&gt;</b></a>
-1   The function names
-          cerf               cexpm1              clog2
-          cerfc              clog10              clgamma
-          cexp2              clog1p              ctgamma
-    and the same names suffixed with f or l may be added to the declarations in the
-    <a href="#7.3">&lt;complex.h&gt;</a> header.
-<a name="7.30.2" href="#7.30.2"><b>    7.30.2 Character handling &lt;ctype.h&gt;</b></a>
-1   Function names that begin with either is or to, and a lowercase letter may be added to
-    the declarations in the <a href="#7.4">&lt;ctype.h&gt;</a> header.
-<a name="7.30.3" href="#7.30.3"><b>    7.30.3 Errors &lt;errno.h&gt;</b></a>
-1   Macros that begin with E and a digit or E and an uppercase letter may be added to the
-    declarations in the <a href="#7.5">&lt;errno.h&gt;</a> header.
-<a name="7.30.4" href="#7.30.4"><b>    7.30.4 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
-1   Macro names beginning with PRI or SCN followed by any lowercase letter or X may be
-    added to the macros defined in the <a href="#7.8">&lt;inttypes.h&gt;</a> header.
-<a name="7.30.5" href="#7.30.5"><b>    7.30.5 Localization &lt;locale.h&gt;</b></a>
-1   Macros that begin with LC_ and an uppercase letter may be added to the definitions in
-    the <a href="#7.11">&lt;locale.h&gt;</a> header.
-<a name="7.30.6" href="#7.30.6"><b>    7.30.6 Signal handling &lt;signal.h&gt;</b></a>
-1   Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
-    letter may be added to the definitions in the <a href="#7.14">&lt;signal.h&gt;</a> header.
-<a name="7.30.7" href="#7.30.7"><b>    7.30.7 Boolean type and values &lt;stdbool.h&gt;</b></a>
-1   The ability to undefine and perhaps then redefine the macros bool, true, and false is
-    an obsolescent feature.
-<a name="7.30.8" href="#7.30.8"><b>    7.30.8 Integer types &lt;stdint.h&gt;</b></a>
-1   Typedef names beginning with int or uint and ending with _t may be added to the
-    types defined in the <a href="#7.20">&lt;stdint.h&gt;</a> header. Macro names beginning with INT or UINT
-    and ending with _MAX, _MIN, or _C may be added to the macros defined in the
-    <a href="#7.20">&lt;stdint.h&gt;</a> header.
-
-[<a name="p452" href="#p452">page 452</a>] (<a href="#Contents">Contents</a>)
-
-<a name="7.30.9" href="#7.30.9"><b>    7.30.9 Input/output &lt;stdio.h&gt;</b></a>
-1   Lowercase letters may be added to the conversion specifiers and length modifiers in
-    fprintf and fscanf. Other characters may be used in extensions.
-2   The use of ungetc on a binary stream where the file position indicator is zero prior to *
-    the call is an obsolescent feature.
-<a name="7.30.10" href="#7.30.10"><b>    7.30.10 General utilities &lt;stdlib.h&gt;</b></a>
-1   Function names that begin with str and a lowercase letter may be added to the
-    declarations in the <a href="#7.22">&lt;stdlib.h&gt;</a> header.
-<a name="7.30.11" href="#7.30.11"><b>    7.30.11 String handling &lt;string.h&gt;</b></a>
-1   Function names that begin with str, mem, or wcs and a lowercase letter may be added
-    to the declarations in the <a href="#7.23">&lt;string.h&gt;</a> header.
-<a name="7.30.12" href="#7.30.12"><b>    7.30.12 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
-1   Function names that begin with wcs and a lowercase letter may be added to the
-    declarations in the <a href="#7.28">&lt;wchar.h&gt;</a> header.
-2   Lowercase letters may be added to the conversion specifiers and length modifiers in
-    fwprintf and fwscanf. Other characters may be used in extensions.
-<a name="7.30.13" href="#7.30.13"><b>    7.30.13 Wide character classification and mapping utilities</b></a>
-    <a href="#7.29">&lt;wctype.h&gt;</a>
-1   Function names that begin with is or to and a lowercase letter may be added to the
-    declarations in the <a href="#7.29">&lt;wctype.h&gt;</a> header.
-
-[<a name="p453" href="#p453">page 453</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A" href="#A"><b>                                                 Annex A</b></a>
-                                               (informative)
-                                Language syntax summary
-1   NOTE   The notation is described in <a href="#6.1">6.1</a>.
-
-<a name="A.1" href="#A.1"><b>    A.1 Lexical grammar</b></a>
-<a name="A.1.1" href="#A.1.1"><b>    A.1.1 Lexical elements</b></a>
-    (<a href="#6.4">6.4</a>) token:
-                   keyword
-                   identifier
-                   constant
-                   string-literal
-                   punctuator
-    (<a href="#6.4">6.4</a>) preprocessing-token:
-                  header-name
-                  identifier
-                  pp-number
-                  character-constant
-                  string-literal
-                  punctuator
-                  each non-white-space character that cannot be one of the above
-
-[<a name="p454" href="#p454">page 454</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.1.2" href="#A.1.2"><b>A.1.2 Keywords</b></a>
-(<a href="#6.4.1">6.4.1</a>) keyword: one of
-              alignof                     goto                  union
-              auto                        if                    unsigned
-              break                       inline                void
-              case                        int                   volatile
-              char                        long                  while
-              const                       register              _Alignas
-              continue                    restrict              _Atomic
-              default                     return                _Bool
-              do                          short                 _Complex
-              double                      signed                _Generic
-              else                        sizeof                _Imaginary
-              enum                        static                _Noreturn
-              extern                      struct                _Static_assert
-              float                       switch                _Thread_local
-              for                         typedef
-<a name="A.1.3" href="#A.1.3"><b>A.1.3 Identifiers</b></a>
-(<a href="#6.4.2.1">6.4.2.1</a>) identifier:
-               identifier-nondigit
-               identifier identifier-nondigit
-               identifier digit
-(<a href="#6.4.2.1">6.4.2.1</a>) identifier-nondigit:
-               nondigit
-               universal-character-name
-               other implementation-defined characters
-(<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
-              _ a b          c    d   e    f   g   h    i   j   k   l   m
-                   n o       p    q   r    s   t   u    v   w   x   y   z
-                   A B       C    D   E    F   G   H    I   J   K   L   M
-                   N O       P    Q   R    S   T   U    V   W   X   Y   Z
-(<a href="#6.4.2.1">6.4.2.1</a>) digit: one of
-               0 1 2         3    4   5    6   7   8    9
-
-[<a name="p455" href="#p455">page 455</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.1.4" href="#A.1.4"><b>A.1.4 Universal character names</b></a>
-(<a href="#6.4.3">6.4.3</a>) universal-character-name:
-              \u hex-quad
-              \U hex-quad hex-quad
-(<a href="#6.4.3">6.4.3</a>) hex-quad:
-              hexadecimal-digit hexadecimal-digit
-                           hexadecimal-digit hexadecimal-digit
-<a name="A.1.5" href="#A.1.5"><b>A.1.5 Constants</b></a>
-(<a href="#6.4.4">6.4.4</a>) constant:
-              integer-constant
-              floating-constant
-              enumeration-constant
-              character-constant
-(<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
-               decimal-constant integer-suffixopt
-               octal-constant integer-suffixopt
-               hexadecimal-constant integer-suffixopt
-(<a href="#6.4.4.1">6.4.4.1</a>) decimal-constant:
-              nonzero-digit
-              decimal-constant digit
-(<a href="#6.4.4.1">6.4.4.1</a>) octal-constant:
-               0
-               octal-constant octal-digit
-(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-constant:
-              hexadecimal-prefix hexadecimal-digit
-              hexadecimal-constant hexadecimal-digit
-(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-prefix: one of
-              0x 0X
-(<a href="#6.4.4.1">6.4.4.1</a>) nonzero-digit: one of
-              1 2 3 4 5              6      7   8   9
-(<a href="#6.4.4.1">6.4.4.1</a>) octal-digit: one of
-               0 1 2 3           4   5      6   7
-
-[<a name="p456" href="#p456">page 456</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-digit: one of
-              0 1 2 3 4 5                6    7    8   9
-              a b c d e f
-              A B C D E F
-(<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
-               unsigned-suffix long-suffixopt
-               unsigned-suffix long-long-suffix
-               long-suffix unsigned-suffixopt
-               long-long-suffix unsigned-suffixopt
-(<a href="#6.4.4.1">6.4.4.1</a>) unsigned-suffix: one of
-               u U
-(<a href="#6.4.4.1">6.4.4.1</a>) long-suffix: one of
-               l L
-(<a href="#6.4.4.1">6.4.4.1</a>) long-long-suffix: one of
-               ll LL
-(<a href="#6.4.4.2">6.4.4.2</a>) floating-constant:
-               decimal-floating-constant
-               hexadecimal-floating-constant
-(<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
-              fractional-constant exponent-partopt floating-suffixopt
-              digit-sequence exponent-part floating-suffixopt
-(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
-              hexadecimal-prefix hexadecimal-fractional-constant
-                            binary-exponent-part floating-suffixopt
-              hexadecimal-prefix hexadecimal-digit-sequence
-                            binary-exponent-part floating-suffixopt
-(<a href="#6.4.4.2">6.4.4.2</a>) fractional-constant:
-               digit-sequenceopt . digit-sequence
-               digit-sequence .
-(<a href="#6.4.4.2">6.4.4.2</a>) exponent-part:
-              e signopt digit-sequence
-              E signopt digit-sequence
-(<a href="#6.4.4.2">6.4.4.2</a>) sign: one of
-               + -
-
-[<a name="p457" href="#p457">page 457</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.4.4.2">6.4.4.2</a>) digit-sequence:
-               digit
-               digit-sequence digit
-(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
-              hexadecimal-digit-sequenceopt .
-                             hexadecimal-digit-sequence
-              hexadecimal-digit-sequence .
-(<a href="#6.4.4.2">6.4.4.2</a>) binary-exponent-part:
-               p signopt digit-sequence
-               P signopt digit-sequence
-(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-digit-sequence:
-              hexadecimal-digit
-              hexadecimal-digit-sequence hexadecimal-digit
-(<a href="#6.4.4.2">6.4.4.2</a>) floating-suffix: one of
-               f l F L
-(<a href="#6.4.4.3">6.4.4.3</a>) enumeration-constant:
-              identifier
-(<a href="#6.4.4.4">6.4.4.4</a>) character-constant:
-              ' c-char-sequence '
-              L' c-char-sequence '
-              u' c-char-sequence '
-              U' c-char-sequence '
-(<a href="#6.4.4.4">6.4.4.4</a>) c-char-sequence:
-               c-char
-               c-char-sequence c-char
-(<a href="#6.4.4.4">6.4.4.4</a>) c-char:
-               any member of the source character set except
-                            the single-quote ', backslash \, or new-line character
-               escape-sequence
-(<a href="#6.4.4.4">6.4.4.4</a>) escape-sequence:
-              simple-escape-sequence
-              octal-escape-sequence
-              hexadecimal-escape-sequence
-              universal-character-name
-
-[<a name="p458" href="#p458">page 458</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.4.4.4">6.4.4.4</a>) simple-escape-sequence: one of
-              \' \" \? \\
-              \a \b \f \n \r \t                   \v
-(<a href="#6.4.4.4">6.4.4.4</a>) octal-escape-sequence:
-               \ octal-digit
-               \ octal-digit octal-digit
-               \ octal-digit octal-digit octal-digit
-(<a href="#6.4.4.4">6.4.4.4</a>) hexadecimal-escape-sequence:
-              \x hexadecimal-digit
-              hexadecimal-escape-sequence hexadecimal-digit
-<a name="A.1.6" href="#A.1.6"><b>A.1.6 String literals</b></a>
-(<a href="#6.4.5">6.4.5</a>) string-literal:
-               encoding-prefixopt " s-char-sequenceopt "
-(<a href="#6.4.5">6.4.5</a>) encoding-prefix:
-              u8
-              u
-              U
-              L
-(<a href="#6.4.5">6.4.5</a>) s-char-sequence:
-               s-char
-               s-char-sequence s-char
-(<a href="#6.4.5">6.4.5</a>) s-char:
-               any member of the source character set except
-                            the double-quote ", backslash \, or new-line character
-               escape-sequence
-<a name="A.1.7" href="#A.1.7"><b>A.1.7 Punctuators</b></a>
-(<a href="#6.4.6">6.4.6</a>) punctuator: one of
-              [ ] ( ) { } . -&gt;
-              ++ -- &amp; * + - ~ !
-              / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                      ==    !=    ^    |   &amp;&amp;   ||
-              ? : ; ...
-              = *= /= %= += -= &lt;&lt;=                     &gt;&gt;=    &amp;=       ^=   |=
-              , # ##
-              &lt;: :&gt; &lt;% %&gt; %: %:%:
-
-[<a name="p459" href="#p459">page 459</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.1.8" href="#A.1.8"><b>A.1.8 Header names</b></a>
-(<a href="#6.4.7">6.4.7</a>) header-name:
-              &lt; h-char-sequence &gt;
-              " q-char-sequence "
-(<a href="#6.4.7">6.4.7</a>) h-char-sequence:
-              h-char
-              h-char-sequence h-char
-(<a href="#6.4.7">6.4.7</a>) h-char:
-              any member of the source character set except
-                           the new-line character and &gt;
-(<a href="#6.4.7">6.4.7</a>) q-char-sequence:
-              q-char
-              q-char-sequence q-char
-(<a href="#6.4.7">6.4.7</a>) q-char:
-              any member of the source character set except
-                           the new-line character and "
-<a name="A.1.9" href="#A.1.9"><b>A.1.9 Preprocessing numbers</b></a>
-(<a href="#6.4.8">6.4.8</a>) pp-number:
-              digit
-              . digit
-              pp-number   digit
-              pp-number   identifier-nondigit
-              pp-number   e sign
-              pp-number   E sign
-              pp-number   p sign
-              pp-number   P sign
-              pp-number   .
-
-[<a name="p460" href="#p460">page 460</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.2" href="#A.2"><b>A.2 Phrase structure grammar</b></a>
-<a name="A.2.1" href="#A.2.1"><b>A.2.1 Expressions</b></a>
-(<a href="#6.5.1">6.5.1</a>) primary-expression:
-              identifier
-              constant
-              string-literal
-              ( expression )
-              generic-selection
-(<a href="#6.5.1.1">6.5.1.1</a>) generic-selection:
-              _Generic ( assignment-expression , generic-assoc-list )
-(<a href="#6.5.1.1">6.5.1.1</a>) generic-assoc-list:
-              generic-association
-              generic-assoc-list , generic-association
-(<a href="#6.5.1.1">6.5.1.1</a>) generic-association:
-              type-name : assignment-expression
-              default : assignment-expression
-(<a href="#6.5.2">6.5.2</a>) postfix-expression:
-              primary-expression
-              postfix-expression [ expression ]
-              postfix-expression ( argument-expression-listopt )
-              postfix-expression . identifier
-              postfix-expression -&gt; identifier
-              postfix-expression ++
-              postfix-expression --
-              ( type-name ) { initializer-list }
-              ( type-name ) { initializer-list , }
-(<a href="#6.5.2">6.5.2</a>) argument-expression-list:
-             assignment-expression
-             argument-expression-list , assignment-expression
-(<a href="#6.5.3">6.5.3</a>) unary-expression:
-              postfix-expression
-              ++ unary-expression
-              -- unary-expression
-              unary-operator cast-expression
-              sizeof unary-expression
-              sizeof ( type-name )
-              alignof ( type-name )
-
-[<a name="p461" href="#p461">page 461</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.5.3">6.5.3</a>) unary-operator: one of
-              &amp; * + - ~                !
-(<a href="#6.5.4">6.5.4</a>) cast-expression:
-               unary-expression
-               ( type-name ) cast-expression
-(<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
-               cast-expression
-               multiplicative-expression * cast-expression
-               multiplicative-expression / cast-expression
-               multiplicative-expression % cast-expression
-(<a href="#6.5.6">6.5.6</a>) additive-expression:
-               multiplicative-expression
-               additive-expression + multiplicative-expression
-               additive-expression - multiplicative-expression
-(<a href="#6.5.7">6.5.7</a>) shift-expression:
-                additive-expression
-                shift-expression &lt;&lt; additive-expression
-                shift-expression &gt;&gt; additive-expression
-(<a href="#6.5.8">6.5.8</a>) relational-expression:
-               shift-expression
-               relational-expression   &lt;    shift-expression
-               relational-expression   &gt;    shift-expression
-               relational-expression   &lt;=   shift-expression
-               relational-expression   &gt;=   shift-expression
-(<a href="#6.5.9">6.5.9</a>) equality-expression:
-               relational-expression
-               equality-expression == relational-expression
-               equality-expression != relational-expression
-(<a href="#6.5.10">6.5.10</a>) AND-expression:
-             equality-expression
-             AND-expression &amp; equality-expression
-(<a href="#6.5.11">6.5.11</a>) exclusive-OR-expression:
-              AND-expression
-              exclusive-OR-expression ^ AND-expression
-
-[<a name="p462" href="#p462">page 462</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.5.12">6.5.12</a>) inclusive-OR-expression:
-               exclusive-OR-expression
-               inclusive-OR-expression | exclusive-OR-expression
-(<a href="#6.5.13">6.5.13</a>) logical-AND-expression:
-              inclusive-OR-expression
-              logical-AND-expression &amp;&amp; inclusive-OR-expression
-(<a href="#6.5.14">6.5.14</a>) logical-OR-expression:
-              logical-AND-expression
-              logical-OR-expression || logical-AND-expression
-(<a href="#6.5.15">6.5.15</a>) conditional-expression:
-              logical-OR-expression
-              logical-OR-expression ? expression : conditional-expression
-(<a href="#6.5.16">6.5.16</a>) assignment-expression:
-              conditional-expression
-              unary-expression assignment-operator assignment-expression
-(<a href="#6.5.16">6.5.16</a>) assignment-operator: one of
-              = *= /= %= +=                -=    &lt;&lt;=    &gt;&gt;=      &amp;=    ^=   |=
-(<a href="#6.5.17">6.5.17</a>) expression:
-              assignment-expression
-              expression , assignment-expression
-(<a href="#6.6">6.6</a>) constant-expression:
-              conditional-expression
-<a name="A.2.2" href="#A.2.2"><b>A.2.2 Declarations</b></a>
-(<a href="#6.7">6.7</a>) declaration:
-               declaration-specifiers init-declarator-listopt ;
-               static_assert-declaration
-(<a href="#6.7">6.7</a>) declaration-specifiers:
-               storage-class-specifier declaration-specifiersopt
-               type-specifier declaration-specifiersopt
-               type-qualifier declaration-specifiersopt
-               function-specifier declaration-specifiersopt
-               alignment-specifier declaration-specifiersopt
-(<a href="#6.7">6.7</a>) init-declarator-list:
-               init-declarator
-               init-declarator-list , init-declarator
-
-[<a name="p463" href="#p463">page 463</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7">6.7</a>) init-declarator:
-               declarator
-               declarator = initializer
-(<a href="#6.7.1">6.7.1</a>) storage-class-specifier:
-              typedef
-              extern
-              static
-              _Thread_local
-              auto
-              register
-(<a href="#6.7.2">6.7.2</a>) type-specifier:
-               void
-               char
-               short
-               int
-               long
-               float
-               double
-               signed
-               unsigned
-               _Bool
-               _Complex
-               atomic-type-specifier
-               struct-or-union-specifier
-               enum-specifier
-               typedef-name
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
-               struct-or-union identifieropt { struct-declaration-list }
-               struct-or-union identifier
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union:
-               struct
-               union
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration-list:
-               struct-declaration
-               struct-declaration-list struct-declaration
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration:
-               specifier-qualifier-list struct-declarator-listopt ;
-               static_assert-declaration
-
-[<a name="p464" href="#p464">page 464</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
-               type-specifier specifier-qualifier-listopt
-               type-qualifier specifier-qualifier-listopt
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator-list:
-               struct-declarator
-               struct-declarator-list , struct-declarator
-(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator:
-               declarator
-               declaratoropt : constant-expression
-(<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
-              enum identifieropt { enumerator-list }
-              enum identifieropt { enumerator-list , }
-              enum identifier
-(<a href="#6.7.2.2">6.7.2.2</a>) enumerator-list:
-              enumerator
-              enumerator-list , enumerator
-(<a href="#6.7.2.2">6.7.2.2</a>) enumerator:
-              enumeration-constant
-              enumeration-constant = constant-expression
-(<a href="#6.7.2.4">6.7.2.4</a>) atomic-type-specifier:
-              _Atomic ( type-name )
-(<a href="#6.7.3">6.7.3</a>) type-qualifier:
-              const
-              restrict
-              volatile
-              _Atomic
-(<a href="#6.7.4">6.7.4</a>) function-specifier:
-               inline
-               _Noreturn
-(<a href="#6.7.5">6.7.5</a>) alignment-specifier:
-              _Alignas ( type-name )
-              _Alignas ( constant-expression )
-(<a href="#6.7.6">6.7.6</a>) declarator:
-              pointeropt direct-declarator
-
-[<a name="p465" href="#p465">page 465</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7.6">6.7.6</a>) direct-declarator:
-               identifier
-               ( declarator )
-               direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
-               direct-declarator [ static type-qualifier-listopt assignment-expression ]
-               direct-declarator [ type-qualifier-list static assignment-expression ]
-               direct-declarator [ type-qualifier-listopt * ]
-               direct-declarator ( parameter-type-list )
-               direct-declarator ( identifier-listopt )
-(<a href="#6.7.6">6.7.6</a>) pointer:
-               * type-qualifier-listopt
-               * type-qualifier-listopt pointer
-(<a href="#6.7.6">6.7.6</a>) type-qualifier-list:
-              type-qualifier
-              type-qualifier-list type-qualifier
-(<a href="#6.7.6">6.7.6</a>) parameter-type-list:
-             parameter-list
-             parameter-list , ...
-(<a href="#6.7.6">6.7.6</a>) parameter-list:
-             parameter-declaration
-             parameter-list , parameter-declaration
-(<a href="#6.7.6">6.7.6</a>) parameter-declaration:
-             declaration-specifiers declarator
-             declaration-specifiers abstract-declaratoropt
-(<a href="#6.7.6">6.7.6</a>) identifier-list:
-               identifier
-               identifier-list , identifier
-(<a href="#6.7.7">6.7.7</a>) type-name:
-              specifier-qualifier-list abstract-declaratoropt
-(<a href="#6.7.7">6.7.7</a>) abstract-declarator:
-              pointer
-              pointeropt direct-abstract-declarator
-
-[<a name="p466" href="#p466">page 466</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.7.7">6.7.7</a>) direct-abstract-declarator:
-               ( abstract-declarator )
-               direct-abstract-declaratoropt [ type-qualifier-listopt
-                              assignment-expressionopt ]
-               direct-abstract-declaratoropt [ static type-qualifier-listopt
-                              assignment-expression ]
-               direct-abstract-declaratoropt [ type-qualifier-list static
-                              assignment-expression ]
-               direct-abstract-declaratoropt [ * ]
-               direct-abstract-declaratoropt ( parameter-type-listopt )
-(<a href="#6.7.8">6.7.8</a>) typedef-name:
-              identifier
-(<a href="#6.7.9">6.7.9</a>) initializer:
-                assignment-expression
-                { initializer-list }
-                { initializer-list , }
-(<a href="#6.7.9">6.7.9</a>) initializer-list:
-                designationopt initializer
-                initializer-list , designationopt initializer
-(<a href="#6.7.9">6.7.9</a>) designation:
-              designator-list =
-(<a href="#6.7.9">6.7.9</a>) designator-list:
-              designator
-              designator-list designator
-(<a href="#6.7.9">6.7.9</a>) designator:
-              [ constant-expression ]
-              . identifier
-(<a href="#6.7.10">6.7.10</a>) static_assert-declaration:
-               _Static_assert ( constant-expression , string-literal ) ;
-
-[<a name="p467" href="#p467">page 467</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.2.3" href="#A.2.3"><b>A.2.3 Statements</b></a>
-(<a href="#6.8">6.8</a>) statement:
-              labeled-statement
-              compound-statement
-              expression-statement
-              selection-statement
-              iteration-statement
-              jump-statement
-(<a href="#6.8.1">6.8.1</a>) labeled-statement:
-               identifier : statement
-               case constant-expression : statement
-               default : statement
-(<a href="#6.8.2">6.8.2</a>) compound-statement:
-             { block-item-listopt }
-(<a href="#6.8.2">6.8.2</a>) block-item-list:
-               block-item
-               block-item-list block-item
-(<a href="#6.8.2">6.8.2</a>) block-item:
-               declaration
-               statement
-(<a href="#6.8.3">6.8.3</a>) expression-statement:
-              expressionopt ;
-(<a href="#6.8.4">6.8.4</a>) selection-statement:
-               if ( expression ) statement
-               if ( expression ) statement else statement
-               switch ( expression ) statement
-(<a href="#6.8.5">6.8.5</a>) iteration-statement:
-                while ( expression ) statement
-                do statement while ( expression ) ;
-                for ( expressionopt ; expressionopt ; expressionopt ) statement
-                for ( declaration expressionopt ; expressionopt ) statement
-(<a href="#6.8.6">6.8.6</a>) jump-statement:
-              goto identifier ;
-              continue ;
-              break ;
-              return expressionopt ;
-
-[<a name="p468" href="#p468">page 468</a>] (<a href="#Contents">Contents</a>)
-
-<a name="A.2.4" href="#A.2.4"><b>A.2.4 External definitions</b></a>
-(<a href="#6.9">6.9</a>) translation-unit:
-               external-declaration
-               translation-unit external-declaration
-(<a href="#6.9">6.9</a>) external-declaration:
-               function-definition
-               declaration
-(<a href="#6.9.1">6.9.1</a>) function-definition:
-               declaration-specifiers declarator declaration-listopt compound-statement
-(<a href="#6.9.1">6.9.1</a>) declaration-list:
-              declaration
-              declaration-list declaration
-<a name="A.3" href="#A.3"><b>A.3 Preprocessing directives</b></a>
-(<a href="#6.10">6.10</a>) preprocessing-file:
-              groupopt
-(<a href="#6.10">6.10</a>) group:
-                group-part
-                group group-part
-(<a href="#6.10">6.10</a>) group-part:
-              if-section
-              control-line
-              text-line
-              # non-directive
-(<a href="#6.10">6.10</a>) if-section:
-                if-group elif-groupsopt else-groupopt endif-line
-(<a href="#6.10">6.10</a>) if-group:
-               # if     constant-expression new-line groupopt
-               # ifdef identifier new-line groupopt
-               # ifndef identifier new-line groupopt
-(<a href="#6.10">6.10</a>) elif-groups:
-               elif-group
-               elif-groups elif-group
-(<a href="#6.10">6.10</a>) elif-group:
-               # elif       constant-expression new-line groupopt
-
-[<a name="p469" href="#p469">page 469</a>] (<a href="#Contents">Contents</a>)
-
-(<a href="#6.10">6.10</a>) else-group:
-               # else        new-line groupopt
-(<a href="#6.10">6.10</a>) endif-line:
-               # endif       new-line
-(<a href="#6.10">6.10</a>) control-line:
-              # include pp-tokens new-line
-              # define identifier replacement-list new-line
-              # define identifier lparen identifier-listopt )
-                                              replacement-list new-line
-              # define identifier lparen ... ) replacement-list new-line
-              # define identifier lparen identifier-list , ... )
-                                              replacement-list new-line
-              # undef   identifier new-line
-              # line    pp-tokens new-line
-              # error   pp-tokensopt new-line
-              # pragma pp-tokensopt new-line
-              #         new-line
-(<a href="#6.10">6.10</a>) text-line:
-               pp-tokensopt new-line
-(<a href="#6.10">6.10</a>) non-directive:
-              pp-tokens new-line
-(<a href="#6.10">6.10</a>) lparen:
-                 a ( character not immediately preceded by white-space
-(<a href="#6.10">6.10</a>) replacement-list:
-              pp-tokensopt
-(<a href="#6.10">6.10</a>) pp-tokens:
-              preprocessing-token
-              pp-tokens preprocessing-token
-(<a href="#6.10">6.10</a>) new-line:
-              the new-line character
-
-[<a name="p470" href="#p470">page 470</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B" href="#B"><b>                               Annex B</b></a>
-                             (informative)
-                         Library summary
-<a name="B.1" href="#B.1"><b>B.1 Diagnostics &lt;assert.h&gt;</b></a>
-        NDEBUG
-        static_assert
-        void assert(scalar expression);
-<a name="B.2" href="#B.2"><b>B.2 Complex &lt;complex.h&gt;</b></a>
-        __STDC_NO_COMPLEX__           imaginary
-        complex                         _Imaginary_I
-        _Complex_I                      I
-        #pragma STDC CX_LIMITED_RANGE on-off-switch
-        double complex cacos(double complex z);
-        float complex cacosf(float complex z);
-        long double complex cacosl(long double complex z);
-        double complex casin(double complex z);
-        float complex casinf(float complex z);
-        long double complex casinl(long double complex z);
+            i = atoi(str);</pre>
+<li>  by use of its associated header (assuredly generating a true function reference)
+ 
+ 
+ 
+ 
+<!--page 202 indent 0-->
+<pre>
+           #include &lt;stdlib.h&gt;
+           #undef atoi
+           const char *str;
+           /* ... */
+           i = atoi(str);</pre>
+  or
+<pre>
+           #include &lt;stdlib.h&gt;
+           const char *str;
+           /* ... */
+           i = (atoi)(str);</pre>
+<li>  by explicit declaration
+<!--page 203 indent 4-->
+<pre>
+           extern int atoi(const char *);
+           const char *str;
+           /* ... */
+           i = atoi(str);</pre>
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note185">185)</a> This means that an implementation shall provide an actual function for each library function, even if it
+ also provides a macro for that function.
+
+<p><a name="note186">186)</a> Such macros might not contain the sequence points that the corresponding function calls do.
+
+<p><a name="note187">187)</a> Because external identifiers and some macro names beginning with an underscore are reserved,
+ implementations may provide special semantics for such names. For example, the identifier
+ _BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
+ appropriate header could specify
+
+<pre>
+           #define abs(x) _BUILTIN_abs(x)</pre>
+  for a compiler whose code generator will accept it.
+  In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
+  function may write
+
+<pre>
+           #undef abs</pre>
+  whether the implementation's header provides a macro implementation of abs or a built-in
+  implementation. The prototype for the function, which precedes and is hidden by any macro
+  definition, is thereby revealed also.
+
+<p><a name="note188">188)</a> Thus, a signal handler cannot, in general, call standard library functions.
+
+<p><a name="note189">189)</a> This means, for example, that an implementation is not permitted to use a static object for internal
+ purposes without synchronization because it could cause a data race even in programs that do not
+ explicitly share objects between threads.
+
+<p><a name="note190">190)</a> This allows implementations to parallelize operations if there are no visible side effects.
+
+
+<a name="7.2" href="#7.2"><h3>7.2 Diagnostics <assert.h></h3></a>
+<p><!--para 1-->
+ The header &lt;assert.h&gt; defines the assert and static_assert macros and
+ refers to another macro,
+<pre>
+         NDEBUG</pre>
+ which is not defined by &lt;assert.h&gt;. If NDEBUG is defined as a macro name at the
+ point in the source file where &lt;assert.h&gt; is included, the assert macro is defined
+ simply as
+<pre>
+         #define assert(ignore) ((void)0)</pre>
+ The assert macro is redefined according to the current state of NDEBUG each time that
+ &lt;assert.h&gt; is included.
+<p><!--para 2-->
+ The assert macro shall be implemented as a macro, not as an actual function. If the
+ macro definition is suppressed in order to access an actual function, the behavior is
+ undefined.
+<p><!--para 3-->
+ The macro
+<pre>
+         static_assert</pre>
+ expands to _Static_assert.
+
+<a name="7.2.1" href="#7.2.1"><h4>7.2.1 Program diagnostics</h4></a>
+
+<a name="7.2.1.1" href="#7.2.1.1"><h5>7.2.1.1 The assert macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;assert.h&gt;
+         void assert(scalar expression);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The assert macro puts diagnostic tests into programs; it expands to a void expression.
+ When it is executed, if expression (which shall have a scalar type) is false (that is,
+ compares equal to 0), the assert macro writes information about the particular call that
+ failed (including the text of the argument, the name of the source file, the source line
+ number, and the name of the enclosing function -- the latter are respectively the values of
+ the preprocessing macros __FILE__ and __LINE__ and of the identifier
+ __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note191"><b>191)</b></a></sup> It
+ then calls the abort function.
+ 
+ 
+ 
+<!--page 204 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The assert macro returns no value.
+ Forward references: the abort function (<a href="#7.22.4.1">7.22.4.1</a>).
+<!--page 205 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note191">191)</a> The message written might be of the form:
+ Assertion failed: expression, function abc, file xyz, line nnn.
+
+
+<a name="7.3" href="#7.3"><h3>7.3 Complex arithmetic <complex.h></h3></a>
+
+<a name="7.3.1" href="#7.3.1"><h4>7.3.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;complex.h&gt; defines macros and declares functions that support complex
+ arithmetic.<sup><a href="#note192"><b>192)</b></a></sup>
+<p><!--para 2-->
+ Implementations that define the macro __STDC_NO_COMPLEX__ need not provide
+ this header nor support any of its facilities.
+<p><!--para 3-->
+ Each synopsis specifies a family of functions consisting of a principal function with one
+ or more double complex parameters and a double complex or double return
+ value; and other functions with the same name but with f and l suffixes which are
+ corresponding functions with float and long double parameters and return values.
+<p><!--para 4-->
+ The macro
+<pre>
+          complex</pre>
+ expands to _Complex; the macro
+<pre>
+          _Complex_I</pre>
+ expands to a constant expression of type const float _Complex, with the value of
+ the imaginary unit.<sup><a href="#note193"><b>193)</b></a></sup>
+<p><!--para 5-->
+ The macros
+<pre>
+          imaginary</pre>
+ and
+<pre>
+          _Imaginary_I</pre>
+ are defined if and only if the implementation supports imaginary types;<sup><a href="#note194"><b>194)</b></a></sup> if defined,
+ they expand to _Imaginary and a constant expression of type const float
+ _Imaginary with the value of the imaginary unit.
+<p><!--para 6-->
+ The macro
+<pre>
+          I</pre>
+ expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
+ defined, I shall expand to _Complex_I.
+<p><!--para 7-->
+ Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+ redefine the macros complex, imaginary, and I.
+ 
+<!--page 206 indent 4-->
+ Forward references: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
+
+<h6>footnotes</h6>
+<p><a name="note192">192)</a> See ''future library directions'' (<a href="#7.30.1">7.30.1</a>).
+
+<p><a name="note193">193)</a> The imaginary unit is a number i such that i 2 = -1.
+
+<p><a name="note194">194)</a> A specification for imaginary types is in informative <a href="#G">annex G</a>.
+
+
+<a name="7.3.2" href="#7.3.2"><h4>7.3.2 Conventions</h4></a>
+<p><!--para 1-->
+ Values are interpreted as radians, not degrees. An implementation may set errno but is
+ not required to.
+
+<a name="7.3.3" href="#7.3.3"><h4>7.3.3 Branch cuts</h4></a>
+<p><!--para 1-->
+ Some of the functions below have branch cuts, across which the function is
+ discontinuous. For implementations with a signed zero (including all IEC 60559
+ implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
+ one side of a cut from another so the function is continuous (except for format
+ limitations) as the cut is approached from either side. For example, for the square root
+ function, which has a branch cut along the negative real axis, the top of the cut, with
+ imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
+ imaginary part -0, maps to the negative imaginary axis.
+<p><!--para 2-->
+ Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
+ sides of branch cuts. These implementations shall map a cut so the function is continuous
+ as the cut is approached coming around the finite endpoint of the cut in a counter
+ clockwise direction. (Branch cuts for the functions specified here have just one finite
+ endpoint.) For example, for the square root function, coming counter clockwise around
+ the finite endpoint of the cut along the negative real axis approaches the cut from above,
+ so the cut maps to the positive imaginary axis.
+
+<a name="7.3.4" href="#7.3.4"><h4>7.3.4 The CX_LIMITED_RANGE pragma</h4></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        #pragma STDC CX_LIMITED_RANGE on-off-switch</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The usual mathematical formulas for complex multiply, divide, and absolute value are
+ problematic because of their treatment of infinities and because of undue overflow and
+ underflow. The CX_LIMITED_RANGE pragma can be used to inform the
+ implementation that (where the state is ''on'') the usual mathematical formulas are
+ acceptable.<sup><a href="#note195"><b>195)</b></a></sup> The pragma can occur either outside external declarations or preceding all
+ explicit declarations and statements inside a compound statement. When outside external
+ declarations, the pragma takes effect from its occurrence until another
+ CX_LIMITED_RANGE pragma is encountered, or until the end of the translation unit.
+ When inside a compound statement, the pragma takes effect from its occurrence until
+ another CX_LIMITED_RANGE pragma is encountered (including within a nested
+ compound statement), or until the end of the compound statement; at the end of a
+ compound statement the state for the pragma is restored to its condition just before the
+<!--page 207 indent 4-->
+ compound statement. If this pragma is used in any other context, the behavior is
+ undefined. The default state for the pragma is ''off''.
+
+<h6>footnotes</h6>
+<p><a name="note195">195)</a> The purpose of the pragma is to allow the implementation to use the formulas:
+
+<pre>
+    (x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
+    (x + iy) / (u + iv) = [(xu + yv) + i(yu - xv)]/(u2 + v 2 )
+    | x + iy | = (sqrt) x 2 + y 2
+                 -----</pre>
+ where the programmer can determine they are safe.
+
+
+<a name="7.3.5" href="#7.3.5"><h4>7.3.5 Trigonometric functions</h4></a>
+
+<a name="7.3.5.1" href="#7.3.5.1"><h5>7.3.5.1 The cacos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex cacos(double complex z);
+         float complex cacosf(float complex z);
+         long double complex cacosl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cacos functions compute the complex arc cosine of z, with branch cuts outside the
+ interval [-1, +1] along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cacos functions return the complex arc cosine value, in the range of a strip
+ mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
+ real axis.
+
+<a name="7.3.5.2" href="#7.3.5.2"><h5>7.3.5.2 The casin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex casin(double complex z);
+         float complex casinf(float complex z);
+         long double complex casinl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The casin functions compute the complex arc sine of z, with branch cuts outside the
+ interval [-1, +1] along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The casin functions return the complex arc sine value, in the range of a strip
+ mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+ 
+<!--page 208 indent 4-->
+ along the real axis.
+
+<a name="7.3.5.3" href="#7.3.5.3"><h5>7.3.5.3 The catan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
         double complex catan(double complex z);
         float complex catanf(float complex z);
-        long double complex catanl(long double complex z);
+        long double complex catanl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The catan functions compute the complex arc tangent of z, with branch cuts outside the
+ interval [-i, +i] along the imaginary axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The catan functions return the complex arc tangent value, in the range of a strip
+ mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+ along the real axis.
+
+<a name="7.3.5.4" href="#7.3.5.4"><h5>7.3.5.4 The ccos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
         double complex ccos(double complex z);
         float complex ccosf(float complex z);
-        long double complex ccosl(long double complex z);
+        long double complex ccosl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ccos functions compute the complex cosine of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ccos functions return the complex cosine value.
+
+<a name="7.3.5.5" href="#7.3.5.5"><h5>7.3.5.5 The csin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
         double complex csin(double complex z);
         float complex csinf(float complex z);
-        long double complex csinl(long double complex z);
-        double complex ctan(double complex z);
-        float complex ctanf(float complex z);
-        long double complex ctanl(long double complex z);
-        double complex cacosh(double complex z);
-        float complex cacoshf(float complex z);
-        long double complex cacoshl(long double complex z);
-        double complex casinh(double complex z);
-        float complex casinhf(float complex z);
-        long double complex casinhl(long double complex z);
-
-[<a name="p471" href="#p471">page 471</a>] (<a href="#Contents">Contents</a>)
-
-      double complex catanh(double complex z);
-      float complex catanhf(float complex z);
-      long double complex catanhl(long double complex z);
-      double complex ccosh(double complex z);
-      float complex ccoshf(float complex z);
-      long double complex ccoshl(long double complex z);
-      double complex csinh(double complex z);
-      float complex csinhf(float complex z);
-      long double complex csinhl(long double complex z);
-      double complex ctanh(double complex z);
-      float complex ctanhf(float complex z);
-      long double complex ctanhl(long double complex z);
-      double complex cexp(double complex z);
-      float complex cexpf(float complex z);
-      long double complex cexpl(long double complex z);
-      double complex clog(double complex z);
-      float complex clogf(float complex z);
-      long double complex clogl(long double complex z);
-      double cabs(double complex z);
-      float cabsf(float complex z);
-      long double cabsl(long double complex z);
-      double complex cpow(double complex x, double complex y);
-      float complex cpowf(float complex x, float complex y);
-      long double complex cpowl(long double complex x,
-           long double complex y);
-      double complex csqrt(double complex z);
-      float complex csqrtf(float complex z);
-      long double complex csqrtl(long double complex z);
-      double carg(double complex z);
-      float cargf(float complex z);
-      long double cargl(long double complex z);
-      double cimag(double complex z);
-      float cimagf(float complex z);
-      long double cimagl(long double complex z);
-      double complex CMPLX(double x, double y);
-      float complex CMPLXF(float x, float y);
-      long double complex CMPLXL(long double x, long double y);
-      double complex conj(double complex z);
-      float complex conjf(float complex z);
-      long double complex conjl(long double complex z);
-      double complex cproj(double complex z);
-
-[<a name="p472" href="#p472">page 472</a>] (<a href="#Contents">Contents</a>)
-
-        float complex cprojf(float complex z);
-        long double complex cprojl(long double complex z);
-        double creal(double complex z);
-        float crealf(float complex z);
-        long double creall(long double complex z);
-<a name="B.3" href="#B.3"><b>B.3 Character handling &lt;ctype.h&gt;</b></a>
-        int   isalnum(int c);
-        int   isalpha(int c);
-        int   isblank(int c);
-        int   iscntrl(int c);
-        int   isdigit(int c);
-        int   isgraph(int c);
-        int   islower(int c);
-        int   isprint(int c);
-        int   ispunct(int c);
-        int   isspace(int c);
-        int   isupper(int c);
-        int   isxdigit(int c);
-        int   tolower(int c);
-        int   toupper(int c);
-<a name="B.4" href="#B.4"><b>B.4 Errors &lt;errno.h&gt;</b></a>
-        EDOM           EILSEQ            ERANGE           errno
-        __STDC_WANT_LIB_EXT1__
-        errno_t
-<a name="B.5" href="#B.5"><b>B.5 Floating-point environment &lt;fenv.h&gt;</b></a>
-        fenv_t               FE_OVERFLOW             FE_TOWARDZERO
-        fexcept_t            FE_UNDERFLOW            FE_UPWARD
-        FE_DIVBYZERO         FE_ALL_EXCEPT           FE_DFL_ENV
-        FE_INEXACT           FE_DOWNWARD
-        FE_INVALID           FE_TONEAREST
-        #pragma STDC FENV_ACCESS on-off-switch
-        int feclearexcept(int excepts);
-        int fegetexceptflag(fexcept_t *flagp, int excepts);
-        int feraiseexcept(int excepts);
-        int fesetexceptflag(const fexcept_t *flagp,
-             int excepts);
-        int fetestexcept(int excepts);
-
-[<a name="p473" href="#p473">page 473</a>] (<a href="#Contents">Contents</a>)
-
-      int   fegetround(void);
-      int   fesetround(int round);
-      int   fegetenv(fenv_t *envp);
-      int   feholdexcept(fenv_t *envp);
-      int   fesetenv(const fenv_t *envp);
-      int   feupdateenv(const fenv_t *envp);
-<a name="B.6" href="#B.6"><b>B.6 Characteristics of floating types &lt;float.h&gt;</b></a>
-      FLT_ROUNDS              DBL_DIG                 FLT_MAX
-      FLT_EVAL_METHOD         LDBL_DIG                DBL_MAX
-      FLT_HAS_SUBNORM         FLT_MIN_EXP             LDBL_MAX
-      DBL_HAS_SUBNORM         DBL_MIN_EXP             FLT_EPSILON
-      LDBL_HAS_SUBNORM        LDBL_MIN_EXP            DBL_EPSILON
-      FLT_RADIX               FLT_MIN_10_EXP          LDBL_EPSILON
-      FLT_MANT_DIG            DBL_MIN_10_EXP          FLT_MIN
-      DBL_MANT_DIG            LDBL_MIN_10_EXP         DBL_MIN
-      LDBL_MANT_DIG           FLT_MAX_EXP             LDBL_MIN
-      FLT_DECIMAL_DIG         DBL_MAX_EXP             FLT_TRUE_MIN
-      DBL_DECIMAL_DIG         LDBL_MAX_EXP            DBL_TRUE_MIN
-      LDBL_DECIMAL_DIG        FLT_MAX_10_EXP          LDBL_TRUE_MIN
-      DECIMAL_DIG             DBL_MAX_10_EXP
-      FLT_DIG                 LDBL_MAX_10_EXP
-<a name="B.7" href="#B.7"><b>B.7 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
-      imaxdiv_t
-      PRIdN         PRIdLEASTN       PRIdFASTN        PRIdMAX    PRIdPTR
-      PRIiN         PRIiLEASTN       PRIiFASTN        PRIiMAX    PRIiPTR
-      PRIoN         PRIoLEASTN       PRIoFASTN        PRIoMAX    PRIoPTR
-      PRIuN         PRIuLEASTN       PRIuFASTN        PRIuMAX    PRIuPTR
-      PRIxN         PRIxLEASTN       PRIxFASTN        PRIxMAX    PRIxPTR
-      PRIXN         PRIXLEASTN       PRIXFASTN        PRIXMAX    PRIXPTR
-      SCNdN         SCNdLEASTN       SCNdFASTN        SCNdMAX    SCNdPTR
-      SCNiN         SCNiLEASTN       SCNiFASTN        SCNiMAX    SCNiPTR
-      SCNoN         SCNoLEASTN       SCNoFASTN        SCNoMAX    SCNoPTR
-      SCNuN         SCNuLEASTN       SCNuFASTN        SCNuMAX    SCNuPTR
-      SCNxN         SCNxLEASTN       SCNxFASTN        SCNxMAX    SCNxPTR
-      intmax_t imaxabs(intmax_t j);
-      imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
-      intmax_t strtoimax(const char * restrict nptr,
-              char ** restrict endptr, int base);
-
-[<a name="p474" href="#p474">page 474</a>] (<a href="#Contents">Contents</a>)
-
+        long double complex csinl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The csin functions compute the complex sine of z.
+<!--page 209 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The csin functions return the complex sine value.
+
+<a name="7.3.5.6" href="#7.3.5.6"><h5>7.3.5.6 The ctan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex ctan(double complex z);
+         float complex ctanf(float complex z);
+         long double complex ctanl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ctan functions compute the complex tangent of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ctan functions return the complex tangent value.
+
+<a name="7.3.6" href="#7.3.6"><h4>7.3.6 Hyperbolic functions</h4></a>
+
+<a name="7.3.6.1" href="#7.3.6.1"><h5>7.3.6.1 The cacosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex cacosh(double complex z);
+         float complex cacoshf(float complex z);
+         long double complex cacoshl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
+ cut at values less than 1 along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
+ half-strip of nonnegative values along the real axis and in the interval [-ipi , +ipi ] along the
+ imaginary axis.
+
+<a name="7.3.6.2" href="#7.3.6.2"><h5>7.3.6.2 The casinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 210 indent 4-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex casinh(double complex z);
+         float complex casinhf(float complex z);
+         long double complex casinhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
+ outside the interval [-i, +i] along the imaginary axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The casinh functions return the complex arc hyperbolic sine value, in the range of a
+ strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+ along the imaginary axis.
+
+<a name="7.3.6.3" href="#7.3.6.3"><h5>7.3.6.3 The catanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex catanh(double complex z);
+        float complex catanhf(float complex z);
+        long double complex catanhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The catanh functions compute the complex arc hyperbolic tangent of z, with branch
+ cuts outside the interval [-1, +1] along the real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The catanh functions return the complex arc hyperbolic tangent value, in the range of a
+ strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+ along the imaginary axis.
+
+<a name="7.3.6.4" href="#7.3.6.4"><h5>7.3.6.4 The ccosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex ccosh(double complex z);
+        float complex ccoshf(float complex z);
+        long double complex ccoshl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ccosh functions compute the complex hyperbolic cosine of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ccosh functions return the complex hyperbolic cosine value.
+<!--page 211 indent 4-->
+
+<a name="7.3.6.5" href="#7.3.6.5"><h5>7.3.6.5 The csinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex csinh(double complex z);
+         float complex csinhf(float complex z);
+         long double complex csinhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The csinh functions compute the complex hyperbolic sine of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The csinh functions return the complex hyperbolic sine value.
+
+<a name="7.3.6.6" href="#7.3.6.6"><h5>7.3.6.6 The ctanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex ctanh(double complex z);
+         float complex ctanhf(float complex z);
+         long double complex ctanhl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ctanh functions compute the complex hyperbolic tangent of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ctanh functions return the complex hyperbolic tangent value.
+
+<a name="7.3.7" href="#7.3.7"><h4>7.3.7 Exponential and logarithmic functions</h4></a>
+
+<a name="7.3.7.1" href="#7.3.7.1"><h5>7.3.7.1 The cexp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex cexp(double complex z);
+         float complex cexpf(float complex z);
+         long double complex cexpl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cexp functions compute the complex base-e exponential of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cexp functions return the complex base-e exponential value.
+<!--page 212 indent 4-->
+
+<a name="7.3.7.2" href="#7.3.7.2"><h5>7.3.7.2 The clog functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex clog(double complex z);
+        float complex clogf(float complex z);
+        long double complex clogl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The clog functions compute the complex natural (base-e) logarithm of z, with a branch
+ cut along the negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The clog functions return the complex natural logarithm value, in the range of a strip
+ mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
+ imaginary axis.
+
+<a name="7.3.8" href="#7.3.8"><h4>7.3.8 Power and absolute-value functions</h4></a>
+
+<a name="7.3.8.1" href="#7.3.8.1"><h5>7.3.8.1 The cabs functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double cabs(double complex z);
+        float cabsf(float complex z);
+        long double cabsl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cabs functions compute the complex absolute value (also called norm, modulus, or
+ magnitude) of z.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cabs functions return the complex absolute value.
+
+<a name="7.3.8.2" href="#7.3.8.2"><h5>7.3.8.2 The cpow functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 213 indent 4-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex cpow(double complex x, double complex y);
+        float complex cpowf(float complex x, float complex y);
+        long double complex cpowl(long double complex x,
+             long double complex y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cpow functions compute the complex power function xy , with a branch cut for the
+ first parameter along the negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cpow functions return the complex power function value.
+
+<a name="7.3.8.3" href="#7.3.8.3"><h5>7.3.8.3 The csqrt functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex csqrt(double complex z);
+         float complex csqrtf(float complex z);
+         long double complex csqrtl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The csqrt functions compute the complex square root of z, with a branch cut along the
+ negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The csqrt functions return the complex square root value, in the range of the right half-
+ plane (including the imaginary axis).
+
+<a name="7.3.9" href="#7.3.9"><h4>7.3.9 Manipulation functions</h4></a>
+
+<a name="7.3.9.1" href="#7.3.9.1"><h5>7.3.9.1 The carg functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double carg(double complex z);
+         float cargf(float complex z);
+         long double cargl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The carg functions compute the argument (also called phase angle) of z, with a branch
+ cut along the negative real axis.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The carg functions return the value of the argument in the interval [-pi , +pi ].
+<!--page 214 indent 4-->
+
+<a name="7.3.9.2" href="#7.3.9.2"><h5>7.3.9.2 The cimag functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double cimag(double complex z);
+        float cimagf(float complex z);
+        long double cimagl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cimag functions compute the imaginary part of z.<sup><a href="#note196"><b>196)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cimag functions return the imaginary part value (as a real).
+
+<h6>footnotes</h6>
+<p><a name="note196">196)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+
+<a name="7.3.9.3" href="#7.3.9.3"><h5>7.3.9.3 The CMPLX macros</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;complex.h&gt;
+        double complex CMPLX(double x, double y);
+        float complex CMPLXF(float x, float y);
+        long double complex CMPLXL(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The CMPLX macros expand to an expression of the specified complex type, with the real
+ part having the (converted) value of x and the imaginary part having the (converted)
+ value of y.
+ Recommended practice
+<p><!--para 3-->
+ The resulting expression should be suitable for use as an initializer for an object with
+ static or thread storage duration, provided both arguments are likewise suitable.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The CMPLX macros return the complex value x + i y.
+<p><!--para 5-->
+ NOTE    These macros act as if the implementation supported imaginary types and the definitions were:
+<pre>
+       #define CMPLX(x, y)  ((double complex)((double)(x) + \
+                                     _Imaginary_I * (double)(y)))
+       #define CMPLXF(x, y) ((float complex)((float)(x) + \
+                                     _Imaginary_I * (float)(y)))
+       #define CMPLXL(x, y) ((long double complex)((long double)(x) + \
+                                     _Imaginary_I * (long double)(y)))</pre>
+ 
+ 
+ 
+ 
+<!--page 215 indent 4-->
+
+<a name="7.3.9.4" href="#7.3.9.4"><h5>7.3.9.4 The conj functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex conj(double complex z);
+         float complex conjf(float complex z);
+         long double complex conjl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The conj functions compute the complex conjugate of z, by reversing the sign of its
+ imaginary part.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The conj functions return the complex conjugate value.
+
+<a name="7.3.9.5" href="#7.3.9.5"><h5>7.3.9.5 The cproj functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double complex cproj(double complex z);
+         float complex cprojf(float complex z);
+         long double complex cprojl(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cproj functions compute a projection of z onto the Riemann sphere: z projects to
+ z except that all complex infinities (even those with one infinite part and one NaN part)
+ project to positive infinity on the real axis. If z has an infinite part, then cproj(z) is
+ equivalent to
+<pre>
+         INFINITY + I * copysign(0.0, cimag(z))</pre>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cproj functions return the value of the projection onto the Riemann sphere.
+
+<a name="7.3.9.6" href="#7.3.9.6"><h5>7.3.9.6 The creal functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;complex.h&gt;
+         double creal(double complex z);
+         float crealf(float complex z);
+         long double creall(long double complex z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The creal functions compute the real part of z.<sup><a href="#note197"><b>197)</b></a></sup>
+<!--page 216 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The creal functions return the real part value.
+ 
+ 
+ 
+ 
+<!--page 217 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note197">197)</a> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+
+<a name="7.4" href="#7.4"><h3>7.4 Character handling <ctype.h></h3></a>
+<p><!--para 1-->
+ The header &lt;ctype.h&gt; declares several functions useful for classifying and mapping
+ characters.<sup><a href="#note198"><b>198)</b></a></sup> In all cases the argument is an int, the value of which shall be
+ representable as an unsigned char or shall equal the value of the macro EOF. If the
+ argument has any other value, the behavior is undefined.
+<p><!--para 2-->
+ The behavior of these functions is affected by the current locale. Those functions that
+ have locale-specific aspects only when not in the "C" locale are noted below.
+<p><!--para 3-->
+ The term printing character refers to a member of a locale-specific set of characters, each
+ of which occupies one printing position on a display device; the term control character
+ refers to a member of a locale-specific set of characters that are not printing
+ characters.<sup><a href="#note199"><b>199)</b></a></sup> All letters and digits are printing characters.
+ Forward references: EOF (<a href="#7.21.1">7.21.1</a>), localization (<a href="#7.11">7.11</a>).
+
+<h6>footnotes</h6>
+<p><a name="note198">198)</a> See ''future library directions'' (<a href="#7.30.2">7.30.2</a>).
+
+<p><a name="note199">199)</a> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
+ whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
+ values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
+
+
+<a name="7.4.1" href="#7.4.1"><h4>7.4.1 Character classification functions</h4></a>
+<p><!--para 1-->
+ The functions in this subclause return nonzero (true) if and only if the value of the
+ argument c conforms to that in the description of the function.
+
+<a name="7.4.1.1" href="#7.4.1.1"><h5>7.4.1.1 The isalnum function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;ctype.h&gt;
+          int isalnum(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isalnum function tests for any character for which isalpha or isdigit is true.
+
+<a name="7.4.1.2" href="#7.4.1.2"><h5>7.4.1.2 The isalpha function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;ctype.h&gt;
+          int isalpha(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isalpha function tests for any character for which isupper or islower is true,
+ or any character that is one of a locale-specific set of alphabetic characters for which
+ 
+ 
+ 
+<!--page 218 indent 4-->
+ none of iscntrl, isdigit, ispunct, or isspace is true.<sup><a href="#note200"><b>200)</b></a></sup> In the "C" locale,
+ isalpha returns true only for the characters for which isupper or islower is true.
+
+<h6>footnotes</h6>
+<p><a name="note200">200)</a> The functions islower and isupper test true or false separately for each of these additional
+ characters; all four combinations are possible.
+
+
+<a name="7.4.1.3" href="#7.4.1.3"><h5>7.4.1.3 The isblank function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isblank(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isblank function tests for any character that is a standard blank character or is one
+ of a locale-specific set of characters for which isspace is true and that is used to
+ separate words within a line of text. The standard blank characters are the following:
+ space (' '), and horizontal tab ('\t'). In the "C" locale, isblank returns true only
+ for the standard blank characters.
+
+<a name="7.4.1.4" href="#7.4.1.4"><h5>7.4.1.4 The iscntrl function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int iscntrl(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iscntrl function tests for any control character.
+
+<a name="7.4.1.5" href="#7.4.1.5"><h5>7.4.1.5 The isdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isdigit(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.4.1.6" href="#7.4.1.6"><h5>7.4.1.6 The isgraph function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isgraph(int c);</pre>
+ 
+ 
+ 
+ 
+<!--page 219 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The isgraph function tests for any printing character except space (' ').
+
+<a name="7.4.1.7" href="#7.4.1.7"><h5>7.4.1.7 The islower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int islower(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The islower function tests for any character that is a lowercase letter or is one of a
+ locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+ isspace is true. In the "C" locale, islower returns true only for the lowercase
+ letters (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.4.1.8" href="#7.4.1.8"><h5>7.4.1.8 The isprint function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isprint(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isprint function tests for any printing character including space (' ').
+
+<a name="7.4.1.9" href="#7.4.1.9"><h5>7.4.1.9 The ispunct function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int ispunct(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ispunct function tests for any printing character that is one of a locale-specific set
+ of punctuation characters for which neither isspace nor isalnum is true. In the "C"
+ locale, ispunct returns true for every printing character for which neither isspace
+ nor isalnum is true.
+
+<a name="7.4.1.10" href="#7.4.1.10"><h5>7.4.1.10 The isspace function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int isspace(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isspace function tests for any character that is a standard white-space character or
+ is one of a locale-specific set of characters for which isalnum is false. The standard
+<!--page 220 indent 4-->
+ white-space characters are the following: space (' '), form feed ('\f'), new-line
+ ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). In the
+ "C" locale, isspace returns true only for the standard white-space characters.
+
+<a name="7.4.1.11" href="#7.4.1.11"><h5>7.4.1.11 The isupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int isupper(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isupper function tests for any character that is an uppercase letter or is one of a
+ locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+ isspace is true. In the "C" locale, isupper returns true only for the uppercase
+ letters (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.4.1.12" href="#7.4.1.12"><h5>7.4.1.12 The isxdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int isxdigit(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isxdigit function tests for any hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+
+<a name="7.4.2" href="#7.4.2"><h4>7.4.2 Character case mapping functions</h4></a>
+
+<a name="7.4.2.1" href="#7.4.2.1"><h5>7.4.2.1 The tolower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;ctype.h&gt;
+        int tolower(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tolower function converts an uppercase letter to a corresponding lowercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a character for which isupper is true and there are one or more
+ corresponding characters, as specified by the current locale, for which islower is true,
+ the tolower function returns one of the corresponding characters (always the same one
+ for any given locale); otherwise, the argument is returned unchanged.
+<!--page 221 indent 4-->
+
+<a name="7.4.2.2" href="#7.4.2.2"><h5>7.4.2.2 The toupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;ctype.h&gt;
+         int toupper(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The toupper function converts a lowercase letter to a corresponding uppercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a character for which islower is true and there are one or more
+ corresponding characters, as specified by the current locale, for which isupper is true,
+ the toupper function returns one of the corresponding characters (always the same one
+ for any given locale); otherwise, the argument is returned unchanged.
+<!--page 222 indent 4-->
+
+<a name="7.5" href="#7.5"><h3>7.5 Errors <errno.h></h3></a>
+<p><!--para 1-->
+ The header &lt;errno.h&gt; defines several macros, all relating to the reporting of error
+ conditions.
+<p><!--para 2-->
+ The macros are
+<pre>
+          EDOM
+          EILSEQ
+          ERANGE</pre>
+ which expand to integer constant expressions with type int, distinct positive values, and
+ which are suitable for use in #if preprocessing directives; and
+<pre>
+          errno</pre>
+ which expands to a modifiable lvalue<sup><a href="#note201"><b>201)</b></a></sup> that has type int and thread local storage
+ duration, the value of which is set to a positive error number by several library functions.
+ If a macro definition is suppressed in order to access an actual object, or a program
+ defines an identifier with the name errno, the behavior is undefined.
+<p><!--para 3-->
+ The value of errno in the initial thread is zero at program startup (the initial value of
+ errno in other threads is an indeterminate value), but is never set to zero by any library
+ function.<sup><a href="#note202"><b>202)</b></a></sup> The value of errno may be set to nonzero by a library function call
+ whether or not there is an error, provided the use of errno is not documented in the
+ description of the function in this International Standard.
+<p><!--para 4-->
+ Additional macro definitions, beginning with E and a digit or E and an uppercase
+ letter,<sup><a href="#note203"><b>203)</b></a></sup> may also be specified by the implementation.
+ 
+ 
+ 
+ 
+<!--page 223 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note201">201)</a> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
+ resulting from a function call (for example, *errno()).
+
+<p><a name="note202">202)</a> Thus, a program that uses errno for error checking should set it to zero before a library function call,
+ then inspect it before a subsequent library function call. Of course, a library function can save the
+ value of errno on entry and then set it to zero, as long as the original value is restored if errno's
+ value is still zero just before the return.
+
+<p><a name="note203">203)</a> See ''future library directions'' (<a href="#7.30.3">7.30.3</a>).
+
+
+<a name="7.6" href="#7.6"><h3>7.6 Floating-point environment <fenv.h></h3></a>
+<p><!--para 1-->
+ The header &lt;fenv.h&gt; defines several macros, and declares types and functions that
+ provide access to the floating-point environment. The floating-point environment refers
+ collectively to any floating-point status flags and control modes supported by the
+ implementation.<sup><a href="#note204"><b>204)</b></a></sup> A floating-point status flag is a system variable whose value is set
+ (but never cleared) when a floating-point exception is raised, which occurs as a side effect
+ of exceptional floating-point arithmetic to provide auxiliary information.<sup><a href="#note205"><b>205)</b></a></sup> A floating-
+ point control mode is a system variable whose value may be set by the user to affect the
+ subsequent behavior of floating-point arithmetic.
+<p><!--para 2-->
+ The floating-point environment has thread storage duration. The initial state for a
+ thread's floating-point environment is the current state of the floating-point environment
+ of the thread that creates it at the time of creation.
+<p><!--para 3-->
+ Certain programming conventions support the intended model of use for the floating-
+ point environment:<sup><a href="#note206"><b>206)</b></a></sup>
+<ul>
+<li>  a function call does not alter its caller's floating-point control modes, clear its caller's
+ floating-point status flags, nor depend on the state of its caller's floating-point status
+ flags unless the function is so documented;
+<li>  a function call is assumed to require default floating-point control modes, unless its
+ documentation promises otherwise;
+<li>  a function call is assumed to have the potential for raising floating-point exceptions,
+ unless its documentation promises otherwise.
+</ul>
+<p><!--para 4-->
+ The type
+<pre>
+         fenv_t</pre>
+ represents the entire floating-point environment.
+<p><!--para 5-->
+ The type
+<pre>
+         fexcept_t</pre>
+ represents the floating-point status flags collectively, including any status the
+ implementation associates with the flags.
+ 
+ 
+<!--page 224 indent 4-->
+<p><!--para 6-->
+ Each of the macros
+<pre>
+          FE_DIVBYZERO
+          FE_INEXACT
+          FE_INVALID
+          FE_OVERFLOW
+          FE_UNDERFLOW</pre>
+ is defined if and only if the implementation supports the floating-point exception by
+ means of the functions in 7.6.2.<sup><a href="#note207"><b>207)</b></a></sup> Additional implementation-defined floating-point
+ exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
+ be specified by the implementation. The defined macros expand to integer constant
+ expressions with values such that bitwise ORs of all combinations of the macros result in
+ distinct values, and furthermore, bitwise ANDs of all combinations of the macros result in
+ zero.<sup><a href="#note208"><b>208)</b></a></sup>
+<p><!--para 7-->
+ The macro
+<pre>
+          FE_ALL_EXCEPT</pre>
+ is simply the bitwise OR of all floating-point exception macros defined by the
+ implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
+<p><!--para 8-->
+ Each of the macros
+<pre>
+          FE_DOWNWARD
+          FE_TONEAREST
+          FE_TOWARDZERO
+          FE_UPWARD</pre>
+ is defined if and only if the implementation supports getting and setting the represented
+ rounding direction by means of the fegetround and fesetround functions.
+ Additional implementation-defined rounding directions, with macro definitions beginning
+ with FE_ and an uppercase letter, may also be specified by the implementation. The
+ defined macros expand to integer constant expressions whose values are distinct
+ nonnegative values.<sup><a href="#note209"><b>209)</b></a></sup>
+<p><!--para 9-->
+ The macro
+ 
+ 
+ 
+<!--page 225 indent 5-->
+<pre>
+          FE_DFL_ENV</pre>
+ represents the default floating-point environment -- the one installed at program startup
+<ul>
+<li>  and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
+</ul>
+ &lt;fenv.h&gt; functions that manage the floating-point environment.
+<p><!--para 10-->
+ Additional implementation-defined environments, with macro definitions beginning with
+ FE_ and an uppercase letter, and having type ''pointer to const-qualified fenv_t'', may
+ also be specified by the implementation.
+
+<h6>footnotes</h6>
+<p><a name="note204">204)</a> This header is designed to support the floating-point exception status flags and directed-rounding
+ control modes required by IEC 60559, and other similar floating-point state information. It is also
+ designed to facilitate code portability among all systems.
+
+<p><a name="note205">205)</a> A floating-point status flag is not an object and can be set more than once within an expression.
+
+<p><a name="note206">206)</a> With these conventions, a programmer can safely assume default floating-point control modes (or be
+ unaware of them). The responsibilities associated with accessing the floating-point environment fall
+ on the programmer or program that does so explicitly.
+
+<p><a name="note207">207)</a> The implementation supports a floating-point exception if there are circumstances where a call to at
+ least one of the functions in <a href="#7.6.2">7.6.2</a>, using the macro as the appropriate argument, will succeed. It is not
+ necessary for all the functions to succeed all the time.
+
+<p><a name="note208">208)</a> The macros should be distinct powers of two.
+
+<p><a name="note209">209)</a> Even though the rounding direction macros may expand to constants corresponding to the values of
+ FLT_ROUNDS, they are not required to do so.
+
+
+<a name="7.6.1" href="#7.6.1"><h4>7.6.1 The FENV_ACCESS pragma</h4></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;fenv.h&gt;
+          #pragma STDC FENV_ACCESS on-off-switch</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The FENV_ACCESS pragma provides a means to inform the implementation when a
+ program might access the floating-point environment to test floating-point status flags or
+ run under non-default floating-point control modes.<sup><a href="#note210"><b>210)</b></a></sup> The pragma shall occur either
+ outside external declarations or preceding all explicit declarations and statements inside a
+ compound statement. When outside external declarations, the pragma takes effect from
+ its occurrence until another FENV_ACCESS pragma is encountered, or until the end of
+ the translation unit. When inside a compound statement, the pragma takes effect from its
+ occurrence until another FENV_ACCESS pragma is encountered (including within a
+ nested compound statement), or until the end of the compound statement; at the end of a
+ compound statement the state for the pragma is restored to its condition just before the
+ compound statement. If this pragma is used in any other context, the behavior is
+ undefined. If part of a program tests floating-point status flags, sets floating-point control
+ modes, or runs under non-default mode settings, but was translated with the state for the
+ FENV_ACCESS pragma ''off'', the behavior is undefined. The default state (''on'' or
+ ''off'') for the pragma is implementation-defined. (When execution passes from a part of
+ the program translated with FENV_ACCESS ''off'' to a part translated with
+ FENV_ACCESS ''on'', the state of the floating-point status flags is unspecified and the
+ floating-point control modes have their default settings.)
+ 
+ 
+ 
+ 
+<!--page 226 indent 4-->
+<p><!--para 3-->
+ EXAMPLE
+<p><!--para 4-->
+<pre>
+         #include &lt;fenv.h&gt;
+         void f(double x)
+         {
+               #pragma STDC FENV_ACCESS ON
+               void g(double);
+               void h(double);
+               /* ... */
+               g(x + 1);
+               h(x + 1);
+               /* ... */
+         }</pre>
+ If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
+ x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
+ contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note211"><b>211)</b></a></sup>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note210">210)</a> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
+ tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
+ folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
+ modes are in effect and the flags are not tested.
+
+<p><a name="note211">211)</a> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
+ hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
+ ''off'', just one evaluation of x + 1 would suffice.
+
+
+<a name="7.6.2" href="#7.6.2"><h4>7.6.2 Floating-point exceptions</h4></a>
+<p><!--para 1-->
+ The following functions provide access to the floating-point status flags.<sup><a href="#note212"><b>212)</b></a></sup> The int
+ input argument for the functions represents a subset of floating-point exceptions, and can
+ be zero or the bitwise OR of one or more floating-point exception macros, for example
+ FE_OVERFLOW | FE_INEXACT. For other argument values the behavior of these
+ functions is undefined.
+
+<h6>footnotes</h6>
+<p><a name="note212">212)</a> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
+ abstraction of flags that are either set or clear. An implementation may endow floating-point status
+ flags with more information -- for example, the address of the code which first raised the floating-
+ point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
+ content of flags.
+
+
+<a name="7.6.2.1" href="#7.6.2.1"><h5>7.6.2.1 The feclearexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int feclearexcept(int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feclearexcept function attempts to clear the supported floating-point exceptions
+ represented by its argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feclearexcept function returns zero if the excepts argument is zero or if all
+ the specified exceptions were successfully cleared. Otherwise, it returns a nonzero value.
+ 
+ 
+<!--page 227 indent 4-->
+
+<a name="7.6.2.2" href="#7.6.2.2"><h5>7.6.2.2 The fegetexceptflag function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;fenv.h&gt;
+          int fegetexceptflag(fexcept_t *flagp,
+               int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fegetexceptflag function attempts to store an implementation-defined
+ representation of the states of the floating-point status flags indicated by the argument
+ excepts in the object pointed to by the argument flagp.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fegetexceptflag function returns zero if the representation was successfully
+ stored. Otherwise, it returns a nonzero value.
+
+<a name="7.6.2.3" href="#7.6.2.3"><h5>7.6.2.3 The feraiseexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;fenv.h&gt;
+          int feraiseexcept(int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feraiseexcept function attempts to raise the supported floating-point exceptions
+ represented by its argument.<sup><a href="#note213"><b>213)</b></a></sup> The order in which these floating-point exceptions are
+ raised is unspecified, except as stated in <a href="#F.8.6">F.8.6</a>. Whether the feraiseexcept function
+ additionally raises the ''inexact'' floating-point exception whenever it raises the
+ ''overflow'' or ''underflow'' floating-point exception is implementation-defined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feraiseexcept function returns zero if the excepts argument is zero or if all
+ the specified exceptions were successfully raised. Otherwise, it returns a nonzero value.
+ 
+ 
+ 
+ 
+<!--page 228 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note213">213)</a> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
+ Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
+ in <a href="#F.8.6">F.8.6</a> is in the same spirit.
+
+
+<a name="7.6.2.4" href="#7.6.2.4"><h5>7.6.2.4 The fesetexceptflag function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fesetexceptflag(const fexcept_t *flagp,
+              int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fesetexceptflag function attempts to set the floating-point status flags
+ indicated by the argument excepts to the states stored in the object pointed to by
+ flagp. The value of *flagp shall have been set by a previous call to
+ fegetexceptflag whose second argument represented at least those floating-point
+ exceptions represented by the argument excepts. This function does not raise floating-
+ point exceptions, but only sets the state of the flags.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fesetexceptflag function returns zero if the excepts argument is zero or if
+ all the specified flags were successfully set to the appropriate state. Otherwise, it returns
+ a nonzero value.
+
+<a name="7.6.2.5" href="#7.6.2.5"><h5>7.6.2.5 The fetestexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fetestexcept(int excepts);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fetestexcept function determines which of a specified subset of the floating-
+ point exception flags are currently set. The excepts argument specifies the floating-
+ point status flags to be queried.<sup><a href="#note214"><b>214)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fetestexcept function returns the value of the bitwise OR of the floating-point
+ exception macros corresponding to the currently set floating-point exceptions included in
+ excepts.
+<p><!--para 4-->
+ EXAMPLE       Call f if ''invalid'' is set, then g if ''overflow'' is set:
+ 
+ 
+ 
+ 
+<!--page 229 indent 4-->
+<pre>
+         #include &lt;fenv.h&gt;
+         /* ... */
+         {
+                 #pragma STDC FENV_ACCESS ON
+                 int set_excepts;
+                 feclearexcept(FE_INVALID | FE_OVERFLOW);
+                 // maybe raise exceptions
+                 set_excepts = fetestexcept(FE_INVALID | FE_OVERFLOW);
+                 if (set_excepts &amp; FE_INVALID) f();
+                 if (set_excepts &amp; FE_OVERFLOW) g();
+                 /* ... */
+         }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note214">214)</a> This mechanism allows testing several floating-point exceptions with just one function call.
+
+
+<a name="7.6.3" href="#7.6.3"><h4>7.6.3 Rounding</h4></a>
+<p><!--para 1-->
+ The fegetround and fesetround functions provide control of rounding direction
+ modes.
+
+<a name="7.6.3.1" href="#7.6.3.1"><h5>7.6.3.1 The fegetround function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fegetround(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fegetround function gets the current rounding direction.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fegetround function returns the value of the rounding direction macro
+ representing the current rounding direction or a negative value if there is no such
+ rounding direction macro or the current rounding direction is not determinable.
+
+<a name="7.6.3.2" href="#7.6.3.2"><h5>7.6.3.2 The fesetround function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fesetround(int round);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fesetround function establishes the rounding direction represented by its
+ argument round. If the argument is not equal to the value of a rounding direction macro,
+ the rounding direction is not changed.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fesetround function returns zero if and only if the requested rounding direction
+ was established.
+<!--page 230 indent 4-->
+<p><!--para 4-->
+ EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
+ rounding direction fails.
+<pre>
+        #include &lt;fenv.h&gt;
+        #include &lt;assert.h&gt;
+        void f(int round_dir)
+        {
+              #pragma STDC FENV_ACCESS ON
+              int save_round;
+              int setround_ok;
+              save_round = fegetround();
+              setround_ok = fesetround(round_dir);
+              assert(setround_ok == 0);
+              /* ... */
+              fesetround(save_round);
+              /* ... */
+        }</pre>
+ 
+
+<a name="7.6.4" href="#7.6.4"><h4>7.6.4 Environment</h4></a>
+<p><!--para 1-->
+ The functions in this section manage the floating-point environment -- status flags and
+ control modes -- as one entity.
+
+<a name="7.6.4.1" href="#7.6.4.1"><h5>7.6.4.1 The fegetenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;fenv.h&gt;
+        int fegetenv(fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fegetenv function attempts to store the current floating-point environment in the
+ object pointed to by envp.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fegetenv function returns zero if the environment was successfully stored.
+ Otherwise, it returns a nonzero value.
+
+<a name="7.6.4.2" href="#7.6.4.2"><h5>7.6.4.2 The feholdexcept function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;fenv.h&gt;
+        int feholdexcept(fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feholdexcept function saves the current floating-point environment in the object
+ pointed to by envp, clears the floating-point status flags, and then installs a non-stop
+ (continue on floating-point exceptions) mode, if available, for all floating-point
+ exceptions.<sup><a href="#note215"><b>215)</b></a></sup>
+<!--page 231 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feholdexcept function returns zero if and only if non-stop floating-point
+ exception handling was successfully installed.
+
+<h6>footnotes</h6>
+<p><a name="note215">215)</a> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
+ handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
+ such systems, the feholdexcept function can be used in conjunction with the feupdateenv
+ function to write routines that hide spurious floating-point exceptions from their callers.
+
+
+<a name="7.6.4.3" href="#7.6.4.3"><h5>7.6.4.3 The fesetenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int fesetenv(const fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fesetenv function attempts to establish the floating-point environment represented
+ by the object pointed to by envp. The argument envp shall point to an object set by a
+ call to fegetenv or feholdexcept, or equal a floating-point environment macro.
+ Note that fesetenv merely installs the state of the floating-point status flags
+ represented through its argument, and does not raise these floating-point exceptions.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fesetenv function returns zero if the environment was successfully established.
+ Otherwise, it returns a nonzero value.
+
+<a name="7.6.4.4" href="#7.6.4.4"><h5>7.6.4.4 The feupdateenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;fenv.h&gt;
+         int feupdateenv(const fenv_t *envp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feupdateenv function attempts to save the currently raised floating-point
+ exceptions in its automatic storage, install the floating-point environment represented by
+ the object pointed to by envp, and then raise the saved floating-point exceptions. The
+ argument envp shall point to an object set by a call to feholdexcept or fegetenv,
+ or equal a floating-point environment macro.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feupdateenv function returns zero if all the actions were successfully carried out.
+ Otherwise, it returns a nonzero value.
+ 
+ 
+ 
+ 
+<!--page 232 indent 4-->
+<p><!--para 4-->
+ EXAMPLE   Hide spurious underflow floating-point exceptions:
+<!--page 233 indent 4-->
+<pre>
+       #include &lt;fenv.h&gt;
+       double f(double x)
+       {
+             #pragma STDC FENV_ACCESS ON
+             double result;
+             fenv_t save_env;
+             if (feholdexcept(&amp;save_env))
+                   return /* indication of an environmental problem */;
+             // compute result
+             if (/* test spurious underflow */)
+                   if (feclearexcept(FE_UNDERFLOW))
+                            return /* indication of an environmental problem */;
+             if (feupdateenv(&amp;save_env))
+                   return /* indication of an environmental problem */;
+             return result;
+       }</pre>
+
+<a name="7.7" href="#7.7"><h3>7.7 Characteristics of floating types <float.h></h3></a>
+<p><!--para 1-->
+ The header &lt;float.h&gt; defines several macros that expand to various limits and
+ parameters of the standard floating-point types.
+<p><!--para 2-->
+ The macros, their meanings, and the constraints (or restrictions) on their values are listed
+ in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+<!--page 234 indent 4-->
+
+<a name="7.8" href="#7.8"><h3>7.8 Format conversion of integer types <inttypes.h></h3></a>
+<p><!--para 1-->
+ The header &lt;inttypes.h&gt; includes the header &lt;stdint.h&gt; and extends it with
+ additional facilities provided by hosted implementations.
+<p><!--para 2-->
+ It declares functions for manipulating greatest-width integers and converting numeric
+ character strings to greatest-width integers, and it declares the type
+<pre>
+          imaxdiv_t</pre>
+ which is a structure type that is the type of the value returned by the imaxdiv function.
+ For each type declared in &lt;stdint.h&gt;, it defines corresponding macros for conversion
+ specifiers for use with the formatted input/output functions.<sup><a href="#note216"><b>216)</b></a></sup>
+ Forward references: integer types &lt;stdint.h&gt; (<a href="#7.20">7.20</a>), formatted input/output
+ functions (<a href="#7.21.6">7.21.6</a>), formatted wide character input/output functions (<a href="#7.28.2">7.28.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note216">216)</a> See ''future library directions'' (<a href="#7.30.4">7.30.4</a>).
+
+
+<a name="7.8.1" href="#7.8.1"><h4>7.8.1 Macros for format specifiers</h4></a>
+<p><!--para 1-->
+ Each of the following object-like macros expands to a character string literal containing a *
+ conversion specifier, possibly modified by a length modifier, suitable for use within the
+ format argument of a formatted input/output function when converting the corresponding
+ integer type. These macro names have the general form of PRI (character string literals
+ for the fprintf and fwprintf family) or SCN (character string literals for the
+ fscanf and fwscanf family),<sup><a href="#note217"><b>217)</b></a></sup> followed by the conversion specifier, followed by a
+ name corresponding to a similar type name in <a href="#7.20.1">7.20.1</a>. In these names, N represents the
+ width of the type as described in <a href="#7.20.1">7.20.1</a>. For example, PRIdFAST32 can be used in a
+ format string to print the value of an integer of type int_fast32_t.
+<p><!--para 2-->
+ The fprintf macros for signed integers are:
+<p><!--para 3-->
+<pre>
+        PRIdN             PRIdLEASTN                PRIdFASTN          PRIdMAX             PRIdPTR
+        PRIiN             PRIiLEASTN                PRIiFASTN          PRIiMAX             PRIiPTR</pre>
+ The fprintf macros for unsigned integers are:
+<p><!--para 4-->
+<pre>
+        PRIoN             PRIoLEASTN                PRIoFASTN          PRIoMAX             PRIoPTR
+        PRIuN             PRIuLEASTN                PRIuFASTN          PRIuMAX             PRIuPTR
+        PRIxN             PRIxLEASTN                PRIxFASTN          PRIxMAX             PRIxPTR
+        PRIXN             PRIXLEASTN                PRIXFASTN          PRIXMAX             PRIXPTR</pre>
+ The fscanf macros for signed integers are:
+ 
+ 
+ 
+<!--page 235 indent 4-->
+<p><!--para 5-->
+<pre>
+        SCNdN           SCNdLEASTN               SCNdFASTN              SCNdMAX             SCNdPTR
+        SCNiN           SCNiLEASTN               SCNiFASTN              SCNiMAX             SCNiPTR</pre>
+ The fscanf macros for unsigned integers are:
+<p><!--para 6-->
+<pre>
+        SCNoN           SCNoLEASTN               SCNoFASTN              SCNoMAX             SCNoPTR
+        SCNuN           SCNuLEASTN               SCNuFASTN              SCNuMAX             SCNuPTR
+        SCNxN           SCNxLEASTN               SCNxFASTN              SCNxMAX             SCNxPTR</pre>
+ For each type that the implementation provides in &lt;stdint.h&gt;, the corresponding
+ fprintf macros shall be defined and the corresponding fscanf macros shall be
+ defined unless the implementation does not have a suitable fscanf length modifier for
+ the type.
+<p><!--para 7-->
+ EXAMPLE
+<pre>
+         #include &lt;inttypes.h&gt;
+         #include &lt;wchar.h&gt;
+         int main(void)
+         {
+               uintmax_t i = UINTMAX_MAX;    // this type always exists
+               wprintf(L"The largest integer value is %020"
+                     PRIxMAX "\n", i);
+               return 0;
+         }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note217">217)</a> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
+ different format specifiers may be required for fprintf and fscanf, even when the type is the
+ same.
+
+
+<a name="7.8.2" href="#7.8.2"><h4>7.8.2 Functions for greatest-width integer types</h4></a>
+
+<a name="7.8.2.1" href="#7.8.2.1"><h5>7.8.2.1 The imaxabs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;inttypes.h&gt;
+         intmax_t imaxabs(intmax_t j);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The imaxabs function computes the absolute value of an integer j. If the result cannot
+ be represented, the behavior is undefined.<sup><a href="#note218"><b>218)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The imaxabs function returns the absolute value.
+ 
+ 
+ 
+ 
+<!--page 236 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note218">218)</a> The absolute value of the most negative number cannot be represented in two's complement.
+
+
+<a name="7.8.2.2" href="#7.8.2.2"><h5>7.8.2.2 The imaxdiv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;inttypes.h&gt;
+        imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The imaxdiv function computes numer / denom and numer % denom in a single
+ operation.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The imaxdiv function returns a structure of type imaxdiv_t comprising both the
+ quotient and the remainder. The structure shall contain (in either order) the members
+ quot (the quotient) and rem (the remainder), each of which has type intmax_t. If
+ either part of the result cannot be represented, the behavior is undefined.
+
+<a name="7.8.2.3" href="#7.8.2.3"><h5>7.8.2.3 The strtoimax and strtoumax functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;inttypes.h&gt;
+        intmax_t strtoimax(const char * restrict nptr,
+             char ** restrict endptr, int base);
         uintmax_t strtoumax(const char * restrict nptr,
-                char ** restrict endptr, int base);
-        intmax_t wcstoimax(const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr, int base);
-        uintmax_t wcstoumax(const wchar_t * restrict nptr,
-                wchar_t ** restrict endptr, int base);
-<a name="B.8" href="#B.8"><b>B.8 Alternative spellings &lt;iso646.h&gt;</b></a>
-        and            bitor             not_eq           xor
-        and_eq         compl             or               xor_eq
-        bitand         not               or_eq
-<a name="B.9" href="#B.9"><b>B.9 Sizes of integer types &lt;limits.h&gt;</b></a>
-        CHAR_BIT       CHAR_MAX          INT_MIN          ULONG_MAX
-        SCHAR_MIN      MB_LEN_MAX        INT_MAX          LLONG_MIN
-        SCHAR_MAX      SHRT_MIN          UINT_MAX         LLONG_MAX
-        UCHAR_MAX      SHRT_MAX          LONG_MIN         ULLONG_MAX
-        CHAR_MIN       USHRT_MAX         LONG_MAX
-<a name="B.10" href="#B.10"><b>B.10 Localization &lt;locale.h&gt;</b></a>
-        struct lconv   LC_ALL            LC_CTYPE         LC_NUMERIC
-        NULL           LC_COLLATE        LC_MONETARY      LC_TIME
-        char *setlocale(int category, const char *locale);
-        struct lconv *localeconv(void);
-<a name="B.11" href="#B.11"><b>B.11 Mathematics &lt;math.h&gt;</b></a>
-        float_t              FP_INFINITE             FP_FAST_FMAL
-        double_t             FP_NAN                  FP_ILOGB0
-        HUGE_VAL             FP_NORMAL               FP_ILOGBNAN
-        HUGE_VALF            FP_SUBNORMAL            MATH_ERRNO
-        HUGE_VALL            FP_ZERO                 MATH_ERREXCEPT
-        INFINITY             FP_FAST_FMA             math_errhandling
-        NAN                  FP_FAST_FMAF
-        #pragma STDC FP_CONTRACT on-off-switch
-        int fpclassify(real-floating x);
-        int isfinite(real-floating x);
-        int isinf(real-floating x);
-        int isnan(real-floating x);
-        int isnormal(real-floating x);
-        int signbit(real-floating x);
-
-[<a name="p475" href="#p475">page 475</a>] (<a href="#Contents">Contents</a>)
-
-      double acos(double x);
-      float acosf(float x);
-      long double acosl(long double x);
-      double asin(double x);
-      float asinf(float x);
-      long double asinl(long double x);
-      double atan(double x);
-      float atanf(float x);
-      long double atanl(long double x);
-      double atan2(double y, double x);
-      float atan2f(float y, float x);
-      long double atan2l(long double y, long double x);
-      double cos(double x);
-      float cosf(float x);
-      long double cosl(long double x);
-      double sin(double x);
-      float sinf(float x);
-      long double sinl(long double x);
-      double tan(double x);
-      float tanf(float x);
-      long double tanl(long double x);
-      double acosh(double x);
-      float acoshf(float x);
-      long double acoshl(long double x);
-      double asinh(double x);
-      float asinhf(float x);
-      long double asinhl(long double x);
-      double atanh(double x);
-      float atanhf(float x);
-      long double atanhl(long double x);
-      double cosh(double x);
-      float coshf(float x);
-      long double coshl(long double x);
-      double sinh(double x);
-      float sinhf(float x);
-      long double sinhl(long double x);
-      double tanh(double x);
-      float tanhf(float x);
-      long double tanhl(long double x);
-      double exp(double x);
-      float expf(float x);
-
-[<a name="p476" href="#p476">page 476</a>] (<a href="#Contents">Contents</a>)
-
-        long double expl(long double x);
-        double exp2(double x);
-        float exp2f(float x);
-        long double exp2l(long double x);
-        double expm1(double x);
-        float expm1f(float x);
-        long double expm1l(long double x);
-        double frexp(double value, int *exp);
-        float frexpf(float value, int *exp);
-        long double frexpl(long double value, int *exp);
-        int ilogb(double x);
-        int ilogbf(float x);
-        int ilogbl(long double x);
-        double ldexp(double x, int exp);
-        float ldexpf(float x, int exp);
-        long double ldexpl(long double x, int exp);
-        double log(double x);
-        float logf(float x);
-        long double logl(long double x);
-        double log10(double x);
-        float log10f(float x);
-        long double log10l(long double x);
-        double log1p(double x);
-        float log1pf(float x);
-        long double log1pl(long double x);
-        double log2(double x);
-        float log2f(float x);
-        long double log2l(long double x);
-        double logb(double x);
-        float logbf(float x);
-        long double logbl(long double x);
-        double modf(double value, double *iptr);
-        float modff(float value, float *iptr);
-        long double modfl(long double value, long double *iptr);
+             char ** restrict endptr, int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strtoimax and strtoumax functions are equivalent to the strtol, strtoll,
+ strtoul, and strtoull functions, except that the initial portion of the string is
+ converted to intmax_t and uintmax_t representation, respectively.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strtoimax and strtoumax functions return the converted value, if any. If no
+ conversion could be performed, zero is returned. If the correct value is outside the range
+ of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
+ (according to the return type and sign of the value, if any), and the value of the macro
+ ERANGE is stored in errno.
+ Forward references: the strtol, strtoll, strtoul, and strtoull functions
+ (<a href="#7.22.1.4">7.22.1.4</a>).
+<!--page 237 indent 4-->
+
+<a name="7.8.2.4" href="#7.8.2.4"><h5>7.8.2.4 The wcstoimax and wcstoumax functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stddef.h&gt;           // for wchar_t
+         #include &lt;inttypes.h&gt;
+         intmax_t wcstoimax(const wchar_t * restrict nptr,
+              wchar_t ** restrict endptr, int base);
+         uintmax_t wcstoumax(const wchar_t * restrict nptr,
+              wchar_t ** restrict endptr, int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstoimax and wcstoumax functions are equivalent to the wcstol, wcstoll,
+ wcstoul, and wcstoull functions except that the initial portion of the wide string is
+ converted to intmax_t and uintmax_t representation, respectively.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcstoimax function returns the converted value, if any. If no conversion could be
+ performed, zero is returned. If the correct value is outside the range of representable
+ values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
+ return type and sign of the value, if any), and the value of the macro ERANGE is stored in
+ errno.
+ Forward references: the wcstol, wcstoll, wcstoul, and wcstoull functions
+ (<a href="#7.28.4.1.2">7.28.4.1.2</a>).
+<!--page 238 indent 4-->
+
+<a name="7.9" href="#7.9"><h3>7.9 Alternative spellings <iso646.h></h3></a>
+<p><!--para 1-->
+ The header &lt;iso646.h&gt; defines the following eleven macros (on the left) that expand
+ to the corresponding tokens (on the right):
+<!--page 239 indent 4-->
+<pre>
+       and           &amp;&amp;
+       and_eq        &amp;=
+       bitand        &amp;
+       bitor         |
+       compl         ~
+       not           !
+       not_eq        !=
+       or            ||
+       or_eq         |=
+       xor           ^
+       xor_eq        ^=</pre>
+
+<a name="7.10" href="#7.10"><h3>7.10 Sizes of integer types <limits.h></h3></a>
+<p><!--para 1-->
+ The header &lt;limits.h&gt; defines several macros that expand to various limits and
+ parameters of the standard integer types.
+<p><!--para 2-->
+ The macros, their meanings, and the constraints (or restrictions) on their values are listed
+ in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+<!--page 240 indent 4-->
+
+<a name="7.11" href="#7.11"><h3>7.11 Localization <locale.h></h3></a>
+<p><!--para 1-->
+ The header &lt;locale.h&gt; declares two functions, one type, and defines several macros.
+<p><!--para 2-->
+ The type is
+<pre>
+        struct lconv</pre>
+ which contains members related to the formatting of numeric values. The structure shall
+ contain at least the following members, in any order. The semantics of the members and
+ their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
+ the values specified in the comments.
+<!--page 241 indent 4-->
+<p><!--para 3-->
+<pre>
+        char   *decimal_point;                 //   "."
+        char   *thousands_sep;                 //   ""
+        char   *grouping;                      //   ""
+        char   *mon_decimal_point;             //   ""
+        char   *mon_thousands_sep;             //   ""
+        char   *mon_grouping;                  //   ""
+        char   *positive_sign;                 //   ""
+        char   *negative_sign;                 //   ""
+        char   *currency_symbol;               //   ""
+        char   frac_digits;                    //   CHAR_MAX
+        char   p_cs_precedes;                  //   CHAR_MAX
+        char   n_cs_precedes;                  //   CHAR_MAX
+        char   p_sep_by_space;                 //   CHAR_MAX
+        char   n_sep_by_space;                 //   CHAR_MAX
+        char   p_sign_posn;                    //   CHAR_MAX
+        char   n_sign_posn;                    //   CHAR_MAX
+        char   *int_curr_symbol;               //   ""
+        char   int_frac_digits;                //   CHAR_MAX
+        char   int_p_cs_precedes;              //   CHAR_MAX
+        char   int_n_cs_precedes;              //   CHAR_MAX
+        char   int_p_sep_by_space;             //   CHAR_MAX
+        char   int_n_sep_by_space;             //   CHAR_MAX
+        char   int_p_sign_posn;                //   CHAR_MAX
+        char   int_n_sign_posn;                //   CHAR_MAX</pre>
+ The macros defined are NULL (described in <a href="#7.19">7.19</a>); and
+<pre>
+          LC_ALL
+          LC_COLLATE
+          LC_CTYPE
+          LC_MONETARY
+          LC_NUMERIC
+          LC_TIME</pre>
+ which expand to integer constant expressions with distinct values, suitable for use as the
+ first argument to the setlocale function.<sup><a href="#note219"><b>219)</b></a></sup> Additional macro definitions, beginning
+ with the characters LC_ and an uppercase letter,<sup><a href="#note220"><b>220)</b></a></sup> may also be specified by the
+ implementation.
+
+<h6>footnotes</h6>
+<p><a name="note219">219)</a> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
+
+<p><a name="note220">220)</a> See ''future library directions'' (<a href="#7.30.5">7.30.5</a>).
+
+
+<a name="7.11.1" href="#7.11.1"><h4>7.11.1 Locale control</h4></a>
+
+<a name="7.11.1.1" href="#7.11.1.1"><h5>7.11.1.1 The setlocale function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;locale.h&gt;
+          char *setlocale(int category, const char *locale);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The setlocale function selects the appropriate portion of the program's locale as
+ specified by the category and locale arguments. The setlocale function may be
+ used to change or query the program's entire current locale or portions thereof. The value
+ LC_ALL for category names the program's entire locale; the other values for
+ category name only a portion of the program's locale. LC_COLLATE affects the
+ behavior of the strcoll and strxfrm functions. LC_CTYPE affects the behavior of
+ the character handling functions<sup><a href="#note221"><b>221)</b></a></sup> and the multibyte and wide character functions.
+ LC_MONETARY affects the monetary formatting information returned by the
+ localeconv function. LC_NUMERIC affects the decimal-point character for the
+ formatted input/output functions and the string conversion functions, as well as the
+ nonmonetary formatting information returned by the localeconv function. LC_TIME
+ affects the behavior of the strftime and wcsftime functions.
+<p><!--para 3-->
+ A value of "C" for locale specifies the minimal environment for C translation; a value
+ of "" for locale specifies the locale-specific native environment. Other
+ implementation-defined strings may be passed as the second argument to setlocale.
+ 
+<!--page 242 indent 4-->
+<p><!--para 4-->
+ At program startup, the equivalent of
+<pre>
+         setlocale(LC_ALL, "C");</pre>
+ is executed.
+<p><!--para 5-->
+ A call to the setlocale function may introduce a data race with other calls to the
+ setlocale function or with calls to functions that are affected by the current locale.
+ The implementation shall behave as if no library function calls the setlocale function.
+<h6>Returns</h6>
+<p><!--para 6-->
+ If a pointer to a string is given for locale and the selection can be honored, the
+ setlocale function returns a pointer to the string associated with the specified
+ category for the new locale. If the selection cannot be honored, the setlocale
+ function returns a null pointer and the program's locale is not changed.
+<p><!--para 7-->
+ A null pointer for locale causes the setlocale function to return a pointer to the
+ string associated with the category for the program's current locale; the program's
+ locale is not changed.<sup><a href="#note222"><b>222)</b></a></sup>
+<p><!--para 8-->
+ The pointer to string returned by the setlocale function is such that a subsequent call
+ with that string value and its associated category will restore that part of the program's
+ locale. The string pointed to shall not be modified by the program, but may be
+ overwritten by a subsequent call to the setlocale function.
+ Forward references: formatted input/output functions (<a href="#7.21.6">7.21.6</a>), multibyte/wide
+ character conversion functions (<a href="#7.22.7">7.22.7</a>), multibyte/wide string conversion functions
+ (<a href="#7.22.8">7.22.8</a>), numeric conversion functions (<a href="#7.22.1">7.22.1</a>), the strcoll function (<a href="#7.23.4.3">7.23.4.3</a>), the
+ strftime function (<a href="#7.26.3.5">7.26.3.5</a>), the strxfrm function (<a href="#7.23.4.5">7.23.4.5</a>).
+
+<h6>footnotes</h6>
+<p><a name="note221">221)</a> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
+ isxdigit.
+
+<p><a name="note222">222)</a> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
+ locale when category has the value LC_ALL.
+
+
+<a name="7.11.2" href="#7.11.2"><h4>7.11.2 Numeric formatting convention inquiry</h4></a>
+
+<a name="7.11.2.1" href="#7.11.2.1"><h5>7.11.2.1 The localeconv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;locale.h&gt;
+         struct lconv *localeconv(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The localeconv function sets the components of an object with type struct lconv
+ with values appropriate for the formatting of numeric quantities (monetary and otherwise)
+ according to the rules of the current locale.
+ 
+ 
+ 
+<!--page 243 indent 4-->
+<p><!--para 3-->
+ The members of the structure with type char * are pointers to strings, any of which
+ (except decimal_point) can point to "", to indicate that the value is not available in
+ the current locale or is of zero length. Apart from grouping and mon_grouping, the
+ strings shall start and end in the initial shift state. The members with type char are
+ nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not
+ available in the current locale. The members include the following:
+ char *decimal_point
+<pre>
+           The decimal-point character used to format nonmonetary quantities.</pre>
+ char *thousands_sep
+<pre>
+           The character used to separate groups of digits before the decimal-point
+           character in formatted nonmonetary quantities.</pre>
+ char *grouping
+<pre>
+           A string whose elements indicate the size of each group of digits in
+           formatted nonmonetary quantities.</pre>
+ char *mon_decimal_point
+<pre>
+           The decimal-point used to format monetary quantities.</pre>
+ char *mon_thousands_sep
+<pre>
+           The separator for groups of digits before the decimal-point in formatted
+           monetary quantities.</pre>
+ char *mon_grouping
+<pre>
+           A string whose elements indicate the size of each group of digits in
+           formatted monetary quantities.</pre>
+ char *positive_sign
+<pre>
+           The string used to indicate a nonnegative-valued formatted monetary
+           quantity.</pre>
+ char *negative_sign
+<pre>
+           The string used to indicate a negative-valued formatted monetary quantity.</pre>
+ char *currency_symbol
+<pre>
+           The local currency symbol applicable to the current locale.</pre>
+ char frac_digits
+<pre>
+           The number of fractional digits (those after the decimal-point) to be
+           displayed in a locally formatted monetary quantity.</pre>
+ char p_cs_precedes
+<!--page 244 indent 0-->
+<pre>
+           Set to 1 or 0 if the currency_symbol respectively precedes or
+           succeeds the value for a nonnegative locally formatted monetary quantity.</pre>
+ char n_cs_precedes
+<pre>
+           Set to 1 or 0 if the currency_symbol respectively precedes or
+           succeeds the value for a negative locally formatted monetary quantity.</pre>
+ char p_sep_by_space
+<pre>
+           Set to a value indicating the separation of the currency_symbol, the
+           sign string, and the value for a nonnegative locally formatted monetary
+           quantity.</pre>
+ char n_sep_by_space
+<pre>
+           Set to a value indicating the separation of the currency_symbol, the
+           sign string, and the value for a negative locally formatted monetary
+           quantity.</pre>
+ char p_sign_posn
+<pre>
+           Set to a value indicating the positioning of the positive_sign for a
+           nonnegative locally formatted monetary quantity.</pre>
+ char n_sign_posn
+<pre>
+           Set to a value indicating the positioning of the negative_sign for a
+           negative locally formatted monetary quantity.</pre>
+ char *int_curr_symbol
+<pre>
+           The international currency symbol applicable to the current locale. The
+           first three characters contain the alphabetic international currency symbol
+           in accordance with those specified in ISO 4217. The fourth character
+           (immediately preceding the null character) is the character used to separate
+           the international currency symbol from the monetary quantity.</pre>
+ char int_frac_digits
+<pre>
+           The number of fractional digits (those after the decimal-point) to be
+           displayed in an internationally formatted monetary quantity.</pre>
+ char int_p_cs_precedes
+<pre>
+           Set to 1 or 0 if the int_curr_symbol respectively precedes or
+           succeeds the value for a nonnegative internationally formatted monetary
+           quantity.</pre>
+ char int_n_cs_precedes
+<pre>
+           Set to 1 or 0 if the int_curr_symbol respectively precedes or
+           succeeds the value for a negative internationally formatted monetary
+           quantity.</pre>
+ char int_p_sep_by_space
+<!--page 245 indent 4-->
+<pre>
+           Set to a value indicating the separation of the int_curr_symbol, the
+           sign string, and the value for a nonnegative internationally formatted
+           monetary quantity.</pre>
+ char int_n_sep_by_space
+<pre>
+           Set to a value indicating the separation of the int_curr_symbol, the
+           sign string, and the value for a negative internationally formatted monetary
+           quantity.</pre>
+ char int_p_sign_posn
+<pre>
+           Set to a value indicating the positioning of the positive_sign for a
+           nonnegative internationally formatted monetary quantity.</pre>
+ char int_n_sign_posn
+<p><!--para 4-->
+<pre>
+           Set to a value indicating the positioning of the negative_sign for a
+           negative internationally formatted monetary quantity.</pre>
+ The elements of grouping and mon_grouping are interpreted according to the
+ following:
+ CHAR_MAX      No further grouping is to be performed.
+ 0             The previous element is to be repeatedly used for the remainder of the
+<pre>
+               digits.</pre>
+ other         The integer value is the number of digits that compose the current group.
+<p><!--para 5-->
+<pre>
+               The next element is examined to determine the size of the next group of
+               digits before the current group.</pre>
+ The values of p_sep_by_space, n_sep_by_space, int_p_sep_by_space,
+ and int_n_sep_by_space are interpreted according to the following:
+ 0   No space separates the currency symbol and value.
+ 1   If the currency symbol and sign string are adjacent, a space separates them from the
+<pre>
+     value; otherwise, a space separates the currency symbol from the value.</pre>
+ 2   If the currency symbol and sign string are adjacent, a space separates them;
+<pre>
+     otherwise, a space separates the sign string from the value.</pre>
+ For int_p_sep_by_space and int_n_sep_by_space, the fourth character of
+ int_curr_symbol is used instead of a space.
+<p><!--para 6-->
+ The values of p_sign_posn, n_sign_posn, int_p_sign_posn,                            and
+ int_n_sign_posn are interpreted according to the following:
+ 0   Parentheses surround the quantity and currency symbol.
+ 1   The sign string precedes the quantity and currency symbol.
+ 2   The sign string succeeds the quantity and currency symbol.
+ 3   The sign string immediately precedes the currency symbol.
+ 4   The sign string immediately succeeds the currency symbol.
+<!--page 246 indent 5-->
+<p><!--para 7-->
+ The implementation shall behave as if no library function calls the localeconv
+ function.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The localeconv function returns a pointer to the filled-in object. The structure
+ pointed to by the return value shall not be modified by the program, but may be
+ overwritten by a subsequent call to the localeconv function. In addition, calls to the
+ setlocale function with categories LC_ALL, LC_MONETARY, or LC_NUMERIC may
+ overwrite the contents of the structure.
+<p><!--para 9-->
+ EXAMPLE 1 The following table illustrates rules which may well be used by four countries to format
+ monetary quantities.
+<pre>
+                               Local format                                     International format</pre>
+ 
+ Country            Positive                  Negative                    Positive               Negative
+ 
+ Country1     1.234,56 mk             -1.234,56 mk                  FIM   1.234,56         FIM -1.234,56
+ Country2     L.1.234                 -L.1.234                      ITL   1.234            -ITL 1.234
+ Country3     fl. 1.234,56              fl. -1.234,56                   NLG   1.234,56         NLG -1.234,56
+ Country4     SFrs.1,234.56           SFrs.1,234.56C                CHF   1,234.56         CHF 1,234.56C
+<p><!--para 10-->
+ For these four countries, the respective values for the monetary members of the structure returned by
+ localeconv could be:
+<pre>
+                                   Country1              Country2              Country3            Country4</pre>
+ 
+ mon_decimal_point                 ","                   ""                   ","                 "."
+ mon_thousands_sep                 "."                   "."                  "."                 ","
+ mon_grouping                      "\3"                  "\3"                 "\3"                "\3"
+ positive_sign                     ""                    ""                   ""                  ""
+ negative_sign                     "-"                   "-"                  "-"                 "C"
+ currency_symbol                   "mk"                  "L."                 "\u0192"            "SFrs."
+ frac_digits                       2                     0                    2                   2
+ p_cs_precedes                     0                     1                    1                   1
+ n_cs_precedes                     0                     1                    1                   1
+ p_sep_by_space                    1                     0                    1                   0
+ n_sep_by_space                    1                     0                    2                   0
+ p_sign_posn                       1                     1                    1                   1
+ n_sign_posn                       1                     1                    4                   2
+ int_curr_symbol                   "FIM "                "ITL "               "NLG "              "CHF "
+ int_frac_digits                   2                     0                    2                   2
+ int_p_cs_precedes                 1                     1                    1                   1
+ int_n_cs_precedes                 1                     1                    1                   1
+ int_p_sep_by_space                1                     1                    1                   1
+ int_n_sep_by_space                2                     1                    2                   1
+ int_p_sign_posn                   1                     1                    1                   1
+ int_n_sign_posn                   4                     1                    4                   2
+<!--page 247 indent 5-->
+<p><!--para 11-->
+ EXAMPLE 2 The following table illustrates how the cs_precedes, sep_by_space, and sign_posn members
+ affect the formatted value.
+<pre>
+                                                               p_sep_by_space</pre>
+ 
+ p_cs_precedes           p_sign_posn                0                   1                  2
+ 
+<pre>
+                 0                    0         (<a href="#1.25">1.25</a>$)            (<a href="#1.25">1.25</a> $)            (<a href="#1.25">1.25</a>$)
+                                      1         +1.25$             +1.25 $             + <a href="#1.25">1.25</a>$
+                                      2         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
+                                      3         <a href="#1.25">1.25</a>+$             <a href="#1.25">1.25</a> +$             <a href="#1.25">1.25</a>+ $
+                                      4         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +</pre>
+ 
+<!--page 248 indent 4-->
+<pre>
+                 1                    0         ($1.25)            ($ <a href="#1.25">1.25</a>)            ($1.25)
+                                      1         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                      2         $1.25+             $ <a href="#1.25">1.25</a>+             $1.25 +
+                                      3         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                      4         $+1.25             $+ <a href="#1.25">1.25</a>             $ +1.25</pre>
+
+<a name="7.12" href="#7.12"><h3>7.12 Mathematics <math.h></h3></a>
+<p><!--para 1-->
+ The header &lt;math.h&gt; declares two types and many mathematical functions and defines
+ several macros. Most synopses specify a family of functions consisting of a principal
+ function with one or more double parameters, a double return value, or both; and
+ other functions with the same name but with f and l suffixes, which are corresponding
+ functions with float and long double parameters, return values, or both.<sup><a href="#note223"><b>223)</b></a></sup>
+ Integer arithmetic functions and conversion functions are discussed later.
+<p><!--para 2-->
+ The types
+<pre>
+         float_t
+         double_t</pre>
+ are floating types at least as wide as float and double, respectively, and such that
+ double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
+ float_t and double_t are float and double, respectively; if
+ FLT_EVAL_METHOD equals 1, they are both double; if FLT_EVAL_METHOD equals
+ 2, they are both long double; and for other values of FLT_EVAL_METHOD, they are
+ otherwise implementation-defined.<sup><a href="#note224"><b>224)</b></a></sup>
+<p><!--para 3-->
+ The macro
+<pre>
+         HUGE_VAL</pre>
+ expands to a positive double constant expression, not necessarily representable as a
+ float. The macros
+<pre>
+         HUGE_VALF
+         HUGE_VALL</pre>
+ are respectively float and long double analogs of HUGE_VAL.<sup><a href="#note225"><b>225)</b></a></sup>
+<p><!--para 4-->
+ The macro
+<pre>
+         INFINITY</pre>
+ expands to a constant expression of type float representing positive or unsigned
+ infinity, if available; else to a positive constant of type float that overflows at
+ 
+ 
+ 
+<!--page 249 indent 4-->
+ translation time.<sup><a href="#note226"><b>226)</b></a></sup>
+<p><!--para 5-->
+ The macro
+<pre>
+          NAN</pre>
+ is defined if and only if the implementation supports quiet NaNs for the float type. It
+ expands to a constant expression of type float representing a quiet NaN.
+<p><!--para 6-->
+ The number classification macros
+<pre>
+          FP_INFINITE
+          FP_NAN
+          FP_NORMAL
+          FP_SUBNORMAL
+          FP_ZERO</pre>
+ represent the mutually exclusive kinds of floating-point values. They expand to integer
+ constant expressions with distinct values. Additional implementation-defined floating-
+ point classifications, with macro definitions beginning with FP_ and an uppercase letter,
+ may also be specified by the implementation.
+<p><!--para 7-->
+ The macro
+<pre>
+          FP_FAST_FMA</pre>
+ is optionally defined. If defined, it indicates that the fma function generally executes
+ about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note227"><b>227)</b></a></sup> The
+ macros
+<pre>
+          FP_FAST_FMAF
+          FP_FAST_FMAL</pre>
+ are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
+ these macros expand to the integer constant 1.
+<p><!--para 8-->
+ The macros
+<pre>
+          FP_ILOGB0
+          FP_ILOGBNAN</pre>
+ expand to integer constant expressions whose values are returned by ilogb(x) if x is
+ zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
+ -INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
+ 
+ 
+<!--page 250 indent 4-->
+<p><!--para 9-->
+ The macros
+<pre>
+         MATH_ERRNO
+         MATH_ERREXCEPT</pre>
+ expand to the integer constants 1 and 2, respectively; the macro
+<pre>
+         math_errhandling</pre>
+ expands to an expression that has type int and the value MATH_ERRNO,
+ MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
+ constant for the duration of the program. It is unspecified whether
+ math_errhandling is a macro or an identifier with external linkage. If a macro
+ definition is suppressed or a program defines an identifier with the name
+ math_errhandling, the behavior is undefined.               If the expression
+ math_errhandling &amp; MATH_ERREXCEPT can be nonzero, the implementation
+ shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
+ &lt;fenv.h&gt;.
+
+<h6>footnotes</h6>
+<p><a name="note223">223)</a> Particularly on systems with wide expression evaluation, a &lt;math.h&gt; function might pass arguments
+ and return values in wider format than the synopsis prototype indicates.
+
+<p><a name="note224">224)</a> The types float_t and double_t are intended to be the implementation's most efficient types at
+ least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
+ type float_t is the narrowest type used by the implementation to evaluate floating expressions.
+
+<p><a name="note225">225)</a> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
+ supports infinities.
+
+<p><a name="note226">226)</a> In this case, using INFINITY will violate the constraint in <a href="#6.4.4">6.4.4</a> and thus require a diagnostic.
+
+<p><a name="note227">227)</a> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
+ directly with a hardware multiply-add instruction. Software implementations are expected to be
+ substantially slower.
+
+
+<a name="7.12.1" href="#7.12.1"><h4>7.12.1 Treatment of error conditions</h4></a>
+<p><!--para 1-->
+ The behavior of each of the functions in &lt;math.h&gt; is specified for all representable
+ values of its input arguments, except where stated otherwise. Each function shall execute
+ as if it were a single operation without raising SIGFPE and without generating any of the
+ floating-point exceptions ''invalid'', ''divide-by-zero'', or ''overflow'' except to reflect
+ the result of the function.
+<p><!--para 2-->
+ For all functions, a domain error occurs if an input argument is outside the domain over
+ which the mathematical function is defined. The description of each function lists any
+ required domain errors; an implementation may define additional domain errors, provided
+ that such errors are consistent with the mathematical definition of the function.<sup><a href="#note228"><b>228)</b></a></sup> On a
+ domain error, the function returns an implementation-defined value; if the integer
+ expression math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression
+ errno acquires the value EDOM; if the integer expression math_errhandling &amp;
+ MATH_ERREXCEPT is nonzero, the ''invalid'' floating-point exception is raised.
+<p><!--para 3-->
+ Similarly, a pole error (also known as a singularity or infinitary) occurs if the
+ mathematical function has an exact infinite result as the finite input argument(s) are
+ approached in the limit (for example, log(0.0)). The description of each function lists
+ any required pole errors; an implementation may define additional pole errors, provided
+ that such errors are consistent with the mathematical definition of the function. On a pole
+ error, the function returns an implementation-defined value; if the integer expression
+ 
+ 
+<!--page 251 indent 4-->
+ math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression errno
+ acquires the value ERANGE; if the integer expression math_errhandling &amp;
+ MATH_ERREXCEPT is nonzero, the ''divide-by-zero'' floating-point exception is raised.
+<p><!--para 4-->
+ Likewise, a range error occurs if the mathematical result of the function cannot be
+ represented in an object of the specified type, due to extreme magnitude.
+<p><!--para 5-->
+ A floating result overflows if the magnitude of the mathematical result is finite but so
+ large that the mathematical result cannot be represented without extraordinary roundoff
+ error in an object of the specified type. If a floating result overflows and default rounding
+ is in effect, then the function returns the value of the macro HUGE_VAL, HUGE_VALF, or *
+ HUGE_VALL according to the return type, with the same sign as the correct value of the
+ function; if the integer expression math_errhandling &amp; MATH_ERRNO is nonzero,
+ the integer expression errno acquires the value ERANGE; if the integer expression
+ math_errhandling &amp; MATH_ERREXCEPT is nonzero, the ''overflow'' floating-
+ point exception is raised.
+<p><!--para 6-->
+ The result underflows if the magnitude of the mathematical result is so small that the
+ mathematical result cannot be represented, without extraordinary roundoff error, in an
+ object of the specified type.<sup><a href="#note229"><b>229)</b></a></sup> If the result underflows, the function returns an
+ implementation-defined value whose magnitude is no greater than the smallest
+ normalized positive number in the specified type; if the integer expression
+ math_errhandling &amp; MATH_ERRNO is nonzero, whether errno acquires the
+ value    ERANGE       is    implementation-defined;     if   the  integer   expression
+ math_errhandling &amp; MATH_ERREXCEPT is nonzero, whether the ''underflow''
+ floating-point exception is raised is implementation-defined.
+<p><!--para 7-->
+ If a domain, pole, or range error occurs and the integer expression
+ math_errhandling &amp; MATH_ERRNO is zero,<sup><a href="#note230"><b>230)</b></a></sup> then errno shall either be set to
+ the value corresponding to the error or left unmodified. If no such error occurs, errno
+ shall be left unmodified regardless of the setting of math_errhandling.
+ 
+ 
+ 
+ 
+<!--page 252 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note228">228)</a> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
+ error if the mathematical domain of the function does not include the infinity.
+
+<p><a name="note229">229)</a> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
+ also ''flush-to-zero'' underflow.
+
+<p><a name="note230">230)</a> Math errors are being indicated by the floating-point exception flags rather than by errno.
+
+
+<a name="7.12.2" href="#7.12.2"><h4>7.12.2 The FP_CONTRACT pragma</h4></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          #pragma STDC FP_CONTRACT on-off-switch</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The FP_CONTRACT pragma can be used to allow (if the state is ''on'') or disallow (if the
+ state is ''off'') the implementation to contract expressions (<a href="#6.5">6.5</a>). Each pragma can occur
+ either outside external declarations or preceding all explicit declarations and statements
+ inside a compound statement. When outside external declarations, the pragma takes
+ effect from its occurrence until another FP_CONTRACT pragma is encountered, or until
+ the end of the translation unit. When inside a compound statement, the pragma takes
+ effect from its occurrence until another FP_CONTRACT pragma is encountered
+ (including within a nested compound statement), or until the end of the compound
+ statement; at the end of a compound statement the state for the pragma is restored to its
+ condition just before the compound statement. If this pragma is used in any other
+ context, the behavior is undefined. The default state (''on'' or ''off'') for the pragma is
+ implementation-defined.
+
+<a name="7.12.3" href="#7.12.3"><h4>7.12.3 Classification macros</h4></a>
+<p><!--para 1-->
+ In the synopses in this subclause, real-floating indicates that the argument shall be an
+ expression of real floating type.
+
+<a name="7.12.3.1" href="#7.12.3.1"><h5>7.12.3.1 The fpclassify macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          int fpclassify(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fpclassify macro classifies its argument value as NaN, infinite, normal,
+ subnormal, zero, or into another implementation-defined category. First, an argument
+ represented in a format wider than its semantic type is converted to its semantic type.
+ Then classification is based on the type of the argument.<sup><a href="#note231"><b>231)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fpclassify macro returns the value of the number classification macro
+ appropriate to the value of its argument.                                *
+ 
+ 
+<!--page 253 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note231">231)</a> Since an expression can be evaluated with more range and precision than its type has, it is important to
+ know the type that classification is based on. For example, a normal long double value might
+ become subnormal when converted to double, and zero when converted to float.
+
+
+<a name="7.12.3.2" href="#7.12.3.2"><h5>7.12.3.2 The isfinite macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isfinite(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isfinite macro determines whether its argument has a finite value (zero,
+ subnormal, or normal, and not infinite or NaN). First, an argument represented in a
+ format wider than its semantic type is converted to its semantic type. Then determination
+ is based on the type of the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isfinite macro returns a nonzero value if and only if its argument has a finite
+ value.
+
+<a name="7.12.3.3" href="#7.12.3.3"><h5>7.12.3.3 The isinf macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isinf(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isinf macro determines whether its argument value is an infinity (positive or
+ negative). First, an argument represented in a format wider than its semantic type is
+ converted to its semantic type. Then determination is based on the type of the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isinf macro returns a nonzero value if and only if its argument has an infinite
+ value.
+
+<a name="7.12.3.4" href="#7.12.3.4"><h5>7.12.3.4 The isnan macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isnan(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isnan macro determines whether its argument value is a NaN. First, an argument
+ represented in a format wider than its semantic type is converted to its semantic type.
+ Then determination is based on the type of the argument.<sup><a href="#note232"><b>232)</b></a></sup>
+ 
+ 
+<!--page 254 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isnan macro returns a nonzero value if and only if its argument has a NaN value.
+
+<h6>footnotes</h6>
+<p><a name="note232">232)</a> For the isnan macro, the type for determination does not matter unless the implementation supports
+ NaNs in the evaluation type but not in the semantic type.
+
+
+<a name="7.12.3.5" href="#7.12.3.5"><h5>7.12.3.5 The isnormal macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isnormal(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isnormal macro determines whether its argument value is normal (neither zero,
+ subnormal, infinite, nor NaN). First, an argument represented in a format wider than its
+ semantic type is converted to its semantic type. Then determination is based on the type
+ of the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isnormal macro returns a nonzero value if and only if its argument has a normal
+ value.
+
+<a name="7.12.3.6" href="#7.12.3.6"><h5>7.12.3.6 The signbit macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int signbit(real-floating x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The signbit macro determines whether the sign of its argument value is negative.<sup><a href="#note233"><b>233)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The signbit macro returns a nonzero value if and only if the sign of its argument value
+ is negative.
+ 
+ 
+ 
+ 
+<!--page 255 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note233">233)</a> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
+ unsigned, it is treated as positive.
+
+
+<a name="7.12.4" href="#7.12.4"><h4>7.12.4 Trigonometric functions</h4></a>
+
+<a name="7.12.4.1" href="#7.12.4.1"><h5>7.12.4.1 The acos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double acos(double x);
+         float acosf(float x);
+         long double acosl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The acos functions compute the principal value of the arc cosine of x. A domain error
+ occurs for arguments not in the interval [-1, +1].
+<h6>Returns</h6>
+<p><!--para 3-->
+ The acos functions return arccos x in the interval [0, pi ] radians.
+
+<a name="7.12.4.2" href="#7.12.4.2"><h5>7.12.4.2 The asin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double asin(double x);
+         float asinf(float x);
+         long double asinl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The asin functions compute the principal value of the arc sine of x. A domain error
+ occurs for arguments not in the interval [-1, +1].
+<h6>Returns</h6>
+<p><!--para 3-->
+ The asin functions return arcsin x in the interval [-pi /2, +pi /2] radians.
+
+<a name="7.12.4.3" href="#7.12.4.3"><h5>7.12.4.3 The atan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double atan(double x);
+         float atanf(float x);
+         long double atanl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atan functions compute the principal value of the arc tangent of x.
+<!--page 256 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atan functions return arctan x in the interval [-pi /2, +pi /2] radians.
+
+<a name="7.12.4.4" href="#7.12.4.4"><h5>7.12.4.4 The atan2 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double atan2(double y, double x);
+        float atan2f(float y, float x);
+        long double atan2l(long double y, long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atan2 functions compute the value of the arc tangent of y/x, using the signs of both
+ arguments to determine the quadrant of the return value. A domain error may occur if
+ both arguments are zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atan2 functions return arctan y/x in the interval [-pi , +pi ] radians.
+
+<a name="7.12.4.5" href="#7.12.4.5"><h5>7.12.4.5 The cos functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double cos(double x);
+        float cosf(float x);
+        long double cosl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cos functions compute the cosine of x (measured in radians).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cos functions return cos x.
+
+<a name="7.12.4.6" href="#7.12.4.6"><h5>7.12.4.6 The sin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double sin(double x);
+        float sinf(float x);
+        long double sinl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sin functions compute the sine of x (measured in radians).
+<!--page 257 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sin functions return sin x.
+
+<a name="7.12.4.7" href="#7.12.4.7"><h5>7.12.4.7 The tan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double tan(double x);
+         float tanf(float x);
+         long double tanl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tan functions return the tangent of x (measured in radians).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tan functions return tan x.
+
+<a name="7.12.5" href="#7.12.5"><h4>7.12.5 Hyperbolic functions</h4></a>
+
+<a name="7.12.5.1" href="#7.12.5.1"><h5>7.12.5.1 The acosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double acosh(double x);
+         float acoshf(float x);
+         long double acoshl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The acosh functions compute the (nonnegative) arc hyperbolic cosine of x. A domain
+ error occurs for arguments less than 1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The acosh functions return arcosh x in the interval [0, +(inf)].
+
+<a name="7.12.5.2" href="#7.12.5.2"><h5>7.12.5.2 The asinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double asinh(double x);
+         float asinhf(float x);
+         long double asinhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The asinh functions compute the arc hyperbolic sine of x.
+<!--page 258 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The asinh functions return arsinh x.
+
+<a name="7.12.5.3" href="#7.12.5.3"><h5>7.12.5.3 The atanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double atanh(double x);
+        float atanhf(float x);
+        long double atanhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atanh functions compute the arc hyperbolic tangent of x. A domain error occurs
+ for arguments not in the interval [-1, +1]. A pole error may occur if the argument equals
+ -1 or +1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atanh functions return artanh x.
+
+<a name="7.12.5.4" href="#7.12.5.4"><h5>7.12.5.4 The cosh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double cosh(double x);
+        float coshf(float x);
+        long double coshl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cosh functions compute the hyperbolic cosine of x. A range error occurs if the
+ magnitude of x is too large.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cosh functions return cosh x.
+
+<a name="7.12.5.5" href="#7.12.5.5"><h5>7.12.5.5 The sinh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double sinh(double x);
+        float sinhf(float x);
+        long double sinhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sinh functions compute the hyperbolic sine of x. A range error occurs if the
+ magnitude of x is too large.
+<!--page 259 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sinh functions return sinh x.
+
+<a name="7.12.5.6" href="#7.12.5.6"><h5>7.12.5.6 The tanh functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double tanh(double x);
+         float tanhf(float x);
+         long double tanhl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tanh functions compute the hyperbolic tangent of x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tanh functions return tanh x.
+
+<a name="7.12.6" href="#7.12.6"><h4>7.12.6 Exponential and logarithmic functions</h4></a>
+
+<a name="7.12.6.1" href="#7.12.6.1"><h5>7.12.6.1 The exp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double exp(double x);
+         float expf(float x);
+         long double expl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The exp functions compute the base-e exponential of x. A range error occurs if the
+ magnitude of x is too large.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The exp functions return ex .
+
+<a name="7.12.6.2" href="#7.12.6.2"><h5>7.12.6.2 The exp2 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double exp2(double x);
+         float exp2f(float x);
+         long double exp2l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The exp2 functions compute the base-2 exponential of x. A range error occurs if the
+ magnitude of x is too large.
+<!--page 260 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The exp2 functions return 2x .
+
+<a name="7.12.6.3" href="#7.12.6.3"><h5>7.12.6.3 The expm1 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double expm1(double x);
+         float expm1f(float x);
+         long double expm1l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The expm1 functions compute the base-e exponential of the argument, minus 1. A range
+ error occurs if x is too large.<sup><a href="#note234"><b>234)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The expm1 functions return ex - 1.
+
+<h6>footnotes</h6>
+<p><a name="note234">234)</a> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
+
+
+<a name="7.12.6.4" href="#7.12.6.4"><h5>7.12.6.4 The frexp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double frexp(double value, int *exp);
+         float frexpf(float value, int *exp);
+         long double frexpl(long double value, int *exp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The frexp functions break a floating-point number into a normalized fraction and an
+ integral power of 2. They store the integer in the int object pointed to by exp.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If value is not a floating-point number or if the integral power of 2 is outside the range
+ of int, the results are unspecified. Otherwise, the frexp functions return the value x,
+ such that x has a magnitude in the interval [1/2, 1) or zero, and value equals x x 2*exp .
+ If value is zero, both parts of the result are zero.
+ 
+ 
+ 
+ 
+<!--page 261 indent 4-->
+
+<a name="7.12.6.5" href="#7.12.6.5"><h5>7.12.6.5 The ilogb functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int ilogb(double x);
+         int ilogbf(float x);
+         int ilogbl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ilogb functions extract the exponent of x as a signed int value. If x is zero they
+ compute the value FP_ILOGB0; if x is infinite they compute the value INT_MAX; if x is
+ a NaN they compute the value FP_ILOGBNAN; otherwise, they are equivalent to calling
+ the corresponding logb function and casting the returned value to type int. A domain
+ error or range error may occur if x is zero, infinite, or NaN. If the correct value is outside
+ the range of the return type, the numeric result is unspecified.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ilogb functions return the exponent of x as a signed int value.
+ Forward references: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
+
+<a name="7.12.6.6" href="#7.12.6.6"><h5>7.12.6.6 The ldexp functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double ldexp(double x, int exp);
+         float ldexpf(float x, int exp);
+         long double ldexpl(long double x, int exp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ldexp functions multiply a floating-point number by an integral power of 2. A
+ range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ldexp functions return x x 2exp .
+
+<a name="7.12.6.7" href="#7.12.6.7"><h5>7.12.6.7 The log functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 262 indent 4-->
+<pre>
+         #include &lt;math.h&gt;
+         double log(double x);
+         float logf(float x);
+         long double logl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log functions compute the base-e (natural) logarithm of x. A domain error occurs if
+ the argument is negative. A pole error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log functions return loge x.
+
+<a name="7.12.6.8" href="#7.12.6.8"><h5>7.12.6.8 The log10 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double log10(double x);
+         float log10f(float x);
+         long double log10l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log10 functions compute the base-10 (common) logarithm of x. A domain error
+ occurs if the argument is negative. A pole error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log10 functions return log10 x.
+
+<a name="7.12.6.9" href="#7.12.6.9"><h5>7.12.6.9 The log1p functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double log1p(double x);
+         float log1pf(float x);
+         long double log1pl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log1p functions compute the base-e (natural) logarithm of 1 plus the argument.<sup><a href="#note235"><b>235)</b></a></sup>
+ A domain error occurs if the argument is less than -1. A pole error may occur if the
+ argument equals -1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log1p functions return loge (1 + x).
+ 
+ 
+ 
+ 
+<!--page 263 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note235">235)</a> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
+
+
+<a name="7.12.6.10" href="#7.12.6.10"><h5>7.12.6.10 The log2 functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double log2(double x);
+         float log2f(float x);
+         long double log2l(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The log2 functions compute the base-2 logarithm of x. A domain error occurs if the
+ argument is less than zero. A pole error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The log2 functions return log2 x.
+
+<a name="7.12.6.11" href="#7.12.6.11"><h5>7.12.6.11 The logb functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double logb(double x);
+         float logbf(float x);
+         long double logbl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The logb functions extract the exponent of x, as a signed integer value in floating-point
+ format. If x is subnormal it is treated as though it were normalized; thus, for positive
+ finite x,
+<pre>
+       1 &lt;= x x FLT_RADIX-logb(x) &lt; FLT_RADIX</pre>
+ A domain error or pole error may occur if the argument is zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The logb functions return the signed exponent of x.
+
+<a name="7.12.6.12" href="#7.12.6.12"><h5>7.12.6.12 The modf functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double modf(double value, double *iptr);
+         float modff(float value, float *iptr);
+         long double modfl(long double value, long double *iptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The modf functions break the argument value into integral and fractional parts, each of
+ which has the same type and sign as the argument. They store the integral part (in
+<!--page 264 indent 4-->
+ floating-point format) in the object pointed to by iptr.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The modf functions return the signed fractional part of value.
+
+<a name="7.12.6.13" href="#7.12.6.13"><h5>7.12.6.13 The scalbn and scalbln functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double scalbn(double x, int n);
         float scalbnf(float x, int n);
         long double scalbnl(long double x, int n);
         double scalbln(double x, long int n);
         float scalblnf(float x, long int n);
-        long double scalblnl(long double x, long int n);
+        long double scalblnl(long double x, long int n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The scalbn and scalbln functions compute x x FLT_RADIXn efficiently, not
+ normally by computing FLT_RADIXn explicitly. A range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The scalbn and scalbln functions return x x FLT_RADIXn .
+
+<a name="7.12.7" href="#7.12.7"><h4>7.12.7 Power and absolute-value functions</h4></a>
+
+<a name="7.12.7.1" href="#7.12.7.1"><h5>7.12.7.1 The cbrt functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double cbrt(double x);
-
-[<a name="p477" href="#p477">page 477</a>] (<a href="#Contents">Contents</a>)
-
-      float cbrtf(float x);
-      long double cbrtl(long double x);
-      double fabs(double x);
-      float fabsf(float x);
-      long double fabsl(long double x);
-      double hypot(double x, double y);
-      float hypotf(float x, float y);
-      long double hypotl(long double x, long double y);
-      double pow(double x, double y);
-      float powf(float x, float y);
-      long double powl(long double x, long double y);
-      double sqrt(double x);
-      float sqrtf(float x);
-      long double sqrtl(long double x);
-      double erf(double x);
-      float erff(float x);
-      long double erfl(long double x);
-      double erfc(double x);
-      float erfcf(float x);
-      long double erfcl(long double x);
-      double lgamma(double x);
-      float lgammaf(float x);
-      long double lgammal(long double x);
-      double tgamma(double x);
-      float tgammaf(float x);
-      long double tgammal(long double x);
-      double ceil(double x);
-      float ceilf(float x);
-      long double ceill(long double x);
-      double floor(double x);
-      float floorf(float x);
-      long double floorl(long double x);
-      double nearbyint(double x);
-      float nearbyintf(float x);
-      long double nearbyintl(long double x);
-      double rint(double x);
-      float rintf(float x);
-      long double rintl(long double x);
-      long int lrint(double x);
-      long int lrintf(float x);
-      long int lrintl(long double x);
-
-[<a name="p478" href="#p478">page 478</a>] (<a href="#Contents">Contents</a>)
-
-        long long int llrint(double x);
-        long long int llrintf(float x);
-        long long int llrintl(long double x);
+        float cbrtf(float x);
+        long double cbrtl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cbrt functions compute the real cube root of x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cbrt functions return x1/3 .
+<!--page 265 indent 4-->
+
+<a name="7.12.7.2" href="#7.12.7.2"><h5>7.12.7.2 The fabs functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fabs(double x);
+         float fabsf(float x);
+         long double fabsl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fabs functions compute the absolute value of a floating-point number x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fabs functions return | x |.
+
+<a name="7.12.7.3" href="#7.12.7.3"><h5>7.12.7.3 The hypot functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double hypot(double x, double y);
+         float hypotf(float x, float y);
+         long double hypotl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The hypot functions compute the square root of the sum of the squares of x and y,
+ without undue overflow or underflow. A range error may occur.
+<p><!--para 3-->
+<h6>Returns</h6>
+<p><!--para 4-->
+ The hypot functions return (sqrt)x2 + y2 .
+<pre>
+                            -
+                            -----</pre>
+
+<a name="7.12.7.4" href="#7.12.7.4"><h5>7.12.7.4 The pow functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double pow(double x, double y);
+         float powf(float x, float y);
+         long double powl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The pow functions compute x raised to the power y. A domain error occurs if x is finite
+ and negative and y is finite and not an integer value. A range error may occur. A domain
+ error may occur if x is zero and y is zero. A domain error or pole error may occur if x is
+ zero and y is less than zero.
+<!--page 266 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The pow functions return xy .
+
+<a name="7.12.7.5" href="#7.12.7.5"><h5>7.12.7.5 The sqrt functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double sqrt(double x);
+        float sqrtf(float x);
+        long double sqrtl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sqrt functions compute the nonnegative square root of x. A domain error occurs if
+ the argument is less than zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sqrt functions return (sqrt)x.
+<pre>
+                           -
+                           -</pre>
+
+<a name="7.12.8" href="#7.12.8"><h4>7.12.8 Error and gamma functions</h4></a>
+
+<a name="7.12.8.1" href="#7.12.8.1"><h5>7.12.8.1 The erf functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double erf(double x);
+        float erff(float x);
+        long double erfl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The erf functions compute the error function of x.
+<h6>Returns</h6>
+<p><!--para 3-->
+<pre>
+                                    2        x
+                                         (integral)       e-t dt.
+                                                   2</pre>
+ The erf functions return erf x =
+<pre>
+                                    (sqrt)pi
+                                    -
+                                    -    0</pre>
+ 
+
+<a name="7.12.8.2" href="#7.12.8.2"><h5>7.12.8.2 The erfc functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double erfc(double x);
+        float erfcf(float x);
+        long double erfcl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The erfc functions compute the complementary error function of x. A range error
+ occurs if x is too large.
+<!--page 267 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+<pre>
+                                                     2       (inf)
+                                                         (integral)       e-t dt.
+                                                                   2</pre>
+ The erfc functions return erfc x = 1 - erf x =
+<pre>
+                                                  (sqrt)pi
+                                                  -
+                                                  -      x</pre>
+ 
+
+<a name="7.12.8.3" href="#7.12.8.3"><h5>7.12.8.3 The lgamma functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double lgamma(double x);
+         float lgammaf(float x);
+         long double lgammal(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The lgamma functions compute the natural logarithm of the absolute value of gamma of
+ x. A range error occurs if x is too large. A pole error may occur if x is a negative integer
+ or zero.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The lgamma functions return loge | (Gamma)(x) |.
+
+<a name="7.12.8.4" href="#7.12.8.4"><h5>7.12.8.4 The tgamma functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double tgamma(double x);
+         float tgammaf(float x);
+         long double tgammal(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tgamma functions compute the gamma function of x. A domain error or pole error
+ may occur if x is a negative integer or zero. A range error occurs if the magnitude of x is
+ too large and may occur if the magnitude of x is too small.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tgamma functions return (Gamma)(x).
+<!--page 268 indent 4-->
+
+<a name="7.12.9" href="#7.12.9"><h4>7.12.9 Nearest integer functions</h4></a>
+
+<a name="7.12.9.1" href="#7.12.9.1"><h5>7.12.9.1 The ceil functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double ceil(double x);
+        float ceilf(float x);
+        long double ceill(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ceil functions compute the smallest integer value not less than x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ceil functions return [^x^], expressed as a floating-point number.
+
+<a name="7.12.9.2" href="#7.12.9.2"><h5>7.12.9.2 The floor functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double floor(double x);
+        float floorf(float x);
+        long double floorl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The floor functions compute the largest integer value not greater than x.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The floor functions return [_x_], expressed as a floating-point number.
+
+<a name="7.12.9.3" href="#7.12.9.3"><h5>7.12.9.3 The nearbyint functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        double nearbyint(double x);
+        float nearbyintf(float x);
+        long double nearbyintl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The nearbyint functions round their argument to an integer value in floating-point
+ format, using the current rounding direction and without raising the ''inexact'' floating-
+ point exception.
+<!--page 269 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The nearbyint functions return the rounded integer value.
+
+<a name="7.12.9.4" href="#7.12.9.4"><h5>7.12.9.4 The rint functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double rint(double x);
+         float rintf(float x);
+         long double rintl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rint functions differ from the nearbyint functions (<a href="#7.12.9.3">7.12.9.3</a>) only in that the
+ rint functions may raise the ''inexact'' floating-point exception if the result differs in
+ value from the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The rint functions return the rounded integer value.
+
+<a name="7.12.9.5" href="#7.12.9.5"><h5>7.12.9.5 The lrint and llrint functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         long int lrint(double x);
+         long int lrintf(float x);
+         long int lrintl(long double x);
+         long long int llrint(double x);
+         long long int llrintf(float x);
+         long long int llrintl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The lrint and llrint functions round their argument to the nearest integer value,
+ rounding according to the current rounding direction. If the rounded value is outside the
+ range of the return type, the numeric result is unspecified and a domain error or range
+ error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The lrint and llrint functions return the rounded integer value.
+<!--page 270 indent 4-->
+
+<a name="7.12.9.6" href="#7.12.9.6"><h5>7.12.9.6 The round functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double round(double x);
         float roundf(float x);
-        long double roundl(long double x);
+        long double roundl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The round functions round their argument to the nearest integer value in floating-point
+ format, rounding halfway cases away from zero, regardless of the current rounding
+ direction.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The round functions return the rounded integer value.
+
+<a name="7.12.9.7" href="#7.12.9.7"><h5>7.12.9.7 The lround and llround functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         long int lround(double x);
         long int lroundf(float x);
         long int lroundl(long double x);
         long long int llround(double x);
         long long int llroundf(float x);
-        long long int llroundl(long double x);
+        long long int llroundl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The lround and llround functions round their argument to the nearest integer value,
+ rounding halfway cases away from zero, regardless of the current rounding direction. If
+ the rounded value is outside the range of the return type, the numeric result is unspecified
+ and a domain error or range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The lround and llround functions return the rounded integer value.
+
+<a name="7.12.9.8" href="#7.12.9.8"><h5>7.12.9.8 The trunc functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 271 indent 4-->
+<pre>
+        #include &lt;math.h&gt;
         double trunc(double x);
         float truncf(float x);
-        long double truncl(long double x);
-        double fmod(double x, double y);
-        float fmodf(float x, float y);
-        long double fmodl(long double x, long double y);
-        double remainder(double x, double y);
-        float remainderf(float x, float y);
-        long double remainderl(long double x, long double y);
+        long double truncl(long double x);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The trunc functions round their argument to the integer value, in floating format,
+ nearest to but no larger in magnitude than the argument.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The trunc functions return the truncated integer value.
+
+<a name="7.12.10" href="#7.12.10"><h4>7.12.10 Remainder functions</h4></a>
+
+<a name="7.12.10.1" href="#7.12.10.1"><h5>7.12.10.1 The fmod functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          double fmod(double x, double y);
+          float fmodf(float x, float y);
+          long double fmodl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fmod functions compute the floating-point remainder of x/y.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fmod functions return the value x - ny, for some integer n such that, if y is nonzero,
+ the result has the same sign as x and magnitude less than the magnitude of y. If y is zero,
+ whether a domain error occurs or the fmod functions return zero is implementation-
+ defined.
+
+<a name="7.12.10.2" href="#7.12.10.2"><h5>7.12.10.2 The remainder functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          double remainder(double x, double y);
+          float remainderf(float x, float y);
+          long double remainderl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The remainder functions compute the remainder x REM y required by IEC 60559.<sup><a href="#note236"><b>236)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 272 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The remainder functions return x REM y. If y is zero, whether a domain error occurs
+ or the functions return zero is implementation defined.
+
+<h6>footnotes</h6>
+<p><a name="note236">236)</a> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
+ mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
+ | n - x/y | = 1/2, then n is even. If r = 0, its sign shall be that of x.'' This definition is applicable for *
+ all implementations.
+
+
+<a name="7.12.10.3" href="#7.12.10.3"><h5>7.12.10.3 The remquo functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double remquo(double x, double y, int *quo);
         float remquof(float x, float y, int *quo);
         long double remquol(long double x, long double y,
-             int *quo);
+             int *quo);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The remquo functions compute the same remainder as the remainder functions. In
+ the object pointed to by quo they store a value whose sign is the sign of x/y and whose
+ magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where
+ n is an implementation-defined integer greater than or equal to 3.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The remquo functions return x REM y. If y is zero, the value stored in the object
+ pointed to by quo is unspecified and whether a domain error occurs or the functions
+ return zero is implementation defined.
+
+<a name="7.12.11" href="#7.12.11"><h4>7.12.11 Manipulation functions</h4></a>
+
+<a name="7.12.11.1" href="#7.12.11.1"><h5>7.12.11.1 The copysign functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
         double copysign(double x, double y);
         float copysignf(float x, float y);
-        long double copysignl(long double x, long double y);
-        double nan(const char *tagp);
-        float nanf(const char *tagp);
-        long double nanl(const char *tagp);
-        double nextafter(double x, double y);
-        float nextafterf(float x, float y);
-        long double nextafterl(long double x, long double y);
-        double nexttoward(double x, long double y);
-        float nexttowardf(float x, long double y);
-        long double nexttowardl(long double x, long double y);
-        double fdim(double x, double y);
-        float fdimf(float x, float y);
-        long double fdiml(long double x, long double y);
-        double fmax(double x, double y);
-
-[<a name="p479" href="#p479">page 479</a>] (<a href="#Contents">Contents</a>)
-
-      float fmaxf(float x, float y);
-      long double fmaxl(long double x, long double y);
-      double fmin(double x, double y);
-      float fminf(float x, float y);
-      long double fminl(long double x, long double y);
-      double fma(double x, double y, double z);
-      float fmaf(float x, float y, float z);
-      long double fmal(long double x, long double y,
-           long double z);
-      int isgreater(real-floating x, real-floating y);
-      int isgreaterequal(real-floating x, real-floating y);
-      int isless(real-floating x, real-floating y);
-      int islessequal(real-floating x, real-floating y);
-      int islessgreater(real-floating x, real-floating y);
-      int isunordered(real-floating x, real-floating y);
-<a name="B.12" href="#B.12"><b>B.12 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
-      jmp_buf
-      int setjmp(jmp_buf env);
-      _Noreturn void longjmp(jmp_buf env, int val);
-<a name="B.13" href="#B.13"><b>B.13 Signal handling &lt;signal.h&gt;</b></a>
-      sig_atomic_t    SIG_IGN           SIGILL           SIGTERM
-      SIG_DFL         SIGABRT           SIGINT
-      SIG_ERR         SIGFPE            SIGSEGV
-      void (*signal(int sig, void (*func)(int)))(int);
-      int raise(int sig);
-
-[<a name="p480" href="#p480">page 480</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.14" href="#B.14"><b>B.14 Alignment &lt;stdalign.h&gt;</b></a>
-        alignas
-        __alignas_is_defined
-<a name="B.15" href="#B.15"><b>B.15 Variable arguments &lt;stdarg.h&gt;</b></a>
-        va_list
-        type va_arg(va_list ap, type);
-        void va_copy(va_list dest, va_list src);
-        void va_end(va_list ap);
-        void va_start(va_list ap, parmN);
-<a name="B.16" href="#B.16"><b>B.16 Atomics &lt;stdatomic.h&gt;</b></a>
-        ATOMIC_CHAR_LOCK_FREE           atomic_uint
-        ATOMIC_CHAR16_T_LOCK_FREE       atomic_long
-        ATOMIC_CHAR32_T_LOCK_FREE       atomic_ulong
-        ATOMIC_WCHAR_T_LOCK_FREE        atomic_llong
-        ATOMIC_SHORT_LOCK_FREE          atomic_ullong
-        ATOMIC_INT_LOCK_FREE            atomic_char16_t
-        ATOMIC_LONG_LOCK_FREE           atomic_char32_t
-        ATOMIC_LLONG_LOCK_FREE          atomic_wchar_t
-        ATOMIC_ADDRESS_LOCK_FREE        atomic_int_least8_t
-        ATOMIC_FLAG_INIT                atomic_uint_least8_t
-        memory_order                    atomic_int_least16_t
-        atomic_flag                     atomic_uint_least16_t
-        atomic_bool                     atomic_int_least32_t
-        atomic_address                  atomic_uint_least32_t
-        memory_order_relaxed            atomic_int_least64_t
-        memory_order_consume            atomic_uint_least64_t
-        memory_order_acquire            atomic_int_fast8_t
-        memory_order_release            atomic_uint_fast8_t
-        memory_order_acq_rel            atomic_int_fast16_t
-        memory_order_seq_cst            atomic_uint_fast16_t
-        atomic_char                     atomic_int_fast32_t
-        atomic_schar                    atomic_uint_fast32_t
-        atomic_uchar                    atomic_int_fast64_t
-        atomic_short                    atomic_uint_fast64_t
-        atomic_ushort                   atomic_intptr_t
-        atomic_int                      atomic_uintptr_t
-
-[<a name="p481" href="#p481">page 481</a>] (<a href="#Contents">Contents</a>)
-
-      atomic_size_t                     atomic_intmax_t
-      atomic_ptrdiff_t                  atomic_uintmax_t
-      #define ATOMIC_VAR_INIT(C value)
-      void atomic_init(volatile A *obj, C value);
-      type kill_dependency(type y);
-      void atomic_thread_fence(memory_order order);
-      void atomic_signal_fence(memory_order order);
-      _Bool atomic_is_lock_free(atomic_type const volatile *obj);
-      void atomic_store(volatile A *object, C desired);
-      void atomic_store_explicit(volatile A *object,
-            C desired, memory_order order);
-      C atomic_load(volatile A *object);
-      C atomic_load_explicit(volatile A *object,
-            memory_order order);
-      C atomic_exchange(volatile A *object, C desired);
-      C atomic_exchange_explicit(volatile A *object,
-            C desired, memory_order order);
-      _Bool atomic_compare_exchange_strong(volatile A *object,
-            C *expected, C desired);
-      _Bool atomic_compare_exchange_strong_explicit(
-            volatile A *object, C *expected, C desired,
-            memory_order success, memory_order failure);
-      _Bool atomic_compare_exchange_weak(volatile A *object,
-            C *expected, C desired);
-      _Bool atomic_compare_exchange_weak_explicit(
-            volatile A *object, C *expected, C desired,
-            memory_order success, memory_order failure);
-      C atomic_fetch_key(volatile A *object, M operand);
-      C atomic_fetch_key_explicit(volatile A *object,
-            M operand, memory_order order);
-      bool atomic_flag_test_and_set(
-            volatile atomic_flag *object);
-      bool atomic_flag_test_and_set_explicit(
-            volatile atomic_flag *object, memory_order order);
-      void atomic_flag_clear(volatile atomic_flag *object);
-      void atomic_flag_clear_explicit(
-            volatile atomic_flag *object, memory_order order);
-
-[<a name="p482" href="#p482">page 482</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.17" href="#B.17"><b>B.17 Boolean type and values &lt;stdbool.h&gt;</b></a>
-        bool
-        true
-        false
-        __bool_true_false_are_defined
-<a name="B.18" href="#B.18"><b>B.18 Common definitions &lt;stddef.h&gt;</b></a>
-        ptrdiff_t       max_align_t       NULL
-        size_t          wchar_t
-        offsetof(type, member-designator)
-        __STDC_WANT_LIB_EXT1__
-        rsize_t
-<a name="B.19" href="#B.19"><b>B.19 Integer types &lt;stdint.h&gt;</b></a>
-        intN_t                INT_LEASTN_MIN          PTRDIFF_MAX
-        uintN_t               INT_LEASTN_MAX          SIG_ATOMIC_MIN
-        int_leastN_t          UINT_LEASTN_MAX         SIG_ATOMIC_MAX
-        uint_leastN_t         INT_FASTN_MIN           SIZE_MAX
-        int_fastN_t           INT_FASTN_MAX           WCHAR_MIN
-        uint_fastN_t          UINT_FASTN_MAX          WCHAR_MAX
-        intptr_t              INTPTR_MIN              WINT_MIN
-        uintptr_t             INTPTR_MAX              WINT_MAX
-        intmax_t              UINTPTR_MAX             INTN_C(value)
-        uintmax_t             INTMAX_MIN              UINTN_C(value)
-        INTN_MIN              INTMAX_MAX              INTMAX_C(value)
-        INTN_MAX              UINTMAX_MAX             UINTMAX_C(value)
-        UINTN_MAX             PTRDIFF_MIN
-        __STDC_WANT_LIB_EXT1__
-        RSIZE_MAX
-
-[<a name="p483" href="#p483">page 483</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.20" href="#B.20"><b>B.20 Input/output &lt;stdio.h&gt;</b></a>
-      size_t          _IOLBF            FILENAME_MAX     TMP_MAX
-      FILE            _IONBF            L_tmpnam         stderr
-      fpos_t          BUFSIZ            SEEK_CUR         stdin
-      NULL            EOF               SEEK_END         stdout
-      _IOFBF          FOPEN_MAX         SEEK_SET
-      int remove(const char *filename);
-      int rename(const char *old, const char *new);
-      FILE *tmpfile(void);
-      char *tmpnam(char *s);
-      int fclose(FILE *stream);
-      int fflush(FILE *stream);
-      FILE *fopen(const char * restrict filename,
-           const char * restrict mode);
-      FILE *freopen(const char * restrict filename,
-           const char * restrict mode,
-           FILE * restrict stream);
-      void setbuf(FILE * restrict stream,
-           char * restrict buf);
-      int setvbuf(FILE * restrict stream,
-           char * restrict buf,
-           int mode, size_t size);
-      int fprintf(FILE * restrict stream,
-           const char * restrict format, ...);
-      int fscanf(FILE * restrict stream,
-           const char * restrict format, ...);
-      int printf(const char * restrict format, ...);
-      int scanf(const char * restrict format, ...);
-      int snprintf(char * restrict s, size_t n,
-           const char * restrict format, ...);
-      int sprintf(char * restrict s,
-           const char * restrict format, ...);
-      int sscanf(const char * restrict s,
-           const char * restrict format, ...);
-      int vfprintf(FILE * restrict stream,
-           const char * restrict format, va_list arg);
-      int vfscanf(FILE * restrict stream,
-           const char * restrict format, va_list arg);
-      int vprintf(const char * restrict format, va_list arg);
-      int vscanf(const char * restrict format, va_list arg);
-
-[<a name="p484" href="#p484">page 484</a>] (<a href="#Contents">Contents</a>)
-
+        long double copysignl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The copysign functions produce a value with the magnitude of x and the sign of y.
+ They produce a NaN (with the sign of y) if x is a NaN. On implementations that
+ represent a signed zero but do not treat negative zero consistently in arithmetic
+ operations, the copysign functions regard the sign of zero as positive.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The copysign functions return a value with the magnitude of x and the sign of y.
+<!--page 273 indent 4-->
+
+<a name="7.12.11.2" href="#7.12.11.2"><h5>7.12.11.2 The nan functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double nan(const char *tagp);
+         float nanf(const char *tagp);
+         long double nanl(const char *tagp);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The call nan("n-char-sequence") is equivalent to strtod("NAN(n-char-
+ sequence)",     (char**)       NULL); the call nan("") is equivalent to
+ strtod("NAN()", (char**) NULL). If tagp does not point to an n-char
+ sequence or an empty string, the call is equivalent to strtod("NAN", (char**)
+ NULL). Calls to nanf and nanl are equivalent to the corresponding calls to strtof
+ and strtold.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The nan functions return a quiet NaN, if available, with content indicated through tagp.
+ If the implementation does not support quiet NaNs, the functions return zero.
+ Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
+
+<a name="7.12.11.3" href="#7.12.11.3"><h5>7.12.11.3 The nextafter functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double nextafter(double x, double y);
+         float nextafterf(float x, float y);
+         long double nextafterl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The nextafter functions determine the next representable value, in the type of the
+ function, after x in the direction of y, where x and y are first converted to the type of the
+ function.<sup><a href="#note237"><b>237)</b></a></sup> The nextafter functions return y if x equals y. A range error may occur
+ if the magnitude of x is the largest finite value representable in the type and the result is
+ infinite or not representable in the type.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The nextafter functions return the next representable value in the specified format
+ after x in the direction of y.
+ 
+ 
+<!--page 274 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note237">237)</a> The argument values are converted to the type of the function, even by a macro implementation of the
+ function.
+
+
+<a name="7.12.11.4" href="#7.12.11.4"><h5>7.12.11.4 The nexttoward functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double nexttoward(double x, long double y);
+         float nexttowardf(float x, long double y);
+         long double nexttowardl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The nexttoward functions are equivalent to the nextafter functions except that the
+ second parameter has type long double and the functions return y converted to the
+ type of the function if x equals y.<sup><a href="#note238"><b>238)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note238">238)</a> The result of the nexttoward functions is determined in the type of the function, without loss of
+ range or precision in a floating second argument.
+
+
+<a name="7.12.12" href="#7.12.12"><h4>7.12.12 Maximum, minimum, and positive difference functions</h4></a>
+
+<a name="7.12.12.1" href="#7.12.12.1"><h5>7.12.12.1 The fdim functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fdim(double x, double y);
+         float fdimf(float x, float y);
+         long double fdiml(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fdim functions determine the positive difference between their arguments:
+<pre>
+       {x - y if x &gt; y
+       {
+       {+0     if x &lt;= y</pre>
+ A range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fdim functions return the positive difference value.
+
+<a name="7.12.12.2" href="#7.12.12.2"><h5>7.12.12.2 The fmax functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fmax(double x, double y);
+         float fmaxf(float x, float y);
+         long double fmaxl(long double x, long double y);</pre>
+ 
+ 
+ 
+<!--page 275 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The fmax functions determine the maximum numeric value of their arguments.<sup><a href="#note239"><b>239)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fmax functions return the maximum numeric value of their arguments.
+
+<h6>footnotes</h6>
+<p><a name="note239">239)</a> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
+ fmax functions choose the numeric value. See <a href="#F.10.9.2">F.10.9.2</a>.
+
+
+<a name="7.12.12.3" href="#7.12.12.3"><h5>7.12.12.3 The fmin functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fmin(double x, double y);
+         float fminf(float x, float y);
+         long double fminl(long double x, long double y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fmin functions determine the minimum numeric value of their arguments.<sup><a href="#note240"><b>240)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fmin functions return the minimum numeric value of their arguments.
+
+<h6>footnotes</h6>
+<p><a name="note240">240)</a> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
+
+
+<a name="7.12.13" href="#7.12.13"><h4>7.12.13 Floating multiply-add</h4></a>
+
+<a name="7.12.13.1" href="#7.12.13.1"><h5>7.12.13.1 The fma functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         double fma(double x, double y, double z);
+         float fmaf(float x, float y, float z);
+         long double fmal(long double x, long double y,
+              long double z);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fma functions compute (x x y) + z, rounded as one ternary operation: they compute
+ the value (as if) to infinite precision and round once to the result format, according to the
+ current rounding mode. A range error may occur.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fma functions return (x x y) + z, rounded as one ternary operation.
+ 
+ 
+ 
+ 
+<!--page 276 indent 4-->
+
+<a name="7.12.14" href="#7.12.14"><h4>7.12.14 Comparison macros</h4></a>
+<p><!--para 1-->
+ The relational and equality operators support the usual mathematical relationships
+ between numeric values. For any ordered pair of numeric values exactly one of the
+ relationships -- less, greater, and equal -- is true. Relational operators may raise the
+ ''invalid'' floating-point exception when argument values are NaNs. For a NaN and a
+ numeric value, or for two NaNs, just the unordered relationship is true.<sup><a href="#note241"><b>241)</b></a></sup> The following
+ subclauses provide macros that are quiet (non floating-point exception raising) versions
+ of the relational operators, and other comparison macros that facilitate writing efficient
+ code that accounts for NaNs without suffering the ''invalid'' floating-point exception. In
+ the synopses in this subclause, real-floating indicates that the argument shall be an
+ expression of real floating type<sup><a href="#note242"><b>242)</b></a></sup> (both arguments need not have the same type).<sup><a href="#note243"><b>243)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note241">241)</a> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
+ the operands compare unordered, as an error indicator for programs written without consideration of
+ NaNs; the result in these cases is false.
+
+<p><a name="note242">242)</a> If any argument is of integer type, or any other type that is not a real floating type, the behavior is
+ undefined.
+
+<p><a name="note243">243)</a> Whether an argument represented in a format wider than its semantic type is converted to the semantic
+ type is unspecified.
+
+
+<a name="7.12.14.1" href="#7.12.14.1"><h5>7.12.14.1 The isgreater macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          int isgreater(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isgreater macro determines whether its first argument is greater than its second
+ argument. The value of isgreater(x, y) is always equal to (x) &gt; (y); however,
+ unlike (x) &gt; (y), isgreater(x, y) does not raise the ''invalid'' floating-point
+ exception when x and y are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isgreater macro returns the value of (x) &gt; (y).
+
+<a name="7.12.14.2" href="#7.12.14.2"><h5>7.12.14.2 The isgreaterequal macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;math.h&gt;
+          int isgreaterequal(real-floating x, real-floating y);</pre>
+ 
+ 
+ 
+ 
+<!--page 277 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The isgreaterequal macro determines whether its first argument is greater than or
+ equal to its second argument. The value of isgreaterequal(x, y) is always equal
+ to (x) &gt;= (y); however, unlike (x) &gt;= (y), isgreaterequal(x, y) does
+ not raise the ''invalid'' floating-point exception when x and y are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isgreaterequal macro returns the value of (x) &gt;= (y).
+
+<a name="7.12.14.3" href="#7.12.14.3"><h5>7.12.14.3 The isless macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int isless(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isless macro determines whether its first argument is less than its second
+ argument. The value of isless(x, y) is always equal to (x) &lt; (y); however,
+ unlike (x) &lt; (y), isless(x, y) does not raise the ''invalid'' floating-point
+ exception when x and y are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isless macro returns the value of (x) &lt; (y).
+
+<a name="7.12.14.4" href="#7.12.14.4"><h5>7.12.14.4 The islessequal macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;math.h&gt;
+         int islessequal(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The islessequal macro determines whether its first argument is less than or equal to
+ its second argument. The value of islessequal(x, y) is always equal to
+ (x) &lt;= (y); however, unlike (x) &lt;= (y), islessequal(x, y) does not raise
+ the ''invalid'' floating-point exception when x and y are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The islessequal macro returns the value of (x) &lt;= (y).
+<!--page 278 indent 4-->
+
+<a name="7.12.14.5" href="#7.12.14.5"><h5>7.12.14.5 The islessgreater macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        int islessgreater(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The islessgreater macro determines whether its first argument is less than or
+ greater than its second argument. The islessgreater(x, y) macro is similar to
+ (x) &lt; (y) || (x) &gt; (y); however, islessgreater(x, y) does not raise
+ the ''invalid'' floating-point exception when x and y are unordered (nor does it evaluate x
+ and y twice).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The islessgreater macro returns the value of (x) &lt; (y) || (x) &gt; (y).
+
+<a name="7.12.14.6" href="#7.12.14.6"><h5>7.12.14.6 The isunordered macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;math.h&gt;
+        int isunordered(real-floating x, real-floating y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The isunordered macro determines whether its arguments are unordered.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The isunordered macro returns 1 if its arguments are unordered and 0 otherwise.
+<!--page 279 indent 4-->
+
+<a name="7.13" href="#7.13"><h3>7.13 Nonlocal jumps <setjmp.h></h3></a>
+<p><!--para 1-->
+ The header &lt;setjmp.h&gt; defines the macro setjmp, and declares one function and
+ one type, for bypassing the normal function call and return discipline.<sup><a href="#note244"><b>244)</b></a></sup>
+<p><!--para 2-->
+ The type declared is
+<pre>
+         jmp_buf</pre>
+ which is an array type suitable for holding the information needed to restore a calling
+ environment. The environment of a call to the setjmp macro consists of information
+ sufficient for a call to the longjmp function to return execution to the correct block and
+ invocation of that block, were it called recursively. It does not include the state of the
+ floating-point status flags, of open files, or of any other component of the abstract
+ machine.
+<p><!--para 3-->
+ It is unspecified whether setjmp is a macro or an identifier declared with external
+ linkage. If a macro definition is suppressed in order to access an actual function, or a
+ program defines an external identifier with the name setjmp, the behavior is undefined.
+
+<h6>footnotes</h6>
+<p><a name="note244">244)</a> These functions are useful for dealing with unusual conditions encountered in a low-level function of
+ a program.
+
+
+<a name="7.13.1" href="#7.13.1"><h4>7.13.1 Save calling environment</h4></a>
+
+<a name="7.13.1.1" href="#7.13.1.1"><h5>7.13.1.1 The setjmp macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;setjmp.h&gt;
+         int setjmp(jmp_buf env);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The setjmp macro saves its calling environment in its jmp_buf argument for later use
+ by the longjmp function.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the return is from a direct invocation, the setjmp macro returns the value zero. If the
+ return is from a call to the longjmp function, the setjmp macro returns a nonzero
+ value.
+ Environmental limits
+<p><!--para 4-->
+ An invocation of the setjmp macro shall appear only in one of the following contexts:
+<ul>
+<li>  the entire controlling expression of a selection or iteration statement;
+<li>  one operand of a relational or equality operator with the other operand an integer
+ constant expression, with the resulting expression being the entire controlling
+ 
+ 
+<!--page 280 indent 4-->
+   expression of a selection or iteration statement;
+<li>  the operand of a unary ! operator with the resulting expression being the entire
+ controlling expression of a selection or iteration statement; or
+<li>  the entire expression of an expression statement (possibly cast to void).
+</ul>
+<p><!--para 5-->
+ If the invocation appears in any other context, the behavior is undefined.
+
+<a name="7.13.2" href="#7.13.2"><h4>7.13.2 Restore calling environment</h4></a>
+
+<a name="7.13.2.1" href="#7.13.2.1"><h5>7.13.2.1 The longjmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;setjmp.h&gt;
+          _Noreturn void longjmp(jmp_buf env, int val);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The longjmp function restores the environment saved by the most recent invocation of
+ the setjmp macro in the same invocation of the program with the corresponding
+ jmp_buf argument. If there has been no such invocation, or if the function containing
+ the invocation of the setjmp macro has terminated execution<sup><a href="#note245"><b>245)</b></a></sup> in the interim, or if the
+ invocation of the setjmp macro was within the scope of an identifier with variably
+ modified type and execution has left that scope in the interim, the behavior is undefined.
+<p><!--para 3-->
+ All accessible objects have values, and all other components of the abstract machine<sup><a href="#note246"><b>246)</b></a></sup>
+ have state, as of the time the longjmp function was called, except that the values of
+ objects of automatic storage duration that are local to the function containing the
+ invocation of the corresponding setjmp macro that do not have volatile-qualified type
+ and have been changed between the setjmp invocation and longjmp call are
+ indeterminate.
+<h6>Returns</h6>
+<p><!--para 4-->
+ After longjmp is completed, program execution continues as if the corresponding
+ invocation of the setjmp macro had just returned the value specified by val. The
+ longjmp function cannot cause the setjmp macro to return the value 0; if val is 0,
+ the setjmp macro returns the value 1.
+<p><!--para 5-->
+ EXAMPLE The longjmp function that returns control back to the point of the setjmp invocation
+ might cause memory associated with a variable length array object to be squandered.
+ 
+ 
+ 
+ 
+<!--page 281 indent -1-->
+<!--page 282 indent 4-->
+<pre>
+         #include &lt;setjmp.h&gt;
+         jmp_buf buf;
+         void g(int n);
+         void h(int n);
+         int n = 6;
+         void f(void)
+         {
+               int x[n];          // valid: f is not terminated
+               setjmp(buf);
+               g(n);
+         }
+         void g(int n)
+         {
+               int a[n];          // a may remain allocated
+               h(n);
+         }
+         void h(int n)
+         {
+               int b[n];          // b may remain allocated
+               longjmp(buf, 2);   // might cause memory loss
+         }</pre>
+
+<h6>footnotes</h6>
+<p><a name="note245">245)</a> For example, by executing a return statement or because another longjmp call has caused a
+ transfer to a setjmp invocation in a function earlier in the set of nested calls.
+
+<p><a name="note246">246)</a> This includes, but is not limited to, the floating-point status flags and the state of open files.
+
+
+<a name="7.14" href="#7.14"><h3>7.14 Signal handling <signal.h></h3></a>
+<p><!--para 1-->
+ The header &lt;signal.h&gt; declares a type and two functions and defines several macros,
+ for handling various signals (conditions that may be reported during program execution).
+<p><!--para 2-->
+ The type defined is
+<pre>
+          sig_atomic_t</pre>
+ which is the (possibly volatile-qualified) integer type of an object that can be accessed as
+ an atomic entity, even in the presence of asynchronous interrupts.
+<p><!--para 3-->
+ The macros defined are
+<pre>
+          SIG_DFL
+          SIG_ERR
+          SIG_IGN</pre>
+ which expand to constant expressions with distinct values that have type compatible with
+ the second argument to, and the return value of, the signal function, and whose values
+ compare unequal to the address of any declarable function; and the following, which
+ expand to positive integer constant expressions with type int and distinct values that are
+ the signal numbers, each corresponding to the specified condition:
+<p><!--para 4-->
+<pre>
+          SIGABRT abnormal termination, such as is initiated by the abort function
+          SIGFPE        an erroneous arithmetic operation, such as zero divide or an operation
+                        resulting in overflow
+          SIGILL        detection of an invalid function image, such as an invalid instruction
+          SIGINT        receipt of an interactive attention signal
+          SIGSEGV an invalid access to storage
+          SIGTERM a termination request sent to the program</pre>
+ An implementation need not generate any of these signals, except as a result of explicit
+ calls to the raise function. Additional signals and pointers to undeclarable functions,
+ with macro definitions beginning, respectively, with the letters SIG and an uppercase
+ letter or with SIG_ and an uppercase letter,<sup><a href="#note247"><b>247)</b></a></sup> may also be specified by the
+ implementation. The complete set of signals, their semantics, and their default handling
+ is implementation-defined; all signal numbers shall be positive.
+ 
+ 
+ 
+ 
+<!--page 283 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note247">247)</a> See ''future library directions'' (<a href="#7.30.6">7.30.6</a>). The names of the signal numbers reflect the following terms
+ (respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
+ and termination.
+
+
+<a name="7.14.1" href="#7.14.1"><h4>7.14.1 Specify signal handling</h4></a>
+
+<a name="7.14.1.1" href="#7.14.1.1"><h5>7.14.1.1 The signal function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;signal.h&gt;
+         void (*signal(int sig, void (*func)(int)))(int);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The signal function chooses one of three ways in which receipt of the signal number
+ sig is to be subsequently handled. If the value of func is SIG_DFL, default handling
+ for that signal will occur. If the value of func is SIG_IGN, the signal will be ignored.
+ Otherwise, func shall point to a function to be called when that signal occurs. An
+ invocation of such a function because of a signal, or (recursively) of any further functions
+ called by that invocation (other than functions in the standard library),<sup><a href="#note248"><b>248)</b></a></sup> is called a
+ signal handler.
+<p><!--para 3-->
+ When a signal occurs and func points to a function, it is implementation-defined
+ whether the equivalent of signal(sig, SIG_DFL); is executed or the
+ implementation prevents some implementation-defined set of signals (at least including
+ sig) from occurring until the current signal handling has completed; in the case of
+ SIGILL, the implementation may alternatively define that no action is taken. Then the
+ equivalent of (*func)(sig); is executed. If and when the function returns, if the
+ value of sig is SIGFPE, SIGILL, SIGSEGV, or any other implementation-defined
+ value corresponding to a computational exception, the behavior is undefined; otherwise
+ the program will resume execution at the point it was interrupted.
+<p><!--para 4-->
+ If the signal occurs as the result of calling the abort or raise function, the signal
+ handler shall not call the raise function.
+<p><!--para 5-->
+ If the signal occurs other than as the result of calling the abort or raise function, the
+ behavior is undefined if the signal handler refers to any object with static or thread
+ storage duration that is not a lock-free atomic object other than by assigning a value to an
+ object declared as volatile sig_atomic_t, or the signal handler calls any function
+ in the standard library other than the abort function, the _Exit function, the
+ quick_exit function, or the signal function with the first argument equal to the
+ signal number corresponding to the signal that caused the invocation of the handler.
+ Furthermore, if such a call to the signal function results in a SIG_ERR return, the
+ value of errno is indeterminate.<sup><a href="#note249"><b>249)</b></a></sup>
+ 
+ 
+<!--page 284 indent 4-->
+<p><!--para 6-->
+ At program startup, the equivalent of
+<pre>
+        signal(sig, SIG_IGN);</pre>
+ may be executed for some signals selected in an implementation-defined manner; the
+ equivalent of
+<pre>
+        signal(sig, SIG_DFL);</pre>
+ is executed for all other signals defined by the implementation.
+<p><!--para 7-->
+ The implementation shall behave as if no library function calls the signal function.
+<h6>Returns</h6>
+<p><!--para 8-->
+ If the request can be honored, the signal function returns the value of func for the
+ most recent successful call to signal for the specified signal sig. Otherwise, a value of
+ SIG_ERR is returned and a positive value is stored in errno.
+ Forward references: the abort function (<a href="#7.22.4.1">7.22.4.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the
+ _Exit function (<a href="#7.22.4.5">7.22.4.5</a>), the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
+
+<h6>footnotes</h6>
+<p><a name="note248">248)</a> This includes functions called indirectly via standard library functions (e.g., a SIGABRT handler
+ called via the abort function).
+
+<p><a name="note249">249)</a> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
+
+
+<a name="7.14.2" href="#7.14.2"><h4>7.14.2 Send signal</h4></a>
+
+<a name="7.14.2.1" href="#7.14.2.1"><h5>7.14.2.1 The raise function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;signal.h&gt;
+        int raise(int sig);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The raise function carries out the actions described in <a href="#7.14.1.1">7.14.1.1</a> for the signal sig. If a
+ signal handler is called, the raise function shall not return until after the signal handler
+ does.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The raise function returns zero if successful, nonzero if unsuccessful.
+<!--page 285 indent 4-->
+
+<a name="7.15" href="#7.15"><h3>7.15 Alignment <stdalign.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdalign.h&gt; defines two macros.
+<p><!--para 2-->
+ The macro
+<pre>
+         alignas</pre>
+ expands to _Alignas.
+<p><!--para 3-->
+ The remaining macro is suitable for use in #if preprocessing directives. It is
+<pre>
+         __alignas_is_defined</pre>
+ which expands to the integer constant 1.
+<!--page 286 indent 4-->
+
+<a name="7.16" href="#7.16"><h3>7.16 Variable arguments <stdarg.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdarg.h&gt; declares a type and defines four macros, for advancing
+ through a list of arguments whose number and types are not known to the called function
+ when it is translated.
+<p><!--para 2-->
+ A function may be called with a variable number of arguments of varying types. As
+ described in <a href="#6.9.1">6.9.1</a>, its parameter list contains one or more parameters. The rightmost
+ parameter plays a special role in the access mechanism, and will be designated parmN in
+ this description.
+<p><!--para 3-->
+ The type declared is
+<pre>
+         va_list</pre>
+ which is a complete object type suitable for holding information needed by the macros
+ va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
+ desired, the called function shall declare an object (generally referred to as ap in this
+ subclause) having type va_list. The object ap may be passed as an argument to
+ another function; if that function invokes the va_arg macro with parameter ap, the
+ value of ap in the calling function is indeterminate and shall be passed to the va_end
+ macro prior to any further reference to ap.<sup><a href="#note250"><b>250)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note250">250)</a> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
+ case the original function may make further use of the original list after the other function returns.
+
+
+<a name="7.16.1" href="#7.16.1"><h4>7.16.1 Variable argument list access macros</h4></a>
+<p><!--para 1-->
+ The va_start and va_arg macros described in this subclause shall be implemented
+ as macros, not functions. It is unspecified whether va_copy and va_end are macros or
+ identifiers declared with external linkage. If a macro definition is suppressed in order to
+ access an actual function, or a program defines an external identifier with the same name,
+ the behavior is undefined. Each invocation of the va_start and va_copy macros
+ shall be matched by a corresponding invocation of the va_end macro in the same
+ function.
+
+<a name="7.16.1.1" href="#7.16.1.1"><h5>7.16.1.1 The va_arg macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         type va_arg(va_list ap, type);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_arg macro expands to an expression that has the specified type and the value of
+ the next argument in the call. The parameter ap shall have been initialized by the
+ va_start or va_copy macro (without an intervening invocation of the va_end
+ 
+<!--page 287 indent 4-->
+ macro for the same ap). Each invocation of the va_arg macro modifies ap so that the
+ values of successive arguments are returned in turn. The parameter type shall be a type
+ name specified such that the type of a pointer to an object that has the specified type can
+ be obtained simply by postfixing a * to type. If there is no actual next argument, or if
+ type is not compatible with the type of the actual next argument (as promoted according
+ to the default argument promotions), the behavior is undefined, except for the following
+ cases:
+<ul>
+<li>  one type is a signed integer type, the other type is the corresponding unsigned integer
+ type, and the value is representable in both types;
+<li>  one type is pointer to void and the other is a pointer to a character type.
+</ul>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The first invocation of the va_arg macro after that of the va_start macro returns the
+ value of the argument after that specified by parmN . Successive invocations return the
+ values of the remaining arguments in succession.
+
+<a name="7.16.1.2" href="#7.16.1.2"><h5>7.16.1.2 The va_copy macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         void va_copy(va_list dest, va_list src);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_copy macro initializes dest as a copy of src, as if the va_start macro had
+ been applied to dest followed by the same sequence of uses of the va_arg macro as
+ had previously been used to reach the present state of src. Neither the va_copy nor
+ va_start macro shall be invoked to reinitialize dest without an intervening
+ invocation of the va_end macro for the same dest.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The va_copy macro returns no value.
+
+<a name="7.16.1.3" href="#7.16.1.3"><h5>7.16.1.3 The va_end macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         void va_end(va_list ap);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_end macro facilitates a normal return from the function whose variable
+ argument list was referred to by the expansion of the va_start macro, or the function
+ containing the expansion of the va_copy macro, that initialized the va_list ap. The
+ va_end macro may modify ap so that it is no longer usable (without being reinitialized
+<!--page 288 indent 4-->
+ by the va_start or va_copy macro). If there is no corresponding invocation of the
+ va_start or va_copy macro, or if the va_end macro is not invoked before the
+ return, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The va_end macro returns no value.
+
+<a name="7.16.1.4" href="#7.16.1.4"><h5>7.16.1.4 The va_start macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         void va_start(va_list ap, parmN);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The va_start macro shall be invoked before any access to the unnamed arguments.
+<p><!--para 3-->
+ The va_start macro initializes ap for subsequent use by the va_arg and va_end
+ macros. Neither the va_start nor va_copy macro shall be invoked to reinitialize ap
+ without an intervening invocation of the va_end macro for the same ap.
+<p><!--para 4-->
+ The parameter parmN is the identifier of the rightmost parameter in the variable
+ parameter list in the function definition (the one just before the , ...). If the parameter
+ parmN is declared with the register storage class, with a function or array type, or
+ with a type that is not compatible with the type that results after application of the default
+ argument promotions, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The va_start macro returns no value.
+<p><!--para 6-->
+ EXAMPLE 1 The function f1 gathers into an array a list of arguments that are pointers to strings (but not
+ more than MAXARGS arguments), then passes the array as a single argument to function f2. The number of
+ pointers is specified by the first argument to f1.
+<!--page 289 indent 4-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #define MAXARGS   31
+         void f1(int n_ptrs, ...)
+         {
+               va_list ap;
+               char *array[MAXARGS];
+               int ptr_no = 0;
+                   if (n_ptrs &gt; MAXARGS)
+                         n_ptrs = MAXARGS;
+                   va_start(ap, n_ptrs);
+                   while (ptr_no &lt; n_ptrs)
+                         array[ptr_no++] = va_arg(ap, char *);
+                   va_end(ap);
+                   f2(n_ptrs, array);
+          }</pre>
+ Each call to f1 is required to have visible the definition of the function or a declaration such as
+<pre>
+          void f1(int, ...);</pre>
+ 
+<p><!--para 7-->
+ EXAMPLE 2 The function f3 is similar, but saves the status of the variable argument list after the
+ indicated number of arguments; after f2 has been called once with the whole list, the trailing part of the list
+ is gathered again and passed to function f4.
+<!--page 290 indent 4-->
+<pre>
+          #include &lt;stdarg.h&gt;
+          #define MAXARGS 31
+          void f3(int n_ptrs, int f4_after, ...)
+          {
+                va_list ap, ap_save;
+                char *array[MAXARGS];
+                int ptr_no = 0;
+                if (n_ptrs &gt; MAXARGS)
+                      n_ptrs = MAXARGS;
+                va_start(ap, f4_after);
+                while (ptr_no &lt; n_ptrs) {
+                      array[ptr_no++] = va_arg(ap, char *);
+                      if (ptr_no == f4_after)
+                            va_copy(ap_save, ap);
+                }
+                va_end(ap);
+                f2(n_ptrs, array);
+                   // Now process the saved copy.
+                   n_ptrs -= f4_after;
+                   ptr_no = 0;
+                   while (ptr_no &lt; n_ptrs)
+                         array[ptr_no++] = va_arg(ap_save, char *);
+                   va_end(ap_save);
+                   f4(n_ptrs, array);
+          }</pre>
+
+<a name="7.17" href="#7.17"><h3>7.17 Atomics <stdatomic.h></h3></a>
+
+<a name="7.17.1" href="#7.17.1"><h4>7.17.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;stdatomic.h&gt; defines several macros and declares several types and
+ functions for performing atomic operations on data shared between threads.
+<p><!--para 2-->
+ Implementations that define the macro __STDC_NO_THREADS__ need not provide
+ this header nor support any of its facilities.
+<p><!--para 3-->
+ The macros defined are the atomic lock-free macros
+<pre>
+        ATOMIC_CHAR_LOCK_FREE
+        ATOMIC_CHAR16_T_LOCK_FREE
+        ATOMIC_CHAR32_T_LOCK_FREE
+        ATOMIC_WCHAR_T_LOCK_FREE
+        ATOMIC_SHORT_LOCK_FREE
+        ATOMIC_INT_LOCK_FREE
+        ATOMIC_LONG_LOCK_FREE
+        ATOMIC_LLONG_LOCK_FREE
+        ATOMIC_ADDRESS_LOCK_FREE</pre>
+ which indicate the lock-free property of the corresponding atomic types (both signed and
+ unsigned); and
+<pre>
+        ATOMIC_FLAG_INIT</pre>
+ which expands to an initializer for an object of type atomic_flag.
+<p><!--para 4-->
+ The types include
+<pre>
+        memory_order</pre>
+ which is an enumerated type whose enumerators identify memory ordering constraints;
+<pre>
+        atomic_flag</pre>
+ which is a structure type representing a lock-free, primitive atomic flag;
+<pre>
+        atomic_bool</pre>
+ which is a structure type representing the atomic analog of the type _Bool;
+<pre>
+        atomic_address</pre>
+ which is a structure type representing the atomic analog of a pointer type; and several
+ atomic analogs of integer types.
+<p><!--para 5-->
+ In the following operation definitions:
+<ul>
+<li>  An A refers to one of the atomic types.
+<!--page 291 indent 4-->
+<li>  A C refers to its corresponding non-atomic type. The atomic_address atomic
+ type corresponds to the void * non-atomic type.
+<li>  An M refers to the type of the other argument for arithmetic operations. For atomic
+ integer types, M is C. For atomic address types, M is ptrdiff_t.
+<li>  The functions not ending in _explicit have the same semantics as the
+ corresponding _explicit function with memory_order_seq_cst for the
+ memory_order argument.
+</ul>
+<p><!--para 6-->
+ NOTE Many operations are volatile-qualified. The ''volatile as device register'' semantics have not
+ changed in the standard. This qualification means that volatility is preserved when applying these
+ operations to volatile objects.
+ 
+
+<a name="7.17.2" href="#7.17.2"><h4>7.17.2 Initialization</h4></a>
+
+<a name="7.17.2.1" href="#7.17.2.1"><h5>7.17.2.1 The ATOMIC_VAR_INIT macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         #define ATOMIC_VAR_INIT(C value)</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ATOMIC_VAR_INIT macro expands to a token sequence suitable for initializing an
+ atomic object of a type that is initialization-compatible with value. An atomic object
+ with automatic storage duration that is not explicitly initialized using
+ ATOMIC_VAR_INIT is initially in an indeterminate state; however, the default (zero)
+ initialization for objects with static or thread-local storage duration is guaranteed to
+ produce a valid state.
+<p><!--para 3-->
+ Concurrent access to the variable being initialized, even via an atomic operation,
+ constitutes a data race.
+<p><!--para 4-->
+ EXAMPLE
+<pre>
+         atomic_int guide = ATOMIC_VAR_INIT(42);</pre>
+ 
+
+<a name="7.17.2.2" href="#7.17.2.2"><h5>7.17.2.2 The atomic_init generic function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         void atomic_init(volatile A *obj, C value);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atomic_init generic function initializes the atomic object pointed to by obj to
+ the value value, while also initializing any additional state that the implementation
+ might need to carry for the atomic object.
+<!--page 292 indent 4-->
+<p><!--para 3-->
+ Although this function initializes an atomic object, it does not avoid data races;
+ concurrent access to the variable being initialized, even via an atomic operation,
+ constitutes a data race.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The atomic_init generic function returns no value.
+<p><!--para 5-->
+ EXAMPLE
+<pre>
+         atomic_int guide;
+         atomic_init(&amp;guide, 42);</pre>
+ 
+
+<a name="7.17.3" href="#7.17.3"><h4>7.17.3 Order and consistency</h4></a>
+<p><!--para 1-->
+ The enumerated type memory_order specifies the detailed regular (non-atomic)
+ memory synchronization operations as defined in <a href="#5.1.2.4">5.1.2.4</a> and may provide for operation
+ ordering. Its enumeration constants are as follows:
+<p><!--para 2-->
+<pre>
+         memory_order_relaxed
+         memory_order_consume
+         memory_order_acquire
+         memory_order_release
+         memory_order_acq_rel
+         memory_order_seq_cst</pre>
+ For memory_order_relaxed, no operation orders memory.
+<p><!--para 3-->
+ For       memory_order_release,       memory_order_acq_rel,             and
+ memory_order_seq_cst, a store operation performs a release operation on the
+ affected memory location.
+<p><!--para 4-->
+ For       memory_order_acquire,       memory_order_acq_rel,             and
+ memory_order_seq_cst, a load operation performs an acquire operation on the
+ affected memory location.
+<p><!--para 5-->
+ For memory_order_consume, a load operation performs a consume operation on the
+ affected memory location.
+<p><!--para 6-->
+ For memory_order_seq_cst, there shall be a single total order S on all operations,
+ consistent with the ''happens before'' order and modification orders for all affected
+ locations, such that each memory_order_seq_cst operation that loads a value
+ observes either the last preceding modification according to this order S, or the result of
+ an operation that is not memory_order_seq_cst.
+<p><!--para 7-->
+ NOTE 1 Although it is not explicitly required that S include lock operations, it can always be extended to
+ an order that does include lock and unlock operations, since the ordering between those is already included
+ in the ''happens before'' ordering.
+ 
+<p><!--para 8-->
+ NOTE 2 Atomic operations specifying memory_order_relaxed are relaxed only with respect to
+ memory ordering. Implementations must still guarantee that any given atomic access to a particular atomic
+<!--page 293 indent 5-->
+ object be indivisible with respect to all other atomic accesses to that object.
+ 
+<p><!--para 9-->
+ For an atomic operation B that reads the value of an atomic object M, if there is a
+ memory_order_seq_cst fence X sequenced before B, then B observes either the
+ last memory_order_seq_cst modification of M preceding X in the total order S or
+ a later modification of M in its modification order.
+<p><!--para 10-->
+ For atomic operations A and B on an atomic object M, where A modifies M and B takes
+ its value, if there is a memory_order_seq_cst fence X such that A is sequenced
+ before X and B follows X in S, then B observes either the effects of A or a later
+ modification of M in its modification order.
+<p><!--para 11-->
+ For atomic operations A and B on an atomic object M, where A modifies M and B takes
+ its value, if there are memory_order_seq_cst fences X and Y such that A is
+ sequenced before X, Y is sequenced before B, and X precedes Y in S, then B observes
+ either the effects of A or a later modification of M in its modification order.
+<p><!--para 12-->
+ Atomic read-modify-write operations shall always read the last value (in the modification
+ order) stored before the write associated with the read-modify-write operation.
+<p><!--para 13-->
+ An atomic store shall only store a value that has been computed from constants and
+ program input values by a finite sequence of program evaluations, such that each
+ evaluation observes the values of variables as computed by the last prior assignment in
+ the sequence.<sup><a href="#note251"><b>251)</b></a></sup> The ordering of evaluations in this sequence shall be such that
+<ul>
+<li>  If an evaluation B observes a value computed by A in a different thread, then B does
+ not happen before A.
+<li>  If an evaluation A is included in the sequence, then all evaluations that assign to the
+ same variable and happen before A are also included.
+</ul>
+<p><!--para 14-->
+ NOTE 3 The second requirement disallows ''out-of-thin-air'', or ''speculative'' stores of atomics when
+ relaxed atomics are used. Since unordered operations are involved, evaluations may appear in this
+ sequence out of thread order. For example, with x and y initially zero,
+<pre>
+          // Thread 1:
+          r1 = atomic_load_explicit(&amp;y, memory_order_relaxed);
+          atomic_store_explicit(&amp;x, r1, memory_order_relaxed);</pre>
+ 
+<pre>
+          // Thread 2:
+          r2 = atomic_load_explicit(&amp;x, memory_order_relaxed);
+          atomic_store_explicit(&amp;y, 42, memory_order_relaxed);</pre>
+ is allowed to produce r1 == 42 &amp;&amp; r2 == 42. The sequence of evaluations justifying this consists of:
+ 
+ 
+ 
+ 
+<!--page 294 indent 5-->
+<pre>
+         atomic_store_explicit(&amp;y, 42,               memory_order_relaxed);
+         r1 = atomic_load_explicit(&amp;y,               memory_order_relaxed);
+         atomic_store_explicit(&amp;x, r1,               memory_order_relaxed);
+         r2 = atomic_load_explicit(&amp;x,               memory_order_relaxed);</pre>
+ On the other hand,
+<pre>
+         // Thread 1:
+         r1 = atomic_load_explicit(&amp;y, memory_order_relaxed);
+         atomic_store_explicit(&amp;x, r1, memory_order_relaxed);</pre>
+ 
+<pre>
+         // Thread 2:
+         r2 = atomic_load_explicit(&amp;x, memory_order_relaxed);
+         atomic_store_explicit(&amp;y, r2, memory_order_relaxed);</pre>
+ is not allowed to produce r1 == 42 &amp;&amp; r2 = 42, since there is no sequence of evaluations that results
+ in the computation of 42. In the absence of ''relaxed'' operations and read-modify-write operations with
+ weaker than memory_order_acq_rel ordering, the second requirement has no impact.
+ 
+ Recommended practice
+<p><!--para 15-->
+ The requirements do not forbid r1 == 42 &amp;&amp; r2 == 42 in the following example,
+ with x and y initially zero:
+<pre>
+         // Thread 1:
+         r1 = atomic_load_explicit(&amp;x, memory_order_relaxed);
+         if (r1 == 42)
+              atomic_store_explicit(&amp;y, r1, memory_order_relaxed);</pre>
+ 
+<pre>
+         // Thread 2:
+         r2 = atomic_load_explicit(&amp;y, memory_order_relaxed);
+         if (r2 == 42)
+              atomic_store_explicit(&amp;x, 42, memory_order_relaxed);</pre>
+ However, this is not useful behavior, and implementations should not allow it.
+<p><!--para 16-->
+ Implementations should make atomic stores visible to atomic loads within a reasonable
+ amount of time.
+
+<h6>footnotes</h6>
+<p><a name="note251">251)</a> Among other implications, atomic variables shall not decay.
+
+
+<a name="7.17.3.1" href="#7.17.3.1"><h5>7.17.3.1 The kill_dependency macro</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         type kill_dependency(type y);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The kill_dependency macro terminates a dependency chain; the argument does not
+ carry a dependency to the return value.
+<!--page 295 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The kill_dependency macro returns the value of y.
+
+<a name="7.17.4" href="#7.17.4"><h4>7.17.4 Fences</h4></a>
+<p><!--para 1-->
+ This subclause introduces synchronization primitives called fences. Fences can have
+ acquire semantics, release semantics, or both. A fence with acquire semantics is called
+ an acquire fence; a fence with release semantics is called a release fence.
+<p><!--para 2-->
+ A release fence A synchronizes with an acquire fence B if there exist atomic operations
+ X and Y , both operating on some atomic object M, such that A is sequenced before X, X
+ modifies M, Y is sequenced before B, and Y reads the value written by X or a value
+ written by any side effect in the hypothetical release sequence X would head if it were a
+ release operation.
+<p><!--para 3-->
+ A release fence A synchronizes with an atomic operation B that performs an acquire
+ operation on an atomic object M if there exists an atomic operation X such that A is
+ sequenced before X, X modifies M, and B reads the value written by X or a value written
+ by any side effect in the hypothetical release sequence X would head if it were a release
+ operation.
+<p><!--para 4-->
+ An atomic operation A that is a release operation on an atomic object M synchronizes
+ with an acquire fence B if there exists some atomic operation X on M such that X is
+ sequenced before B and reads the value written by A or a value written by any side effect
+ in the release sequence headed by A.
+
+<a name="7.17.4.1" href="#7.17.4.1"><h5>7.17.4.1 The atomic_thread_fence function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         void atomic_thread_fence(memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ Depending on the value of order, this operation:
+<ul>
+<li>  has no effects, if order == memory_order_relaxed;
+<li>  is an acquire fence, if order == memory_order_acquire or order ==
+ memory_order_consume;
+<li>  is a release fence, if order == memory_order_release;
+<li>  is both an acquire fence              and   a    release   fence,    if   order     ==
+ memory_order_acq_rel;
+<li>  is a sequentially consistent acquire and release fence, if order                    ==
+ memory_order_seq_cst.
+<!--page 296 indent 4-->
+</ul>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atomic_thread_fence function returns no value.
+
+<a name="7.17.4.2" href="#7.17.4.2"><h5>7.17.4.2 The atomic_signal_fence function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         void atomic_signal_fence(memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ Equivalent to atomic_thread_fence(order), except that ''synchronizes with''
+ relationships are established only between a thread and a signal handler executed in the
+ same thread.
+<p><!--para 3-->
+ NOTE 1 The atomic_signal_fence function can be used to specify the order in which actions
+ performed by the thread become visible to the signal handler.
+ 
+<p><!--para 4-->
+ NOTE 2 Compiler optimizations and reorderings of loads and stores are inhibited in the same way as with
+ atomic_thread_fence, but the hardware fence instructions that atomic_thread_fence would
+ have inserted are not emitted.
+ 
+<h6>Returns</h6>
+<p><!--para 5-->
+ The atomic_signal_fence function returns no value.
+
+<a name="7.17.5" href="#7.17.5"><h4>7.17.5 Lock-free property</h4></a>
+<p><!--para 1-->
+ The atomic lock-free macros indicate the lock-free property of integer and address atomic
+ types. A value of 0 indicates that the type is never lock-free; a value of 1 indicates that
+ the type is sometimes lock-free; a value of 2 indicates that the type is always lock-free.
+<p><!--para 2-->
+ NOTE Operations that are lock-free should also be address-free. That is, atomic operations on the same
+ memory location via two different addresses will communicate atomically. The implementation should not
+ depend on any per-process state. This restriction enables communication via memory mapped into a
+ process more than once and memory shared between two processes.
+ 
+
+<a name="7.17.5.1" href="#7.17.5.1"><h5>7.17.5.1 The atomic_is_lock_free generic function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         _Bool atomic_is_lock_free(atomic_type const volatile *obj);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atomic_is_lock_free generic function indicates whether or not the object
+ pointed to by obj is lock-free. atomic_type can be any atomic type.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atomic_is_lock_free generic function returns nonzero (true) if and only if the
+ object's operations are lock-free. The result of a lock-free query on one object cannot be
+<!--page 297 indent 4-->
+ inferred from the result of a lock-free query on another object.
+
+<a name="7.17.6" href="#7.17.6"><h4>7.17.6 Atomic integer and address types</h4></a>
+<p><!--para 1-->
+ For each line in the following table, the atomic type name is declared as the
+ corresponding direct type.
+<!--page 298 indent 4-->
+<p><!--para 2-->
+<pre>
+            Atomic type name                              Direct type
+        atomic_char                           _Atomic    char
+        atomic_schar                          _Atomic    signed char
+        atomic_uchar                          _Atomic    unsigned char
+        atomic_short                          _Atomic    short
+        atomic_ushort                         _Atomic    unsigned short
+        atomic_int                            _Atomic    int
+        atomic_uint                           _Atomic    unsigned int
+        atomic_long                           _Atomic    long
+        atomic_ulong                          _Atomic    unsigned long
+        atomic_llong                          _Atomic    long long
+        atomic_ullong                         _Atomic    unsigned long long
+        atomic_char16_t                       _Atomic    char16_t
+        atomic_char32_t                       _Atomic    char32_t
+        atomic_wchar_t                        _Atomic    wchar_t
+        atomic_int_least8_t                   _Atomic    int_least8_t
+        atomic_uint_least8_t                  _Atomic    uint_least8_t
+        atomic_int_least16_t                  _Atomic    int_least16_t
+        atomic_uint_least16_t                 _Atomic    uint_least16_t
+        atomic_int_least32_t                  _Atomic    int_least32_t
+        atomic_uint_least32_t                 _Atomic    uint_least32_t
+        atomic_int_least64_t                  _Atomic    int_least64_t
+        atomic_uint_least64_t                 _Atomic    uint_least64_t
+        atomic_int_fast8_t                    _Atomic    int_fast8_t
+        atomic_uint_fast8_t                   _Atomic    uint_fast8_t
+        atomic_int_fast16_t                   _Atomic    int_fast16_t
+        atomic_uint_fast16_t                  _Atomic    uint_fast16_t
+        atomic_int_fast32_t                   _Atomic    int_fast32_t
+        atomic_uint_fast32_t                  _Atomic    uint_fast32_t
+        atomic_int_fast64_t                   _Atomic    int_fast64_t
+        atomic_uint_fast64_t                  _Atomic    uint_fast64_t
+        atomic_intptr_t                       _Atomic    intptr_t
+        atomic_uintptr_t                      _Atomic    uintptr_t
+        atomic_size_t                         _Atomic    size_t
+        atomic_ptrdiff_t                      _Atomic    ptrdiff_t
+        atomic_intmax_t                       _Atomic    intmax_t
+        atomic_uintmax_t                      _Atomic    uintmax_t</pre>
+ The semantics of the operations on these types are defined in <a href="#7.17.7">7.17.7</a>.
+<p><!--para 3-->
+ The atomic_bool type provides an atomic boolean.
+<!--page 299 indent 4-->
+<p><!--para 4-->
+ The atomic_address type provides atomic void * operations. The unit of
+ addition/subtraction shall be one byte.
+<p><!--para 5-->
+ NOTE The representation of atomic integer and address types need not have the same size as their
+ corresponding regular types. They should have the same size whenever possible, as it eases effort required
+ to port existing code.
+ 
+
+<a name="7.17.7" href="#7.17.7"><h4>7.17.7 Operations on atomic types</h4></a>
+<p><!--para 1-->
+ There are only a few kinds of operations on atomic types, though there are many
+ instances of those kinds. This subclause specifies each general kind.
+
+<a name="7.17.7.1" href="#7.17.7.1"><h5>7.17.7.1 The atomic_store generic functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         void atomic_store(volatile A *object, C desired);
+         void atomic_store_explicit(volatile A *object,
+              C desired, memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The      order      argument    shall    not    be    memory_order_acquire,
+ memory_order_consume, nor memory_order_acq_rel. Atomically replace the
+ value pointed to by object with the value of desired. Memory is affected according
+ to the value of order.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atomic_store generic functions return no value.
+
+<a name="7.17.7.2" href="#7.17.7.2"><h5>7.17.7.2 The atomic_load generic functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         C atomic_load(volatile A *object);
+         C atomic_load_explicit(volatile A *object,
+              memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The order argument shall not be memory_order_release nor
+ memory_order_acq_rel. Memory is affected according to the value of order.
+<h6>Returns</h6>
+ Atomically returns the value pointed to by object.
+<!--page 300 indent 4-->
+
+<a name="7.17.7.3" href="#7.17.7.3"><h5>7.17.7.3 The atomic_exchange generic functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdatomic.h&gt;
+          C atomic_exchange(volatile A *object, C desired);
+          C atomic_exchange_explicit(volatile A *object,
+               C desired, memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ Atomically replace the value pointed to by object with desired. Memory is affected
+ according to the value of order. These operations are read-modify-write operations
+ (<a href="#5.1.2.4">5.1.2.4</a>).
+<h6>Returns</h6>
+<p><!--para 3-->
+ Atomically returns the value pointed to by object immediately before the effects.
+
+<a name="7.17.7.4" href="#7.17.7.4"><h5>7.17.7.4 The atomic_compare_exchange generic functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdatomic.h&gt;
+          _Bool atomic_compare_exchange_strong(volatile A *object,
+               C *expected, C desired);
+          _Bool atomic_compare_exchange_strong_explicit(
+               volatile A *object, C *expected, C desired,
+               memory_order success, memory_order failure);
+          _Bool atomic_compare_exchange_weak(volatile A *object,
+               C *expected, C desired);
+          _Bool atomic_compare_exchange_weak_explicit(
+               volatile A *object, C *expected, C desired,
+               memory_order success, memory_order failure);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The failure argument shall not be memory_order_release nor
+ memory_order_acq_rel. The failure argument shall be no stronger than the
+ success argument. Atomically, compares the value pointed to by object for equality
+ with that in expected, and if true, replaces the value pointed to by object with
+ desired, and if false, updates the value in expected with the value pointed to by
+ object. Further, if the comparison is true, memory is affected according to the value of
+ success, and if the comparison is false, memory is affected according to the value of
+ failure. These operations are atomic read-modify-write operations (<a href="#5.1.2.4">5.1.2.4</a>).
+<p><!--para 3-->
+ NOTE 1    The effect of the compare-and-exchange operations is
+<!--page 301 indent 4-->
+<pre>
+          if (*object == *expected)
+                *object = desired;
+          else
+                *expected = *object;</pre>
+ 
+<p><!--para 4-->
+ The weak compare-and-exchange operations may fail spuriously, that is, return zero
+ while leaving the value pointed to by expected unchanged.
+<p><!--para 5-->
+ NOTE 2 This spurious failure enables implementation of compare-and-exchange on a broader class of
+ machines, e.g. load-locked store-conditional machines.
+ 
+<p><!--para 6-->
+ EXAMPLE         A consequence of spurious failure is that nearly all uses of weak compare-and-exchange will
+ be in a loop.
+<pre>
+          exp = atomic_load(&amp;cur);
+          do {
+                des = function(exp);
+          } while (!atomic_compare_exchange_weak(&amp;cur, &amp;exp, des));</pre>
+ When a compare-and-exchange is in a loop, the weak version will yield better performance on some
+ platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
+ strong one is preferable.
+ 
+<h6>Returns</h6>
+<p><!--para 7-->
+ The result of the comparison.
+
+<a name="7.17.7.5" href="#7.17.7.5"><h5>7.17.7.5 The atomic_fetch and modify generic functions</h5></a>
+<p><!--para 1-->
+ The following operations perform arithmetic and bitwise computations. All of these
+ operations are applicable to an object of any atomic integer type. Only addition and
+ subtraction are applicable to atomic_address. None of these operations is applicable
+ to atomic_bool. The key, operator, and computation correspondence is:
+  key            op          computation
+  add            +       addition
+  sub            -       subtraction
+  or             |       bitwise inclusive or
+  xor            ^       bitwise exclusive or
+  and            &amp;       bitwise and
+<h6>Synopsis</h6>
+<p><!--para 2-->
+<pre>
+          #include &lt;stdatomic.h&gt;
+          C atomic_fetch_key(volatile A *object, M operand);
+          C atomic_fetch_key_explicit(volatile A *object,
+               M operand, memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 3-->
+ Atomically replaces the value pointed to by object with the result of the computation
+ applied to the value pointed to by object and the given operand. Memory is affected
+ according to the value of order. These operations are atomic read-modify-write
+<!--page 302 indent 4-->
+ operations (<a href="#5.1.2.4">5.1.2.4</a>). For signed integer types, arithmetic is defined to use two's
+ complement representation with silent wrap-around on overflow; there are no undefined
+ results. For address types, the result may be an undefined address, but the operations
+ otherwise have no undefined behavior.
+<h6>Returns</h6>
+<p><!--para 4-->
+ Atomically, the value pointed to by object immediately before the effects.
+<p><!--para 5-->
+ NOTE The operation of the atomic_fetch and modify generic functions are nearly equivalent to the
+ operation of the corresponding op= compound assignment operators. The only differences are that the
+ compound assignment operators are not guaranteed to operate atomically, and the value yielded by a
+ compound assignment operator is the updated value of the object, whereas the value returned by the
+ atomic_fetch and modify generic functions is the previous value of the atomic object.
+ 
+
+<a name="7.17.8" href="#7.17.8"><h4>7.17.8 Atomic flag type and operations</h4></a>
+<p><!--para 1-->
+ The atomic_flag type provides the classic test-and-set functionality. It has two
+ states, set and clear.
+<p><!--para 2-->
+ Operations on an object of type atomic_flag shall be lock free.
+<p><!--para 3-->
+ NOTE Hence the operations should also be address-free. No other type requires lock-free operations, so
+ the atomic_flag type is the minimum hardware-implemented type needed to conform to this
+ International standard. The remaining types can be emulated with atomic_flag, though with less than
+ ideal properties.
+ 
+<p><!--para 4-->
+ The macro ATOMIC_FLAG_INIT may be used to initialize an atomic_flag to the
+ clear state. An atomic_flag that is not explicitly initialized with
+ ATOMIC_FLAG_INIT is initially in an indeterminate state.
+<p><!--para 5-->
+ EXAMPLE
+<pre>
+         atomic_flag guard = ATOMIC_FLAG_INIT;</pre>
+ 
+
+<a name="7.17.8.1" href="#7.17.8.1"><h5>7.17.8.1 The atomic_flag_test_and_set functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         bool atomic_flag_test_and_set(
+              volatile atomic_flag *object);
+         bool atomic_flag_test_and_set_explicit(
+              volatile atomic_flag *object, memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ Atomically sets the value pointed to by object to true. Memory is affected according
+ to the value of order. These operations are atomic read-modify-write operations
+ (<a href="#5.1.2.4">5.1.2.4</a>).
+<!--page 303 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ Atomically, the value of the object immediately before the effects.
+
+<a name="7.17.8.2" href="#7.17.8.2"><h5>7.17.8.2 The atomic_flag_clear functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdatomic.h&gt;
+         void atomic_flag_clear(volatile atomic_flag *object);
+         void atomic_flag_clear_explicit(
+              volatile atomic_flag *object, memory_order order);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The order argument shall not be memory_order_acquire nor
+ memory_order_acq_rel. Atomically sets the value pointed to by object to false.
+ Memory is affected according to the value of order.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atomic_flag_clear functions return no value.
+<!--page 304 indent 4-->
+
+<a name="7.18" href="#7.18"><h3>7.18 Boolean type and values <stdbool.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdbool.h&gt; defines four macros.
+<p><!--para 2-->
+ The macro
+<pre>
+          bool</pre>
+ expands to _Bool.
+<p><!--para 3-->
+ The remaining three macros are suitable for use in #if preprocessing directives. They
+ are
+<pre>
+          true</pre>
+ which expands to the integer constant 1,
+<pre>
+          false</pre>
+ which expands to the integer constant 0, and
+<pre>
+          __bool_true_false_are_defined</pre>
+ which expands to the integer constant 1.
+<p><!--para 4-->
+ Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+ redefine the macros bool, true, and false.<sup><a href="#note252"><b>252)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 305 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note252">252)</a> See ''future library directions'' (<a href="#7.30.7">7.30.7</a>).
+
+
+<a name="7.19" href="#7.19"><h3>7.19 Common definitions <stddef.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stddef.h&gt; defines the following macros and declares the following types.
+ Some are also defined in other headers, as noted in their respective subclauses.
+<p><!--para 2-->
+ The types are
+<pre>
+         ptrdiff_t</pre>
+ which is the signed integer type of the result of subtracting two pointers;
+<pre>
+         size_t</pre>
+ which is the unsigned integer type of the result of the sizeof operator;
+<pre>
+         max_align_t</pre>
+ which is an object type whose alignment is as great as is supported by the implementation
+ in all contexts; and
+<pre>
+         wchar_t</pre>
+ which is an integer type whose range of values can represent distinct codes for all
+ members of the largest extended character set specified among the supported locales; the
+ null character shall have the code value zero. Each member of the basic character set
+ shall have a code value equal to its value when used as the lone character in an integer
+ character      constant     if     an      implementation      does      not      define
+ __STDC_MB_MIGHT_NEQ_WC__.
+<p><!--para 3-->
+ The macros are
+<pre>
+         NULL</pre>
+ which expands to an implementation-defined null pointer constant; and
+<pre>
+         offsetof(type, member-designator)</pre>
+ which expands to an integer constant expression that has type size_t, the value of
+ which is the offset in bytes, to the structure member (designated by member-designator),
+ from the beginning of its structure (designated by type). The type and member designator
+ shall be such that given
+<pre>
+         static type t;</pre>
+ then the expression &amp;(t.member-designator) evaluates to an address constant. (If the
+ specified member is a bit-field, the behavior is undefined.)
+ Recommended practice
+<p><!--para 4-->
+ The types used for size_t and ptrdiff_t should not have an integer conversion rank
+ greater than that of signed long int unless the implementation supports objects
+ large enough to make this necessary.
+<!--page 306 indent 0-->
+ Forward references: localization (<a href="#7.11">7.11</a>).
+<!--page 307 indent 4-->
+
+<a name="7.20" href="#7.20"><h3>7.20 Integer types <stdint.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdint.h&gt; declares sets of integer types having specified widths, and
+ defines corresponding sets of macros.<sup><a href="#note253"><b>253)</b></a></sup> It also defines macros that specify limits of
+ integer types corresponding to types defined in other standard headers.
+<p><!--para 2-->
+ Types are defined in the following categories:
+<ul>
+<li>  integer types having certain exact widths;
+<li>  integer types having at least certain specified widths;
+<li>  fastest integer types having at least certain specified widths;
+<li>  integer types wide enough to hold pointers to objects;
+<li>  integer types having greatest width.
+</ul>
+ (Some of these types may denote the same type.)
+<p><!--para 3-->
+ Corresponding macros specify limits of the declared types and construct suitable
+ constants.
+<p><!--para 4-->
+ For each type described herein that the implementation provides,<sup><a href="#note254"><b>254)</b></a></sup> &lt;stdint.h&gt; shall
+ declare that typedef name and define the associated macros. Conversely, for each type
+ described herein that the implementation does not provide, &lt;stdint.h&gt; shall not
+ declare that typedef name nor shall it define the associated macros. An implementation
+ shall provide those types described as ''required'', but need not provide any of the others
+ (described as ''optional'').
+
+<h6>footnotes</h6>
+<p><a name="note253">253)</a> See ''future library directions'' (<a href="#7.30.8">7.30.8</a>).
+
+<p><a name="note254">254)</a> Some of these types may denote implementation-defined extended integer types.
+
+
+<a name="7.20.1" href="#7.20.1"><h4>7.20.1 Integer types</h4></a>
+<p><!--para 1-->
+ When typedef names differing only in the absence or presence of the initial u are defined,
+ they shall denote corresponding signed and unsigned types as described in <a href="#6.2.5">6.2.5</a>; an
+ implementation providing one of these corresponding types shall also provide the other.
+<p><!--para 2-->
+ In the following descriptions, the symbol N represents an unsigned decimal integer with
+ no leading zeros (e.g., 8 or 24, but not 04 or 048).
+ 
+ 
+ 
+ 
+<!--page 308 indent 4-->
+
+<a name="7.20.1.1" href="#7.20.1.1"><h5>7.20.1.1 Exact-width integer types</h5></a>
+<p><!--para 1-->
+ The typedef name intN_t designates a signed integer type with width N , no padding
+ bits, and a two's complement representation. Thus, int8_t denotes such a signed
+ integer type with a width of exactly 8 bits.
+<p><!--para 2-->
+ The typedef name uintN_t designates an unsigned integer type with width N and no
+ padding bits. Thus, uint24_t denotes such an unsigned integer type with a width of
+ exactly 24 bits.
+<p><!--para 3-->
+ These types are optional. However, if an implementation provides integer types with
+ widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a
+ two's complement representation, it shall define the corresponding typedef names.
+
+<a name="7.20.1.2" href="#7.20.1.2"><h5>7.20.1.2 Minimum-width integer types</h5></a>
+<p><!--para 1-->
+ The typedef name int_leastN_t designates a signed integer type with a width of at
+ least N , such that no signed integer type with lesser size has at least the specified width.
+ Thus, int_least32_t denotes a signed integer type with a width of at least 32 bits.
+<p><!--para 2-->
+ The typedef name uint_leastN_t designates an unsigned integer type with a width
+ of at least N , such that no unsigned integer type with lesser size has at least the specified
+ width. Thus, uint_least16_t denotes an unsigned integer type with a width of at
+ least 16 bits.
+<p><!--para 3-->
+ The following types are required:
+<pre>
+          int_least8_t                                      uint_least8_t
+          int_least16_t                                     uint_least16_t
+          int_least32_t                                     uint_least32_t
+          int_least64_t                                     uint_least64_t</pre>
+ All other types of this form are optional.
+
+<a name="7.20.1.3" href="#7.20.1.3"><h5>7.20.1.3 Fastest minimum-width integer types</h5></a>
+<p><!--para 1-->
+ Each of the following types designates an integer type that is usually fastest<sup><a href="#note255"><b>255)</b></a></sup> to operate
+ with among all integer types that have at least the specified width.
+<p><!--para 2-->
+ The typedef name int_fastN_t designates the fastest signed integer type with a width
+ of at least N . The typedef name uint_fastN_t designates the fastest unsigned integer
+ type with a width of at least N .
+ 
+ 
+ 
+ 
+<!--page 309 indent 4-->
+<p><!--para 3-->
+ The following types are required:
+<pre>
+         int_fast8_t                                    uint_fast8_t
+         int_fast16_t                                   uint_fast16_t
+         int_fast32_t                                   uint_fast32_t
+         int_fast64_t                                   uint_fast64_t</pre>
+ All other types of this form are optional.
+
+<h6>footnotes</h6>
+<p><a name="note255">255)</a> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
+ grounds for choosing one type over another, it will simply pick some integer type satisfying the
+ signedness and width requirements.
+
+
+<a name="7.20.1.4" href="#7.20.1.4"><h5>7.20.1.4 Integer types capable of holding object pointers</h5></a>
+<p><!--para 1-->
+ The following type designates a signed integer type with the property that any valid
+ pointer to void can be converted to this type, then converted back to pointer to void,
+ and the result will compare equal to the original pointer:
+<pre>
+         intptr_t</pre>
+ The following type designates an unsigned integer type with the property that any valid
+ pointer to void can be converted to this type, then converted back to pointer to void,
+ and the result will compare equal to the original pointer:
+<pre>
+         uintptr_t</pre>
+ These types are optional.
+
+<a name="7.20.1.5" href="#7.20.1.5"><h5>7.20.1.5 Greatest-width integer types</h5></a>
+<p><!--para 1-->
+ The following type designates a signed integer type capable of representing any value of
+ any signed integer type:
+<pre>
+         intmax_t</pre>
+ The following type designates an unsigned integer type capable of representing any value
+ of any unsigned integer type:
+<pre>
+         uintmax_t</pre>
+ These types are required.
+
+<a name="7.20.2" href="#7.20.2"><h4>7.20.2 Limits of specified-width integer types</h4></a>
+<p><!--para 1-->
+ The following object-like macros specify the minimum and maximum limits of the types *
+ declared in &lt;stdint.h&gt;. Each macro name corresponds to a similar type name in
+ <a href="#7.20.1">7.20.1</a>.
+<p><!--para 2-->
+ Each instance of any defined macro shall be replaced by a constant expression suitable
+ for use in #if preprocessing directives, and this expression shall have the same type as
+ would an expression that is an object of the corresponding type converted according to
+ the integer promotions. Its implementation-defined value shall be equal to or greater in
+ magnitude (absolute value) than the corresponding value given below, with the same sign,
+ except where stated to be exactly the given value.
+<!--page 310 indent 4-->
+
+<a name="7.20.2.1" href="#7.20.2.1"><h5>7.20.2.1 Limits of exact-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum values of exact-width signed integer types
+<pre>
+     INTN_MIN                                  exactly -(2 N -1 )</pre>
+<li>  maximum values of exact-width signed integer types
+<pre>
+     INTN_MAX                                  exactly 2 N -1 - 1</pre>
+<li>  maximum values of exact-width unsigned integer types
+  UINTN_MAX                                    exactly 2 N - 1
+</ul>
+
+<a name="7.20.2.2" href="#7.20.2.2"><h5>7.20.2.2 Limits of minimum-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum values of minimum-width signed integer types
+<pre>
+     INT_LEASTN_MIN                                    -(2 N -1 - 1)</pre>
+<li>  maximum values of minimum-width signed integer types
+<pre>
+     INT_LEASTN_MAX                                    2 N -1 - 1</pre>
+<li>  maximum values of minimum-width unsigned integer types
+  UINT_LEASTN_MAX                                      2N - 1
+</ul>
+
+<a name="7.20.2.3" href="#7.20.2.3"><h5>7.20.2.3 Limits of fastest minimum-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum values of fastest minimum-width signed integer types
+<pre>
+     INT_FASTN_MIN                                     -(2 N -1 - 1)</pre>
+<li>  maximum values of fastest minimum-width signed integer types
+  INT_FASTN_MAX                                        2 N -1 - 1
+<li>  maximum values of fastest minimum-width unsigned integer types
+  UINT_FASTN_MAX                                       2N - 1
+</ul>
+
+<a name="7.20.2.4" href="#7.20.2.4"><h5>7.20.2.4 Limits of integer types capable of holding object pointers</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum value of pointer-holding signed integer type
+<pre>
+     INTPTR_MIN                                        -(215 - 1)</pre>
+<li>  maximum value of pointer-holding signed integer type
+  INTPTR_MAX                                           215 - 1
+<li>  maximum value of pointer-holding unsigned integer type
+  UINTPTR_MAX                                          216 - 1
+<!--page 311 indent 4-->
+</ul>
+
+<a name="7.20.2.5" href="#7.20.2.5"><h5>7.20.2.5 Limits of greatest-width integer types</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  minimum value of greatest-width signed integer type
+   INTMAX_MIN                                                    -(263 - 1)
+<li>  maximum value of greatest-width signed integer type
+   INTMAX_MAX                                                    263 - 1
+<li>  maximum value of greatest-width unsigned integer type
+   UINTMAX_MAX                                                   264 - 1
+</ul>
+
+<a name="7.20.3" href="#7.20.3"><h4>7.20.3 Limits of other integer types</h4></a>
+<p><!--para 1-->
+ The following object-like macros specify the minimum and maximum limits of integer *
+ types corresponding to types defined in other standard headers.
+<p><!--para 2-->
+ Each instance of these macros shall be replaced by a constant expression suitable for use
+ in #if preprocessing directives, and this expression shall have the same type as would an
+ expression that is an object of the corresponding type converted according to the integer
+ promotions. Its implementation-defined value shall be equal to or greater in magnitude
+ (absolute value) than the corresponding value given below, with the same sign. An
+ implementation shall define only the macros corresponding to those typedef names it
+ actually provides.<sup><a href="#note256"><b>256)</b></a></sup>
+<ul>
+<li>  limits of ptrdiff_t
+   PTRDIFF_MIN                                                 -65535
+   PTRDIFF_MAX                                                 +65535
+<li>  limits of sig_atomic_t
+   SIG_ATOMIC_MIN                                              see below
+   SIG_ATOMIC_MAX                                              see below
+<li>  limit of size_t
+   SIZE_MAX                                                      65535
+<li>  limits of wchar_t
+   WCHAR_MIN                                                   see below
+   WCHAR_MAX                                                   see below
+<li>  limits of wint_t
+ 
+ 
+ 
+ 
+<!--page 312 indent 4-->
+   WINT_MIN                                              see below
+   WINT_MAX                                              see below
+</ul>
+<p><!--para 3-->
+ If sig_atomic_t (see <a href="#7.14">7.14</a>) is defined as a signed integer type, the value of
+ SIG_ATOMIC_MIN shall be no greater than -127 and the value of SIG_ATOMIC_MAX
+ shall be no less than 127; otherwise, sig_atomic_t is defined as an unsigned integer
+ type, and the value of SIG_ATOMIC_MIN shall be 0 and the value of
+ SIG_ATOMIC_MAX shall be no less than 255.
+<p><!--para 4-->
+ If wchar_t (see <a href="#7.19">7.19</a>) is defined as a signed integer type, the value of WCHAR_MIN
+ shall be no greater than -127 and the value of WCHAR_MAX shall be no less than 127;
+ otherwise, wchar_t is defined as an unsigned integer type, and the value of
+ WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.<sup><a href="#note257"><b>257)</b></a></sup>
+<p><!--para 5-->
+ If wint_t (see <a href="#7.28">7.28</a>) is defined as a signed integer type, the value of WINT_MIN shall
+ be no greater than -32767 and the value of WINT_MAX shall be no less than 32767;
+ otherwise, wint_t is defined as an unsigned integer type, and the value of WINT_MIN
+ shall be 0 and the value of WINT_MAX shall be no less than 65535.
+
+<h6>footnotes</h6>
+<p><a name="note256">256)</a> A freestanding implementation need not provide all of these types.
+
+<p><a name="note257">257)</a> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
+ character set.
+
+
+<a name="7.20.4" href="#7.20.4"><h4>7.20.4 Macros for integer constants</h4></a>
+<p><!--para 1-->
+ The following function-like macros expand to integer constants suitable for initializing *
+ objects that have integer types corresponding to types defined in &lt;stdint.h&gt;. Each
+ macro name corresponds to a similar type name in <a href="#7.20.1.2">7.20.1.2</a> or <a href="#7.20.1.5">7.20.1.5</a>.
+<p><!--para 2-->
+ The argument in any instance of these macros shall be an unsuffixed integer constant (as
+ defined in <a href="#6.4.4.1">6.4.4.1</a>) with a value that does not exceed the limits for the corresponding type.
+<p><!--para 3-->
+ Each invocation of one of these macros shall expand to an integer constant expression
+ suitable for use in #if preprocessing directives. The type of the expression shall have
+ the same type as would an expression of the corresponding type converted according to
+ the integer promotions. The value of the expression shall be that of the argument.
+
+<a name="7.20.4.1" href="#7.20.4.1"><h5>7.20.4.1 Macros for minimum-width integer constants</h5></a>
+<p><!--para 1-->
+ The macro INTN_C(value) shall expand to an integer constant expression
+ corresponding to the type int_leastN_t. The macro UINTN_C(value) shall expand
+ to an integer constant expression corresponding to the type uint_leastN_t. For
+ example, if uint_least64_t is a name for the type unsigned long long int,
+ then UINT64_C(0x123) might expand to the integer constant 0x123ULL.
+ 
+ 
+ 
+ 
+<!--page 313 indent 4-->
+
+<a name="7.20.4.2" href="#7.20.4.2"><h5>7.20.4.2 Macros for greatest-width integer constants</h5></a>
+<p><!--para 1-->
+ The following macro expands to an integer constant expression having the value specified
+ by its argument and the type intmax_t:
+<pre>
+         INTMAX_C(value)</pre>
+ The following macro expands to an integer constant expression having the value specified
+ by its argument and the type uintmax_t:
+<!--page 314 indent 4-->
+<pre>
+         UINTMAX_C(value)</pre>
+
+<a name="7.21" href="#7.21"><h3>7.21 Input/output <stdio.h></h3></a>
+
+<a name="7.21.1" href="#7.21.1"><h4>7.21.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;stdio.h&gt; defines several macros, and declares three types and many
+ functions for performing input and output.
+<p><!--para 2-->
+ The types declared are size_t (described in <a href="#7.19">7.19</a>);
+<pre>
+        FILE</pre>
+ which is an object type capable of recording all the information needed to control a
+ stream, including its file position indicator, a pointer to its associated buffer (if any), an
+ error indicator that records whether a read/write error has occurred, and an end-of-file
+ indicator that records whether the end of the file has been reached; and
+<pre>
+        fpos_t</pre>
+ which is a complete object type other than an array type capable of recording all the
+ information needed to specify uniquely every position within a file.
+<p><!--para 3-->
+ The macros are NULL (described in <a href="#7.19">7.19</a>);
+<pre>
+        _IOFBF
+        _IOLBF
+        _IONBF</pre>
+ which expand to integer constant expressions with distinct values, suitable for use as the
+ third argument to the setvbuf function;
+<pre>
+        BUFSIZ</pre>
+ which expands to an integer constant expression that is the size of the buffer used by the
+ setbuf function;
+<pre>
+        EOF</pre>
+ which expands to an integer constant expression, with type int and a negative value, that
+ is returned by several functions to indicate end-of-file, that is, no more input from a
+ stream;
+<pre>
+        FOPEN_MAX</pre>
+ which expands to an integer constant expression that is the minimum number of files that
+ the implementation guarantees can be open simultaneously;
+<pre>
+        FILENAME_MAX</pre>
+ which expands to an integer constant expression that is the size needed for an array of
+ char large enough to hold the longest file name string that the implementation
+<!--page 315 indent 4-->
+ guarantees can be opened;<sup><a href="#note258"><b>258)</b></a></sup>
+<pre>
+         L_tmpnam</pre>
+ which expands to an integer constant expression that is the size needed for an array of
+ char large enough to hold a temporary file name string generated by the tmpnam
+ function;
+<pre>
+         SEEK_CUR
+         SEEK_END
+         SEEK_SET</pre>
+ which expand to integer constant expressions with distinct values, suitable for use as the
+ third argument to the fseek function;
+<pre>
+         TMP_MAX</pre>
+ which expands to an integer constant expression that is the minimum number of unique
+ file names that can be generated by the tmpnam function;
+<pre>
+         stderr
+         stdin
+         stdout</pre>
+ which are expressions of type ''pointer to FILE'' that point to the FILE objects
+ associated, respectively, with the standard error, input, and output streams.
+<p><!--para 4-->
+ The header &lt;wchar.h&gt; declares a number of functions useful for wide character input
+ and output. The wide character input/output functions described in that subclause
+ provide operations analogous to most of those described here, except that the
+ fundamental units internal to the program are wide characters. The external
+ representation (in the file) is a sequence of ''generalized'' multibyte characters, as
+ described further in <a href="#7.21.3">7.21.3</a>.
+<p><!--para 5-->
+ The input/output functions are given the following collective terms:
+<ul>
+<li>  The wide character input functions -- those functions described in <a href="#7.28">7.28</a> that perform
+ input into wide characters and wide strings: fgetwc, fgetws, getwc, getwchar,
+ fwscanf, wscanf, vfwscanf, and vwscanf.
+<li>  The wide character output functions -- those functions described in <a href="#7.28">7.28</a> that perform
+ output from wide characters and wide strings: fputwc, fputws, putwc,
+ putwchar, fwprintf, wprintf, vfwprintf, and vwprintf.
+ 
+ 
+<!--page 316 indent 4-->
+<li>  The wide character input/output functions -- the union of the ungetwc function, the
+ wide character input functions, and the wide character output functions.
+<li>  The byte input/output functions -- those functions described in this subclause that
+ perform input/output: fgetc, fgets, fprintf, fputc, fputs, fread,
+ fscanf, fwrite, getc, getchar, printf, putc, putchar, puts, scanf, *
+ ungetc, vfprintf, vfscanf, vprintf, and vscanf.
+</ul>
+ Forward references: files (<a href="#7.21.3">7.21.3</a>), the fseek function (<a href="#7.21.9.2">7.21.9.2</a>), streams (<a href="#7.21.2">7.21.2</a>), the
+ tmpnam function (<a href="#7.21.4.4">7.21.4.4</a>), &lt;wchar.h&gt; (<a href="#7.28">7.28</a>).
+
+<h6>footnotes</h6>
+<p><a name="note258">258)</a> If the implementation imposes no practical limit on the length of file name strings, the value of
+ FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
+ string. Of course, file name string contents are subject to other system-specific constraints; therefore
+ all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
+
+
+<a name="7.21.2" href="#7.21.2"><h4>7.21.2 Streams</h4></a>
+<p><!--para 1-->
+ Input and output, whether to or from physical devices such as terminals and tape drives,
+ or whether to or from files supported on structured storage devices, are mapped into
+ logical data streams, whose properties are more uniform than their various inputs and
+ outputs. Two forms of mapping are supported, for text streams and for binary
+ streams.<sup><a href="#note259"><b>259)</b></a></sup>
+<p><!--para 2-->
+ A text stream is an ordered sequence of characters composed into lines, each line
+ consisting of zero or more characters plus a terminating new-line character. Whether the
+ last line requires a terminating new-line character is implementation-defined. Characters
+ may have to be added, altered, or deleted on input and output to conform to differing
+ conventions for representing text in the host environment. Thus, there need not be a one-
+ to-one correspondence between the characters in a stream and those in the external
+ representation. Data read in from a text stream will necessarily compare equal to the data
+ that were earlier written out to that stream only if: the data consist only of printing
+ characters and the control characters horizontal tab and new-line; no new-line character is
+ immediately preceded by space characters; and the last character is a new-line character.
+ Whether space characters that are written out immediately before a new-line character
+ appear when read in is implementation-defined.
+<p><!--para 3-->
+ A binary stream is an ordered sequence of characters that can transparently record
+ internal data. Data read in from a binary stream shall compare equal to the data that were
+ earlier written out to that stream, under the same implementation. Such a stream may,
+ however, have an implementation-defined number of null characters appended to the end
+ of the stream.
+<p><!--para 4-->
+ Each stream has an orientation. After a stream is associated with an external file, but
+ before any operations are performed on it, the stream is without orientation. Once a wide
+ character input/output function has been applied to a stream without orientation, the
+ 
+ 
+<!--page 317 indent 4-->
+ stream becomes a wide-oriented stream. Similarly, once a byte input/output function has
+ been applied to a stream without orientation, the stream becomes a byte-oriented stream.
+ Only a call to the freopen function or the fwide function can otherwise alter the
+ orientation of a stream. (A successful call to freopen removes any orientation.)<sup><a href="#note260"><b>260)</b></a></sup>
+<p><!--para 5-->
+ Byte input/output functions shall not be applied to a wide-oriented stream and wide
+ character input/output functions shall not be applied to a byte-oriented stream. The
+ remaining stream operations do not affect, and are not affected by, a stream's orientation,
+ except for the following additional restrictions:
+<ul>
+<li>  Binary wide-oriented streams have the file-positioning restrictions ascribed to both
+ text and binary streams.
+<li>  For wide-oriented streams, after a successful call to a file-positioning function that
+ leaves the file position indicator prior to the end-of-file, a wide character output
+ function can overwrite a partial multibyte character; any file contents beyond the
+ byte(s) written are henceforth indeterminate.
+</ul>
+<p><!--para 6-->
+ Each wide-oriented stream has an associated mbstate_t object that stores the current
+ parse state of the stream. A successful call to fgetpos stores a representation of the
+ value of this mbstate_t object as part of the value of the fpos_t object. A later
+ successful call to fsetpos using the same stored fpos_t value restores the value of
+ the associated mbstate_t object as well as the position within the controlled stream.
+ Environmental limits
+<p><!--para 7-->
+ An implementation shall support text files with lines containing at least 254 characters,
+ including the terminating new-line character. The value of the macro BUFSIZ shall be at
+ least 256.
+ Forward references: the freopen function (<a href="#7.21.5.4">7.21.5.4</a>), the fwide function (<a href="#7.28.3.5">7.28.3.5</a>),
+ mbstate_t (<a href="#7.29.1">7.29.1</a>), the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>), the fsetpos function
+ (<a href="#7.21.9.3">7.21.9.3</a>).
+ 
+ 
+ 
+ 
+<!--page 318 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note259">259)</a> An implementation need not distinguish between text streams and binary streams. In such an
+ implementation, there need be no new-line characters in a text stream nor any limit to the length of a
+ line.
+
+<p><a name="note260">260)</a> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
+
+
+<a name="7.21.3" href="#7.21.3"><h4>7.21.3 Files</h4></a>
+<p><!--para 1-->
+ A stream is associated with an external file (which may be a physical device) by opening
+ a file, which may involve creating a new file. Creating an existing file causes its former
+ contents to be discarded, if necessary. If a file can support positioning requests (such as a
+ disk file, as opposed to a terminal), then a file position indicator associated with the
+ stream is positioned at the start (character number zero) of the file, unless the file is
+ opened with append mode in which case it is implementation-defined whether the file
+ position indicator is initially positioned at the beginning or the end of the file. The file
+ position indicator is maintained by subsequent reads, writes, and positioning requests, to
+ facilitate an orderly progression through the file.
+<p><!--para 2-->
+ Binary files are not truncated, except as defined in <a href="#7.21.5.3">7.21.5.3</a>. Whether a write on a text
+ stream causes the associated file to be truncated beyond that point is implementation-
+ defined.
+<p><!--para 3-->
+ When a stream is unbuffered, characters are intended to appear from the source or at the
+ destination as soon as possible. Otherwise characters may be accumulated and
+ transmitted to or from the host environment as a block. When a stream is fully buffered,
+ characters are intended to be transmitted to or from the host environment as a block when
+ a buffer is filled. When a stream is line buffered, characters are intended to be
+ transmitted to or from the host environment as a block when a new-line character is
+ encountered. Furthermore, characters are intended to be transmitted as a block to the host
+ environment when a buffer is filled, when input is requested on an unbuffered stream, or
+ when input is requested on a line buffered stream that requires the transmission of
+ characters from the host environment. Support for these characteristics is
+ implementation-defined, and may be affected via the setbuf and setvbuf functions.
+<p><!--para 4-->
+ A file may be disassociated from a controlling stream by closing the file. Output streams
+ are flushed (any unwritten buffer contents are transmitted to the host environment) before
+ the stream is disassociated from the file. The value of a pointer to a FILE object is
+ indeterminate after the associated file is closed (including the standard text streams).
+ Whether a file of zero length (on which no characters have been written by an output
+ stream) actually exists is implementation-defined.
+<p><!--para 5-->
+ The file may be subsequently reopened, by the same or another program execution, and
+ its contents reclaimed or modified (if it can be repositioned at its start). If the main
+ function returns to its original caller, or if the exit function is called, all open files are
+ closed (hence all output streams are flushed) before program termination. Other paths to
+ program termination, such as calling the abort function, need not close all files
+ properly.
+<p><!--para 6-->
+ The address of the FILE object used to control a stream may be significant; a copy of a
+ FILE object need not serve in place of the original.
+<!--page 319 indent 5-->
+<p><!--para 7-->
+ At program startup, three text streams are predefined and need not be opened explicitly
+<ul>
+<li>  standard input (for reading conventional input), standard output (for writing
+</ul>
+ conventional output), and standard error (for writing diagnostic output). As initially
+ opened, the standard error stream is not fully buffered; the standard input and standard
+ output streams are fully buffered if and only if the stream can be determined not to refer
+ to an interactive device.
+<p><!--para 8-->
+ Functions that open additional (nontemporary) files require a file name, which is a string.
+ The rules for composing valid file names are implementation-defined. Whether the same
+ file can be simultaneously open multiple times is also implementation-defined.
+<p><!--para 9-->
+ Although both text and binary wide-oriented streams are conceptually sequences of wide
+ characters, the external file associated with a wide-oriented stream is a sequence of
+ multibyte characters, generalized as follows:
+<ul>
+<li>  Multibyte encodings within files may contain embedded null bytes (unlike multibyte
+ encodings valid for use internal to the program).
+<li>  A file need not begin nor end in the initial shift state.<sup><a href="#note261"><b>261)</b></a></sup>
+</ul>
+<p><!--para 10-->
+ Moreover, the encodings used for multibyte characters may differ among files. Both the
+ nature and choice of such encodings are implementation-defined.
+<p><!--para 11-->
+ The wide character input functions read multibyte characters from the stream and convert
+ them to wide characters as if they were read by successive calls to the fgetwc function.
+ Each conversion occurs as if by a call to the mbrtowc function, with the conversion state
+ described by the stream's own mbstate_t object. The byte input functions read
+ characters from the stream as if by successive calls to the fgetc function.
+<p><!--para 12-->
+ The wide character output functions convert wide characters to multibyte characters and
+ write them to the stream as if they were written by successive calls to the fputwc
+ function. Each conversion occurs as if by a call to the wcrtomb function, with the
+ conversion state described by the stream's own mbstate_t object. The byte output
+ functions write characters to the stream as if by successive calls to the fputc function.
+<p><!--para 13-->
+ In some cases, some of the byte input/output functions also perform conversions between
+ multibyte characters and wide characters. These conversions also occur as if by calls to
+ the mbrtowc and wcrtomb functions.
+<p><!--para 14-->
+ An encoding error occurs if the character sequence presented to the underlying
+ mbrtowc function does not form a valid (generalized) multibyte character, or if the code
+ value passed to the underlying wcrtomb does not correspond to a valid (generalized)
+ 
+ 
+<!--page 320 indent 5-->
+ multibyte character. The wide character input/output functions and the byte input/output
+ functions store the value of the macro EILSEQ in errno if and only if an encoding error
+ occurs.
+ Environmental limits
+<p><!--para 15-->
+ The value of FOPEN_MAX shall be at least eight, including the three standard text
+ streams.
+ Forward references: the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the fgetc function (<a href="#7.21.7.1">7.21.7.1</a>), the
+ fopen function (<a href="#7.21.5.3">7.21.5.3</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>), the setbuf function
+ (<a href="#7.21.5.5">7.21.5.5</a>), the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>), the fgetwc function (<a href="#7.28.3.1">7.28.3.1</a>), the
+ fputwc function (<a href="#7.28.3.3">7.28.3.3</a>), conversion state (<a href="#7.28.6">7.28.6</a>), the mbrtowc function
+ (<a href="#7.28.6.3.2">7.28.6.3.2</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note261">261)</a> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
+ undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
+ with state-dependent encoding that does not assuredly end in the initial shift state.
+
+
+<a name="7.21.4" href="#7.21.4"><h4>7.21.4 Operations on files</h4></a>
+
+<a name="7.21.4.1" href="#7.21.4.1"><h5>7.21.4.1 The remove function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int remove(const char *filename);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The remove function causes the file whose name is the string pointed to by filename
+ to be no longer accessible by that name. A subsequent attempt to open that file using that
+ name will fail, unless it is created anew. If the file is open, the behavior of the remove
+ function is implementation-defined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The remove function returns zero if the operation succeeds, nonzero if it fails.
+
+<a name="7.21.4.2" href="#7.21.4.2"><h5>7.21.4.2 The rename function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int rename(const char *old, const char *new);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rename function causes the file whose name is the string pointed to by old to be
+ henceforth known by the name given by the string pointed to by new. The file named
+ old is no longer accessible by that name. If a file named by the string pointed to by new
+ exists prior to the call to the rename function, the behavior is implementation-defined.
+<!--page 321 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The rename function returns zero if the operation succeeds, nonzero if it fails,<sup><a href="#note262"><b>262)</b></a></sup> in
+ which case if the file existed previously it is still known by its original name.
+
+<h6>footnotes</h6>
+<p><a name="note262">262)</a> Among the reasons the implementation may cause the rename function to fail are that the file is open
+ or that it is necessary to copy its contents to effectuate its renaming.
+
+
+<a name="7.21.4.3" href="#7.21.4.3"><h5>7.21.4.3 The tmpfile function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         FILE *tmpfile(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tmpfile function creates a temporary binary file that is different from any other
+ existing file and that will automatically be removed when it is closed or at program
+ termination. If the program terminates abnormally, whether an open temporary file is
+ removed is implementation-defined. The file is opened for update with "wb+" mode.
+ Recommended practice
+<p><!--para 3-->
+ It should be possible to open at least TMP_MAX temporary files during the lifetime of the
+ program (this limit may be shared with tmpnam) and there should be no limit on the
+ number simultaneously open other than this limit and any limit on the number of open
+ files (FOPEN_MAX).
+<h6>Returns</h6>
+<p><!--para 4-->
+ The tmpfile function returns a pointer to the stream of the file that it created. If the file
+ cannot be created, the tmpfile function returns a null pointer.
+ Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+
+<a name="7.21.4.4" href="#7.21.4.4"><h5>7.21.4.4 The tmpnam function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         char *tmpnam(char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tmpnam function generates a string that is a valid file name and that is not the same
+ as the name of an existing file.<sup><a href="#note263"><b>263)</b></a></sup> The function is potentially capable of generating at
+ 
+ 
+<!--page 322 indent 4-->
+ least TMP_MAX different strings, but any or all of them may already be in use by existing
+ files and thus not be suitable return values.
+<p><!--para 3-->
+ The tmpnam function generates a different string each time it is called.
+<p><!--para 4-->
+ Calls to the tmpnam function with a null pointer argument may introduce data races with
+ each other. The implementation shall behave as if no library function calls the tmpnam
+ function.
+<h6>Returns</h6>
+<p><!--para 5-->
+ If no suitable string can be generated, the tmpnam function returns a null pointer.
+ Otherwise, if the argument is a null pointer, the tmpnam function leaves its result in an
+ internal static object and returns a pointer to that object (subsequent calls to the tmpnam
+ function may modify the same object). If the argument is not a null pointer, it is assumed
+ to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
+ in that array and returns the argument as its value.
+ Environmental limits
+<p><!--para 6-->
+ The value of the macro TMP_MAX shall be at least 25.
+
+<h6>footnotes</h6>
+<p><a name="note263">263)</a> Files created using strings generated by the tmpnam function are temporary only in the sense that
+ their names should not collide with those generated by conventional naming rules for the
+ implementation. It is still necessary to use the remove function to remove such files when their use
+ is ended, and before program termination.
+
+
+<a name="7.21.5" href="#7.21.5"><h4>7.21.5 File access functions</h4></a>
+
+<a name="7.21.5.1" href="#7.21.5.1"><h5>7.21.5.1 The fclose function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fclose(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A successful call to the fclose function causes the stream pointed to by stream to be
+ flushed and the associated file to be closed. Any unwritten buffered data for the stream
+ are delivered to the host environment to be written to the file; any unread buffered data
+ are discarded. Whether or not the call succeeds, the stream is disassociated from the file
+ and any buffer set by the setbuf or setvbuf function is disassociated from the stream
+ (and deallocated if it was automatically allocated).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fclose function returns zero if the stream was successfully closed, or EOF if any
+ errors were detected.
+<!--page 323 indent 4-->
+
+<a name="7.21.5.2" href="#7.21.5.2"><h5>7.21.5.2 The fflush function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fflush(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If stream points to an output stream or an update stream in which the most recent
+ operation was not input, the fflush function causes any unwritten data for that stream
+ to be delivered to the host environment to be written to the file; otherwise, the behavior is
+ undefined.
+<p><!--para 3-->
+ If stream is a null pointer, the fflush function performs this flushing action on all
+ streams for which the behavior is defined above.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The fflush function sets the error indicator for the stream and returns EOF if a write
+ error occurs, otherwise it returns zero.
+ Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+
+<a name="7.21.5.3" href="#7.21.5.3"><h5>7.21.5.3 The fopen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         FILE *fopen(const char * restrict filename,
+              const char * restrict mode);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fopen function opens the file whose name is the string pointed to by filename,
+ and associates a stream with it.
+<p><!--para 3-->
+ The argument mode points to a string. If the string is one of the following, the file is
+ open in the indicated mode. Otherwise, the behavior is undefined.<sup><a href="#note264"><b>264)</b></a></sup>
+ r                     open text file for reading
+ w                     truncate to zero length or create text file for writing
+ wx                    create text file for writing
+ a                     append; open or create text file for writing at end-of-file
+ rb                    open binary file for reading
+ wb                    truncate to zero length or create binary file for writing
+ 
+ 
+<!--page 324 indent 4-->
+ wbx               create binary file for writing
+ ab                append; open or create binary file for writing at end-of-file
+ r+                open text file for update (reading and writing)
+ w+                truncate to zero length or create text file for update
+ w+x               create text file for update
+ a+                append; open or create text file for update, writing at end-of-file
+ r+b or rb+        open binary file for update (reading and writing)
+ w+b or wb+        truncate to zero length or create binary file for update
+ w+bx or wb+x      create binary file for update
+ a+b or ab+        append; open or create binary file for update, writing at end-of-file
+<p><!--para 4-->
+ Opening a file with read mode ('r' as the first character in the mode argument) fails if
+ the file does not exist or cannot be read.
+<p><!--para 5-->
+ Opening a file with exclusive mode ('x' as the last character in the mode argument)
+ fails if the file already exists or cannot be created. Otherwise, the file is created with
+ exclusive (also known as non-shared) access to the extent that the underlying system
+ supports exclusive access.
+<p><!--para 6-->
+ Opening a file with append mode ('a' as the first character in the mode argument)
+ causes all subsequent writes to the file to be forced to the then current end-of-file,
+ regardless of intervening calls to the fseek function. In some implementations, opening
+ a binary file with append mode ('b' as the second or third character in the above list of
+ mode argument values) may initially position the file position indicator for the stream
+ beyond the last data written, because of null character padding.
+<p><!--para 7-->
+ When a file is opened with update mode ('+' as the second or third character in the
+ above list of mode argument values), both input and output may be performed on the
+ associated stream. However, output shall not be directly followed by input without an
+ intervening call to the fflush function or to a file positioning function (fseek,
+ fsetpos, or rewind), and input shall not be directly followed by output without an
+ intervening call to a file positioning function, unless the input operation encounters end-
+ of-file. Opening (or creating) a text file with update mode may instead open (or create) a
+ binary stream in some implementations.
+<p><!--para 8-->
+ When opened, a stream is fully buffered if and only if it can be determined not to refer to
+ an interactive device. The error and end-of-file indicators for the stream are cleared.
+<h6>Returns</h6>
+<p><!--para 9-->
+ The fopen function returns a pointer to the object controlling the stream. If the open
+ operation fails, fopen returns a null pointer.
+ Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
+<!--page 325 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note264">264)</a> If the string begins with one of the above sequences, the implementation might choose to ignore the
+ remaining characters, or it might use them to select different kinds of a file (some of which might not
+ conform to the properties in <a href="#7.21.2">7.21.2</a>).
+
+
+<a name="7.21.5.4" href="#7.21.5.4"><h5>7.21.5.4 The freopen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         FILE *freopen(const char * restrict filename,
+              const char * restrict mode,
+              FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The freopen function opens the file whose name is the string pointed to by filename
+ and associates the stream pointed to by stream with it. The mode argument is used just
+ as in the fopen function.<sup><a href="#note265"><b>265)</b></a></sup>
+<p><!--para 3-->
+ If filename is a null pointer, the freopen function attempts to change the mode of
+ the stream to that specified by mode, as if the name of the file currently associated with
+ the stream had been used. It is implementation-defined which changes of mode are
+ permitted (if any), and under what circumstances.
+<p><!--para 4-->
+ The freopen function first attempts to close any file that is associated with the specified
+ stream. Failure to close the file is ignored. The error and end-of-file indicators for the
+ stream are cleared.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The freopen function returns a null pointer if the open operation fails. Otherwise,
+ freopen returns the value of stream.
+
+<h6>footnotes</h6>
+<p><a name="note265">265)</a> The primary use of the freopen function is to change the file associated with a standard text stream
+ (stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
+ returned by the fopen function may be assigned.
+
+
+<a name="7.21.5.5" href="#7.21.5.5"><h5>7.21.5.5 The setbuf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         void setbuf(FILE * restrict stream,
+              char * restrict buf);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ Except that it returns no value, the setbuf function is equivalent to the setvbuf
+ function invoked with the values _IOFBF for mode and BUFSIZ for size, or (if buf
+ is a null pointer), with the value _IONBF for mode.
+ 
+ 
+ 
+ 
+<!--page 326 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The setbuf function returns no value.
+ Forward references: the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
+
+<a name="7.21.5.6" href="#7.21.5.6"><h5>7.21.5.6 The setvbuf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int setvbuf(FILE * restrict stream,
+              char * restrict buf,
+              int mode, size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The setvbuf function may be used only after the stream pointed to by stream has
+ been associated with an open file and before any other operation (other than an
+ unsuccessful call to setvbuf) is performed on the stream. The argument mode
+ determines how stream will be buffered, as follows: _IOFBF causes input/output to be
+ fully buffered; _IOLBF causes input/output to be line buffered; _IONBF causes
+ input/output to be unbuffered. If buf is not a null pointer, the array it points to may be
+ used instead of a buffer allocated by the setvbuf function<sup><a href="#note266"><b>266)</b></a></sup> and the argument size
+ specifies the size of the array; otherwise, size may determine the size of a buffer
+ allocated by the setvbuf function. The contents of the array at any time are
+ indeterminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The setvbuf function returns zero on success, or nonzero if an invalid value is given
+ for mode or if the request cannot be honored.
+ 
+ 
+ 
+ 
+<!--page 327 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note266">266)</a> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
+ before a buffer that has automatic storage duration is deallocated upon block exit.
+
+
+<a name="7.21.6" href="#7.21.6"><h4>7.21.6 Formatted input/output functions</h4></a>
+<p><!--para 1-->
+ The formatted input/output functions shall behave as if there is a sequence point after the
+ actions associated with each specifier.<sup><a href="#note267"><b>267)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note267">267)</a> The fprintf functions perform writes to memory for the %n specifier.
+
+
+<a name="7.21.6.1" href="#7.21.6.1"><h5>7.21.6.1 The fprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdio.h&gt;
+          int fprintf(FILE * restrict stream,
+               const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fprintf function writes output to the stream pointed to by stream, under control
+ of the string pointed to by format that specifies how subsequent arguments are
+ converted for output. If there are insufficient arguments for the format, the behavior is
+ undefined. If the format is exhausted while arguments remain, the excess arguments are
+ evaluated (as always) but are otherwise ignored. The fprintf function returns when
+ the end of the format string is encountered.
+<p><!--para 3-->
+ The format shall be a multibyte character sequence, beginning and ending in its initial
+ shift state. The format is composed of zero or more directives: ordinary multibyte
+ characters (not %), which are copied unchanged to the output stream; and conversion
+ specifications, each of which results in fetching zero or more subsequent arguments,
+ converting them, if applicable, according to the corresponding conversion specifier, and
+ then writing the result to the output stream.
+<p><!--para 4-->
+ Each conversion specification is introduced by the character %. After the %, the following
+ appear in sequence:
+<ul>
+<li>  Zero or more flags (in any order) that modify the meaning of the conversion
+ specification.
+<li>  An optional minimum field width. If the converted value has fewer characters than the
+ field width, it is padded with spaces (by default) on the left (or right, if the left
+ adjustment flag, described later, has been given) to the field width. The field width
+ takes the form of an asterisk * (described later) or a nonnegative decimal integer.<sup><a href="#note268"><b>268)</b></a></sup>
+<li>  An optional precision that gives the minimum number of digits to appear for the d, i,
+ o, u, x, and X conversions, the number of digits to appear after the decimal-point
+ character for a, A, e, E, f, and F conversions, the maximum number of significant
+ digits for the g and G conversions, or the maximum number of bytes to be written for
+ 
+ 
+<!--page 328 indent 4-->
+   s conversions. The precision takes the form of a period (.) followed either by an
+   asterisk * (described later) or by an optional decimal integer; if only the period is
+   specified, the precision is taken as zero. If a precision appears with any other
+   conversion specifier, the behavior is undefined.
+<li>  An optional length modifier that specifies the size of the argument.
+<li>  A conversion specifier character that specifies the type of conversion to be applied.
+</ul>
+<p><!--para 5-->
+ As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+ this case, an int argument supplies the field width or precision. The arguments
+ specifying field width, or precision, or both, shall appear (in that order) before the
+ argument (if any) to be converted. A negative field width argument is taken as a - flag
+ followed by a positive field width. A negative precision argument is taken as if the
+ precision were omitted.
+<p><!--para 6-->
+ The flag characters and their meanings are:
+ -       The result of the conversion is left-justified within the field. (It is right-justified if
+<pre>
+         this flag is not specified.)</pre>
+ +       The result of a signed conversion always begins with a plus or minus sign. (It
+<pre>
+         begins with a sign only when a negative value is converted if this flag is not
+         specified.)<sup><a href="#note269"><b>269)</b></a></sup></pre>
+ space If the first character of a signed conversion is not a sign, or if a signed conversion
+<pre>
+       results in no characters, a space is prefixed to the result. If the space and + flags
+       both appear, the space flag is ignored.</pre>
+ #       The result is converted to an ''alternative form''. For o conversion, it increases
+<pre>
+         the precision, if and only if necessary, to force the first digit of the result to be a
+         zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+         conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
+         and G conversions, the result of converting a floating-point number always
+         contains a decimal-point character, even if no digits follow it. (Normally, a
+         decimal-point character appears in the result of these conversions only if a digit
+         follows it.) For g and G conversions, trailing zeros are not removed from the
+         result. For other conversions, the behavior is undefined.</pre>
+ 0       For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+<pre>
+         (following any indication of sign or base) are used to pad to the field width rather
+         than performing space padding, except when converting an infinity or NaN. If the
+         0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X</pre>
+ 
+ 
+<!--page 329 indent 4-->
+<p><!--para 7-->
+<pre>
+           conversions, if a precision is specified, the 0 flag is ignored. For other
+           conversions, the behavior is undefined.</pre>
+ The length modifiers and their meanings are:
+ hh            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+               signed char or unsigned char argument (the argument will have
+               been promoted according to the integer promotions, but its value shall be
+               converted to signed char or unsigned char before printing); or that
+               a following n conversion specifier applies to a pointer to a signed char
+               argument.</pre>
+ h             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+               short int or unsigned short int argument (the argument will
+               have been promoted according to the integer promotions, but its value shall
+               be converted to short int or unsigned short int before printing);
+               or that a following n conversion specifier applies to a pointer to a short
+               int argument.</pre>
+ l (ell)       Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+               long int or unsigned long int argument; that a following n
+               conversion specifier applies to a pointer to a long int argument; that a
+               following c conversion specifier applies to a wint_t argument; that a
+               following s conversion specifier applies to a pointer to a wchar_t
+               argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+               specifier.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              long long int or unsigned long long int argument; or that a
+              following n conversion specifier applies to a pointer to a long long int
+              argument.</pre>
+ j             Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+<pre>
+               an intmax_t or uintmax_t argument; or that a following n conversion
+               specifier applies to a pointer to an intmax_t argument.</pre>
+ z             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+               size_t or the corresponding signed integer type argument; or that a
+               following n conversion specifier applies to a pointer to a signed integer type
+               corresponding to size_t argument.</pre>
+ t             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<!--page 330 indent 4-->
+<pre>
+               ptrdiff_t or the corresponding unsigned integer type argument; or that a
+               following n conversion specifier applies to a pointer to a ptrdiff_t
+               argument.</pre>
+ L              Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+                applies to a long double argument.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 8-->
+ The conversion specifiers and their meanings are:
+ d,i          The int argument is converted to signed decimal in the style [-]dddd. The
+<pre>
+              precision specifies the minimum number of digits to appear; if the value
+              being converted can be represented in fewer digits, it is expanded with
+              leading zeros. The default precision is 1. The result of converting a zero
+              value with a precision of zero is no characters.</pre>
+ o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+<pre>
+         decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+         letters abcdef are used for x conversion and the letters ABCDEF for X
+         conversion. The precision specifies the minimum number of digits to appear;
+         if the value being converted can be represented in fewer digits, it is expanded
+         with leading zeros. The default precision is 1. The result of converting a
+         zero value with a precision of zero is no characters.</pre>
+ f,F          A double argument representing a floating-point number is converted to
+<pre>
+              decimal notation in the style [-]ddd.ddd, where the number of digits after
+              the decimal-point character is equal to the precision specification. If the
+              precision is missing, it is taken as 6; if the precision is zero and the # flag is
+              not specified, no decimal-point character appears. If a decimal-point
+              character appears, at least one digit appears before it. The value is rounded to
+              the appropriate number of digits.
+              A double argument representing an infinity is converted in one of the styles
+              [-]inf or [-]infinity -- which style is implementation-defined. A
+              double argument representing a NaN is converted in one of the styles
+              [-]nan or [-]nan(n-char-sequence) -- which style, and the meaning of
+              any n-char-sequence, is implementation-defined. The F conversion specifier
+              produces INF, INFINITY, or NAN instead of inf, infinity, or nan,
+              respectively.<sup><a href="#note270"><b>270)</b></a></sup></pre>
+ e,E          A double argument representing a floating-point number is converted in the
+<pre>
+              style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+              argument is nonzero) before the decimal-point character and the number of
+              digits after it is equal to the precision; if the precision is missing, it is taken as</pre>
+ 
+ 
+<!--page 331 indent 0-->
+<pre>
+               6; if the precision is zero and the # flag is not specified, no decimal-point
+               character appears. The value is rounded to the appropriate number of digits.
+               The E conversion specifier produces a number with E instead of e
+               introducing the exponent. The exponent always contains at least two digits,
+               and only as many more digits as necessary to represent the exponent. If the
+               value is zero, the exponent is zero.
+               A double argument representing an infinity or NaN is converted in the style
+               of an f or F conversion specifier.</pre>
+ g,G           A double argument representing a floating-point number is converted in
+<pre>
+               style f or e (or in style F or E in the case of a G conversion specifier),
+               depending on the value converted and the precision. Let P equal the
+               precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+               Then, if a conversion with style E would have an exponent of X:
+               -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+                 P - (X + 1).
+               -- otherwise, the conversion is with style e (or E) and precision P - 1.
+               Finally, unless the # flag is used, any trailing zeros are removed from the
+               fractional portion of the result and the decimal-point character is removed if
+               there is no fractional portion remaining.
+               A double argument representing an infinity or NaN is converted in the style
+               of an f or F conversion specifier.</pre>
+ a,A           A double argument representing a floating-point number is converted in the
+<pre>
+               style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+               nonzero if the argument is a normalized floating-point number and is
+               otherwise unspecified) before the decimal-point character<sup><a href="#note271"><b>271)</b></a></sup> and the number
+               of hexadecimal digits after it is equal to the precision; if the precision is
+               missing and FLT_RADIX is a power of 2, then the precision is sufficient for
+               an exact representation of the value; if the precision is missing and
+               FLT_RADIX is not a power of 2, then the precision is sufficient to</pre>
+ 
+ 
+ 
+ 
+<!--page 332 indent 0-->
+<pre>
+               distinguish<sup><a href="#note272"><b>272)</b></a></sup> values of type double, except that trailing zeros may be
+               omitted; if the precision is zero and the # flag is not specified, no decimal-
+               point character appears. The letters abcdef are used for a conversion and
+               the letters ABCDEF for A conversion. The A conversion specifier produces a
+               number with X and P instead of x and p. The exponent always contains at
+               least one digit, and only as many more digits as necessary to represent the
+               decimal exponent of 2. If the value is zero, the exponent is zero.
+               A double argument representing an infinity or NaN is converted in the style
+               of an f or F conversion specifier.</pre>
+ c             If no l length modifier is present, the int argument is converted to an
+<pre>
+               unsigned char, and the resulting character is written.
+               If an l length modifier is present, the wint_t argument is converted as if by
+               an ls conversion specification with no precision and an argument that points
+               to the initial element of a two-element array of wchar_t, the first element
+               containing the wint_t argument to the lc conversion specification and the
+               second a null wide character.</pre>
+ s             If no l length modifier is present, the argument shall be a pointer to the initial
+<pre>
+               element of an array of character type.<sup><a href="#note273"><b>273)</b></a></sup> Characters from the array are
+               written up to (but not including) the terminating null character. If the
+               precision is specified, no more than that many bytes are written. If the
+               precision is not specified or is greater than the size of the array, the array shall
+               contain a null character.
+               If an l length modifier is present, the argument shall be a pointer to the initial
+               element of an array of wchar_t type. Wide characters from the array are
+               converted to multibyte characters (each as if by a call to the wcrtomb
+               function, with the conversion state described by an mbstate_t object
+               initialized to zero before the first wide character is converted) up to and
+               including a terminating null wide character. The resulting multibyte
+               characters are written up to (but not including) the terminating null character
+               (byte). If no precision is specified, the array shall contain a null wide
+               character. If a precision is specified, no more than that many bytes are
+               written (including shift sequences, if any), and the array shall contain a null
+               wide character if, to equal the multibyte character sequence length given by</pre>
+ 
+<!--page 333 indent 5-->
+<pre>
+                the precision, the function would need to access a wide character one past the
+                end of the array. In no case is a partial multibyte character written.<sup><a href="#note274"><b>274)</b></a></sup></pre>
+ p              The argument shall be a pointer to void. The value of the pointer is
+<pre>
+                converted to a sequence of printing characters, in an implementation-defined
+                manner.</pre>
+ n              The argument shall be a pointer to signed integer into which is written the
+<pre>
+                number of characters written to the output stream so far by this call to
+                fprintf. No argument is converted, but one is consumed. If the conversion
+                specification includes any flags, a field width, or a precision, the behavior is
+                undefined.</pre>
+ %              A % character is written. No argument is converted. The complete
+<p><!--para 9-->
+<pre>
+                conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note275"><b>275)</b></a></sup> If any argument is
+ not the correct type for the corresponding conversion specification, the behavior is
+ undefined.
+<p><!--para 10-->
+ In no case does a nonexistent or small field width cause truncation of a field; if the result
+ of a conversion is wider than the field width, the field is expanded to contain the
+ conversion result.
+<p><!--para 11-->
+ For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+ to a hexadecimal floating number with the given precision.
+ Recommended practice
+<p><!--para 12-->
+ For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+ representable in the given precision, the result should be one of the two adjacent numbers
+ in hexadecimal floating style with the given precision, with the extra stipulation that the
+ error should have a correct sign for the current rounding direction.
+<p><!--para 13-->
+ For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+ DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note276"><b>276)</b></a></sup> If the number of
+ significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+ representable with DECIMAL_DIG digits, then the result should be an exact
+ representation with trailing zeros. Otherwise, the source value is bounded by two
+ adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+ 
+ 
+<!--page 334 indent 5-->
+ of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+ the error should have a correct sign for the current rounding direction.
+<h6>Returns</h6>
+<p><!--para 14-->
+ The fprintf function returns the number of characters transmitted, or a negative value
+ if an output or encoding error occurred.
+ Environmental limits
+<p><!--para 15-->
+ The number of characters that can be produced by any single conversion shall be at least
+ 4095.
+<p><!--para 16-->
+ EXAMPLE 1         To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+ places:
+<pre>
+          #include &lt;math.h&gt;
+          #include &lt;stdio.h&gt;
+          /* ... */
+          char *weekday, *month;      // pointers to strings
+          int day, hour, min;
+          fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
+                  weekday, month, day, hour, min);
+          fprintf(stdout, "pi = %.5f\n", 4 * atan(1.0));</pre>
+ 
+<p><!--para 17-->
+ EXAMPLE 2 In this example, multibyte characters do not have a state-dependent encoding, and the
+ members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+ the first of which is denoted here by a and the second by an uppercase letter.
+<p><!--para 18-->
+ Given the following wide string with length seven,
+<pre>
+          static wchar_t wstr[] = L" X Yabc Z W";</pre>
+ the seven calls
+<pre>
+          fprintf(stdout,          "|1234567890123|\n");
+          fprintf(stdout,          "|%13ls|\n", wstr);
+          fprintf(stdout,          "|%-13.9ls|\n", wstr);
+          fprintf(stdout,          "|%13.10ls|\n", wstr);
+          fprintf(stdout,          "|%13.11ls|\n", wstr);
+          fprintf(stdout,          "|%13.15ls|\n", &amp;wstr[2]);
+          fprintf(stdout,          "|%13lc|\n", (wint_t) wstr[5]);</pre>
+ will print the following seven lines:
+<pre>
+          |1234567890123|
+          |   X Yabc Z W|
+          | X Yabc Z    |
+          |     X Yabc Z|
+          |   X Yabc Z W|
+          |      abc Z W|
+          |            Z|</pre>
+ 
+ Forward references: conversion state (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+<!--page 335 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note268">268)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
+
+<p><a name="note269">269)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+ include a minus sign.
+
+<p><a name="note270">270)</a> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
+ the # and 0 flag characters have no effect.
+
+<p><a name="note271">271)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
+ that subsequent digits align to nibble (4-bit) boundaries.
+
+<p><a name="note272">272)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+ FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+ might suffice depending on the implementation's scheme for determining the digit to the left of the
+ decimal-point character.
+
+<p><a name="note273">273)</a> No special provisions are made for multibyte characters.
+
+<p><a name="note274">274)</a> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
+
+<p><a name="note275">275)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+
+<p><a name="note276">276)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+ given format specifier. The number of significant digits is determined by the format specifier, and in
+ the case of fixed-point conversion by the source value as well.
+
+
+<a name="7.21.6.2" href="#7.21.6.2"><h5>7.21.6.2 The fscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fscanf(FILE * restrict stream,
+              const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fscanf function reads input from the stream pointed to by stream, under control
+ of the string pointed to by format that specifies the admissible input sequences and how
+ they are to be converted for assignment, using subsequent arguments as pointers to the
+ objects to receive the converted input. If there are insufficient arguments for the format,
+ the behavior is undefined. If the format is exhausted while arguments remain, the excess
+ arguments are evaluated (as always) but are otherwise ignored.
+<p><!--para 3-->
+ The format shall be a multibyte character sequence, beginning and ending in its initial
+ shift state. The format is composed of zero or more directives: one or more white-space
+ characters, an ordinary multibyte character (neither % nor a white-space character), or a
+ conversion specification. Each conversion specification is introduced by the character %.
+ After the %, the following appear in sequence:
+<ul>
+<li>  An optional assignment-suppressing character *.
+<li>  An optional decimal integer greater than zero that specifies the maximum field width
+ (in characters).
+<li>  An optional length modifier that specifies the size of the receiving object.
+<li>  A conversion specifier character that specifies the type of conversion to be applied.
+</ul>
+<p><!--para 4-->
+ The fscanf function executes each directive of the format in turn. When all directives
+ have been executed, or if a directive fails (as detailed below), the function returns.
+ Failures are described as input failures (due to the occurrence of an encoding error or the
+ unavailability of input characters), or matching failures (due to inappropriate input).
+<p><!--para 5-->
+ A directive composed of white-space character(s) is executed by reading input up to the
+ first non-white-space character (which remains unread), or until no more characters can
+ be read.
+<p><!--para 6-->
+ A directive that is an ordinary multibyte character is executed by reading the next
+ characters of the stream. If any of those characters differ from the ones composing the
+ directive, the directive fails and the differing and subsequent characters remain unread.
+ Similarly, if end-of-file, an encoding error, or a read error prevents a character from being
+ read, the directive fails.
+<p><!--para 7-->
+ A directive that is a conversion specification defines a set of matching input sequences, as
+ described below for each specifier. A conversion specification is executed in the
+<!--page 336 indent 5-->
+ following steps:
+<p><!--para 8-->
+ Input white-space characters (as specified by the isspace function) are skipped, unless
+ the specification includes a [, c, or n specifier.<sup><a href="#note277"><b>277)</b></a></sup>
+<p><!--para 9-->
+ An input item is read from the stream, unless the specification includes an n specifier. An
+ input item is defined as the longest sequence of input characters which does not exceed
+ any specified field width and which is, or is a prefix of, a matching input sequence.<sup><a href="#note278"><b>278)</b></a></sup>
+ The first character, if any, after the input item remains unread. If the length of the input
+ item is zero, the execution of the directive fails; this condition is a matching failure unless
+ end-of-file, an encoding error, or a read error prevented input from the stream, in which
+ case it is an input failure.
+<p><!--para 10-->
+ Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+ count of input characters) is converted to a type appropriate to the conversion specifier. If
+ the input item is not a matching sequence, the execution of the directive fails: this
+ condition is a matching failure. Unless assignment suppression was indicated by a *, the
+ result of the conversion is placed in the object pointed to by the first argument following
+ the format argument that has not already received a conversion result. If this object
+ does not have an appropriate type, or if the result of the conversion cannot be represented
+ in the object, the behavior is undefined.
+<p><!--para 11-->
+ The length modifiers and their meanings are:
+ hh             Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+                to an argument with type pointer to signed char or unsigned char.</pre>
+ h              Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+                to an argument with type pointer to short int or unsigned short
+                int.</pre>
+ l (ell)        Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+                to an argument with type pointer to long int or unsigned long
+                int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+                an argument with type pointer to double; or that a following c, s, or [
+                conversion specifier applies to an argument with type pointer to wchar_t.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to long long int or unsigned
+              long long int.</pre>
+ 
+ 
+ 
+<!--page 337 indent 5-->
+ j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to intmax_t or uintmax_t.</pre>
+ z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to size_t or the corresponding signed
+              integer type.</pre>
+ t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to ptrdiff_t or the corresponding
+              unsigned integer type.</pre>
+ L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+              applies to an argument with type pointer to long double.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 12-->
+ The conversion specifiers and their meanings are:
+ d           Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+             expected for the subject sequence of the strtol function with the value 10
+             for the base argument. The corresponding argument shall be a pointer to
+             signed integer.</pre>
+ i           Matches an optionally signed integer, whose format is the same as expected
+<pre>
+             for the subject sequence of the strtol function with the value 0 for the
+             base argument. The corresponding argument shall be a pointer to signed
+             integer.</pre>
+ o           Matches an optionally signed octal integer, whose format is the same as
+<pre>
+             expected for the subject sequence of the strtoul function with the value 8
+             for the base argument. The corresponding argument shall be a pointer to
+             unsigned integer.</pre>
+ u           Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+             expected for the subject sequence of the strtoul function with the value 10
+             for the base argument. The corresponding argument shall be a pointer to
+             unsigned integer.</pre>
+ x           Matches an optionally signed hexadecimal integer, whose format is the same
+<pre>
+             as expected for the subject sequence of the strtoul function with the value
+             16 for the base argument. The corresponding argument shall be a pointer to
+             unsigned integer.</pre>
+ a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+<!--page 338 indent 0-->
+<pre>
+         format is the same as expected for the subject sequence of the strtod
+         function. The corresponding argument shall be a pointer to floating.</pre>
+ c             Matches a sequence of characters of exactly the number specified by the field
+<pre>
+               width (1 if no field width is present in the directive).<sup><a href="#note279"><b>279)</b></a></sup>
+               If no l length modifier is present, the corresponding argument shall be a
+               pointer to the initial element of a character array large enough to accept the
+               sequence. No null character is added.
+               If an l length modifier is present, the input shall be a sequence of multibyte
+               characters that begins in the initial shift state. Each multibyte character in the
+               sequence is converted to a wide character as if by a call to the mbrtowc
+               function, with the conversion state described by an mbstate_t object
+               initialized to zero before the first multibyte character is converted. The
+               corresponding argument shall be a pointer to the initial element of an array of
+               wchar_t large enough to accept the resulting sequence of wide characters.
+               No null wide character is added.</pre>
+ s             Matches a sequence of non-white-space characters.279)
+<pre>
+               If no l length modifier is present, the corresponding argument shall be a
+               pointer to the initial element of a character array large enough to accept the
+               sequence and a terminating null character, which will be added automatically.
+               If an l length modifier is present, the input shall be a sequence of multibyte
+               characters that begins in the initial shift state. Each multibyte character is
+               converted to a wide character as if by a call to the mbrtowc function, with
+               the conversion state described by an mbstate_t object initialized to zero
+               before the first multibyte character is converted. The corresponding argument
+               shall be a pointer to the initial element of an array of wchar_t large enough
+               to accept the sequence and the terminating null wide character, which will be
+               added automatically.</pre>
+ [             Matches a nonempty sequence of characters from a set of expected characters
+<pre>
+               (the scanset).279)
+               If no l length modifier is present, the corresponding argument shall be a
+               pointer to the initial element of a character array large enough to accept the
+               sequence and a terminating null character, which will be added automatically.
+               If an l length modifier is present, the input shall be a sequence of multibyte
+               characters that begins in the initial shift state. Each multibyte character is
+               converted to a wide character as if by a call to the mbrtowc function, with
+               the conversion state described by an mbstate_t object initialized to zero</pre>
+ 
+<!--page 339 indent 5-->
+<pre>
+                before the first multibyte character is converted. The corresponding argument
+                shall be a pointer to the initial element of an array of wchar_t large enough
+                to accept the sequence and the terminating null wide character, which will be
+                added automatically.
+                The conversion specifier includes all subsequent characters in the format
+                string, up to and including the matching right bracket (]). The characters
+                between the brackets (the scanlist) compose the scanset, unless the character
+                after the left bracket is a circumflex (^), in which case the scanset contains all
+                characters that do not appear in the scanlist between the circumflex and the
+                right bracket. If the conversion specifier begins with [] or [^], the right
+                bracket character is in the scanlist and the next following right bracket
+                character is the matching right bracket that ends the specification; otherwise
+                the first following right bracket character is the one that ends the
+                specification. If a - character is in the scanlist and is not the first, nor the
+                second where the first character is a ^, nor the last character, the behavior is
+                implementation-defined.</pre>
+ p              Matches an implementation-defined set of sequences, which should be the
+<pre>
+                same as the set of sequences that may be produced by the %p conversion of
+                the fprintf function. The corresponding argument shall be a pointer to a
+                pointer to void. The input item is converted to a pointer value in an
+                implementation-defined manner. If the input item is a value converted earlier
+                during the same program execution, the pointer that results shall compare
+                equal to that value; otherwise the behavior of the %p conversion is undefined.</pre>
+ n              No input is consumed. The corresponding argument shall be a pointer to
+<pre>
+                signed integer into which is to be written the number of characters read from
+                the input stream so far by this call to the fscanf function. Execution of a
+                %n directive does not increment the assignment count returned at the
+                completion of execution of the fscanf function. No argument is converted,
+                but one is consumed. If the conversion specification includes an assignment-
+                suppressing character or a field width, the behavior is undefined.</pre>
+ %              Matches a single % character; no conversion or assignment occurs. The
+<p><!--para 13-->
+<pre>
+                complete conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note280"><b>280)</b></a></sup>
+<p><!--para 14-->
+ The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+ respectively, a, e, f, g, and x.
+ 
+ 
+ 
+<!--page 340 indent 5-->
+<p><!--para 15-->
+ Trailing white space (including new-line characters) is left unread unless matched by a
+ directive. The success of literal matches and suppressed assignments is not directly
+ determinable other than via the %n directive.
+<h6>Returns</h6>
+<p><!--para 16-->
+ The fscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the function returns the
+ number of input items assigned, which can be fewer than provided for, or even zero, in
+ the event of an early matching failure.
+<p><!--para 17-->
+ EXAMPLE 1        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int n, i; float x; char name[50];
+          n = fscanf(stdin, "%d%f%s", &amp;i, &amp;x, name);</pre>
+ with the input line:
+<pre>
+          25 54.32E-1 thompson</pre>
+ will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+ thompson\0.
+ 
+<p><!--para 18-->
+ EXAMPLE 2        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int i; float x; char name[50];
+          fscanf(stdin, "%2d%f%*d %[0123456789]", &amp;i, &amp;x, name);</pre>
+ with input:
+<pre>
+          56789 0123 56a72</pre>
+ will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
+ sequence 56\0. The next character read from the input stream will be a.
+ 
+<p><!--para 19-->
+ EXAMPLE 3        To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
+<p><!--para 20-->
+<pre>
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int count; float quant; char units[21], item[21];
+          do {
+                  count = fscanf(stdin, "%f%20s of %20s", &amp;quant, units, item);
+                  fscanf(stdin,"%*[^\n]");
+          } while (!feof(stdin) &amp;&amp; !ferror(stdin));</pre>
+ If the stdin stream contains the following lines:
+<!--page 341 indent 5-->
+<pre>
+          2 quarts of oil
+          -12.8degrees Celsius
+          lots of luck
+          10.0LBS     of
+          dirt
+          100ergs of energy</pre>
+ the execution of the above example will be analogous to the following assignments:
+<pre>
+           quant     =   2; strcpy(units, "quarts"); strcpy(item, "oil");
+           count     =   3;
+           quant     =   -12.8; strcpy(units, "degrees");
+           count     =   2; // "C" fails to match "o"
+           count     =   0; // "l" fails to match "%f"
+           quant     =   10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
+           count     =   3;
+           count     =   0; // "100e" fails to match "%f"
+           count     =   EOF;</pre>
+ 
+<p><!--para 21-->
+ EXAMPLE 4         In:
+<pre>
+           #include &lt;stdio.h&gt;
+           /* ... */
+           int d1, d2, n1, n2, i;
+           i = sscanf("123", "%d%n%n%d", &amp;d1, &amp;n1, &amp;n2, &amp;d2);</pre>
+ the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
+ of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
+ 
+<p><!--para 22-->
+ EXAMPLE 5 In these examples, multibyte characters do have a state-dependent encoding, and the
+ members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+ the first of which is denoted here by a and the second by an uppercase letter, but are only recognized as
+ such when in the alternate shift state. The shift sequences are denoted by (uparrow) and (downarrow), in which the first causes
+ entry into the alternate shift state.
+<p><!--para 23-->
+ After the call:
+<pre>
+           #include &lt;stdio.h&gt;
+           /* ... */
+           char str[50];
+           fscanf(stdin, "a%s", str);</pre>
+ with the input line:
+<pre>
+           a(uparrow) X Y(downarrow) bc</pre>
+ str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
+ characters, in the more general case) appears to be a single-byte white-space character.
+<p><!--para 24-->
+ In contrast, after the call:
+<pre>
+           #include &lt;stdio.h&gt;
+           #include &lt;stddef.h&gt;
+           /* ... */
+           wchar_t wstr[50];
+           fscanf(stdin, "a%ls", wstr);</pre>
+ with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
+ terminating null wide character.
+<p><!--para 25-->
+ However, the call:
+<!--page 342 indent 5-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;stddef.h&gt;
+         /* ... */
+         wchar_t wstr[50];
+         fscanf(stdin, "a(uparrow) X(downarrow)%ls", wstr);</pre>
+ with the same input line will return zero due to a matching failure against the (downarrow) sequence in the format
+ string.
+<p><!--para 26-->
+ Assuming that the first byte of the multibyte character X is the same as the first byte of the multibyte
+ character Y, after the call:
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;stddef.h&gt;
+         /* ... */
+         wchar_t wstr[50];
+         fscanf(stdin, "a(uparrow) Y(downarrow)%ls", wstr);</pre>
+ with the same input line, zero will again be returned, but stdin will be left with a partially consumed
+ multibyte character.
+ 
+ Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>), the
+ strtol, strtoll, strtoul, and strtoull functions (<a href="#7.22.1.4">7.22.1.4</a>), conversion state
+ (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note277">277)</a> These white-space characters are not counted against a specified field width.
+
+<p><a name="note278">278)</a> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
+ that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
+
+<p><a name="note279">279)</a> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
+ conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
+ resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
+
+<p><a name="note280">280)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+
+
+<a name="7.21.6.3" href="#7.21.6.3"><h5>7.21.6.3 The printf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int printf(const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The printf function is equivalent to fprintf with the argument stdout interposed
+ before the arguments to printf.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The printf function returns the number of characters transmitted, or a negative value if
+ an output or encoding error occurred.
+
+<a name="7.21.6.4" href="#7.21.6.4"><h5>7.21.6.4 The scanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int scanf(const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The scanf function is equivalent to fscanf with the argument stdin interposed
+ before the arguments to scanf.
+<!--page 343 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The scanf function returns the value of the macro EOF if an input failure occurs before
+ the first conversion (if any) has completed. Otherwise, the scanf function returns the
+ number of input items assigned, which can be fewer than provided for, or even zero, in
+ the event of an early matching failure.
+
+<a name="7.21.6.5" href="#7.21.6.5"><h5>7.21.6.5 The snprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int snprintf(char * restrict s, size_t n,
+              const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The snprintf function is equivalent to fprintf, except that the output is written into
+ an array (specified by argument s) rather than to a stream. If n is zero, nothing is written,
+ and s may be a null pointer. Otherwise, output characters beyond the n-1st are
+ discarded rather than being written to the array, and a null character is written at the end
+ of the characters actually written into the array. If copying takes place between objects
+ that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The snprintf function returns the number of characters that would have been written
+ had n been sufficiently large, not counting the terminating null character, or a negative
+ value if an encoding error occurred. Thus, the null-terminated output has been
+ completely written if and only if the returned value is nonnegative and less than n.
+
+<a name="7.21.6.6" href="#7.21.6.6"><h5>7.21.6.6 The sprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int sprintf(char * restrict s,
+              const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sprintf function is equivalent to fprintf, except that the output is written into
+ an array (specified by the argument s) rather than to a stream. A null character is written
+ at the end of the characters written; it is not counted as part of the returned value. If
+ copying takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sprintf function returns the number of characters written in the array, not
+ counting the terminating null character, or a negative value if an encoding error occurred.
+<!--page 344 indent 4-->
+
+<a name="7.21.6.7" href="#7.21.6.7"><h5>7.21.6.7 The sscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int sscanf(const char * restrict s,
+             const char * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The sscanf function is equivalent to fscanf, except that input is obtained from a
+ string (specified by the argument s) rather than from a stream. Reaching the end of the
+ string is equivalent to encountering end-of-file for the fscanf function. If copying
+ takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The sscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the sscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.21.6.8" href="#7.21.6.8"><h5>7.21.6.8 The vfprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vfprintf(FILE * restrict stream,
+             const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfprintf function is equivalent to fprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfprintf function does not invoke the
+ va_end macro.<sup><a href="#note281"><b>281)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfprintf function returns the number of characters transmitted, or a negative
+ value if an output or encoding error occurred.
+<p><!--para 4-->
+ EXAMPLE       The following shows the use of the vfprintf function in a general error-reporting routine.
+ 
+ 
+ 
+ 
+<!--page 345 indent 4-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         void error(char *function_name, char *format, ...)
+         {
+               va_list args;
+               va_start(args, format);
+               // print out name of function causing error
+               fprintf(stderr, "ERROR in %s: ", function_name);
+               // print out remainder of message
+               vfprintf(stderr, format, args);
+               va_end(args);
+         }</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note281">281)</a> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
+ vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+
+<a name="7.21.6.9" href="#7.21.6.9"><h5>7.21.6.9 The vfscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         int vfscanf(FILE * restrict stream,
+              const char * restrict format,
+              va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfscanf function is equivalent to fscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfscanf function does not invoke the
+ va_end macro.281)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the vfscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.21.6.10" href="#7.21.6.10"><h5>7.21.6.10 The vprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         int vprintf(const char * restrict format,
+              va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vprintf function is equivalent to printf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+<!--page 346 indent 4-->
+ possibly subsequent va_arg calls). The vprintf function does not invoke the
+ va_end macro.281)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vprintf function returns the number of characters transmitted, or a negative value
+ if an output or encoding error occurred.
+
+<a name="7.21.6.11" href="#7.21.6.11"><h5>7.21.6.11 The vscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vscanf(const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vscanf function is equivalent to scanf, with the variable argument list replaced
+ by arg, which shall have been initialized by the va_start macro (and possibly
+ subsequent va_arg calls). The vscanf function does not invoke the va_end
+ macro.281)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the vscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.21.6.12" href="#7.21.6.12"><h5>7.21.6.12 The vsnprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
         int vsnprintf(char * restrict s, size_t n,
-             const char * restrict format, va_list arg);
-        int vsprintf(char * restrict s,
-             const char * restrict format, va_list arg);
-        int vsscanf(const char * restrict s,
-             const char * restrict format, va_list arg);
-        int fgetc(FILE *stream);
-        char *fgets(char * restrict s, int n,
-             FILE * restrict stream);
-        int fputc(int c, FILE *stream);
-        int fputs(const char * restrict s,
-             FILE * restrict stream);
-        int getc(FILE *stream);
-        int getchar(void);
-        int putc(int c, FILE *stream);                                       *
-        int putchar(int c);
-        int puts(const char *s);
-        int ungetc(int c, FILE *stream);
-        size_t fread(void * restrict ptr,
-             size_t size, size_t nmemb,
-             FILE * restrict stream);
-        size_t fwrite(const void * restrict ptr,
-             size_t size, size_t nmemb,
-             FILE * restrict stream);
-        int fgetpos(FILE * restrict stream,
-             fpos_t * restrict pos);
-        int fseek(FILE *stream, long int offset, int whence);
-        int fsetpos(FILE *stream, const fpos_t *pos);
-        long int ftell(FILE *stream);
-        void rewind(FILE *stream);
-        void clearerr(FILE *stream);
-        int feof(FILE *stream);
-        int ferror(FILE *stream);
-        void perror(const char *s);
-        __STDC_WANT_LIB_EXT1__
-        L_tmpnam_s    TMP_MAX_S         errno_t          rsize_t
-        errno_t tmpfile_s(FILE * restrict * restrict streamptr);
-        errno_t tmpnam_s(char *s, rsize_t maxsize);
-
-[<a name="p485" href="#p485">page 485</a>] (<a href="#Contents">Contents</a>)
-
-      errno_t fopen_s(FILE * restrict * restrict streamptr,
-           const char * restrict filename,
-           const char * restrict mode);
-      errno_t freopen_s(FILE * restrict * restrict newstreamptr,
-           const char * restrict filename,
-           const char * restrict mode,
-           FILE * restrict stream);
-      int fprintf_s(FILE * restrict stream,
-           const char * restrict format, ...);
-      int fscanf_s(FILE * restrict stream,
-           const char * restrict format, ...);
-      int printf_s(const char * restrict format, ...);
-      int scanf_s(const char * restrict format, ...);
-      int snprintf_s(char * restrict s, rsize_t n,
-           const char * restrict format, ...);
-      int sprintf_s(char * restrict s, rsize_t n,
-           const char * restrict format, ...);
-      int sscanf_s(const char * restrict s,
-           const char * restrict format, ...);
-      int vfprintf_s(FILE * restrict stream,
-           const char * restrict format,
-           va_list arg);
-      int vfscanf_s(FILE * restrict stream,
-           const char * restrict format,
-           va_list arg);
-      int vprintf_s(const char * restrict format,
-           va_list arg);
-      int vscanf_s(const char * restrict format,
-           va_list arg);
-      int vsnprintf_s(char * restrict s, rsize_t n,
-           const char * restrict format,
-           va_list arg);
-      int vsprintf_s(char * restrict s, rsize_t n,
-           const char * restrict format,
-           va_list arg);
-      int vsscanf_s(const char * restrict s,
-           const char * restrict format,
-           va_list arg);
-      char *gets_s(char *s, rsize_t n);
-
-[<a name="p486" href="#p486">page 486</a>] (<a href="#Contents">Contents</a>)
-
-<a name="B.21" href="#B.21"><b>B.21 General utilities &lt;stdlib.h&gt;</b></a>
-        size_t       ldiv_t            EXIT_FAILURE     MB_CUR_MAX
-        wchar_t      lldiv_t           EXIT_SUCCESS
-        div_t        NULL              RAND_MAX
-        double atof(const char *nptr);
-        int atoi(const char *nptr);
-        long int atol(const char *nptr);
-        long long int atoll(const char *nptr);
+             const char * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vsnprintf function is equivalent to snprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vsnprintf function does not invoke the
+ va_end macro.281) If copying takes place between objects that overlap, the behavior is
+ undefined.
+<!--page 347 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vsnprintf function returns the number of characters that would have been written
+ had n been sufficiently large, not counting the terminating null character, or a negative
+ value if an encoding error occurred. Thus, the null-terminated output has been
+ completely written if and only if the returned value is nonnegative and less than n.
+
+<a name="7.21.6.13" href="#7.21.6.13"><h5>7.21.6.13 The vsprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         int vsprintf(char * restrict s,
+              const char * restrict format,
+              va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vsprintf function is equivalent to sprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vsprintf function does not invoke the
+ va_end macro.281) If copying takes place between objects that overlap, the behavior is
+ undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vsprintf function returns the number of characters written in the array, not
+ counting the terminating null character, or a negative value if an encoding error occurred.
+
+<a name="7.21.6.14" href="#7.21.6.14"><h5>7.21.6.14 The vsscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         int vsscanf(const char * restrict s,
+              const char * restrict format,
+              va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vsscanf function is equivalent to sscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vsscanf function does not invoke the
+ va_end macro.281)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vsscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the vsscanf function
+<!--page 348 indent 4-->
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.21.7" href="#7.21.7"><h4>7.21.7 Character input/output functions</h4></a>
+
+<a name="7.21.7.1" href="#7.21.7.1"><h5>7.21.7.1 The fgetc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fgetc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If the end-of-file indicator for the input stream pointed to by stream is not set and a
+ next character is present, the fgetc function obtains that character as an unsigned
+ char converted to an int and advances the associated file position indicator for the
+ stream (if defined).
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+ of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the
+ fgetc function returns the next character from the input stream pointed to by stream.
+ If a read error occurs, the error indicator for the stream is set and the fgetc function
+ returns EOF.<sup><a href="#note282"><b>282)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note282">282)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+
+
+<a name="7.21.7.2" href="#7.21.7.2"><h5>7.21.7.2 The fgets function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         char *fgets(char * restrict s, int n,
+              FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fgets function reads at most one less than the number of characters specified by n
+ from the stream pointed to by stream into the array pointed to by s. No additional
+ characters are read after a new-line character (which is retained) or after end-of-file. A
+ null character is written immediately after the last character read into the array.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fgets function returns s if successful. If end-of-file is encountered and no
+ characters have been read into the array, the contents of the array remain unchanged and a
+ null pointer is returned. If a read error occurs during the operation, the array contents are
+ indeterminate and a null pointer is returned.
+ 
+<!--page 349 indent 4-->
+
+<a name="7.21.7.3" href="#7.21.7.3"><h5>7.21.7.3 The fputc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fputc(int c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputc function writes the character specified by c (converted to an unsigned
+ char) to the output stream pointed to by stream, at the position indicated by the
+ associated file position indicator for the stream (if defined), and advances the indicator
+ appropriately. If the file cannot support positioning requests, or if the stream was opened
+ with append mode, the character is appended to the output stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputc function returns the character written. If a write error occurs, the error
+ indicator for the stream is set and fputc returns EOF.
+
+<a name="7.21.7.4" href="#7.21.7.4"><h5>7.21.7.4 The fputs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fputs(const char * restrict s,
+              FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputs function writes the string pointed to by s to the stream pointed to by
+ stream. The terminating null character is not written.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputs function returns EOF if a write error occurs; otherwise it returns a
+ nonnegative value.
+
+<a name="7.21.7.5" href="#7.21.7.5"><h5>7.21.7.5 The getc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int getc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getc function is equivalent to fgetc, except that if it is implemented as a macro, it
+ may evaluate stream more than once, so the argument should never be an expression
+ with side effects.
+<!--page 350 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getc function returns the next character from the input stream pointed to by
+ stream. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+ getc returns EOF. If a read error occurs, the error indicator for the stream is set and
+ getc returns EOF.
+
+<a name="7.21.7.6" href="#7.21.7.6"><h5>7.21.7.6 The getchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int getchar(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getchar function is equivalent to getc with the argument stdin.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getchar function returns the next character from the input stream pointed to by
+ stdin. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+ getchar returns EOF. If a read error occurs, the error indicator for the stream is set and
+ getchar returns EOF.                                                                       *
+
+<a name="7.21.7.7" href="#7.21.7.7"><h5>7.21.7.7 The putc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int putc(int c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putc function is equivalent to fputc, except that if it is implemented as a macro, it
+ may evaluate stream more than once, so that argument should never be an expression
+ with side effects.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putc function returns the character written. If a write error occurs, the error
+ indicator for the stream is set and putc returns EOF.
+
+<a name="7.21.7.8" href="#7.21.7.8"><h5>7.21.7.8 The putchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int putchar(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putchar function is equivalent to putc with the second argument stdout.
+<!--page 351 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putchar function returns the character written. If a write error occurs, the error
+ indicator for the stream is set and putchar returns EOF.
+
+<a name="7.21.7.9" href="#7.21.7.9"><h5>7.21.7.9 The puts function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int puts(const char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The puts function writes the string pointed to by s to the stream pointed to by stdout,
+ and appends a new-line character to the output. The terminating null character is not
+ written.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The puts function returns EOF if a write error occurs; otherwise it returns a nonnegative
+ value.
+
+<a name="7.21.7.10" href="#7.21.7.10"><h5>7.21.7.10 The ungetc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int ungetc(int c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ungetc function pushes the character specified by c (converted to an unsigned
+ char) back onto the input stream pointed to by stream. Pushed-back characters will be
+ returned by subsequent reads on that stream in the reverse order of their pushing. A
+ successful intervening call (with the stream pointed to by stream) to a file positioning
+ function (fseek, fsetpos, or rewind) discards any pushed-back characters for the
+ stream. The external storage corresponding to the stream is unchanged.
+<p><!--para 3-->
+ One character of pushback is guaranteed. If the ungetc function is called too many
+ times on the same stream without an intervening read or file positioning operation on that
+ stream, the operation may fail.
+<p><!--para 4-->
+ If the value of c equals that of the macro EOF, the operation fails and the input stream is
+ unchanged.
+<p><!--para 5-->
+ A successful call to the ungetc function clears the end-of-file indicator for the stream.
+ The value of the file position indicator for the stream after reading or discarding all
+ pushed-back characters shall be the same as it was before the characters were pushed
+ back. For a text stream, the value of its file position indicator after a successful call to the
+ ungetc function is unspecified until all pushed-back characters are read or discarded.
+<!--page 352 indent 4-->
+ For a binary stream, its file position indicator is decremented by each successful call to
+ the ungetc function; if its value was zero before a call, it is indeterminate after the
+ call.<sup><a href="#note283"><b>283)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 6-->
+ The ungetc function returns the character pushed back after conversion, or EOF if the
+ operation fails.
+ Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
+
+<h6>footnotes</h6>
+<p><a name="note283">283)</a> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+
+
+<a name="7.21.8" href="#7.21.8"><h4>7.21.8 Direct input/output functions</h4></a>
+
+<a name="7.21.8.1" href="#7.21.8.1"><h5>7.21.8.1 The fread function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdio.h&gt;
+          size_t fread(void * restrict ptr,
+               size_t size, size_t nmemb,
+               FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fread function reads, into the array pointed to by ptr, up to nmemb elements
+ whose size is specified by size, from the stream pointed to by stream. For each
+ object, size calls are made to the fgetc function and the results stored, in the order
+ read, in an array of unsigned char exactly overlaying the object. The file position
+ indicator for the stream (if defined) is advanced by the number of characters successfully
+ read. If an error occurs, the resulting value of the file position indicator for the stream is
+ indeterminate. If a partial element is read, its value is indeterminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fread function returns the number of elements successfully read, which may be
+ less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero,
+ fread returns zero and the contents of the array and the state of the stream remain
+ unchanged.
+ 
+ 
+ 
+ 
+<!--page 353 indent 4-->
+
+<a name="7.21.8.2" href="#7.21.8.2"><h5>7.21.8.2 The fwrite function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         size_t fwrite(const void * restrict ptr,
+              size_t size, size_t nmemb,
+              FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwrite function writes, from the array pointed to by ptr, up to nmemb elements
+ whose size is specified by size, to the stream pointed to by stream. For each object,
+ size calls are made to the fputc function, taking the values (in order) from an array of
+ unsigned char exactly overlaying the object. The file position indicator for the
+ stream (if defined) is advanced by the number of characters successfully written. If an
+ error occurs, the resulting value of the file position indicator for the stream is
+ indeterminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fwrite function returns the number of elements successfully written, which will be
+ less than nmemb only if a write error is encountered. If size or nmemb is zero,
+ fwrite returns zero and the state of the stream remains unchanged.
+
+<a name="7.21.9" href="#7.21.9"><h4>7.21.9 File positioning functions</h4></a>
+
+<a name="7.21.9.1" href="#7.21.9.1"><h5>7.21.9.1 The fgetpos function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         int fgetpos(FILE * restrict stream,
+              fpos_t * restrict pos);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fgetpos function stores the current values of the parse state (if any) and file
+ position indicator for the stream pointed to by stream in the object pointed to by pos.
+ The values stored contain unspecified information usable by the fsetpos function for
+ repositioning the stream to its position at the time of the call to the fgetpos function.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If successful, the fgetpos function returns zero; on failure, the fgetpos function
+ returns nonzero and stores an implementation-defined positive value in errno.
+ Forward references: the fsetpos function (<a href="#7.21.9.3">7.21.9.3</a>).
+<!--page 354 indent 4-->
+
+<a name="7.21.9.2" href="#7.21.9.2"><h5>7.21.9.2 The fseek function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fseek(FILE *stream, long int offset, int whence);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fseek function sets the file position indicator for the stream pointed to by stream.
+ If a read or write error occurs, the error indicator for the stream is set and fseek fails.
+<p><!--para 3-->
+ For a binary stream, the new position, measured in characters from the beginning of the
+ file, is obtained by adding offset to the position specified by whence. The specified
+ position is the beginning of the file if whence is SEEK_SET, the current value of the file
+ position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
+ meaningfully support fseek calls with a whence value of SEEK_END.
+<p><!--para 4-->
+ For a text stream, either offset shall be zero, or offset shall be a value returned by
+ an earlier successful call to the ftell function on a stream associated with the same file
+ and whence shall be SEEK_SET.
+<p><!--para 5-->
+ After determining the new position, a successful call to the fseek function undoes any
+ effects of the ungetc function on the stream, clears the end-of-file indicator for the
+ stream, and then establishes the new position. After a successful fseek call, the next
+ operation on an update stream may be either input or output.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The fseek function returns nonzero only for a request that cannot be satisfied.
+ Forward references: the ftell function (<a href="#7.21.9.4">7.21.9.4</a>).
+
+<a name="7.21.9.3" href="#7.21.9.3"><h5>7.21.9.3 The fsetpos function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int fsetpos(FILE *stream, const fpos_t *pos);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fsetpos function sets the mbstate_t object (if any) and file position indicator
+ for the stream pointed to by stream according to the value of the object pointed to by
+ pos, which shall be a value obtained from an earlier successful call to the fgetpos
+ function on a stream associated with the same file. If a read or write error occurs, the
+ error indicator for the stream is set and fsetpos fails.
+<p><!--para 3-->
+ A successful call to the fsetpos function undoes any effects of the ungetc function
+ on the stream, clears the end-of-file indicator for the stream, and then establishes the new
+ parse state and position. After a successful fsetpos call, the next operation on an
+<!--page 355 indent 4-->
+ update stream may be either input or output.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If successful, the fsetpos function returns zero; on failure, the fsetpos function
+ returns nonzero and stores an implementation-defined positive value in errno.
+
+<a name="7.21.9.4" href="#7.21.9.4"><h5>7.21.9.4 The ftell function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         long int ftell(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ftell function obtains the current value of the file position indicator for the stream
+ pointed to by stream. For a binary stream, the value is the number of characters from
+ the beginning of the file. For a text stream, its file position indicator contains unspecified
+ information, usable by the fseek function for returning the file position indicator for the
+ stream to its position at the time of the ftell call; the difference between two such
+ return values is not necessarily a meaningful measure of the number of characters written
+ or read.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If successful, the ftell function returns the current value of the file position indicator
+ for the stream. On failure, the ftell function returns -1L and stores an
+ implementation-defined positive value in errno.
+
+<a name="7.21.9.5" href="#7.21.9.5"><h5>7.21.9.5 The rewind function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         void rewind(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rewind function sets the file position indicator for the stream pointed to by
+ stream to the beginning of the file. It is equivalent to
+<pre>
+         (void)fseek(stream, 0L, SEEK_SET)</pre>
+ except that the error indicator for the stream is also cleared.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The rewind function returns no value.
+<!--page 356 indent 4-->
+
+<a name="7.21.10" href="#7.21.10"><h4>7.21.10 Error-handling functions</h4></a>
+
+<a name="7.21.10.1" href="#7.21.10.1"><h5>7.21.10.1 The clearerr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        void clearerr(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The clearerr function clears the end-of-file and error indicators for the stream pointed
+ to by stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The clearerr function returns no value.
+
+<a name="7.21.10.2" href="#7.21.10.2"><h5>7.21.10.2 The feof function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int feof(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The feof function tests the end-of-file indicator for the stream pointed to by stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The feof function returns nonzero if and only if the end-of-file indicator is set for
+ stream.
+
+<a name="7.21.10.3" href="#7.21.10.3"><h5>7.21.10.3 The ferror function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdio.h&gt;
+        int ferror(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ferror function tests the error indicator for the stream pointed to by stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ferror function returns nonzero if and only if the error indicator is set for
+ stream.
+<!--page 357 indent 4-->
+
+<a name="7.21.10.4" href="#7.21.10.4"><h5>7.21.10.4 The perror function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         void perror(const char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The perror function maps the error number in the integer expression errno to an
+ error message. It writes a sequence of characters to the standard error stream thus: first
+ (if s is not a null pointer and the character pointed to by s is not the null character), the
+ string pointed to by s followed by a colon (:) and a space; then an appropriate error
+ message string followed by a new-line character. The contents of the error message
+ strings are the same as those returned by the strerror function with argument errno.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The perror function returns no value.
+ Forward references: the strerror function (<a href="#7.23.6.2">7.23.6.2</a>).
+<!--page 358 indent 4-->
+
+<a name="7.22" href="#7.22"><h3>7.22 General utilities <stdlib.h></h3></a>
+<p><!--para 1-->
+ The header &lt;stdlib.h&gt; declares five types and several functions of general utility, and
+ defines several macros.<sup><a href="#note284"><b>284)</b></a></sup>
+<p><!--para 2-->
+ The types declared are size_t and wchar_t (both described in <a href="#7.19">7.19</a>),
+<pre>
+          div_t</pre>
+ which is a structure type that is the type of the value returned by the div function,
+<pre>
+          ldiv_t</pre>
+ which is a structure type that is the type of the value returned by the ldiv function, and
+<pre>
+          lldiv_t</pre>
+ which is a structure type that is the type of the value returned by the lldiv function.
+<p><!--para 3-->
+ The macros defined are NULL (described in <a href="#7.19">7.19</a>);
+<pre>
+          EXIT_FAILURE</pre>
+ and
+<pre>
+          EXIT_SUCCESS</pre>
+ which expand to integer constant expressions that can be used as the argument to the
+ exit function to return unsuccessful or successful termination status, respectively, to the
+ host environment;
+<pre>
+          RAND_MAX</pre>
+ which expands to an integer constant expression that is the maximum value returned by
+ the rand function; and
+<pre>
+          MB_CUR_MAX</pre>
+ which expands to a positive integer expression with type size_t that is the maximum
+ number of bytes in a multibyte character for the extended character set specified by the
+ current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
+ 
+ 
+ 
+ 
+<!--page 359 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note284">284)</a> See ''future library directions'' (<a href="#7.30.10">7.30.10</a>).
+
+
+<a name="7.22.1" href="#7.22.1"><h4>7.22.1 Numeric conversion functions</h4></a>
+<p><!--para 1-->
+ The functions atof, atoi, atol, and atoll need not affect the value of the integer
+ expression errno on an error. If the value of the result cannot be represented, the
+ behavior is undefined.
+
+<a name="7.22.1.1" href="#7.22.1.1"><h5>7.22.1.1 The atof function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         double atof(const char *nptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atof function converts the initial portion of the string pointed to by nptr to
+ double representation. Except for the behavior on error, it is equivalent to
+<pre>
+         strtod(nptr, (char **)NULL)</pre>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atof function returns the converted value.
+ Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
+
+<a name="7.22.1.2" href="#7.22.1.2"><h5>7.22.1.2 The atoi, atol, and atoll functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         int atoi(const char *nptr);
+         long int atol(const char *nptr);
+         long long int atoll(const char *nptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atoi, atol, and atoll functions convert the initial portion of the string pointed
+ to by nptr to int, long int, and long long int representation, respectively.
+ Except for the behavior on error, they are equivalent to
+<pre>
+         atoi: (int)strtol(nptr, (char **)NULL, 10)
+         atol: strtol(nptr, (char **)NULL, 10)
+         atoll: strtoll(nptr, (char **)NULL, 10)</pre>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The atoi, atol, and atoll functions return the converted value.
+ Forward references: the strtol, strtoll, strtoul, and strtoull functions
+ (<a href="#7.22.1.4">7.22.1.4</a>).
+<!--page 360 indent 4-->
+
+<a name="7.22.1.3" href="#7.22.1.3"><h5>7.22.1.3 The strtod, strtof, and strtold functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
         double strtod(const char * restrict nptr,
              char ** restrict endptr);
         float strtof(const char * restrict nptr,
              char ** restrict endptr);
         long double strtold(const char * restrict nptr,
-             char ** restrict endptr);
-        long int strtol(const char * restrict nptr,
-             char ** restrict endptr, int base);
-        long long int strtoll(const char * restrict nptr,
-             char ** restrict endptr, int base);
-        unsigned long int strtoul(
-             const char * restrict nptr,
-             char ** restrict endptr, int base);
-        unsigned long long int strtoull(
-             const char * restrict nptr,
-             char ** restrict endptr, int base);
-        int rand(void);
-        void srand(unsigned int seed);
-        void *aligned_alloc(size_t alignment, size_t size);
-        void *calloc(size_t nmemb, size_t size);
-        void free(void *ptr);
-        void *malloc(size_t size);
-        void *realloc(void *ptr, size_t size);
-        _Noreturn void abort(void);
-        int atexit(void (*func)(void));
-        int at_quick_exit(void (*func)(void));
-        _Noreturn void exit(int status);
-        _Noreturn void _Exit(int status);
-        char *getenv(const char *name);
-        _Noreturn void quick_exit(int status);
-        int system(const char *string);
-
-[<a name="p487" href="#p487">page 487</a>] (<a href="#Contents">Contents</a>)
-
-      void *bsearch(const void *key, const void *base,
-           size_t nmemb, size_t size,
-           int (*compar)(const void *, const void *));
-      void qsort(void *base, size_t nmemb, size_t size,
-           int (*compar)(const void *, const void *));
-      int abs(int j);
-      long int labs(long int j);
-      long long int llabs(long long int j);
-      div_t div(int numer, int denom);
-      ldiv_t ldiv(long int numer, long int denom);
-      lldiv_t lldiv(long long int numer,
-           long long int denom);
-      int mblen(const char *s, size_t n);
-      int mbtowc(wchar_t * restrict pwc,
-           const char * restrict s, size_t n);
-      int wctomb(char *s, wchar_t wchar);
-      size_t mbstowcs(wchar_t * restrict pwcs,
-           const char * restrict s, size_t n);
-      size_t wcstombs(char * restrict s,
-           const wchar_t * restrict pwcs, size_t n);
-      __STDC_WANT_LIB_EXT1__
-      errno_t
-      rsize_t
-      constraint_handler_t
-      constraint_handler_t set_constraint_handler_s(
-           constraint_handler_t handler);
-      void abort_handler_s(
-           const char * restrict msg,
-           void * restrict ptr,
-           errno_t error);
-      void ignore_handler_s(
-           const char * restrict msg,
-           void * restrict ptr,
-           errno_t error);
-      errno_t getenv_s(size_t * restrict len,
-                char * restrict value, rsize_t maxsize,
-                const char * restrict name);
-
-[<a name="p488" href="#p488">page 488</a>] (<a href="#Contents">Contents</a>)
-
-        void *bsearch_s(const void *key, const void *base,
-             rsize_t nmemb, rsize_t size,
-             int (*compar)(const void *k, const void *y,
-                             void *context),
-             void *context);
-        errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
-             int (*compar)(const void *x, const void *y,
-                             void *context),
-             void *context);
-        errno_t wctomb_s(int * restrict status,
-             char * restrict s,
-             rsize_t smax,
-             wchar_t wc);
-        errno_t mbstowcs_s(size_t * restrict retval,
-             wchar_t * restrict dst, rsize_t dstmax,
-             const char * restrict src, rsize_t len);
-        errno_t wcstombs_s(size_t * restrict retval,
-             char * restrict dst, rsize_t dstmax,
-             const wchar_t * restrict src, rsize_t len);
-<a name="B.22" href="#B.22"><b>B.22 String handling &lt;string.h&gt;</b></a>
-        size_t
-        NULL
-        void *memcpy(void * restrict s1,
-             const void * restrict s2, size_t n);
-        void *memmove(void *s1, const void *s2, size_t n);
-        char *strcpy(char * restrict s1,
-             const char * restrict s2);
-        char *strncpy(char * restrict s1,
-             const char * restrict s2, size_t n);
-        char *strcat(char * restrict s1,
-             const char * restrict s2);
-        char *strncat(char * restrict s1,
-             const char * restrict s2, size_t n);
-        int memcmp(const void *s1, const void *s2, size_t n);
-        int strcmp(const char *s1, const char *s2);
-        int strcoll(const char *s1, const char *s2);
-        int strncmp(const char *s1, const char *s2, size_t n);
+             char ** restrict endptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strtod, strtof, and strtold functions convert the initial portion of the string
+ pointed to by nptr to double, float, and long double representation,
+ respectively. First, they decompose the input string into three parts: an initial, possibly
+ empty, sequence of white-space characters (as specified by the isspace function), a
+ subject sequence resembling a floating-point constant or representing an infinity or NaN;
+ and a final string of one or more unrecognized characters, including the terminating null
+ character of the input string. Then, they attempt to convert the subject sequence to a
+ floating-point number, and return the result.
+<p><!--para 3-->
+ The expected form of the subject sequence is an optional plus or minus sign, then one of
+ the following:
+<ul>
+<li>  a nonempty sequence of decimal digits optionally containing a decimal-point
+ character, then an optional exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+ decimal-point character, then an optional binary exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  INF or INFINITY, ignoring case
+<li>  NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part, where:
+<pre>
+          n-char-sequence:
+                 digit
+                 nondigit
+                 n-char-sequence digit
+                 n-char-sequence nondigit</pre>
+</ul>
+ The subject sequence is defined as the longest initial subsequence of the input string,
+ starting with the first non-white-space character, that is of the expected form. The subject
+ sequence contains no characters if the input string is not of the expected form.
+<p><!--para 4-->
+ If the subject sequence has the expected form for a floating-point number, the sequence of
+ characters starting with the first digit or the decimal-point character (whichever occurs
+ first) is interpreted as a floating constant according to the rules of <a href="#6.4.4.2">6.4.4.2</a>, except that the
+<!--page 361 indent 4-->
+ decimal-point character is used in place of a period, and that if neither an exponent part
+ nor a decimal-point character appears in a decimal floating point number, or if a binary
+ exponent part does not appear in a hexadecimal floating point number, an exponent part
+ of the appropriate type with value zero is assumed to follow the last digit in the string. If
+ the subject sequence begins with a minus sign, the sequence is interpreted as negated.<sup><a href="#note285"><b>285)</b></a></sup>
+ A character sequence INF or INFINITY is interpreted as an infinity, if representable in
+ the return type, else like a floating constant that is too large for the range of the return
+ type. A character sequence NAN or NAN(n-char-sequenceopt), is interpreted as a quiet
+ NaN, if supported in the return type, else like a subject sequence part that does not have
+ the expected form; the meaning of the n-char sequences is implementation-defined.<sup><a href="#note286"><b>286)</b></a></sup> A
+ pointer to the final string is stored in the object pointed to by endptr, provided that
+ endptr is not a null pointer.
+<p><!--para 5-->
+ If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+ value resulting from the conversion is correctly rounded.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+ Recommended practice
+<p><!--para 8-->
+ If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+ the result is not exactly representable, the result should be one of the two numbers in the
+ appropriate internal format that are adjacent to the hexadecimal floating source value,
+ with the extra stipulation that the error should have a correct sign for the current rounding
+ direction.
+<p><!--para 9-->
+ If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+ &lt;float.h&gt;) significant digits, the result should be correctly rounded. If the subject
+ sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+ consider the two bounding, adjacent decimal strings L and U, both having
+ DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+ The result should be one of the (equal or adjacent) values that would be obtained by
+ correctly rounding L and U according to the current rounding direction, with the extra
+ 
+<!--page 362 indent 5-->
+ stipulation that the error with respect to D should have a correct sign for the current
+ rounding direction.<sup><a href="#note287"><b>287)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 10-->
+ The functions return the converted value, if any. If no conversion could be performed,
+ zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
+ plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
+ return type and sign of the value), and the value of the macro ERANGE is stored in
+ errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
+ no greater than the smallest normalized positive number in the return type; whether
+ errno acquires the value ERANGE is implementation-defined.
+
+<h6>footnotes</h6>
+<p><a name="note285">285)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+ negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+ methods may yield different results if rounding is toward positive or negative infinity. In either case,
+ the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+
+<p><a name="note286">286)</a> An implementation may use the n-char sequence to determine extra information to be represented in
+ the NaN's significand.
+
+<p><a name="note287">287)</a> DECIMAL_DIG, defined in &lt;float.h&gt;, should be sufficiently large that L and U will usually round
+ to the same internal floating value, but if not will round to adjacent values.
+
+
+<a name="7.22.1.4" href="#7.22.1.4"><h5>7.22.1.4 The strtol, strtoll, strtoul, and strtoull functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         long int strtol(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);
+         long long int strtoll(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);
+         unsigned long int strtoul(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);
+         unsigned long long int strtoull(
+              const char * restrict nptr,
+              char ** restrict endptr,
+              int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strtol, strtoll, strtoul, and strtoull functions convert the initial
+ portion of the string pointed to by nptr to long int, long long int, unsigned
+ long int, and unsigned long long int representation, respectively. First,
+ they decompose the input string into three parts: an initial, possibly empty, sequence of
+ white-space characters (as specified by the isspace function), a subject sequence
+ 
+ 
+<!--page 363 indent 4-->
+ resembling an integer represented in some radix determined by the value of base, and a
+ final string of one or more unrecognized characters, including the terminating null
+ character of the input string. Then, they attempt to convert the subject sequence to an
+ integer, and return the result.
+<p><!--para 3-->
+ If the value of base is zero, the expected form of the subject sequence is that of an
+ integer constant as described in <a href="#6.4.4.1">6.4.4.1</a>, optionally preceded by a plus or minus sign, but
+ not including an integer suffix. If the value of base is between 2 and 36 (inclusive), the
+ expected form of the subject sequence is a sequence of letters and digits representing an
+ integer with the radix specified by base, optionally preceded by a plus or minus sign,
+ but not including an integer suffix. The letters from a (or A) through z (or Z) are
+ ascribed the values 10 through 35; only letters and digits whose ascribed values are less
+ than that of base are permitted. If the value of base is 16, the characters 0x or 0X may
+ optionally precede the sequence of letters and digits, following the sign if present.
+<p><!--para 4-->
+ The subject sequence is defined as the longest initial subsequence of the input string,
+ starting with the first non-white-space character, that is of the expected form. The subject
+ sequence contains no characters if the input string is empty or consists entirely of white
+ space, or if the first non-white-space character is other than a sign or a permissible letter
+ or digit.
+<p><!--para 5-->
+ If the subject sequence has the expected form and the value of base is zero, the sequence
+ of characters starting with the first digit is interpreted as an integer constant according to
+ the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the value of base
+ is between 2 and 36, it is used as the base for conversion, ascribing to each letter its value
+ as given above. If the subject sequence begins with a minus sign, the value resulting from
+ the conversion is negated (in the return type). A pointer to the final string is stored in the
+ object pointed to by endptr, provided that endptr is not a null pointer.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The strtol, strtoll, strtoul, and strtoull functions return the converted
+ value, if any. If no conversion could be performed, zero is returned. If the correct value
+ is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+ LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+ and sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+<!--page 364 indent 4-->
+
+<a name="7.22.2" href="#7.22.2"><h4>7.22.2 Pseudo-random sequence generation functions</h4></a>
+
+<a name="7.22.2.1" href="#7.22.2.1"><h5>7.22.2.1 The rand function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         int rand(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The rand function computes a sequence of pseudo-random integers in the range 0 to
+ RAND_MAX.<sup><a href="#note288"><b>288)</b></a></sup>
+<p><!--para 3-->
+ The rand function is not required to avoid data races. The implementation shall behave
+ as if no library function calls the rand function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The rand function returns a pseudo-random integer.
+ Environmental limits
+<p><!--para 5-->
+ The value of the RAND_MAX macro shall be at least 32767.
+
+<h6>footnotes</h6>
+<p><a name="note288">288)</a> There are no guarantees as to the quality of the random sequence produced and some implementations
+ are known to produce sequences with distressingly non-random low-order bits. Applications with
+ particular requirements should use a generator that is known to be sufficient for their needs.
+
+
+<a name="7.22.2.2" href="#7.22.2.2"><h5>7.22.2.2 The srand function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void srand(unsigned int seed);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The srand function uses the argument as a seed for a new sequence of pseudo-random
+ numbers to be returned by subsequent calls to rand. If srand is then called with the
+ same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is
+ called before any calls to srand have been made, the same sequence shall be generated
+ as when srand is first called with a seed value of 1.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the srand function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The srand function returns no value.
+ 
+ 
+ 
+ 
+<!--page 365 indent 4-->
+<p><!--para 5-->
+ EXAMPLE       The following functions define a portable implementation of rand and srand.
+<pre>
+         static unsigned long int next = 1;
+         int rand(void)   // RAND_MAX assumed to be 32767
+         {
+               next = next * 1103515245 + 12345;
+               return (unsigned int)(next/65536) % 32768;
+         }
+         void srand(unsigned int seed)
+         {
+               next = seed;
+         }</pre>
+ 
+
+<a name="7.22.3" href="#7.22.3"><h4>7.22.3 Memory management functions</h4></a>
+<p><!--para 1-->
+ The order and contiguity of storage allocated by successive calls to the
+ aligned_alloc, calloc, malloc, and realloc functions is unspecified. The
+ pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to
+ a pointer to any type of object with a fundamental alignment requirement and then used
+ to access such an object or an array of such objects in the space allocated (until the space
+ is explicitly deallocated). The lifetime of an allocated object extends from the allocation
+ until the deallocation. Each such allocation shall yield a pointer to an object disjoint from
+ any other object. The pointer returned points to the start (lowest byte address) of the
+ allocated space. If the space cannot be allocated, a null pointer is returned. If the size of
+ the space requested is zero, the behavior is implementation-defined: either a null pointer
+ is returned, or the behavior is as if the size were some nonzero value, except that the
+ returned pointer shall not be used to access an object.
+
+<a name="7.22.3.1" href="#7.22.3.1"><h5>7.22.3.1 The aligned_alloc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void *aligned_alloc(size_t alignment, size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The aligned_alloc function allocates space for an object whose alignment is
+ specified by alignment, whose size is specified by size, and whose value is
+ indeterminate. The value of alignment shall be a valid alignment supported by the
+ implementation and the value of size shall be an integral multiple of alignment.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The aligned_alloc function returns either a null pointer or a pointer to the allocated
+ space.
+<!--page 366 indent 4-->
+
+<a name="7.22.3.2" href="#7.22.3.2"><h5>7.22.3.2 The calloc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void *calloc(size_t nmemb, size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The calloc function allocates space for an array of nmemb objects, each of whose size
+ is size. The space is initialized to all bits zero.<sup><a href="#note289"><b>289)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The calloc function returns either a null pointer or a pointer to the allocated space.
+
+<h6>footnotes</h6>
+<p><a name="note289">289)</a> Note that this need not be the same as the representation of floating-point zero or a null pointer
+ constant.
+
+
+<a name="7.22.3.3" href="#7.22.3.3"><h5>7.22.3.3 The free function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void free(void *ptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The free function causes the space pointed to by ptr to be deallocated, that is, made
+ available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if
+ the argument does not match a pointer earlier returned by a memory management
+ function, or if the space has been deallocated by a call to free or realloc, the
+ behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The free function returns no value.
+
+<a name="7.22.3.4" href="#7.22.3.4"><h5>7.22.3.4 The malloc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void *malloc(size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The malloc function allocates space for an object whose size is specified by size and
+ whose value is indeterminate.
+ 
+ 
+ 
+ 
+<!--page 367 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The malloc function returns either a null pointer or a pointer to the allocated space.
+
+<a name="7.22.3.5" href="#7.22.3.5"><h5>7.22.3.5 The realloc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void *realloc(void *ptr, size_t size);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The realloc function deallocates the old object pointed to by ptr and returns a
+ pointer to a new object that has the size specified by size. The contents of the new
+ object shall be the same as that of the old object prior to deallocation, up to the lesser of
+ the new and old sizes. Any bytes in the new object beyond the size of the old object have
+ indeterminate values.
+<p><!--para 3-->
+ If ptr is a null pointer, the realloc function behaves like the malloc function for the
+ specified size. Otherwise, if ptr does not match a pointer earlier returned by a memory
+ management function, or if the space has been deallocated by a call to the free or
+ realloc function, the behavior is undefined. If memory for the new object cannot be
+ allocated, the old object is not deallocated and its value is unchanged.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The realloc function returns a pointer to the new object (which may have the same
+ value as a pointer to the old object), or a null pointer if the new object could not be
+ allocated.
+
+<a name="7.22.4" href="#7.22.4"><h4>7.22.4 Communication with the environment</h4></a>
+
+<a name="7.22.4.1" href="#7.22.4.1"><h5>7.22.4.1 The abort function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         _Noreturn void abort(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The abort function causes abnormal program termination to occur, unless the signal
+ SIGABRT is being caught and the signal handler does not return. Whether open streams
+ with unwritten buffered data are flushed, open streams are closed, or temporary files are
+ removed is implementation-defined. An implementation-defined form of the status
+ unsuccessful termination is returned to the host environment by means of the function
+ call raise(SIGABRT).
+<!--page 368 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The abort function does not return to its caller.
+
+<a name="7.22.4.2" href="#7.22.4.2"><h5>7.22.4.2 The atexit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int atexit(void (*func)(void));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The atexit function registers the function pointed to by func, to be called without
+ arguments at normal program termination.<sup><a href="#note290"><b>290)</b></a></sup>
+ Environmental limits
+<p><!--para 3-->
+ The implementation shall support the registration of at least 32 functions.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The atexit function returns zero if the registration succeeds, nonzero if it fails.
+ Forward references: the at_quick_exit function (<a href="#7.22.4.3">7.22.4.3</a>), the exit function
+ (<a href="#7.22.4.4">7.22.4.4</a>).
+
+<h6>footnotes</h6>
+<p><a name="note290">290)</a> The atexit function registrations are distinct from the at_quick_exit registrations, so
+ applications may need to call both registration functions with the same argument.
+
+
+<a name="7.22.4.3" href="#7.22.4.3"><h5>7.22.4.3 The at_quick_exit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int at_quick_exit(void (*func)(void));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The at_quick_exit function registers the function pointed to by func, to be called
+ without arguments should quick_exit be called.<sup><a href="#note291"><b>291)</b></a></sup>
+ Environmental limits
+<p><!--para 3-->
+ The implementation shall support the registration of at least 32 functions.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The at_quick_exit function returns zero if the registration succeeds, nonzero if it
+ fails.
+ Forward references: the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
+ 
+ 
+<!--page 369 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note291">291)</a> The at_quick_exit function registrations are distinct from the atexit registrations, so
+ applications may need to call both registration functions with the same argument.
+
+
+<a name="7.22.4.4" href="#7.22.4.4"><h5>7.22.4.4 The exit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         _Noreturn void exit(int status);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The exit function causes normal program termination to occur. No functions registered
+ by the at_quick_exit function are called. If a program calls the exit function
+ more than once, or calls the quick_exit function in addition to the exit function, the
+ behavior is undefined.
+<p><!--para 3-->
+ First, all functions registered by the atexit function are called, in the reverse order of
+ their registration,<sup><a href="#note292"><b>292)</b></a></sup> except that a function is called after any previously registered
+ functions that had already been called at the time it was registered. If, during the call to
+ any such function, a call to the longjmp function is made that would terminate the call
+ to the registered function, the behavior is undefined.
+<p><!--para 4-->
+ Next, all open streams with unwritten buffered data are flushed, all open streams are
+ closed, and all files created by the tmpfile function are removed.
+<p><!--para 5-->
+ Finally, control is returned to the host environment. If the value of status is zero or
+ EXIT_SUCCESS, an implementation-defined form of the status successful termination is
+ returned. If the value of status is EXIT_FAILURE, an implementation-defined form
+ of the status unsuccessful termination is returned. Otherwise the status returned is
+ implementation-defined.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The exit function cannot return to its caller.
+
+<h6>footnotes</h6>
+<p><a name="note292">292)</a> Each function is called as many times as it was registered, and in the correct order with respect to
+ other registered functions.
+
+
+<a name="7.22.4.5" href="#7.22.4.5"><h5>7.22.4.5 The _Exit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         _Noreturn void _Exit(int status);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The _Exit function causes normal program termination to occur and control to be
+ returned to the host environment. No functions registered by the atexit function, the
+ at_quick_exit function, or signal handlers registered by the signal function are
+ called. The status returned to the host environment is determined in the same way as for
+ 
+ 
+<!--page 370 indent 4-->
+ the exit function (<a href="#7.22.4.4">7.22.4.4</a>). Whether open streams with unwritten buffered data are
+ flushed, open streams are closed, or temporary files are removed is implementation-
+ defined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The _Exit function cannot return to its caller.
+
+<a name="7.22.4.6" href="#7.22.4.6"><h5>7.22.4.6 The getenv function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         char *getenv(const char *name);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getenv function searches an environment list, provided by the host environment,
+ for a string that matches the string pointed to by name. The set of environment names
+ and the method for altering the environment list are implementation-defined. The
+ getenv function need not avoid data races with other threads of execution that modify
+ the environment list.<sup><a href="#note293"><b>293)</b></a></sup>
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the getenv function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The getenv function returns a pointer to a string associated with the matched list
+ member. The string pointed to shall not be modified by the program, but may be
+ overwritten by a subsequent call to the getenv function. If the specified name cannot
+ be found, a null pointer is returned.
+
+<h6>footnotes</h6>
+<p><a name="note293">293)</a> Many implementations provide non-standard functions that modify the environment list.
+
+
+<a name="7.22.4.7" href="#7.22.4.7"><h5>7.22.4.7 The quick_exit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         _Noreturn void quick_exit(int status);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The quick_exit function causes normal program termination to occur. No functions
+ registered by the atexit function or signal handlers registered by the signal function
+ are called. If a program calls the quick_exit function more than once, or calls the
+ exit function in addition to the quick_exit function, the behavior is undefined.
+<p><!--para 3-->
+ The quick_exit function first calls all functions registered by the at_quick_exit
+ function, in the reverse order of their registration,<sup><a href="#note294"><b>294)</b></a></sup> except that a function is called after
+ 
+ 
+<!--page 371 indent 4-->
+ any previously registered functions that had already been called at the time it was
+ registered. If, during the call to any such function, a call to the longjmp function is
+ made that would terminate the call to the registered function, the behavior is undefined.
+<p><!--para 4-->
+ Then control is returned to the host environment by means of the function call
+ _Exit(status).
+<h6>Returns</h6>
+<p><!--para 5-->
+ The quick_exit function cannot return to its caller.
+
+<h6>footnotes</h6>
+<p><a name="note294">294)</a> Each function is called as many times as it was registered, and in the correct order with respect to
+ other registered functions.
+
+
+<a name="7.22.4.8" href="#7.22.4.8"><h5>7.22.4.8 The system function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         int system(const char *string);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If string is a null pointer, the system function determines whether the host
+ environment has a command processor. If string is not a null pointer, the system
+ function passes the string pointed to by string to that command processor to be
+ executed in a manner which the implementation shall document; this might then cause the
+ program calling system to behave in a non-conforming manner or to terminate.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a null pointer, the system function returns nonzero only if a
+ command processor is available. If the argument is not a null pointer, and the system
+ function does return, it returns an implementation-defined value.
+
+<a name="7.22.5" href="#7.22.5"><h4>7.22.5 Searching and sorting utilities</h4></a>
+<p><!--para 1-->
+ These utilities make use of a comparison function to search or sort arrays of unspecified
+ type. Where an argument declared as size_t nmemb specifies the length of the array
+ for a function, nmemb can have the value zero on a call to that function; the comparison
+ function is not called, a search finds no matching element, and sorting performs no
+ rearrangement. Pointer arguments on such a call shall still have valid values, as described
+ in <a href="#7.1.4">7.1.4</a>.
+<p><!--para 2-->
+ The implementation shall ensure that the second argument of the comparison function
+ (when called from bsearch), or both arguments (when called from qsort), are
+ pointers to elements of the array.<sup><a href="#note295"><b>295)</b></a></sup> The first argument when called from bsearch
+ shall equal key.
+ 
+ 
+ 
+<!--page 372 indent 4-->
+<p><!--para 3-->
+ The comparison function shall not alter the contents of the array. The implementation
+ may reorder elements of the array between calls to the comparison function, but shall not
+ alter the contents of any individual element.
+<p><!--para 4-->
+ When the same objects (consisting of size bytes, irrespective of their current positions
+ in the array) are passed more than once to the comparison function, the results shall be
+ consistent with one another. That is, for qsort they shall define a total ordering on the
+ array, and for bsearch the same object shall always compare the same way with the
+ key.
+<p><!--para 5-->
+ A sequence point occurs immediately before and immediately after each call to the
+ comparison function, and also between any call to the comparison function and any
+ movement of the objects passed as arguments to that call.
+
+<h6>footnotes</h6>
+<p><a name="note295">295)</a> That is, if the value passed is p, then the following expressions are always nonzero:
+
+<pre>
+          ((char *)p - (char *)base) % size == 0
+          (char *)p &gt;= (char *)base
+          (char *)p &lt; (char *)base + nmemb * size</pre>
+ 
+
+
+<a name="7.22.5.1" href="#7.22.5.1"><h5>7.22.5.1 The bsearch function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          void *bsearch(const void *key, const void *base,
+               size_t nmemb, size_t size,
+               int (*compar)(const void *, const void *));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The bsearch function searches an array of nmemb objects, the initial element of which
+ is pointed to by base, for an element that matches the object pointed to by key. The
+ size of each element of the array is specified by size.
+<p><!--para 3-->
+ The comparison function pointed to by compar is called with two arguments that point
+ to the key object and to an array element, in that order. The function shall return an
+ integer less than, equal to, or greater than zero if the key object is considered,
+ respectively, to be less than, to match, or to be greater than the array element. The array
+ shall consist of: all the elements that compare less than, all the elements that compare
+ equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note296"><b>296)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The bsearch function returns a pointer to a matching element of the array, or a null
+ pointer if no match is found. If two elements compare as equal, which element is
+ 
+ 
+<!--page 373 indent 4-->
+ matched is unspecified.
+
+<h6>footnotes</h6>
+<p><a name="note296">296)</a> In practice, the entire array is sorted according to the comparison function.
+
+
+<a name="7.22.5.2" href="#7.22.5.2"><h5>7.22.5.2 The qsort function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         void qsort(void *base, size_t nmemb, size_t size,
+              int (*compar)(const void *, const void *));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The qsort function sorts an array of nmemb objects, the initial element of which is
+ pointed to by base. The size of each object is specified by size.
+<p><!--para 3-->
+ The contents of the array are sorted into ascending order according to a comparison
+ function pointed to by compar, which is called with two arguments that point to the
+ objects being compared. The function shall return an integer less than, equal to, or
+ greater than zero if the first argument is considered to be respectively less than, equal to,
+ or greater than the second.
+<p><!--para 4-->
+ If two elements compare as equal, their order in the resulting sorted array is unspecified.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The qsort function returns no value.
+
+<a name="7.22.6" href="#7.22.6"><h4>7.22.6 Integer arithmetic functions</h4></a>
+
+<a name="7.22.6.1" href="#7.22.6.1"><h5>7.22.6.1 The abs, labs and llabs functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         int abs(int j);
+         long int labs(long int j);
+         long long int llabs(long long int j);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The abs, labs, and llabs functions compute the absolute value of an integer j. If the
+ result cannot be represented, the behavior is undefined.<sup><a href="#note297"><b>297)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The abs, labs, and llabs, functions return the absolute value.
+ 
+ 
+ 
+ 
+<!--page 374 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note297">297)</a> The absolute value of the most negative number cannot be represented in two's complement.
+
+
+<a name="7.22.6.2" href="#7.22.6.2"><h5>7.22.6.2 The div, ldiv, and lldiv functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          div_t div(int numer, int denom);
+          ldiv_t ldiv(long int numer, long int denom);
+          lldiv_t lldiv(long long int numer, long long int denom);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The div, ldiv, and lldiv, functions compute numer / denom and numer %
+ denom in a single operation.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The div, ldiv, and lldiv functions return a structure of type div_t, ldiv_t, and
+ lldiv_t, respectively, comprising both the quotient and the remainder. The structures
+ shall contain (in either order) the members quot (the quotient) and rem (the remainder),
+ each of which has the same type as the arguments numer and denom. If either part of
+ the result cannot be represented, the behavior is undefined.
+
+<a name="7.22.7" href="#7.22.7"><h4>7.22.7 Multibyte/wide character conversion functions</h4></a>
+<p><!--para 1-->
+ The behavior of the multibyte character functions is affected by the LC_CTYPE category
+ of the current locale. For a state-dependent encoding, each function is placed into its
+ initial conversion state at program startup and can be returned to that state by a call for
+ which its character pointer argument, s, is a null pointer. Subsequent calls with s as
+ other than a null pointer cause the internal conversion state of the function to be altered as
+ necessary. A call with s as a null pointer causes these functions to return a nonzero value
+ if encodings have state dependency, and zero otherwise.<sup><a href="#note298"><b>298)</b></a></sup> Changing the LC_CTYPE
+ category causes the conversion state of these functions to be indeterminate.
+
+<h6>footnotes</h6>
+<p><a name="note298">298)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+ character codes, but are grouped with an adjacent multibyte character.
+
+
+<a name="7.22.7.1" href="#7.22.7.1"><h5>7.22.7.1 The mblen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          int mblen(const char *s, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is not a null pointer, the mblen function determines the number of bytes contained
+ in the multibyte character pointed to by s. Except that the conversion state of the
+ mbtowc function is not affected, it is equivalent to
+ 
+ 
+ 
+<!--page 375 indent 4-->
+<p><!--para 3-->
+<pre>
+         mbtowc((wchar_t *)0, (const char *)0, 0);
+         mbtowc((wchar_t *)0, s, n);</pre>
+ The implementation shall behave as if no library function calls the mblen function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If s is a null pointer, the mblen function returns a nonzero or zero value, if multibyte
+ character encodings, respectively, do or do not have state-dependent encodings. If s is
+ not a null pointer, the mblen function either returns 0 (if s points to the null character),
+ or returns the number of bytes that are contained in the multibyte character (if the next n
+ or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
+ multibyte character).
+ Forward references: the mbtowc function (<a href="#7.22.7.2">7.22.7.2</a>).
+
+<a name="7.22.7.2" href="#7.22.7.2"><h5>7.22.7.2 The mbtowc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         int mbtowc(wchar_t * restrict pwc,
+              const char * restrict s,
+              size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is not a null pointer, the mbtowc function inspects at most n bytes beginning with
+ the byte pointed to by s to determine the number of bytes needed to complete the next
+ multibyte character (including any shift sequences). If the function determines that the
+ next multibyte character is complete and valid, it determines the value of the
+ corresponding wide character and then, if pwc is not a null pointer, stores that value in
+ the object pointed to by pwc. If the corresponding wide character is the null wide
+ character, the function is left in the initial conversion state.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the mbtowc function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If s is a null pointer, the mbtowc function returns a nonzero or zero value, if multibyte
+ character encodings, respectively, do or do not have state-dependent encodings. If s is
+ not a null pointer, the mbtowc function either returns 0 (if s points to the null character),
+ or returns the number of bytes that are contained in the converted multibyte character (if
+ the next n or fewer bytes form a valid multibyte character), or returns -1 (if they do not
+ form a valid multibyte character).
+<p><!--para 5-->
+ In no case will the value returned be greater than n or the value of the MB_CUR_MAX
+ macro.
+<!--page 376 indent 4-->
+
+<a name="7.22.7.3" href="#7.22.7.3"><h5>7.22.7.3 The wctomb function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        int wctomb(char *s, wchar_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctomb function determines the number of bytes needed to represent the multibyte
+ character corresponding to the wide character given by wc (including any shift
+ sequences), and stores the multibyte character representation in the array whose first
+ element is pointed to by s (if s is not a null pointer). At most MB_CUR_MAX characters
+ are stored. If wc is a null wide character, a null byte is stored, preceded by any shift
+ sequence needed to restore the initial shift state, and the function is left in the initial
+ conversion state.
+<p><!--para 3-->
+ The implementation shall behave as if no library function calls the wctomb function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If s is a null pointer, the wctomb function returns a nonzero or zero value, if multibyte
+ character encodings, respectively, do or do not have state-dependent encodings. If s is
+ not a null pointer, the wctomb function returns -1 if the value of wc does not correspond
+ to a valid multibyte character, or returns the number of bytes that are contained in the
+ multibyte character corresponding to the value of wc.
+<p><!--para 5-->
+ In no case will the value returned be greater than the value of the MB_CUR_MAX macro.
+
+<a name="7.22.8" href="#7.22.8"><h4>7.22.8 Multibyte/wide string conversion functions</h4></a>
+<p><!--para 1-->
+ The behavior of the multibyte string functions is affected by the LC_CTYPE category of
+ the current locale.
+
+<a name="7.22.8.1" href="#7.22.8.1"><h5>7.22.8.1 The mbstowcs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdlib.h&gt;
+        size_t mbstowcs(wchar_t * restrict pwcs,
+             const char * restrict s,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mbstowcs function converts a sequence of multibyte characters that begins in the
+ initial shift state from the array pointed to by s into a sequence of corresponding wide
+ characters and stores not more than n wide characters into the array pointed to by pwcs.
+ No multibyte characters that follow a null character (which is converted into a null wide
+ character) will be examined or converted. Each multibyte character is converted as if by
+ a call to the mbtowc function, except that the conversion state of the mbtowc function is
+<!--page 377 indent 4-->
+ not affected.
+<p><!--para 3-->
+ No more than n elements will be modified in the array pointed to by pwcs. If copying
+ takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If an invalid multibyte character is encountered, the mbstowcs function returns
+ (size_t)(-1). Otherwise, the mbstowcs function returns the number of array
+ elements modified, not including a terminating null wide character, if any.<sup><a href="#note299"><b>299)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note299">299)</a> The array will not be null-terminated if the value returned is n.
+
+
+<a name="7.22.8.2" href="#7.22.8.2"><h5>7.22.8.2 The wcstombs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          size_t wcstombs(char * restrict s,
+               const wchar_t * restrict pwcs,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstombs function converts a sequence of wide characters from the array pointed
+ to by pwcs into a sequence of corresponding multibyte characters that begins in the
+ initial shift state, and stores these multibyte characters into the array pointed to by s,
+ stopping if a multibyte character would exceed the limit of n total bytes or if a null
+ character is stored. Each wide character is converted as if by a call to the wctomb
+ function, except that the conversion state of the wctomb function is not affected.
+<p><!--para 3-->
+ No more than n bytes will be modified in the array pointed to by s. If copying takes place
+ between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If a wide character is encountered that does not correspond to a valid multibyte character,
+ the wcstombs function returns (size_t)(-1). Otherwise, the wcstombs function
+ returns the number of bytes modified, not including a terminating null character, if
+ any.299)
+ 
+ 
+ 
+ 
+<!--page 378 indent 4-->
+
+<a name="7.23" href="#7.23"><h3>7.23 String handling <string.h></h3></a>
+
+<a name="7.23.1" href="#7.23.1"><h4>7.23.1 String function conventions</h4></a>
+<p><!--para 1-->
+ The header &lt;string.h&gt; declares one type and several functions, and defines one
+ macro useful for manipulating arrays of character type and other objects treated as arrays
+ of character type.<sup><a href="#note300"><b>300)</b></a></sup> The type is size_t and the macro is NULL (both described in
+ <a href="#7.19">7.19</a>). Various methods are used for determining the lengths of the arrays, but in all cases
+ a char * or void * argument points to the initial (lowest addressed) character of the
+ array. If an array is accessed beyond the end of an object, the behavior is undefined.
+<p><!--para 2-->
+ Where an argument declared as size_t n specifies the length of the array for a
+ function, n can have the value zero on a call to that function. Unless explicitly stated
+ otherwise in the description of a particular function in this subclause, pointer arguments
+ on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+ function that locates a character finds no occurrence, a function that compares two
+ character sequences returns zero, and a function that copies characters copies zero
+ characters.
+<p><!--para 3-->
+ For all functions in this subclause, each character shall be interpreted as if it had the type
+ unsigned char (and therefore every possible object representation is valid and has a
+ different value).
+
+<h6>footnotes</h6>
+<p><a name="note300">300)</a> See ''future library directions'' (<a href="#7.30.11">7.30.11</a>).
+
+
+<a name="7.23.2" href="#7.23.2"><h4>7.23.2 Copying functions</h4></a>
+
+<a name="7.23.2.1" href="#7.23.2.1"><h5>7.23.2.1 The memcpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;string.h&gt;
+          void *memcpy(void * restrict s1,
+               const void * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memcpy function copies n characters from the object pointed to by s2 into the
+ object pointed to by s1. If copying takes place between objects that overlap, the behavior
+ is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memcpy function returns the value of s1.
+ 
+ 
+ 
+ 
+<!--page 379 indent 4-->
+
+<a name="7.23.2.2" href="#7.23.2.2"><h5>7.23.2.2 The memmove function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         void *memmove(void *s1, const void *s2, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memmove function copies n characters from the object pointed to by s2 into the
+ object pointed to by s1. Copying takes place as if the n characters from the object
+ pointed to by s2 are first copied into a temporary array of n characters that does not
+ overlap the objects pointed to by s1 and s2, and then the n characters from the
+ temporary array are copied into the object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memmove function returns the value of s1.
+
+<a name="7.23.2.3" href="#7.23.2.3"><h5>7.23.2.3 The strcpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         char *strcpy(char * restrict s1,
+              const char * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcpy function copies the string pointed to by s2 (including the terminating null
+ character) into the array pointed to by s1. If copying takes place between objects that
+ overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcpy function returns the value of s1.
+
+<a name="7.23.2.4" href="#7.23.2.4"><h5>7.23.2.4 The strncpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         char *strncpy(char * restrict s1,
+              const char * restrict s2,
+              size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strncpy function copies not more than n characters (characters that follow a null
+ character are not copied) from the array pointed to by s2 to the array pointed to by
+<!--page 380 indent 4-->
+ s1.<sup><a href="#note301"><b>301)</b></a></sup> If copying takes place between objects that overlap, the behavior is undefined.
+<p><!--para 3-->
+ If the array pointed to by s2 is a string that is shorter than n characters, null characters
+ are appended to the copy in the array pointed to by s1, until n characters in all have been
+ written.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The strncpy function returns the value of s1.
+
+<h6>footnotes</h6>
+<p><a name="note301">301)</a> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
+ not be null-terminated.
+
+
+<a name="7.23.3" href="#7.23.3"><h4>7.23.3 Concatenation functions</h4></a>
+
+<a name="7.23.3.1" href="#7.23.3.1"><h5>7.23.3.1 The strcat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;string.h&gt;
+          char *strcat(char * restrict s1,
+               const char * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcat function appends a copy of the string pointed to by s2 (including the
+ terminating null character) to the end of the string pointed to by s1. The initial character
+ of s2 overwrites the null character at the end of s1. If copying takes place between
+ objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcat function returns the value of s1.
+
+<a name="7.23.3.2" href="#7.23.3.2"><h5>7.23.3.2 The strncat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;string.h&gt;
+          char *strncat(char * restrict s1,
+               const char * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strncat function appends not more than n characters (a null character and
+ characters that follow it are not appended) from the array pointed to by s2 to the end of
+ the string pointed to by s1. The initial character of s2 overwrites the null character at the
+ end of s1. A terminating null character is always appended to the result.<sup><a href="#note302"><b>302)</b></a></sup> If copying
+ 
+<!--page 381 indent 4-->
+ takes place between objects that overlap, the behavior is undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strncat function returns the value of s1.
+ Forward references: the strlen function (<a href="#7.23.6.3">7.23.6.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note302">302)</a> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
+ strlen(s1)+n+1.
+
+
+<a name="7.23.4" href="#7.23.4"><h4>7.23.4 Comparison functions</h4></a>
+<p><!--para 1-->
+ The sign of a nonzero value returned by the comparison functions memcmp, strcmp,
+ and strncmp is determined by the sign of the difference between the values of the first
+ pair of characters (both interpreted as unsigned char) that differ in the objects being
+ compared.
+
+<a name="7.23.4.1" href="#7.23.4.1"><h5>7.23.4.1 The memcmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         int memcmp(const void *s1, const void *s2, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memcmp function compares the first n characters of the object pointed to by s1 to
+ the first n characters of the object pointed to by s2.<sup><a href="#note303"><b>303)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memcmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+ pointed to by s2.
+
+<h6>footnotes</h6>
+<p><a name="note303">303)</a> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
+ indeterminate. Strings shorter than their allocated space and unions may also cause problems in
+ comparison.
+
+
+<a name="7.23.4.2" href="#7.23.4.2"><h5>7.23.4.2 The strcmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         int strcmp(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcmp function compares the string pointed to by s1 to the string pointed to by
+ s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+ 
+<!--page 382 indent 4-->
+ pointed to by s2.
+
+<a name="7.23.4.3" href="#7.23.4.3"><h5>7.23.4.3 The strcoll function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        int strcoll(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcoll function compares the string pointed to by s1 to the string pointed to by
+ s2, both interpreted as appropriate to the LC_COLLATE category of the current locale.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcoll function returns an integer greater than, equal to, or less than zero,
+ accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+ pointed to by s2 when both are interpreted as appropriate to the current locale.
+
+<a name="7.23.4.4" href="#7.23.4.4"><h5>7.23.4.4 The strncmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        int strncmp(const char *s1, const char *s2, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strncmp function compares not more than n characters (characters that follow a
+ null character are not compared) from the array pointed to by s1 to the array pointed to
+ by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strncmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+ to, or less than the possibly null-terminated array pointed to by s2.
+
+<a name="7.23.4.5" href="#7.23.4.5"><h5>7.23.4.5 The strxfrm function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
         size_t strxfrm(char * restrict s1,
-             const char * restrict s2, size_t n);
-        void *memchr(const void *s, int c, size_t n);
-
-[<a name="p489" href="#p489">page 489</a>] (<a href="#Contents">Contents</a>)
-
-      char *strchr(const char *s, int c);
-      size_t strcspn(const char *s1, const char *s2);
-      char *strpbrk(const char *s1, const char *s2);
-      char *strrchr(const char *s, int c);
-      size_t strspn(const char *s1, const char *s2);
-      char *strstr(const char *s1, const char *s2);
-      char *strtok(char * restrict s1,
-           const char * restrict s2);
-      void *memset(void *s, int c, size_t n);
-      char *strerror(int errnum);
-      size_t strlen(const char *s);
-      __STDC_WANT_LIB_EXT1__
-      errno_t
-      rsize_t
-      errno_t memcpy_s(void * restrict s1, rsize_t s1max,
-           const void * restrict s2, rsize_t n);
-      errno_t memmove_s(void *s1, rsize_t s1max,
-           const void *s2, rsize_t n);
-      errno_t strcpy_s(char * restrict s1,
-           rsize_t s1max,
-           const char * restrict s2);
-      errno_t strncpy_s(char * restrict s1,
-           rsize_t s1max,
-           const char * restrict s2,
-           rsize_t n);
-      errno_t strcat_s(char * restrict s1,
-           rsize_t s1max,
-           const char * restrict s2);
-      errno_t strncat_s(char * restrict s1,
-           rsize_t s1max,
-           const char * restrict s2,
-           rsize_t n);
-      char *strtok_s(char * restrict s1,
-           rsize_t * restrict s1max,
-           const char * restrict s2,
-           char ** restrict ptr);
-      errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)
-      errno_t strerror_s(char *s, rsize_t maxsize,
-           errno_t errnum);
-      size_t strerrorlen_s(errno_t errnum);
-
-[<a name="p490" href="#p490">page 490</a>] (<a href="#Contents">Contents</a>)
-
-        size_t strnlen_s(const char *s, size_t maxsize);
-<a name="B.23" href="#B.23"><b>B.23 Type-generic math &lt;tgmath.h&gt;</b></a>
-        acos         sqrt              fmod             nextafter
-        asin         fabs              frexp            nexttoward
-        atan         atan2             hypot            remainder
-        acosh        cbrt              ilogb            remquo
-        asinh        ceil              ldexp            rint
-        atanh        copysign          lgamma           round
-        cos          erf               llrint           scalbn
-        sin          erfc              llround          scalbln
-        tan          exp2              log10            tgamma
-        cosh         expm1             log1p            trunc
-        sinh         fdim              log2             carg
-        tanh         floor             logb             cimag
-        exp          fma               lrint            conj
-        log          fmax              lround           cproj
-        pow          fmin              nearbyint        creal
-<a name="B.24" href="#B.24"><b>B.24 Threads &lt;threads.h&gt;</b></a>
-        ONCE_FLAG_INIT                 mtx_plain
-        TSS_DTOR_ITERATIONS            mtx_recursive
-        cnd_t                          mtx_timed
-        thrd_t                         mtx_try
-        tss_t                          thrd_timeout
-        mtx_t                          thrd_success
-        tss_dtor_t                     thrd_busy
-        thrd_start_t                   thrd_error
-        once_flag                      thrd_nomem
-        xtime
-      void call_once(once_flag *flag, void (*func)(void));
-      int cnd_broadcast(cnd_t *cond);
-      void cnd_destroy(cnd_t *cond);
-      int cnd_init(cnd_t *cond);
-      int cnd_signal(cnd_t *cond);
-      int cnd_timedwait(cnd_t *cond, mtx_t *mtx,
-           const xtime *xt);
-      int cnd_wait(cnd_t *cond, mtx_t *mtx);
-      void mtx_destroy(mtx_t *mtx);
-      int mtx_init(mtx_t *mtx, int type);
-      int mtx_lock(mtx_t *mtx);
-
-[<a name="p491" href="#p491">page 491</a>] (<a href="#Contents">Contents</a>)
-
-      int mtx_timedlock(mtx_t *mtx, const xtime *xt);
-      int mtx_trylock(mtx_t *mtx);
-      int mtx_unlock(mtx_t *mtx);
-      int thrd_create(thrd_t *thr, thrd_start_t func,
-           void *arg);
-      thrd_t thrd_current(void);
-      int thrd_detach(thrd_t thr);
-      int thrd_equal(thrd_t thr0, thrd_t thr1);
-      void thrd_exit(int res);
-      int thrd_join(thrd_t thr, int *res);
-      void thrd_sleep(const xtime *xt);
-      void thrd_yield(void);
-      int tss_create(tss_t *key, tss_dtor_t dtor);
-      void tss_delete(tss_t key);
-      void *tss_get(tss_t key);
-      int tss_set(tss_t key, void *val);
-      int xtime_get(xtime *xt, int base);
-<a name="B.25" href="#B.25"><b>B.25 Date and time &lt;time.h&gt;</b></a>
-      NULL                  size_t                  time_t
-      CLOCKS_PER_SEC        clock_t                 struct tm
-      clock_t clock(void);
-      double difftime(time_t time1, time_t time0);
-      time_t mktime(struct tm *timeptr);
-      time_t time(time_t *timer);
-      char *asctime(const struct tm *timeptr);
-      char *ctime(const time_t *timer);
-      struct tm *gmtime(const time_t *timer);
-      struct tm *localtime(const time_t *timer);
-      size_t strftime(char * restrict s,
-           size_t maxsize,
-           const char * restrict format,
-           const struct tm * restrict timeptr);
-      __STDC_WANT_LIB_EXT1__
-      errno_t
-      rsize_t
-      errno_t asctime_s(char *s, rsize_t maxsize,
-           const struct tm *timeptr);
-
-[<a name="p492" href="#p492">page 492</a>] (<a href="#Contents">Contents</a>)
-
-        errno_t ctime_s(char *s, rsize_t maxsize,
-             const time_t *timer);
-        struct tm *gmtime_s(const time_t * restrict timer,
-             struct tm * restrict result);
-        struct tm *localtime_s(const time_t * restrict timer,
-             struct tm * restrict result);
-<a name="B.26" href="#B.26"><b>B.26 Unicode utilities &lt;uchar.h&gt;</b></a>
-        mbstate_t     size_t            char16_t         char32_t
-        size_t mbrtoc16(char16_t * restrict pc16,
-             const char * restrict s, size_t n,
-             mbstate_t * restrict ps);
-        size_t c16rtomb(char * restrict s, char16_t c16,
-             mbstate_t * restrict ps);
-        size_t mbrtoc32(char32_t * restrict pc32,
-             const char * restrict s, size_t n,
-             mbstate_t * restrict ps);
-        size_t c32rtomb(char * restrict s, char32_t c32,
-             mbstate_t * restrict ps);
-<a name="B.27" href="#B.27"><b>B.27 Extended multibyte/wide character utilities &lt;wchar.h&gt;</b></a>
-        wchar_t             wint_t                  WCHAR_MAX
-        size_t              struct tm               WCHAR_MIN
-        mbstate_t           NULL                    WEOF
-        int fwprintf(FILE * restrict stream,
-             const wchar_t * restrict format, ...);
-        int fwscanf(FILE * restrict stream,
-             const wchar_t * restrict format, ...);
-        int swprintf(wchar_t * restrict s, size_t n,
-             const wchar_t * restrict format, ...);
-        int swscanf(const wchar_t * restrict s,
-             const wchar_t * restrict format, ...);
+             const char * restrict s2,
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strxfrm function transforms the string pointed to by s2 and places the resulting
+ string into the array pointed to by s1. The transformation is such that if the strcmp
+ function is applied to two transformed strings, it returns a value greater than, equal to, or
+<!--page 383 indent 4-->
+ less than zero, corresponding to the result of the strcoll function applied to the same
+ two original strings. No more than n characters are placed into the resulting array
+ pointed to by s1, including the terminating null character. If n is zero, s1 is permitted to
+ be a null pointer. If copying takes place between objects that overlap, the behavior is
+ undefined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strxfrm function returns the length of the transformed string (not including the
+ terminating null character). If the value returned is n or more, the contents of the array
+ pointed to by s1 are indeterminate.
+<p><!--para 4-->
+ EXAMPLE The value of the following expression is the size of the array needed to hold the
+ transformation of the string pointed to by s.
+<pre>
+         1 + strxfrm(NULL, s, 0)</pre>
+ 
+
+<a name="7.23.5" href="#7.23.5"><h4>7.23.5 Search functions</h4></a>
+
+<a name="7.23.5.1" href="#7.23.5.1"><h5>7.23.5.1 The memchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         void *memchr(const void *s, int c, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memchr function locates the first occurrence of c (converted to an unsigned
+ char) in the initial n characters (each interpreted as unsigned char) of the object
+ pointed to by s. The implementation shall behave as if it reads the characters sequentially
+ and stops as soon as a matching character is found.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memchr function returns a pointer to the located character, or a null pointer if the
+ character does not occur in the object.
+
+<a name="7.23.5.2" href="#7.23.5.2"><h5>7.23.5.2 The strchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         char *strchr(const char *s, int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strchr function locates the first occurrence of c (converted to a char) in the
+ string pointed to by s. The terminating null character is considered to be part of the
+ string.
+<!--page 384 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strchr function returns a pointer to the located character, or a null pointer if the
+ character does not occur in the string.
+
+<a name="7.23.5.3" href="#7.23.5.3"><h5>7.23.5.3 The strcspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        size_t strcspn(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strcspn function computes the length of the maximum initial segment of the string
+ pointed to by s1 which consists entirely of characters not from the string pointed to by
+ s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strcspn function returns the length of the segment.
+
+<a name="7.23.5.4" href="#7.23.5.4"><h5>7.23.5.4 The strpbrk function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        char *strpbrk(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strpbrk function locates the first occurrence in the string pointed to by s1 of any
+ character from the string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strpbrk function returns a pointer to the character, or a null pointer if no character
+ from s2 occurs in s1.
+
+<a name="7.23.5.5" href="#7.23.5.5"><h5>7.23.5.5 The strrchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        char *strrchr(const char *s, int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strrchr function locates the last occurrence of c (converted to a char) in the
+ string pointed to by s. The terminating null character is considered to be part of the
+ string.
+<!--page 385 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strrchr function returns a pointer to the character, or a null pointer if c does not
+ occur in the string.
+
+<a name="7.23.5.6" href="#7.23.5.6"><h5>7.23.5.6 The strspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         size_t strspn(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strspn function computes the length of the maximum initial segment of the string
+ pointed to by s1 which consists entirely of characters from the string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strspn function returns the length of the segment.
+
+<a name="7.23.5.7" href="#7.23.5.7"><h5>7.23.5.7 The strstr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         char *strstr(const char *s1, const char *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strstr function locates the first occurrence in the string pointed to by s1 of the
+ sequence of characters (excluding the terminating null character) in the string pointed to
+ by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strstr function returns a pointer to the located string, or a null pointer if the string
+ is not found. If s2 points to a string with zero length, the function returns s1.
+
+<a name="7.23.5.8" href="#7.23.5.8"><h5>7.23.5.8 The strtok function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         char *strtok(char * restrict s1,
+              const char * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A sequence of calls to the strtok function breaks the string pointed to by s1 into a
+ sequence of tokens, each of which is delimited by a character from the string pointed to
+ by s2. The first call in the sequence has a non-null first argument; subsequent calls in the
+ sequence have a null first argument. The separator string pointed to by s2 may be
+ different from call to call.
+<!--page 386 indent 4-->
+<p><!--para 3-->
+ The first call in the sequence searches the string pointed to by s1 for the first character
+ that is not contained in the current separator string pointed to by s2. If no such character
+ is found, then there are no tokens in the string pointed to by s1 and the strtok function
+ returns a null pointer. If such a character is found, it is the start of the first token.
+<p><!--para 4-->
+ The strtok function then searches from there for a character that is contained in the
+ current separator string. If no such character is found, the current token extends to the
+ end of the string pointed to by s1, and subsequent searches for a token will return a null
+ pointer. If such a character is found, it is overwritten by a null character, which
+ terminates the current token. The strtok function saves a pointer to the following
+ character, from which the next search for a token will start.
+<p><!--para 5-->
+ Each subsequent call, with a null pointer as the value of the first argument, starts
+ searching from the saved pointer and behaves as described above.
+<p><!--para 6-->
+ The strtok function is not required to avoid data races. The implementation shall
+ behave as if no library function calls the strtok function.
+<h6>Returns</h6>
+<p><!--para 7-->
+ The strtok function returns a pointer to the first character of a token, or a null pointer
+ if there is no token.
+<p><!--para 8-->
+ EXAMPLE
+<pre>
+        #include &lt;string.h&gt;
+        static char str[] = "?a???b,,,#c";
+        char *t;
+        t   =   strtok(str, "?");      //   t   points to the token "a"
+        t   =   strtok(NULL, ",");     //   t   points to the token "??b"
+        t   =   strtok(NULL, "#,");    //   t   points to the token "c"
+        t   =   strtok(NULL, "?");     //   t   is a null pointer</pre>
+ 
+
+<a name="7.23.6" href="#7.23.6"><h4>7.23.6 Miscellaneous functions</h4></a>
+
+<a name="7.23.6.1" href="#7.23.6.1"><h5>7.23.6.1 The memset function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;string.h&gt;
+        void *memset(void *s, int c, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The memset function copies the value of c (converted to an unsigned char) into
+ each of the first n characters of the object pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The memset function returns the value of s.
+<!--page 387 indent 4-->
+
+<a name="7.23.6.2" href="#7.23.6.2"><h5>7.23.6.2 The strerror function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         char *strerror(int errnum);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strerror function maps the number in errnum to a message string. Typically,
+ the values for errnum come from errno, but strerror shall map any value of type
+ int to a message.
+<p><!--para 3-->
+ The strerror function is not required to avoid data races. The implementation shall
+ behave as if no library function calls the strerror function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The strerror function returns a pointer to the string, the contents of which are locale-
+ specific. The array pointed to shall not be modified by the program, but may be
+ overwritten by a subsequent call to the strerror function.
+
+<a name="7.23.6.3" href="#7.23.6.3"><h5>7.23.6.3 The strlen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;string.h&gt;
+         size_t strlen(const char *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strlen function computes the length of the string pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strlen function returns the number of characters that precede the terminating null
+ character.
+<!--page 388 indent 4-->
+
+<a name="7.24" href="#7.24"><h3>7.24 Type-generic math <tgmath.h></h3></a>
+<p><!--para 1-->
+ The header &lt;tgmath.h&gt; includes the headers &lt;math.h&gt; and &lt;complex.h&gt; and
+ defines several type-generic macros.
+<p><!--para 2-->
+ Of the &lt;math.h&gt; and &lt;complex.h&gt; functions without an f (float) or l (long
+ double) suffix, several have one or more parameters whose corresponding real type is
+ double. For each such function, except modf, there is a corresponding type-generic
+ macro.<sup><a href="#note304"><b>304)</b></a></sup> The parameters whose corresponding real type is double in the function
+ synopsis are generic parameters. Use of the macro invokes a function whose
+ corresponding real type and type domain are determined by the arguments for the generic
+ parameters.<sup><a href="#note305"><b>305)</b></a></sup>
+<p><!--para 3-->
+ Use of the macro invokes a function whose generic parameters have the corresponding
+ real type determined as follows:
+<ul>
+<li>  First, if any argument for generic parameters has type long double, the type
+ determined is long double.
+<li>  Otherwise, if any argument for generic parameters has type double or is of integer
+ type, the type determined is double.
+<li>  Otherwise, the type determined is float.
+</ul>
+<p><!--para 4-->
+ For each unsuffixed function in &lt;math.h&gt; for which there is a function in
+ &lt;complex.h&gt; with the same name except for a c prefix, the corresponding type-
+ generic macro (for both functions) has the same name as the function in &lt;math.h&gt;. The
+ corresponding type-generic macro for fabs and cabs is fabs.
+ 
+ 
+ 
+ 
+<!--page 389 indent 4-->
+<pre>
+          &lt;math.h&gt;         &lt;complex.h&gt;              type-generic
+           function           function                 macro
+            acos              cacos                   acos
+            asin              casin                   asin
+            atan              catan                   atan
+            acosh             cacosh                  acosh
+            asinh             casinh                  asinh
+            atanh             catanh                  atanh
+            cos               ccos                    cos
+            sin               csin                    sin
+            tan               ctan                    tan
+            cosh              ccosh                   cosh
+            sinh              csinh                   sinh
+            tanh              ctanh                   tanh
+            exp               cexp                    exp
+            log               clog                    log
+            pow               cpow                    pow
+            sqrt              csqrt                   sqrt
+            fabs              cabs                    fabs</pre>
+ If at least one argument for a generic parameter is complex, then use of the macro invokes
+ a complex function; otherwise, use of the macro invokes a real function.
+<p><!--para 5-->
+ For each unsuffixed function in &lt;math.h&gt; without a c-prefixed counterpart in
+ &lt;complex.h&gt; (except modf), the corresponding type-generic macro has the same
+ name as the function. These type-generic macros are:
+<pre>
+         atan2              fma                  llround              remainder
+         cbrt               fmax                 log10                remquo
+         ceil               fmin                 log1p                rint
+         copysign           fmod                 log2                 round
+         erf                frexp                logb                 scalbn
+         erfc               hypot                lrint                scalbln
+         exp2               ilogb                lround               tgamma
+         expm1              ldexp                nearbyint            trunc
+         fdim               lgamma               nextafter
+         floor              llrint               nexttoward</pre>
+ If all arguments for generic parameters are real, then use of the macro invokes a real
+ function; otherwise, use of the macro results in undefined behavior.
+<!--page 390 indent 4-->
+<p><!--para 6-->
+ For each unsuffixed function in &lt;complex.h&gt; that is not a c-prefixed counterpart to a
+ function in &lt;math.h&gt;, the corresponding type-generic macro has the same name as the
+ function. These type-generic macros are:
+<pre>
+        carg                     conj                     creal
+        cimag                    cproj</pre>
+ Use of the macro with any real or complex argument invokes a complex function.
+<p><!--para 7-->
+ EXAMPLE       With the declarations
+<pre>
+         #include &lt;tgmath.h&gt;
+         int n;
+         float f;
+         double d;
+         long double ld;
+         float complex fc;
+         double complex dc;
+         long double complex ldc;</pre>
+ functions invoked by use of type-generic macros are shown in the following table:
+<!--page 391 indent 4-->
+<pre>
+                  macro use                                  invokes
+             exp(n)                              exp(n), the function
+             acosh(f)                            acoshf(f)
+             sin(d)                              sin(d), the function
+             atan(ld)                            atanl(ld)
+             log(fc)                             clogf(fc)
+             sqrt(dc)                            csqrt(dc)
+             pow(ldc, f)                         cpowl(ldc, f)
+             remainder(n, n)                     remainder(n, n), the function
+             nextafter(d, f)                     nextafter(d, f), the function
+             nexttoward(f, ld)                   nexttowardf(f, ld)
+             copysign(n, ld)                     copysignl(n, ld)
+             ceil(fc)                            undefined behavior
+             rint(dc)                            undefined behavior
+             fmax(ldc, ld)                       undefined behavior
+             carg(n)                             carg(n), the function
+             cproj(f)                            cprojf(f)
+             creal(d)                            creal(d), the function
+             cimag(ld)                           cimagl(ld)
+             fabs(fc)                            cabsf(fc)
+             carg(dc)                            carg(dc), the function
+             cproj(ldc)                          cprojl(ldc)</pre>
+
+<h6>footnotes</h6>
+<p><a name="note304">304)</a> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
+ make available the corresponding ordinary function.
+
+<p><a name="note305">305)</a> If the type of the argument is not compatible with the type of the parameter for the selected function,
+ the behavior is undefined.
+
+
+<a name="7.25" href="#7.25"><h3>7.25 Threads <threads.h></h3></a>
+
+<a name="7.25.1" href="#7.25.1"><h4>7.25.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;threads.h&gt; defines macros, and declares types, enumeration constants,
+ and functions that support multiple threads of execution.
+<p><!--para 2-->
+ Implementations that define the macro __STDC_NO_THREADS__ need not provide
+ this header nor support any of its facilities.
+<p><!--para 3-->
+ The macros are
+<pre>
+         ONCE_FLAG_INIT</pre>
+ which expands to a value that can be used to initialize an object of type once_flag;
+ and
+<pre>
+         TSS_DTOR_ITERATIONS</pre>
+ which expands to an integer constant expression representing the maximum number of
+ times that destructors will be called when a thread terminates.
+<p><!--para 4-->
+ The types are
+<pre>
+         cnd_t</pre>
+ which is a complete object type that holds an identifier for a condition variable;
+<pre>
+         thrd_t</pre>
+ which is a complete object type that holds an identifier for a thread;
+<pre>
+         tss_t</pre>
+ which is a complete object type that holds an identifier for a thread-specific storage
+ pointer;
+<pre>
+         mtx_t</pre>
+ which is a complete object type that holds an identifier for a mutex;
+<pre>
+         tss_dtor_t</pre>
+ which is the function pointer type void (*)(void*), used for a destructor for a
+ thread-specific storage pointer;
+<pre>
+         thrd_start_t</pre>
+ which is the function pointer type int (*)(void*) that is passed to thrd_create
+ to create a new thread;
+<pre>
+         once_flag</pre>
+ which is a complete object type that holds a flag for use by call_once; and
+<!--page 392 indent 4-->
+<pre>
+        xtime</pre>
+ which is a structure type that holds a time specified in seconds and nanoseconds. The
+ structure shall contain at least the following members, in any order.
+<p><!--para 5-->
+<pre>
+        time_t sec;
+        long nsec;</pre>
+ The enumeration constants are
+<pre>
+        mtx_plain</pre>
+ which is passed to mtx_init to create a mutex object that supports neither timeout nor
+ test and return;
+<pre>
+        mtx_recursive</pre>
+ which is passed to mtx_init to create a mutex object that supports recursive locking;
+<pre>
+        mtx_timed</pre>
+ which is passed to mtx_init to create a mutex object that supports timeout;
+<pre>
+        mtx_try</pre>
+ which is passed to mtx_init to create a mutex object that supports test and return;
+<pre>
+        thrd_timeout</pre>
+ which is returned by a timed wait function to indicate that the time specified in the call
+ was reached without acquiring the requested resource;
+<pre>
+        thrd_success</pre>
+ which is returned by a function to indicate that the requested operation succeeded;
+<pre>
+        thrd_busy</pre>
+ which is returned by a function to indicate that the requested operation failed because a
+ resource requested by a test and return function is already in use;
+<pre>
+        thrd_error</pre>
+ which is returned by a function to indicate that the requested operation failed; and
+<pre>
+        thrd_nomem</pre>
+ which is returned by a function to indicate that the requested operation failed because it
+ was unable to allocate memory.
+<!--page 393 indent 4-->
+
+<a name="7.25.2" href="#7.25.2"><h4>7.25.2 Initialization functions</h4></a>
+
+<a name="7.25.2.1" href="#7.25.2.1"><h5>7.25.2.1 The call_once function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         void call_once(once_flag *flag, void (*func)(void));</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The call_once function uses the once_flag pointed to by flag to ensure that
+ func is called exactly once, the first time the call_once function is called with that
+ value of flag. Completion of an effective call to the call_once function synchronizes
+ with all subsequent calls to the call_once function with the same value of flag.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The call_once function returns no value.
+
+<a name="7.25.3" href="#7.25.3"><h4>7.25.3 Condition variable functions</h4></a>
+
+<a name="7.25.3.1" href="#7.25.3.1"><h5>7.25.3.1 The cnd_broadcast function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int cnd_broadcast(cnd_t *cond);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cnd_broadcast function unblocks all of the threads that are blocked on the
+ condition variable pointed to by cond at the time of the call. If no threads are blocked
+ on the condition variable pointed to by cond at the time of the call, the function does
+ nothing.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cnd_broadcast function returns thrd_success on success, or thrd_error
+ if the request could not be honored.
+
+<a name="7.25.3.2" href="#7.25.3.2"><h5>7.25.3.2 The cnd_destroy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         void cnd_destroy(cnd_t *cond);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cnd_destroy function releases all resources used by the condition variable
+ pointed to by cond. The cnd_destroy function requires that no threads be blocked
+ waiting for the condition variable pointed to by cond.
+<!--page 394 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cnd_destroy function returns no value.
+
+<a name="7.25.3.3" href="#7.25.3.3"><h5>7.25.3.3 The cnd_init function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        int cnd_init(cnd_t *cond);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cnd_init function creates a condition variable. If it succeeds it sets the variable
+ pointed to by cond to a value that uniquely identifies the newly created condition
+ variable. A thread that calls cnd_wait on a newly created condition variable will
+ block.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cnd_init function returns thrd_success on success, or thrd_nomem if no
+ memory could be allocated for the newly created condition, or thrd_error if the
+ request could not be honored.
+
+<a name="7.25.3.4" href="#7.25.3.4"><h5>7.25.3.4 The cnd_signal function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        int cnd_signal(cnd_t *cond);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cnd_signal function unblocks one of the threads that are blocked on the
+ condition variable pointed to by cond at the time of the call. If no threads are blocked
+ on the condition variable at the time of the call, the function does nothing and return
+ success.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cnd_signal function returns thrd_success on success or thrd_error if
+ the request could not be honored.
+
+<a name="7.25.3.5" href="#7.25.3.5"><h5>7.25.3.5 The cnd_timedwait function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 395 indent 4-->
+<pre>
+        #include &lt;threads.h&gt;
+        int cnd_timedwait(cnd_t *cond, mtx_t *mtx,
+             const xtime *xt);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cnd_timedwait function atomically unlocks the mutex pointed to by mtx and
+ endeavors to block until the condition variable pointed to by cond is signaled by a call to
+ cnd_signal or to cnd_broadcast, or until after the time specified by the xtime
+ object pointed to by xt. When the calling thread becomes unblocked it locks the variable
+ pointed to by mtx before it returns. The cnd_timedwait function requires that the
+ mutex pointed to by mtx be locked by the calling thread.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cnd_timedwait function returns thrd_success upon success, or
+ thrd_timeout if the time specified in the call was reached without acquiring the
+ requested resource, or thrd_error if the request could not be honored.
+
+<a name="7.25.3.6" href="#7.25.3.6"><h5>7.25.3.6 The cnd_wait function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int cnd_wait(cnd_t *cond, mtx_t *mtx);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The cnd_wait function atomically unlocks the mutex pointed to by mtx and endeavors
+ to block until the condition variable pointed to by cond is signaled by a call to
+ cnd_signal or to cnd_broadcast. When the calling thread becomes unblocked it
+ locks the mutex pointed to by mtx before it returns. If the mutex pointed to by mtx is
+ not locked by the calling thread, the cnd_wait function will act as if the abort
+ function is called.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The cnd_wait function returns thrd_success on success or thrd_error if the
+ request could not be honored.
+
+<a name="7.25.4" href="#7.25.4"><h4>7.25.4 Mutex functions</h4></a>
+
+<a name="7.25.4.1" href="#7.25.4.1"><h5>7.25.4.1 The mtx_destroy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         void mtx_destroy(mtx_t *mtx);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mtx_destroy function releases any resources used by the mutex pointed to by
+ mtx. No threads can be blocked waiting for the mutex pointed to by mtx.
+<!--page 396 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mtx_destroy function returns no value.
+
+<a name="7.25.4.2" href="#7.25.4.2"><h5>7.25.4.2 The mtx_init function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        int mtx_init(mtx_t *mtx, int type);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mtx_init function creates a mutex object with properties indicated by type,
+ which must have one of the six values:
+ mtx_plain for a simple non-recursive mutex,
+ mtx_timed for a non-recursive mutex that supports timeout,
+ mtx_try      for a non-recursive mutex that supports test and return,
+ mtx_plain | mtx_recursive for a simple recursive mutex,
+ mtx_timed | mtx_recursive for a recursive mutex that supports timeout, or
+ mtx_try | mtx_recursive for a recursive mutex that supports test and return.
+<p><!--para 3-->
+ If the mtx_init function succeeds, it sets the mutex pointed to by mtx to a value that
+ uniquely identifies the newly created mutex.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The mtx_init function returns thrd_success on success, or thrd_error if the
+ request could not be honored.
+
+<a name="7.25.4.3" href="#7.25.4.3"><h5>7.25.4.3 The mtx_lock function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        int mtx_lock(mtx_t *mtx);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mtx_lock function blocks until it locks the mutex pointed to by mtx. If the mutex
+ is non-recursive, it shall not be locked by the calling thread. Prior calls to mtx_unlock
+ on the same mutex shall synchronize with this operation.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mtx_lock function returns thrd_success on success, or thrd_busy if the
+ resource requested is already in use, or thrd_error if the request could not be
+ honored.
+<!--page 397 indent 4-->
+
+<a name="7.25.4.4" href="#7.25.4.4"><h5>7.25.4.4 The mtx_timedlock function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int mtx_timedlock(mtx_t *mtx, const xtime *xt);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mtx_timedlock function endeavors to block until it locks the mutex pointed to by
+ mtx or until the time specified by the xtime object xt has passed. The specified mutex
+ shall support timeout. If the operation succeeds, prior calls to mtx_unlock on the same
+ mutex shall synchronize with this operation.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mtx_timedlock function returns thrd_success on success, or thrd_busy
+ if the resource requested is already in use, or thrd_timeout if the time specified was
+ reached without acquiring the requested resource, or thrd_error if the request could
+ not be honored.
+
+<a name="7.25.4.5" href="#7.25.4.5"><h5>7.25.4.5 The mtx_trylock function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int mtx_trylock(mtx_t *mtx);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mtx_trylock function endeavors to lock the mutex pointed to by mtx. The
+ specified mutex shall support either test and return or timeout. If the mutex is already
+ locked, the function returns without blocking. If the operation succeeds, prior calls to
+ mtx_unlock on the same mutex shall synchronize with this operation.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mtx_trylock function returns thrd_success on success, or thrd_busy if
+ the resource requested is already in use, or thrd_error if the request could not be
+ honored.
+
+<a name="7.25.4.6" href="#7.25.4.6"><h5>7.25.4.6 The mtx_unlock function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int mtx_unlock(mtx_t *mtx);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mtx_unlock function unlocks the mutex pointed to by mtx. The mutex pointed to
+ by mtx shall be locked by the calling thread.
+<!--page 398 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mtx_unlock function returns thrd_success on success or thrd_error if
+ the request could not be honored.
+
+<a name="7.25.5" href="#7.25.5"><h4>7.25.5 Thread functions</h4></a>
+
+<a name="7.25.5.1" href="#7.25.5.1"><h5>7.25.5.1 The thrd_create function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        int thrd_create(thrd_t *thr, thrd_start_t func,
+             void *arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_create function creates a new thread executing func(arg). If the
+ thrd_create function succeeds, it sets the object pointed to by thr to the identifier of
+ the newly created thread. (A thread's identifier may be reused for a different thread once
+ the original thread has exited and either been detached or joined to another thread.) The
+ completion of the thrd_create function synchronizes with the beginning of the
+ execution of the new thread.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_create function returns thrd_success on success, or thrd_nomem if
+ no memory could be allocated for the thread requested, or thrd_error if the request
+ could not be honored.
+
+<a name="7.25.5.2" href="#7.25.5.2"><h5>7.25.5.2 The thrd_current function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        thrd_t thrd_current(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_current function identifies the thread that called it.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_current function returns the identifier of the thread that called it.
+
+<a name="7.25.5.3" href="#7.25.5.3"><h5>7.25.5.3 The thrd_detach function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 399 indent 4-->
+<pre>
+        #include &lt;threads.h&gt;
+        int thrd_detach(thrd_t thr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_detach function tells the operating system to dispose of any resources
+ allocated to the thread identified by thr when that thread terminates. The thread
+ identified by thr shall not have been previously detached or joined with another thread.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_detach function returns thrd_success on success or thrd_error if
+ the request could not be honored.
+
+<a name="7.25.5.4" href="#7.25.5.4"><h5>7.25.5.4 The thrd_equal function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int thrd_equal(thrd_t thr0, thrd_t thr1);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_equal function will determine whether the thread identified by thr0 refers
+ to the thread identified by thr1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_equal function returns zero if the thread thr0 and the thread thr1 refer to
+ different threads. Otherwise the thrd_equal function returns a nonzero value.
+
+<a name="7.25.5.5" href="#7.25.5.5"><h5>7.25.5.5 The thrd_exit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         void thrd_exit(int res);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_exit function terminates execution of the calling thread and sets its result
+ code to res.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_exit function returns no value.
+
+<a name="7.25.5.6" href="#7.25.5.6"><h5>7.25.5.6 The thrd_join function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int thrd_join(thrd_t thr, int *res);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_join function joins the thread identified by thr with the current thread by
+ blocking until the other thread has terminated. If the parameter res is not a null pointer,
+<!--page 400 indent 4-->
+ it stores the thread's result code in the integer pointed to by res. The termination of the
+ other thread synchronizes with the completion of the thrd_join function. The thread
+ identified by thr shall not have been previously detached or joined with another thread.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_join function returns thrd_success on success or thrd_error if the
+ request could not be honored.
+
+<a name="7.25.5.7" href="#7.25.5.7"><h5>7.25.5.7 The thrd_sleep function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        void thrd_sleep(const xtime *xt);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_sleep function suspends execution of the calling thread until after the time
+ specified by the xtime object pointed to by xt.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_sleep function returns no value.
+
+<a name="7.25.5.8" href="#7.25.5.8"><h5>7.25.5.8 The thrd_yield function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        void thrd_yield(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The thrd_yield function endeavors to permit other threads to run, even if the current
+ thread would ordinarily continue to run.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The thrd_yield function returns no value.
+
+<a name="7.25.6" href="#7.25.6"><h4>7.25.6 Thread-specific storage functions</h4></a>
+
+<a name="7.25.6.1" href="#7.25.6.1"><h5>7.25.6.1 The tss_create function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;threads.h&gt;
+        int tss_create(tss_t *key, tss_dtor_t dtor);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tss_create function creates a thread-specific storage pointer with destructor
+ dtor, which may be null.
+<!--page 401 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the tss_create function is successful, it sets the thread-specific storage pointed to
+ by key to a value that uniquely identifies the newly created pointer and returns
+ thrd_success; otherwise, thrd_error is returned and the thread-specific storage
+ pointed to by key is set to an undefined value.
+
+<a name="7.25.6.2" href="#7.25.6.2"><h5>7.25.6.2 The tss_delete function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         void tss_delete(tss_t key);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tss_delete function releases any resources used by the thread-specific storage
+ identified by key.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tss_delete function returns no value.
+
+<a name="7.25.6.3" href="#7.25.6.3"><h5>7.25.6.3 The tss_get function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         void *tss_get(tss_t key);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tss_get function returns the value for the current thread held in the thread-specific
+ storage identified by key.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tss_get function returns the value for the current thread if successful, or zero if
+ unsuccessful.
+
+<a name="7.25.6.4" href="#7.25.6.4"><h5>7.25.6.4 The tss_set function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int tss_set(tss_t key, void *val);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The tss_set function sets the value for the current thread held in the thread-specific
+ storage identified by key to val.
+<!--page 402 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The tss_set function returns thrd_success on success or thrd_error if the
+ request could not be honored.
+
+<a name="7.25.7" href="#7.25.7"><h4>7.25.7 Time functions</h4></a>
+
+<a name="7.25.7.1" href="#7.25.7.1"><h5>7.25.7.1 The xtime_get function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;threads.h&gt;
+         int xtime_get(xtime *xt, int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The xtime_get function sets the xtime object pointed to by xt to hold the current
+ time based on the time base base.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the xtime_get function is successful it returns the nonzero value base, which must
+ be TIME_UTC; otherwise, it returns zero.<sup><a href="#note306"><b>306)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 403 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note306">306)</a> Although an xtime object describes times with nanosecond resolution, the actual resolution in an
+ xtime object is system dependent.
+
+
+<a name="7.26" href="#7.26"><h3>7.26 Date and time <time.h></h3></a>
+
+<a name="7.26.1" href="#7.26.1"><h4>7.26.1 Components of time</h4></a>
+<p><!--para 1-->
+ The header &lt;time.h&gt; defines two macros, and declares several types and functions for
+ manipulating time. Many functions deal with a calendar time that represents the current
+ date (according to the Gregorian calendar) and time. Some functions deal with local
+ time, which is the calendar time expressed for some specific time zone, and with Daylight
+ Saving Time, which is a temporary change in the algorithm for determining local time.
+ The local time zone and Daylight Saving Time are implementation-defined.
+<p><!--para 2-->
+ The macros defined are NULL (described in <a href="#7.19">7.19</a>); and
+<pre>
+         CLOCKS_PER_SEC</pre>
+ which expands to an expression with type clock_t (described below) that is the
+ number per second of the value returned by the clock function.
+<p><!--para 3-->
+ The types declared are size_t (described in <a href="#7.19">7.19</a>);
+<pre>
+         clock_t</pre>
+ and
+<pre>
+         time_t</pre>
+ which are arithmetic types capable of representing times; and
+<pre>
+         struct tm</pre>
+ which holds the components of a calendar time, called the broken-down time.
+<p><!--para 4-->
+ The range and precision of times representable in clock_t and time_t are
+ implementation-defined. The tm structure shall contain at least the following members,
+ in any order. The semantics of the members and their normal ranges are expressed in the
+ comments.<sup><a href="#note307"><b>307)</b></a></sup>
+<pre>
+         int    tm_sec;           //   seconds after the minute -- [0, 60]
+         int    tm_min;           //   minutes after the hour -- [0, 59]
+         int    tm_hour;          //   hours since midnight -- [0, 23]
+         int    tm_mday;          //   day of the month -- [1, 31]
+         int    tm_mon;           //   months since January -- [0, 11]
+         int    tm_year;          //   years since 1900
+         int    tm_wday;          //   days since Sunday -- [0, 6]
+         int    tm_yday;          //   days since January 1 -- [0, 365]
+         int    tm_isdst;         //   Daylight Saving Time flag</pre>
+ 
+ 
+ 
+<!--page 404 indent 4-->
+ The value of tm_isdst is positive if Daylight Saving Time is in effect, zero if Daylight
+ Saving Time is not in effect, and negative if the information is not available.
+
+<h6>footnotes</h6>
+<p><a name="note307">307)</a> The range [0, 60] for tm_sec allows for a positive leap second.
+
+
+<a name="7.26.2" href="#7.26.2"><h4>7.26.2 Time manipulation functions</h4></a>
+
+<a name="7.26.2.1" href="#7.26.2.1"><h5>7.26.2.1 The clock function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;time.h&gt;
+         clock_t clock(void);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The clock function determines the processor time used.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The clock function returns the implementation's best approximation to the processor
+ time used by the program since the beginning of an implementation-defined era related
+ only to the program invocation. To determine the time in seconds, the value returned by
+ the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
+ the processor time used is not available or its value cannot be represented, the function
+ returns the value (clock_t)(-1).<sup><a href="#note308"><b>308)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note308">308)</a> In order to measure the time spent in a program, the clock function should be called at the start of
+ the program and its return value subtracted from the value returned by subsequent calls.
+
+
+<a name="7.26.2.2" href="#7.26.2.2"><h5>7.26.2.2 The difftime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;time.h&gt;
+         double difftime(time_t time1, time_t time0);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The difftime function computes the difference between two calendar times: time1 -
+ time0.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The difftime function returns the difference expressed in seconds as a double.
+ 
+ 
+ 
+ 
+<!--page 405 indent 4-->
+
+<a name="7.26.2.3" href="#7.26.2.3"><h5>7.26.2.3 The mktime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;time.h&gt;
+         time_t mktime(struct tm *timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mktime function converts the broken-down time, expressed as local time, in the
+ structure pointed to by timeptr into a calendar time value with the same encoding as
+ that of the values returned by the time function. The original values of the tm_wday
+ and tm_yday components of the structure are ignored, and the original values of the
+ other components are not restricted to the ranges indicated above.<sup><a href="#note309"><b>309)</b></a></sup> On successful
+ completion, the values of the tm_wday and tm_yday components of the structure are
+ set appropriately, and the other components are set to represent the specified calendar
+ time, but with their values forced to the ranges indicated above; the final value of
+ tm_mday is not set until tm_mon and tm_year are determined.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mktime function returns the specified calendar time encoded as a value of type
+ time_t. If the calendar time cannot be represented, the function returns the value
+ (time_t)(-1).
+<p><!--para 4-->
+ EXAMPLE       What day of the week is July 4, 2001?
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;time.h&gt;
+         static const char *const wday[] = {
+                 "Sunday", "Monday", "Tuesday", "Wednesday",
+                 "Thursday", "Friday", "Saturday", "-unknown-"
+         };
+         struct tm time_str;
+         /* ... */</pre>
+ 
+ 
+ 
+ 
+<!--page 406 indent 4-->
+<pre>
+        time_str.tm_year   = 2001 - 1900;
+        time_str.tm_mon    = 7 - 1;
+        time_str.tm_mday   = 4;
+        time_str.tm_hour   = 0;
+        time_str.tm_min    = 0;
+        time_str.tm_sec    = 1;
+        time_str.tm_isdst = -1;
+        if (mktime(&amp;time_str) == (time_t)(-1))
+              time_str.tm_wday = 7;
+        printf("%s\n", wday[time_str.tm_wday]);</pre>
+ 
+
+<h6>footnotes</h6>
+<p><a name="note309">309)</a> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
+ Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
+ causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
+
+
+<a name="7.26.2.4" href="#7.26.2.4"><h5>7.26.2.4 The time function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        time_t time(time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The time function determines the current calendar time. The encoding of the value is
+ unspecified.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The time function returns the implementation's best approximation to the current
+ calendar time. The value (time_t)(-1) is returned if the calendar time is not
+ available. If timer is not a null pointer, the return value is also assigned to the object it
+ points to.
+
+<a name="7.26.3" href="#7.26.3"><h4>7.26.3 Time conversion functions</h4></a>
+<p><!--para 1-->
+ Except for the strftime function, these functions each return a pointer to one of two
+ types of static objects: a broken-down time structure or an array of char. Execution of
+ any of the functions that return a pointer to one of these object types may overwrite the
+ information in any object of the same type pointed to by the value returned from any
+ previous call to any of them and the functions are not required to avoid data races. The
+ implementation shall behave as if no other library functions call these functions.
+
+<a name="7.26.3.1" href="#7.26.3.1"><h5>7.26.3.1 The asctime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        char *asctime(const struct tm *timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The asctime function converts the broken-down time in the structure pointed to by
+ timeptr into a string in the form
+<!--page 407 indent 4-->
+<pre>
+        Sun Sep 16 01:03:52 1973\n\0</pre>
+ using the equivalent of the following algorithm.
+ char *asctime(const struct tm *timeptr)
+ {
+<pre>
+      static const char wday_name[7][3] = {
+           "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+      };
+      static const char mon_name[12][3] = {
+           "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+      };
+      static char result[26];
+         sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
+              wday_name[timeptr-&gt;tm_wday],
+              mon_name[timeptr-&gt;tm_mon],
+              timeptr-&gt;tm_mday, timeptr-&gt;tm_hour,
+              timeptr-&gt;tm_min, timeptr-&gt;tm_sec,
+              1900 + timeptr-&gt;tm_year);
+         return result;</pre>
+ }
+<p><!--para 3-->
+ If any of the fields of the broken-down time contain values that are outside their normal
+ ranges,<sup><a href="#note310"><b>310)</b></a></sup> the behavior of the asctime function is undefined. Likewise, if the
+ calculated year exceeds four digits or is less than the year 1000, the behavior is
+ undefined.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The asctime function returns a pointer to the string.
+
+<h6>footnotes</h6>
+<p><a name="note310">310)</a> See <a href="#7.26.1">7.26.1</a>.
+
+
+<a name="7.26.3.2" href="#7.26.3.2"><h5>7.26.3.2 The ctime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;time.h&gt;
+         char *ctime(const time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ctime function converts the calendar time pointed to by timer to local time in the
+ form of a string. It is equivalent to
+<pre>
+         asctime(localtime(timer))</pre>
+ 
+ 
+ 
+<!--page 408 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The ctime function returns the pointer returned by the asctime function with that
+ broken-down time as argument.
+ Forward references: the localtime function (<a href="#7.26.3.4">7.26.3.4</a>).
+
+<a name="7.26.3.3" href="#7.26.3.3"><h5>7.26.3.3 The gmtime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        struct tm *gmtime(const time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The gmtime function converts the calendar time pointed to by timer into a broken-
+ down time, expressed as UTC.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The gmtime function returns a pointer to the broken-down time, or a null pointer if the
+ specified time cannot be converted to UTC.
+
+<a name="7.26.3.4" href="#7.26.3.4"><h5>7.26.3.4 The localtime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        struct tm *localtime(const time_t *timer);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The localtime function converts the calendar time pointed to by timer into a
+ broken-down time, expressed as local time.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The localtime function returns a pointer to the broken-down time, or a null pointer if
+ the specified time cannot be converted to local time.
+
+<a name="7.26.3.5" href="#7.26.3.5"><h5>7.26.3.5 The strftime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<!--page 409 indent 4-->
+<pre>
+        #include &lt;time.h&gt;
+        size_t strftime(char * restrict s,
+             size_t maxsize,
+             const char * restrict format,
+             const struct tm * restrict timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strftime function places characters into the array pointed to by s as controlled by
+ the string pointed to by format. The format shall be a multibyte character sequence,
+ beginning and ending in its initial shift state. The format string consists of zero or
+ more conversion specifiers and ordinary multibyte characters. A conversion specifier
+ consists of a % character, possibly followed by an E or O modifier character (described
+ below), followed by a character that determines the behavior of the conversion specifier.
+ All ordinary multibyte characters (including the terminating null character) are copied
+ unchanged into the array. If copying takes place between objects that overlap, the
+ behavior is undefined. No more than maxsize characters are placed into the array.
+<p><!--para 3-->
+ Each conversion specifier is replaced by appropriate characters as described in the
+ following list. The appropriate characters are determined using the LC_TIME category
+ of the current locale and by the values of zero or more members of the broken-down time
+ structure pointed to by timeptr, as specified in brackets in the description. If any of
+ the specified values is outside the normal range, the characters stored are unspecified.
+ %a   is replaced by the locale's abbreviated weekday name. [tm_wday]
+ %A   is replaced by the locale's full weekday name. [tm_wday]
+ %b   is replaced by the locale's abbreviated month name. [tm_mon]
+ %B   is replaced by the locale's full month name. [tm_mon]
+ %c   is replaced by the locale's appropriate date and time representation. [all specified
+<pre>
+      in <a href="#7.26.1">7.26.1</a>]</pre>
+ %C   is replaced by the year divided by 100 and truncated to an integer, as a decimal
+<pre>
+      number (00-99). [tm_year]</pre>
+ %d   is replaced by the day of the month as a decimal number (01-31). [tm_mday]
+ %D   is equivalent to ''%m/%d/%y''. [tm_mon, tm_mday, tm_year]
+ %e   is replaced by the day of the month as a decimal number (1-31); a single digit is
+<pre>
+      preceded by a space. [tm_mday]</pre>
+ %F   is equivalent to ''%Y-%m-%d'' (the ISO 8601 date format). [tm_year, tm_mon,
+<pre>
+      tm_mday]</pre>
+ %g   is replaced by the last 2 digits of the week-based year (see below) as a decimal
+<pre>
+      number (00-99). [tm_year, tm_wday, tm_yday]</pre>
+ %G   is replaced by the week-based year (see below) as a decimal number (e.g., 1997).
+<pre>
+      [tm_year, tm_wday, tm_yday]</pre>
+ %h   is equivalent to ''%b''. [tm_mon]
+ %H   is replaced by the hour (24-hour clock) as a decimal number (00-23). [tm_hour]
+ %I   is replaced by the hour (12-hour clock) as a decimal number (01-12). [tm_hour]
+ %j   is replaced by the day of the year as a decimal number (001-366). [tm_yday]
+ %m   is replaced by the month as a decimal number (01-12). [tm_mon]
+ %M   is replaced by the minute as a decimal number (00-59). [tm_min]
+ %n   is replaced by a new-line character.
+<!--page 410 indent 4-->
+ %p    is replaced by the locale's equivalent of the AM/PM designations associated with a
+<pre>
+       12-hour clock. [tm_hour]</pre>
+ %r    is replaced by the locale's 12-hour clock time. [tm_hour, tm_min, tm_sec]
+ %R    is equivalent to ''%H:%M''. [tm_hour, tm_min]
+ %S    is replaced by the second as a decimal number (00-60). [tm_sec]
+ %t    is replaced by a horizontal-tab character.
+ %T    is equivalent to ''%H:%M:%S'' (the ISO 8601 time format). [tm_hour, tm_min,
+<pre>
+       tm_sec]</pre>
+ %u    is replaced by the ISO 8601 weekday as a decimal number (1-7), where Monday
+<pre>
+       is 1. [tm_wday]</pre>
+ %U    is replaced by the week number of the year (the first Sunday as the first day of week
+<pre>
+       1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]</pre>
+ %V    is replaced by the ISO 8601 week number (see below) as a decimal number
+<pre>
+       (01-53). [tm_year, tm_wday, tm_yday]</pre>
+ %w    is replaced by the weekday as a decimal number (0-6), where Sunday is 0.
+<pre>
+       [tm_wday]</pre>
+ %W    is replaced by the week number of the year (the first Monday as the first day of
+<pre>
+       week 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]</pre>
+ %x    is replaced by the locale's appropriate date representation. [all specified in <a href="#7.26.1">7.26.1</a>]
+ %X    is replaced by the locale's appropriate time representation. [all specified in <a href="#7.26.1">7.26.1</a>]
+ %y    is replaced by the last 2 digits of the year as a decimal number (00-99).
+<pre>
+       [tm_year]</pre>
+ %Y    is replaced by the year as a decimal number (e.g., 1997). [tm_year]
+ %z    is replaced by the offset from UTC in the ISO 8601 format ''-0430'' (meaning 4
+<pre>
+       hours 30 minutes behind UTC, west of Greenwich), or by no characters if no time
+       zone is determinable. [tm_isdst]</pre>
+ %Z    is replaced by the locale's time zone name or abbreviation, or by no characters if no
+<pre>
+       time zone is determinable. [tm_isdst]</pre>
+ %%    is replaced by %.
+<p><!--para 4-->
+ Some conversion specifiers can be modified by the inclusion of an E or O modifier
+ character to indicate an alternative format or specification. If the alternative format or
+ specification does not exist for the current locale, the modifier is ignored.
+ %Ec is replaced by the locale's alternative date and time representation.
+ %EC is replaced by the name of the base year (period) in the locale's alternative
+<pre>
+     representation.</pre>
+ %Ex is replaced by the locale's alternative date representation.
+ %EX is replaced by the locale's alternative time representation.
+ %Ey is replaced by the offset from %EC (year only) in the locale's alternative
+<pre>
+     representation.</pre>
+ %EY is replaced by the locale's full alternative year representation.
+<!--page 411 indent 4-->
+ %Od is replaced by the day of the month, using the locale's alternative numeric symbols
+<pre>
+     (filled as needed with leading zeros, or with leading spaces if there is no alternative
+     symbol for zero).</pre>
+ %Oe is replaced by the day of the month, using the locale's alternative numeric symbols
+<pre>
+     (filled as needed with leading spaces).</pre>
+ %OH is replaced by the hour (24-hour clock), using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %OI is replaced by the hour (12-hour clock), using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %Om is replaced by the month, using the locale's alternative numeric symbols.
+ %OM is replaced by the minutes, using the locale's alternative numeric symbols.
+ %OS is replaced by the seconds, using the locale's alternative numeric symbols.
+ %Ou is replaced by the ISO 8601 weekday as a number in the locale's alternative
+<pre>
+     representation, where Monday is 1.</pre>
+ %OU is replaced by the week number, using the locale's alternative numeric symbols.
+ %OV is replaced by the ISO 8601 week number, using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %Ow is replaced by the weekday as a number, using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %OW is replaced by the week number of the year, using the locale's alternative numeric
+<pre>
+     symbols.</pre>
+ %Oy is replaced by the last 2 digits of the year, using the locale's alternative numeric
+<p><!--para 5-->
+<pre>
+     symbols.</pre>
+ %g, %G, and %V give values according to the ISO 8601 week-based year. In this system,
+ weeks begin on a Monday and week 1 of the year is the week that includes January 4th,
+ which is also the week that includes the first Thursday of the year, and is also the first
+ week that contains at least four days in the year. If the first Monday of January is the
+ 2nd, 3rd, or 4th, the preceding days are part of the last week of the preceding year; thus,
+ for Saturday 2nd January 1999, %G is replaced by 1998 and %V is replaced by 53. If
+ December 29th, 30th, or 31st is a Monday, it and any following days are part of week 1 of
+ the following year. Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and
+ %V is replaced by 01.
+<p><!--para 6-->
+ If a conversion specifier is not one of the above, the behavior is undefined.
+<p><!--para 7-->
+ In the "C" locale, the E and O modifiers are ignored and the replacement strings for the
+ following specifiers are:
+ %a the first three characters of %A.
+ %A one of ''Sunday'', ''Monday'', ... , ''Saturday''.
+ %b the first three characters of %B.
+ %B one of ''January'', ''February'', ... , ''December''.
+ %c equivalent to ''%a %b %e %T %Y''.
+<!--page 412 indent 4-->
+ %p    one of ''AM'' or ''PM''.
+ %r    equivalent to ''%I:%M:%S %p''.
+ %x    equivalent to ''%m/%d/%y''.
+ %X    equivalent to %T.
+ %Z    implementation-defined.
+<h6>Returns</h6>
+<p><!--para 8-->
+ If the total number of resulting characters including the terminating null character is not
+ more than maxsize, the strftime function returns the number of characters placed
+ into the array pointed to by s not including the terminating null character. Otherwise,
+ zero is returned and the contents of the array are indeterminate.
+<!--page 413 indent 4-->
+
+<a name="7.27" href="#7.27"><h3>7.27 Unicode utilities <uchar.h></h3></a>
+<p><!--para 1-->
+ The header &lt;uchar.h&gt; declares types and functions for manipulating Unicode
+ characters.
+<p><!--para 2-->
+ The types declared are mbstate_t (described in <a href="#7.29.1">7.29.1</a>) and size_t (described in
+ <a href="#7.19">7.19</a>);
+<pre>
+         char16_t</pre>
+ which is an unsigned integer type used for 16-bit characters and is the same type as
+ uint_least16_t (described in <a href="#7.20.1.2">7.20.1.2</a>); and
+<pre>
+         char32_t</pre>
+ which is an unsigned integer type used for 32-bit characters and is the same type as
+ uint_least32_t (also described in <a href="#7.20.1.2">7.20.1.2</a>).
+
+<a name="7.27.1" href="#7.27.1"><h4>7.27.1 Restartable multibyte/wide character conversion functions</h4></a>
+<p><!--para 1-->
+ These functions have a parameter, ps, of type pointer to mbstate_t that points to an
+ object that can completely describe the current conversion state of the associated
+ multibyte character sequence, which the functions alter as necessary. If ps is a null
+ pointer, each function uses its own internal mbstate_t object instead, which is
+ initialized at program startup to the initial conversion state; the functions are not required
+ to avoid data races in this case. The implementation behaves as if no library function
+ calls these functions with a null pointer for ps.
+
+<a name="7.27.1.1" href="#7.27.1.1"><h5>7.27.1.1 The mbrtoc16 function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;uchar.h&gt;
+         size_t mbrtoc16(char16_t * restrict pc16,
+              const char * restrict s, size_t n,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the mbrtoc16 function is equivalent to the call:
+<pre>
+                mbrtoc16(NULL, "", 1, ps)</pre>
+ In this case, the values of the parameters pc16 and n are ignored.
+<p><!--para 3-->
+ If s is not a null pointer, the mbrtoc16 function inspects at most n bytes beginning with
+ the byte pointed to by s to determine the number of bytes needed to complete the next
+ multibyte character (including any shift sequences). If the function determines that the
+ next multibyte character is complete and valid, it determines the values of the
+ corresponding wide characters and then, if pc16 is not a null pointer, stores the value of
+ the first (or only) such character in the object pointed to by pc16. Subsequent calls will
+<!--page 414 indent 4-->
+ store successive wide characters without consuming any additional input until all the
+ characters have been stored. If the corresponding wide character is the null wide
+ character, the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The mbrtoc16 function returns the first of the following that applies (given the current
+ conversion state):
+ 0                     if the next n or fewer bytes complete the multibyte character that
+<pre>
+                       corresponds to the null wide character (which is the value stored).</pre>
+ between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+<pre>
+                    character (which is the value stored); the value returned is the number
+                    of bytes that complete the multibyte character.</pre>
+ (size_t)(-3) if the next character resulting from a previous call has been stored (no
+<pre>
+              bytes from the input have been consumed by this call).</pre>
+ (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+<pre>
+              multibyte character, and all n bytes have been processed (no value is
+              stored).<sup><a href="#note311"><b>311)</b></a></sup></pre>
+ (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+<pre>
+              do not contribute to a complete and valid multibyte character (no
+              value is stored); the value of the macro EILSEQ is stored in errno,
+              and the conversion state is unspecified.</pre>
+
+<h6>footnotes</h6>
+<p><a name="note311">311)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+ sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+
+<a name="7.27.1.2" href="#7.27.1.2"><h5>7.27.1.2 The c16rtomb function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;uchar.h&gt;
+         size_t c16rtomb(char * restrict s, char16_t c16,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the c16rtomb function is equivalent to the call
+<pre>
+                 c16rtomb(buf, L'\0', ps)</pre>
+ where buf is an internal buffer.
+<p><!--para 3-->
+ If s is not a null pointer, the c16rtomb function determines the number of bytes needed
+ to represent the multibyte character that corresponds to the wide character given by c16
+ (including any shift sequences), and stores the multibyte character representation in the
+ 
+ 
+<!--page 415 indent 4-->
+ array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+ c16 is a null wide character, a null byte is stored, preceded by any shift sequence needed
+ to restore the initial shift state; the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The c16rtomb function returns the number of bytes stored in the array object (including
+ any shift sequences). When c16 is not a valid wide character, an encoding error occurs:
+ the function stores the value of the macro EILSEQ in errno and returns
+ (size_t)(-1); the conversion state is unspecified.
+
+<a name="7.27.1.3" href="#7.27.1.3"><h5>7.27.1.3 The mbrtoc32 function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;uchar.h&gt;
+         size_t mbrtoc32(char32_t * restrict pc32,
+              const char * restrict s, size_t n,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the mbrtoc32 function is equivalent to the call:
+<pre>
+                 mbrtoc32(NULL, "", 1, ps)</pre>
+ In this case, the values of the parameters pc32 and n are ignored.
+<p><!--para 3-->
+ If s is not a null pointer, the mbrtoc32 function inspects at most n bytes beginning with
+ the byte pointed to by s to determine the number of bytes needed to complete the next
+ multibyte character (including any shift sequences). If the function determines that the
+ next multibyte character is complete and valid, it determines the values of the
+ corresponding wide characters and then, if pc32 is not a null pointer, stores the value of
+ the first (or only) such character in the object pointed to by pc32. Subsequent calls will
+ store successive wide characters without consuming any additional input until all the
+ characters have been stored. If the corresponding wide character is the null wide
+ character, the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The mbrtoc32 function returns the first of the following that applies (given the current
+ conversion state):
+ 0                    if the next n or fewer bytes complete the multibyte character that
+<pre>
+                      corresponds to the null wide character (which is the value stored).</pre>
+ between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+<!--page 416 indent 4-->
+<pre>
+                    character (which is the value stored); the value returned is the number
+                    of bytes that complete the multibyte character.</pre>
+ (size_t)(-3) if the next character resulting from a previous call has been stored (no
+<pre>
+              bytes from the input have been consumed by this call).</pre>
+ (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+<pre>
+              multibyte character, and all n bytes have been processed (no value is
+              stored).<sup><a href="#note312"><b>312)</b></a></sup></pre>
+ (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+<pre>
+              do not contribute to a complete and valid multibyte character (no
+              value is stored); the value of the macro EILSEQ is stored in errno,
+              and the conversion state is unspecified.</pre>
+
+<h6>footnotes</h6>
+<p><a name="note312">312)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+ sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+
+<a name="7.27.1.4" href="#7.27.1.4"><h5>7.27.1.4 The c32rtomb function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;uchar.h&gt;
+         size_t c32rtomb(char * restrict s, char32_t c32,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the c32rtomb function is equivalent to the call
+<pre>
+                 c32rtomb(buf, L'\0', ps)</pre>
+ where buf is an internal buffer.
+<p><!--para 3-->
+ If s is not a null pointer, the c32rtomb function determines the number of bytes needed
+ to represent the multibyte character that corresponds to the wide character given by c32
+ (including any shift sequences), and stores the multibyte character representation in the
+ array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+ c32 is a null wide character, a null byte is stored, preceded by any shift sequence needed
+ to restore the initial shift state; the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The c32rtomb function returns the number of bytes stored in the array object (including
+ any shift sequences). When c32 is not a valid wide character, an encoding error occurs:
+ the function stores the value of the macro EILSEQ in errno and returns
+ (size_t)(-1); the conversion state is unspecified.
+ 
+ 
+ 
+ 
+<!--page 417 indent 4-->
+
+<a name="7.28" href="#7.28"><h3>7.28 Extended multibyte and wide character utilities <wchar.h></h3></a>
+
+<a name="7.28.1" href="#7.28.1"><h4>7.28.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;wchar.h&gt; defines four macros, and declares four data types, one tag, and
+ many functions.<sup><a href="#note313"><b>313)</b></a></sup>
+<p><!--para 2-->
+ The types declared are wchar_t and size_t (both described in <a href="#7.19">7.19</a>);
+<pre>
+           mbstate_t</pre>
+ which is a complete object type other than an array type that can hold the conversion state
+ information necessary to convert between sequences of multibyte characters and wide
+ characters;
+<pre>
+          wint_t</pre>
+ which is an integer type unchanged by default argument promotions that can hold any
+ value corresponding to members of the extended character set, as well as at least one
+ value that does not correspond to any member of the extended character set (see WEOF
+ below);<sup><a href="#note314"><b>314)</b></a></sup> and
+<pre>
+          struct tm</pre>
+ which is declared as an incomplete structure type (the contents are described in <a href="#7.26.1">7.26.1</a>).
+<p><!--para 3-->
+ The macros defined are NULL (described in <a href="#7.19">7.19</a>); WCHAR_MIN and WCHAR_MAX
+ (described in <a href="#7.20.3">7.20.3</a>); and
+<pre>
+          WEOF</pre>
+ which expands to a constant expression of type wint_t whose value does not
+ correspond to any member of the extended character set.<sup><a href="#note315"><b>315)</b></a></sup> It is accepted (and returned)
+ by several functions in this subclause to indicate end-of-file, that is, no more input from a
+ stream. It is also used as a wide character value that does not correspond to any member
+ of the extended character set.
+<p><!--para 4-->
+ The functions declared are grouped as follows:
+<ul>
+<li>  Functions that perform input and output of wide characters, or multibyte characters,
+ or both;
+<li>  Functions that provide wide string numeric conversion;
+<li>  Functions that perform general wide string manipulation;
+ 
+ 
+<!--page 418 indent 4-->
+<li>  Functions for wide string date and time conversion; and
+<li>  Functions that provide extended capabilities for conversion between multibyte and
+ wide character sequences.
+</ul>
+<p><!--para 5-->
+ Unless explicitly stated otherwise, if the execution of a function described in this
+ subclause causes copying to take place between objects that overlap, the behavior is
+ undefined.
+
+<h6>footnotes</h6>
+<p><a name="note313">313)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+
+<p><a name="note314">314)</a> wchar_t and wint_t can be the same integer type.
+
+<p><a name="note315">315)</a> The value of the macro WEOF may differ from that of EOF and need not be negative.
+
+
+<a name="7.28.2" href="#7.28.2"><h4>7.28.2 Formatted wide character input/output functions</h4></a>
+<p><!--para 1-->
+ The formatted wide character input/output functions shall behave as if there is a sequence
+ point after the actions associated with each specifier.<sup><a href="#note316"><b>316)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note316">316)</a> The fwprintf functions perform writes to memory for the %n specifier.
+
+
+<a name="7.28.2.1" href="#7.28.2.1"><h5>7.28.2.1 The fwprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int fwprintf(FILE * restrict stream,
+              const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwprintf function writes output to the stream pointed to by stream, under
+ control of the wide string pointed to by format that specifies how subsequent arguments
+ are converted for output. If there are insufficient arguments for the format, the behavior
+ is undefined. If the format is exhausted while arguments remain, the excess arguments
+ are evaluated (as always) but are otherwise ignored. The fwprintf function returns
+ when the end of the format string is encountered.
+<p><!--para 3-->
+ The format is composed of zero or more directives: ordinary wide characters (not %),
+ which are copied unchanged to the output stream; and conversion specifications, each of
+ which results in fetching zero or more subsequent arguments, converting them, if
+ applicable, according to the corresponding conversion specifier, and then writing the
+ result to the output stream.
+<p><!--para 4-->
+ Each conversion specification is introduced by the wide character %. After the %, the
+ following appear in sequence:
+<ul>
+<li>  Zero or more flags (in any order) that modify the meaning of the conversion
+ specification.
+<li>  An optional minimum field width. If the converted value has fewer wide characters
+ than the field width, it is padded with spaces (by default) on the left (or right, if the
+ 
+ 
+<!--page 419 indent 4-->
+   left adjustment flag, described later, has been given) to the field width. The field
+   width takes the form of an asterisk * (described later) or a nonnegative decimal
+   integer.<sup><a href="#note317"><b>317)</b></a></sup>
+<li>  An optional precision that gives the minimum number of digits to appear for the d, i,
+ o, u, x, and X conversions, the number of digits to appear after the decimal-point
+ wide character for a, A, e, E, f, and F conversions, the maximum number of
+ significant digits for the g and G conversions, or the maximum number of wide
+ characters to be written for s conversions. The precision takes the form of a period
+ (.) followed either by an asterisk * (described later) or by an optional decimal
+ integer; if only the period is specified, the precision is taken as zero. If a precision
+ appears with any other conversion specifier, the behavior is undefined.
+<li>  An optional length modifier that specifies the size of the argument.
+<li>  A conversion specifier wide character that specifies the type of conversion to be
+ applied.
+</ul>
+<p><!--para 5-->
+ As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+ this case, an int argument supplies the field width or precision. The arguments
+ specifying field width, or precision, or both, shall appear (in that order) before the
+ argument (if any) to be converted. A negative field width argument is taken as a - flag
+ followed by a positive field width. A negative precision argument is taken as if the
+ precision were omitted.
+<p><!--para 6-->
+ The flag wide characters and their meanings are:
+ -        The result of the conversion is left-justified within the field. (It is right-justified if
+<pre>
+          this flag is not specified.)</pre>
+ +        The result of a signed conversion always begins with a plus or minus sign. (It
+<pre>
+          begins with a sign only when a negative value is converted if this flag is not
+          specified.)<sup><a href="#note318"><b>318)</b></a></sup></pre>
+ space If the first wide character of a signed conversion is not a sign, or if a signed
+<pre>
+       conversion results in no wide characters, a space is prefixed to the result. If the
+       space and + flags both appear, the space flag is ignored.</pre>
+ #        The result is converted to an ''alternative form''. For o conversion, it increases
+<pre>
+          the precision, if and only if necessary, to force the first digit of the result to be a
+          zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+          conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,</pre>
+ 
+ 
+<!--page 420 indent 4-->
+<pre>
+           and G conversions, the result of converting a floating-point number always
+           contains a decimal-point wide character, even if no digits follow it. (Normally, a
+           decimal-point wide character appears in the result of these conversions only if a
+           digit follows it.) For g and G conversions, trailing zeros are not removed from the
+           result. For other conversions, the behavior is undefined.</pre>
+ 0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+<p><!--para 7-->
+<pre>
+           (following any indication of sign or base) are used to pad to the field width rather
+           than performing space padding, except when converting an infinity or NaN. If the
+           0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
+           conversions, if a precision is specified, the 0 flag is ignored. For other
+           conversions, the behavior is undefined.</pre>
+ The length modifiers and their meanings are:
+ hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                signed char or unsigned char argument (the argument will have
+                been promoted according to the integer promotions, but its value shall be
+                converted to signed char or unsigned char before printing); or that
+                a following n conversion specifier applies to a pointer to a signed char
+                argument.</pre>
+ h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                short int or unsigned short int argument (the argument will
+                have been promoted according to the integer promotions, but its value shall
+                be converted to short int or unsigned short int before printing);
+                or that a following n conversion specifier applies to a pointer to a short
+                int argument.</pre>
+ l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+                long int or unsigned long int argument; that a following n
+                conversion specifier applies to a pointer to a long int argument; that a
+                following c conversion specifier applies to a wint_t argument; that a
+                following s conversion specifier applies to a pointer to a wchar_t
+                argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+                specifier.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              long long int or unsigned long long int argument; or that a
+              following n conversion specifier applies to a pointer to a long long int
+              argument.</pre>
+ j              Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+<!--page 421 indent 4-->
+<pre>
+                an intmax_t or uintmax_t argument; or that a following n conversion
+                specifier applies to a pointer to an intmax_t argument.</pre>
+ z            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              size_t or the corresponding signed integer type argument; or that a
+              following n conversion specifier applies to a pointer to a signed integer type
+              corresponding to size_t argument.</pre>
+ t            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+<pre>
+              ptrdiff_t or the corresponding unsigned integer type argument; or that a
+              following n conversion specifier applies to a pointer to a ptrdiff_t
+              argument.</pre>
+ L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+              applies to a long double argument.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 8-->
+ The conversion specifiers and their meanings are:
+ d,i         The int argument is converted to signed decimal in the style [-]dddd. The
+<pre>
+             precision specifies the minimum number of digits to appear; if the value
+             being converted can be represented in fewer digits, it is expanded with
+             leading zeros. The default precision is 1. The result of converting a zero
+             value with a precision of zero is no wide characters.</pre>
+ o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+<pre>
+         decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+         letters abcdef are used for x conversion and the letters ABCDEF for X
+         conversion. The precision specifies the minimum number of digits to appear;
+         if the value being converted can be represented in fewer digits, it is expanded
+         with leading zeros. The default precision is 1. The result of converting a
+         zero value with a precision of zero is no wide characters.</pre>
+ f,F         A double argument representing a floating-point number is converted to
+<!--page 422 indent 0-->
+<pre>
+             decimal notation in the style [-]ddd.ddd, where the number of digits after
+             the decimal-point wide character is equal to the precision specification. If the
+             precision is missing, it is taken as 6; if the precision is zero and the # flag is
+             not specified, no decimal-point wide character appears. If a decimal-point
+             wide character appears, at least one digit appears before it. The value is
+             rounded to the appropriate number of digits.
+             A double argument representing an infinity is converted in one of the styles
+             [-]inf or [-]infinity -- which style is implementation-defined. A
+             double argument representing a NaN is converted in one of the styles
+             [-]nan or [-]nan(n-wchar-sequence) -- which style, and the meaning of
+             any n-wchar-sequence, is implementation-defined. The F conversion
+             specifier produces INF, INFINITY, or NAN instead of inf, infinity, or
+              nan, respectively.<sup><a href="#note319"><b>319)</b></a></sup></pre>
+ e,E          A double argument representing a floating-point number is converted in the
+<pre>
+              style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+              argument is nonzero) before the decimal-point wide character and the number
+              of digits after it is equal to the precision; if the precision is missing, it is taken
+              as 6; if the precision is zero and the # flag is not specified, no decimal-point
+              wide character appears. The value is rounded to the appropriate number of
+              digits. The E conversion specifier produces a number with E instead of e
+              introducing the exponent. The exponent always contains at least two digits,
+              and only as many more digits as necessary to represent the exponent. If the
+              value is zero, the exponent is zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.</pre>
+ g,G          A double argument representing a floating-point number is converted in
+<pre>
+              style f or e (or in style F or E in the case of a G conversion specifier),
+              depending on the value converted and the precision. Let P equal the
+              precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+              Then, if a conversion with style E would have an exponent of X:
+              -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+                P - (X + 1).
+              -- otherwise, the conversion is with style e (or E) and precision P - 1.
+              Finally, unless the # flag is used, any trailing zeros are removed from the
+              fractional portion of the result and the decimal-point wide character is
+              removed if there is no fractional portion remaining.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.</pre>
+ a,A          A double argument representing a floating-point number is converted in the
+<pre>
+              style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+              nonzero if the argument is a normalized floating-point number and is
+              otherwise unspecified) before the decimal-point wide character<sup><a href="#note320"><b>320)</b></a></sup> and the
+              number of hexadecimal digits after it is equal to the precision; if the precision
+              is missing and FLT_RADIX is a power of 2, then the precision is sufficient</pre>
+ 
+ 
+<!--page 423 indent 0-->
+<pre>
+              for an exact representation of the value; if the precision is missing and
+              FLT_RADIX is not a power of 2, then the precision is sufficient to
+              distinguish<sup><a href="#note321"><b>321)</b></a></sup> values of type double, except that trailing zeros may be
+              omitted; if the precision is zero and the # flag is not specified, no decimal-
+              point wide character appears. The letters abcdef are used for a conversion
+              and the letters ABCDEF for A conversion. The A conversion specifier
+              produces a number with X and P instead of x and p. The exponent always
+              contains at least one digit, and only as many more digits as necessary to
+              represent the decimal exponent of 2. If the value is zero, the exponent is
+              zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.</pre>
+ c            If no l length modifier is present, the int argument is converted to a wide
+<pre>
+              character as if by calling btowc and the resulting wide character is written.
+              If an l length modifier is present, the wint_t argument is converted to
+              wchar_t and written.</pre>
+ s            If no l length modifier is present, the argument shall be a pointer to the initial
+<pre>
+              element of a character array containing a multibyte character sequence
+              beginning in the initial shift state. Characters from the array are converted as
+              if by repeated calls to the mbrtowc function, with the conversion state
+              described by an mbstate_t object initialized to zero before the first
+              multibyte character is converted, and written up to (but not including) the
+              terminating null wide character. If the precision is specified, no more than
+              that many wide characters are written. If the precision is not specified or is
+              greater than the size of the converted array, the converted array shall contain a
+              null wide character.
+              If an l length modifier is present, the argument shall be a pointer to the initial
+              element of an array of wchar_t type. Wide characters from the array are
+              written up to (but not including) a terminating null wide character. If the
+              precision is specified, no more than that many wide characters are written. If
+              the precision is not specified or is greater than the size of the array, the array
+              shall contain a null wide character.</pre>
+ p            The argument shall be a pointer to void. The value of the pointer is
+<pre>
+              converted to a sequence of printing wide characters, in an implementation-</pre>
+ 
+<!--page 424 indent 5-->
+<pre>
+                defined manner.</pre>
+ n              The argument shall be a pointer to signed integer into which is written the
+<pre>
+                number of wide characters written to the output stream so far by this call to
+                fwprintf. No argument is converted, but one is consumed. If the
+                conversion specification includes any flags, a field width, or a precision, the
+                behavior is undefined.</pre>
+ %              A % wide character is written. No argument is converted. The complete
+<p><!--para 9-->
+<pre>
+                conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note322"><b>322)</b></a></sup> If any argument is
+ not the correct type for the corresponding conversion specification, the behavior is
+ undefined.
+<p><!--para 10-->
+ In no case does a nonexistent or small field width cause truncation of a field; if the result
+ of a conversion is wider than the field width, the field is expanded to contain the
+ conversion result.
+<p><!--para 11-->
+ For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+ to a hexadecimal floating number with the given precision.
+ Recommended practice
+<p><!--para 12-->
+ For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+ representable in the given precision, the result should be one of the two adjacent numbers
+ in hexadecimal floating style with the given precision, with the extra stipulation that the
+ error should have a correct sign for the current rounding direction.
+<p><!--para 13-->
+ For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+ DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note323"><b>323)</b></a></sup> If the number of
+ significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+ representable with DECIMAL_DIG digits, then the result should be an exact
+ representation with trailing zeros. Otherwise, the source value is bounded by two
+ adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+ of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+ the error should have a correct sign for the current rounding direction.
+<h6>Returns</h6>
+<p><!--para 14-->
+ The fwprintf function returns the number of wide characters transmitted, or a negative
+ value if an output or encoding error occurred.
+ 
+<!--page 425 indent 5-->
+ Environmental limits
+<p><!--para 15-->
+ The number of wide characters that can be produced by any single conversion shall be at
+ least 4095.
+<p><!--para 16-->
+ EXAMPLE       To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+ places:
+<pre>
+         #include &lt;math.h&gt;
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         /* ... */
+         wchar_t *weekday, *month; // pointers to wide strings
+         int day, hour, min;
+         fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
+                 weekday, month, day, hour, min);
+         fwprintf(stdout, L"pi = %.5f\n", 4 * atan(1.0));</pre>
+ 
+ Forward references:          the btowc function (<a href="#7.28.6.1.1">7.28.6.1.1</a>), the mbrtowc function
+ (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note317">317)</a> Note that 0 is taken as a flag, not as the beginning of a field width.
+
+<p><a name="note318">318)</a> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+ include a minus sign.
+
+<p><a name="note319">319)</a> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
+ meaning; the # and 0 flag wide characters have no effect.
+
+<p><a name="note320">320)</a> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
+ character so that subsequent digits align to nibble (4-bit) boundaries.
+
+<p><a name="note321">321)</a> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+ FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+ might suffice depending on the implementation's scheme for determining the digit to the left of the
+ decimal-point wide character.
+
+<p><a name="note322">322)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+
+<p><a name="note323">323)</a> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+ given format specifier. The number of significant digits is determined by the format specifier, and in
+ the case of fixed-point conversion by the source value as well.
+
+
+<a name="7.28.2.2" href="#7.28.2.2"><h5>7.28.2.2 The fwscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int fwscanf(FILE * restrict stream,
+              const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwscanf function reads input from the stream pointed to by stream, under
+ control of the wide string pointed to by format that specifies the admissible input
+ sequences and how they are to be converted for assignment, using subsequent arguments
+ as pointers to the objects to receive the converted input. If there are insufficient
+ arguments for the format, the behavior is undefined. If the format is exhausted while
+ arguments remain, the excess arguments are evaluated (as always) but are otherwise
+ ignored.
+<p><!--para 3-->
+ The format is composed of zero or more directives: one or more white-space wide
+ characters, an ordinary wide character (neither % nor a white-space wide character), or a
+ conversion specification. Each conversion specification is introduced by the wide
+ character %. After the %, the following appear in sequence:
+<ul>
+<li>  An optional assignment-suppressing wide character *.
+<li>  An optional decimal integer greater than zero that specifies the maximum field width
+ (in wide characters).
+<!--page 426 indent 5-->
+<li>  An optional length modifier that specifies the size of the receiving object.
+<li>  A conversion specifier wide character that specifies the type of conversion to be
+ applied.
+</ul>
+<p><!--para 4-->
+ The fwscanf function executes each directive of the format in turn. When all directives
+ have been executed, or if a directive fails (as detailed below), the function returns.
+ Failures are described as input failures (due to the occurrence of an encoding error or the
+ unavailability of input characters), or matching failures (due to inappropriate input).
+<p><!--para 5-->
+ A directive composed of white-space wide character(s) is executed by reading input up to
+ the first non-white-space wide character (which remains unread), or until no more wide
+ characters can be read.
+<p><!--para 6-->
+ A directive that is an ordinary wide character is executed by reading the next wide
+ character of the stream. If that wide character differs from the directive, the directive
+ fails and the differing and subsequent wide characters remain unread. Similarly, if end-
+ of-file, an encoding error, or a read error prevents a wide character from being read, the
+ directive fails.
+<p><!--para 7-->
+ A directive that is a conversion specification defines a set of matching input sequences, as
+ described below for each specifier. A conversion specification is executed in the
+ following steps:
+<p><!--para 8-->
+ Input white-space wide characters (as specified by the iswspace function) are skipped,
+ unless the specification includes a [, c, or n specifier.<sup><a href="#note324"><b>324)</b></a></sup>
+<p><!--para 9-->
+ An input item is read from the stream, unless the specification includes an n specifier. An
+ input item is defined as the longest sequence of input wide characters which does not
+ exceed any specified field width and which is, or is a prefix of, a matching input
+ sequence.<sup><a href="#note325"><b>325)</b></a></sup> The first wide character, if any, after the input item remains unread. If the
+ length of the input item is zero, the execution of the directive fails; this condition is a
+ matching failure unless end-of-file, an encoding error, or a read error prevented input
+ from the stream, in which case it is an input failure.
+<p><!--para 10-->
+ Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+ count of input wide characters) is converted to a type appropriate to the conversion
+ specifier. If the input item is not a matching sequence, the execution of the directive fails:
+ this condition is a matching failure. Unless assignment suppression was indicated by a *,
+ the result of the conversion is placed in the object pointed to by the first argument
+ following the format argument that has not already received a conversion result. If this
+ 
+ 
+<!--page 427 indent 5-->
+ object does not have an appropriate type, or if the result of the conversion cannot be
+ represented in the object, the behavior is undefined.
+<p><!--para 11-->
+ The length modifiers and their meanings are:
+ hh           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to signed char or unsigned char.</pre>
+ h            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to short int or unsigned short
+              int.</pre>
+ l (ell)      Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to long int or unsigned long
+              int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+              an argument with type pointer to double; or that a following c, s, or [
+              conversion specifier applies to an argument with type pointer to wchar_t.</pre>
+ ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to long long int or unsigned
+              long long int.</pre>
+ j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to intmax_t or uintmax_t.</pre>
+ z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to size_t or the corresponding signed
+              integer type.</pre>
+ t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+<pre>
+              to an argument with type pointer to ptrdiff_t or the corresponding
+              unsigned integer type.</pre>
+ L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+<pre>
+              applies to an argument with type pointer to long double.</pre>
+ If a length modifier appears with any conversion specifier other than as specified above,
+ the behavior is undefined.
+<p><!--para 12-->
+ The conversion specifiers and their meanings are:
+ d           Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+             expected for the subject sequence of the wcstol function with the value 10
+             for the base argument. The corresponding argument shall be a pointer to
+             signed integer.</pre>
+ i           Matches an optionally signed integer, whose format is the same as expected
+<!--page 428 indent 0-->
+<pre>
+             for the subject sequence of the wcstol function with the value 0 for the
+             base argument. The corresponding argument shall be a pointer to signed
+           integer.</pre>
+ o         Matches an optionally signed octal integer, whose format is the same as
+<pre>
+           expected for the subject sequence of the wcstoul function with the value 8
+           for the base argument. The corresponding argument shall be a pointer to
+           unsigned integer.</pre>
+ u         Matches an optionally signed decimal integer, whose format is the same as
+<pre>
+           expected for the subject sequence of the wcstoul function with the value 10
+           for the base argument. The corresponding argument shall be a pointer to
+           unsigned integer.</pre>
+ x         Matches an optionally signed hexadecimal integer, whose format is the same
+<pre>
+           as expected for the subject sequence of the wcstoul function with the value
+           16 for the base argument. The corresponding argument shall be a pointer to
+           unsigned integer.</pre>
+ a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+<pre>
+         format is the same as expected for the subject sequence of the wcstod
+         function. The corresponding argument shall be a pointer to floating.</pre>
+ c         Matches a sequence of wide characters of exactly the number specified by the
+<pre>
+           field width (1 if no field width is present in the directive).
+           If no l length modifier is present, characters from the input field are
+           converted as if by repeated calls to the wcrtomb function, with the
+           conversion state described by an mbstate_t object initialized to zero
+           before the first wide character is converted. The corresponding argument
+           shall be a pointer to the initial element of a character array large enough to
+           accept the sequence. No null character is added.
+           If an l length modifier is present, the corresponding argument shall be a
+           pointer to the initial element of an array of wchar_t large enough to accept
+           the sequence. No null wide character is added.</pre>
+ s         Matches a sequence of non-white-space wide characters.
+<!--page 429 indent 0-->
+<pre>
+           If no l length modifier is present, characters from the input field are
+           converted as if by repeated calls to the wcrtomb function, with the
+           conversion state described by an mbstate_t object initialized to zero
+           before the first wide character is converted. The corresponding argument
+           shall be a pointer to the initial element of a character array large enough to
+           accept the sequence and a terminating null character, which will be added
+           automatically.
+           If an l length modifier is present, the corresponding argument shall be a
+           pointer to the initial element of an array of wchar_t large enough to accept
+             the sequence and the terminating null wide character, which will be added
+             automatically.</pre>
+ [           Matches a nonempty sequence of wide characters from a set of expected
+<pre>
+             characters (the scanset).
+             If no l length modifier is present, characters from the input field are
+             converted as if by repeated calls to the wcrtomb function, with the
+             conversion state described by an mbstate_t object initialized to zero
+             before the first wide character is converted. The corresponding argument
+             shall be a pointer to the initial element of a character array large enough to
+             accept the sequence and a terminating null character, which will be added
+             automatically.
+             If an l length modifier is present, the corresponding argument shall be a
+             pointer to the initial element of an array of wchar_t large enough to accept
+             the sequence and the terminating null wide character, which will be added
+             automatically.
+             The conversion specifier includes all subsequent wide characters in the
+             format string, up to and including the matching right bracket (]). The wide
+             characters between the brackets (the scanlist) compose the scanset, unless the
+             wide character after the left bracket is a circumflex (^), in which case the
+             scanset contains all wide characters that do not appear in the scanlist between
+             the circumflex and the right bracket. If the conversion specifier begins with
+             [] or [^], the right bracket wide character is in the scanlist and the next
+             following right bracket wide character is the matching right bracket that ends
+             the specification; otherwise the first following right bracket wide character is
+             the one that ends the specification. If a - wide character is in the scanlist and
+             is not the first, nor the second where the first wide character is a ^, nor the
+             last character, the behavior is implementation-defined.</pre>
+ p           Matches an implementation-defined set of sequences, which should be the
+<pre>
+             same as the set of sequences that may be produced by the %p conversion of
+             the fwprintf function. The corresponding argument shall be a pointer to a
+             pointer to void. The input item is converted to a pointer value in an
+             implementation-defined manner. If the input item is a value converted earlier
+             during the same program execution, the pointer that results shall compare
+             equal to that value; otherwise the behavior of the %p conversion is undefined.</pre>
+ n           No input is consumed. The corresponding argument shall be a pointer to
+<!--page 430 indent 5-->
+<pre>
+             signed integer into which is to be written the number of wide characters read
+             from the input stream so far by this call to the fwscanf function. Execution
+             of a %n directive does not increment the assignment count returned at the
+             completion of execution of the fwscanf function. No argument is
+                converted, but one is consumed. If the conversion specification includes an
+                assignment-suppressing wide character or a field width, the behavior is
+                undefined.</pre>
+ %              Matches a single % wide character; no conversion or assignment occurs. The
+<p><!--para 13-->
+<pre>
+                complete conversion specification shall be %%.</pre>
+ If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note326"><b>326)</b></a></sup>
+<p><!--para 14-->
+ The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+ respectively, a, e, f, g, and x.
+<p><!--para 15-->
+ Trailing white space (including new-line wide characters) is left unread unless matched
+ by a directive. The success of literal matches and suppressed assignments is not directly
+ determinable other than via the %n directive.
+<h6>Returns</h6>
+<p><!--para 16-->
+ The fwscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the function returns the
+ number of input items assigned, which can be fewer than provided for, or even zero, in
+ the event of an early matching failure.
+<p><!--para 17-->
+ EXAMPLE 1        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          #include &lt;wchar.h&gt;
+          /* ... */
+          int n, i; float x; wchar_t name[50];
+          n = fwscanf(stdin, L"%d%f%ls", &amp;i, &amp;x, name);</pre>
+ with the input line:
+<pre>
+          25 54.32E-1 thompson</pre>
+ will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+ thompson\0.
+ 
+<p><!--para 18-->
+ EXAMPLE 2        The call:
+<pre>
+          #include &lt;stdio.h&gt;
+          #include &lt;wchar.h&gt;
+          /* ... */
+          int i; float x; double y;
+          fwscanf(stdin, L"%2d%f%*d %lf", &amp;i, &amp;x, &amp;y);</pre>
+ with input:
+<pre>
+          56789 0123 56a72</pre>
+ will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
+ 56.0. The next wide character read from the input stream will be a.
+ 
+ 
+<!--page 431 indent 4-->
+ Forward references: the wcstod, wcstof, and wcstold functions (<a href="#7.28.4.1.1">7.28.4.1.1</a>), the
+ wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.28.4.1.2">7.28.4.1.2</a>), the wcrtomb
+ function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+
+<h6>footnotes</h6>
+<p><a name="note324">324)</a> These white-space wide characters are not counted against a specified field width.
+
+<p><a name="note325">325)</a> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
+ sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
+
+<p><a name="note326">326)</a> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+
+
+<a name="7.28.2.3" href="#7.28.2.3"><h5>7.28.2.3 The swprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int swprintf(wchar_t * restrict s,
+              size_t n,
+              const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The swprintf function is equivalent to fwprintf, except that the argument s
+ specifies an array of wide characters into which the generated output is to be written,
+ rather than written to a stream. No more than n wide characters are written, including a
+ terminating null wide character, which is always added (unless n is zero).
+<h6>Returns</h6>
+<p><!--para 3-->
+ The swprintf function returns the number of wide characters written in the array, not
+ counting the terminating null wide character, or a negative value if an encoding error
+ occurred or if n or more wide characters were requested to be written.
+
+<a name="7.28.2.4" href="#7.28.2.4"><h5>7.28.2.4 The swscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int swscanf(const wchar_t * restrict s,
+              const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The swscanf function is equivalent to fwscanf, except that the argument s specifies a
+ wide string from which the input is to be obtained, rather than from a stream. Reaching
+ the end of the wide string is equivalent to encountering end-of-file for the fwscanf
+ function.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The swscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the swscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+<!--page 432 indent 4-->
+
+<a name="7.28.2.5" href="#7.28.2.5"><h5>7.28.2.5 The vfwprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
         int vfwprintf(FILE * restrict stream,
-             const wchar_t * restrict format, va_list arg);
-        int vfwscanf(FILE * restrict stream,
-             const wchar_t * restrict format, va_list arg);
-        int vswprintf(wchar_t * restrict s, size_t n,
-             const wchar_t * restrict format, va_list arg);
-
-[<a name="p493" href="#p493">page 493</a>] (<a href="#Contents">Contents</a>)
-
-      int vswscanf(const wchar_t * restrict s,
-           const wchar_t * restrict format, va_list arg);
-      int vwprintf(const wchar_t * restrict format,
-           va_list arg);
-      int vwscanf(const wchar_t * restrict format,
-           va_list arg);
-      int wprintf(const wchar_t * restrict format, ...);
-      int wscanf(const wchar_t * restrict format, ...);
-      wint_t fgetwc(FILE *stream);
-      wchar_t *fgetws(wchar_t * restrict s, int n,
-           FILE * restrict stream);
-      wint_t fputwc(wchar_t c, FILE *stream);
-      int fputws(const wchar_t * restrict s,
-           FILE * restrict stream);
-      int fwide(FILE *stream, int mode);
-      wint_t getwc(FILE *stream);
-      wint_t getwchar(void);
-      wint_t putwc(wchar_t c, FILE *stream);
-      wint_t putwchar(wchar_t c);
-      wint_t ungetwc(wint_t c, FILE *stream);
-      double wcstod(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr);
-      float wcstof(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr);
-      long double wcstold(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr);
-      long int wcstol(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      long long int wcstoll(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      unsigned long int wcstoul(const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      unsigned long long int wcstoull(
-           const wchar_t * restrict nptr,
-           wchar_t ** restrict endptr, int base);
-      wchar_t *wcscpy(wchar_t * restrict s1,
-           const wchar_t * restrict s2);
-      wchar_t *wcsncpy(wchar_t * restrict s1,
-           const wchar_t * restrict s2, size_t n);
-
-[<a name="p494" href="#p494">page 494</a>] (<a href="#Contents">Contents</a>)
-
-        wchar_t *wmemcpy(wchar_t * restrict s1,
-             const wchar_t * restrict s2, size_t n);
-        wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
-             size_t n);
-        wchar_t *wcscat(wchar_t * restrict s1,
-             const wchar_t * restrict s2);
-        wchar_t *wcsncat(wchar_t * restrict s1,
-             const wchar_t * restrict s2, size_t n);
-        int wcscmp(const wchar_t *s1, const wchar_t *s2);
-        int wcscoll(const wchar_t *s1, const wchar_t *s2);
-        int wcsncmp(const wchar_t *s1, const wchar_t *s2,
-             size_t n);
-        size_t wcsxfrm(wchar_t * restrict s1,
-             const wchar_t * restrict s2, size_t n);
+             const wchar_t * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfwprintf function is equivalent to fwprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfwprintf function does not invoke the
+ va_end macro.<sup><a href="#note327"><b>327)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfwprintf function returns the number of wide characters transmitted, or a
+ negative value if an output or encoding error occurred.
+<p><!--para 4-->
+ EXAMPLE       The following shows the use of the vfwprintf function in a general error-reporting
+ routine.
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        #include &lt;wchar.h&gt;
+        void error(char *function_name, wchar_t *format, ...)
+        {
+              va_list args;
+                 va_start(args, format);
+                 // print out name of function causing error
+                 fwprintf(stderr, L"ERROR in %s: ", function_name);
+                 // print out remainder of message
+                 vfwprintf(stderr, format, args);
+                 va_end(args);
+        }</pre>
+ 
+ 
+ 
+ 
+<!--page 433 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note327">327)</a> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
+ invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+
+<a name="7.28.2.6" href="#7.28.2.6"><h5>7.28.2.6 The vfwscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int vfwscanf(FILE * restrict stream,
+              const wchar_t * restrict format,
+              va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vfwscanf function is equivalent to fwscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfwscanf function does not invoke the
+ va_end macro.327)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vfwscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the vfwscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.28.2.7" href="#7.28.2.7"><h5>7.28.2.7 The vswprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;wchar.h&gt;
+         int vswprintf(wchar_t * restrict s,
+              size_t n,
+              const wchar_t * restrict format,
+              va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vswprintf function is equivalent to swprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vswprintf function does not invoke the
+ va_end macro.327)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vswprintf function returns the number of wide characters written in the array, not
+ counting the terminating null wide character, or a negative value if an encoding error
+ occurred or if n or more wide characters were requested to be generated.
+<!--page 434 indent 4-->
+
+<a name="7.28.2.8" href="#7.28.2.8"><h5>7.28.2.8 The vswscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;wchar.h&gt;
+        int vswscanf(const wchar_t * restrict s,
+             const wchar_t * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vswscanf function is equivalent to swscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vswscanf function does not invoke the
+ va_end macro.327)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vswscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the vswscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.28.2.9" href="#7.28.2.9"><h5>7.28.2.9 The vwprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;stdarg.h&gt;
+        #include &lt;wchar.h&gt;
+        int vwprintf(const wchar_t * restrict format,
+             va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vwprintf function is equivalent to wprintf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vwprintf function does not invoke the
+ va_end macro.327)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vwprintf function returns the number of wide characters transmitted, or a negative
+ value if an output or encoding error occurred.
+<!--page 435 indent 4-->
+
+<a name="7.28.2.10" href="#7.28.2.10"><h5>7.28.2.10 The vwscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdarg.h&gt;
+         #include &lt;wchar.h&gt;
+         int vwscanf(const wchar_t * restrict format,
+              va_list arg);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The vwscanf function is equivalent to wscanf, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vwscanf function does not invoke the
+ va_end macro.327)
+<h6>Returns</h6>
+<p><!--para 3-->
+ The vwscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the vwscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.28.2.11" href="#7.28.2.11"><h5>7.28.2.11 The wprintf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int wprintf(const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wprintf function is equivalent to fwprintf with the argument stdout
+ interposed before the arguments to wprintf.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wprintf function returns the number of wide characters transmitted, or a negative
+ value if an output or encoding error occurred.
+
+<a name="7.28.2.12" href="#7.28.2.12"><h5>7.28.2.12 The wscanf function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int wscanf(const wchar_t * restrict format, ...);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wscanf function is equivalent to fwscanf with the argument stdin interposed
+ before the arguments to wscanf.
+<!--page 436 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wscanf function returns the value of the macro EOF if an input failure occurs
+ before the first conversion (if any) has completed. Otherwise, the wscanf function
+ returns the number of input items assigned, which can be fewer than provided for, or even
+ zero, in the event of an early matching failure.
+
+<a name="7.28.3" href="#7.28.3"><h4>7.28.3 Wide character input/output functions</h4></a>
+
+<a name="7.28.3.1" href="#7.28.3.1"><h5>7.28.3.1 The fgetwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wint_t fgetwc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If the end-of-file indicator for the input stream pointed to by stream is not set and a
+ next wide character is present, the fgetwc function obtains that wide character as a
+ wchar_t converted to a wint_t and advances the associated file position indicator for
+ the stream (if defined).
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+ of-file indicator for the stream is set and the fgetwc function returns WEOF. Otherwise,
+ the fgetwc function returns the next wide character from the input stream pointed to by
+ stream. If a read error occurs, the error indicator for the stream is set and the fgetwc
+ function returns WEOF. If an encoding error occurs (including too few bytes), the value of
+ the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note328"><b>328)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note328">328)</a> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+ Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
+
+
+<a name="7.28.3.2" href="#7.28.3.2"><h5>7.28.3.2 The fgetws function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wchar_t *fgetws(wchar_t * restrict s,
+              int n, FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fgetws function reads at most one less than the number of wide characters
+ specified by n from the stream pointed to by stream into the array pointed to by s. No
+ 
+ 
+<!--page 437 indent 4-->
+ additional wide characters are read after a new-line wide character (which is retained) or
+ after end-of-file. A null wide character is written immediately after the last wide
+ character read into the array.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fgetws function returns s if successful. If end-of-file is encountered and no
+ characters have been read into the array, the contents of the array remain unchanged and a
+ null pointer is returned. If a read or encoding error occurs during the operation, the array
+ contents are indeterminate and a null pointer is returned.
+
+<a name="7.28.3.3" href="#7.28.3.3"><h5>7.28.3.3 The fputwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wint_t fputwc(wchar_t c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputwc function writes the wide character specified by c to the output stream
+ pointed to by stream, at the position indicated by the associated file position indicator
+ for the stream (if defined), and advances the indicator appropriately. If the file cannot
+ support positioning requests, or if the stream was opened with append mode, the
+ character is appended to the output stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputwc function returns the wide character written. If a write error occurs, the
+ error indicator for the stream is set and fputwc returns WEOF. If an encoding error
+ occurs, the value of the macro EILSEQ is stored in errno and fputwc returns WEOF.
+
+<a name="7.28.3.4" href="#7.28.3.4"><h5>7.28.3.4 The fputws function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int fputws(const wchar_t * restrict s,
+              FILE * restrict stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fputws function writes the wide string pointed to by s to the stream pointed to by
+ stream. The terminating null wide character is not written.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fputws function returns EOF if a write or encoding error occurs; otherwise, it
+ returns a nonnegative value.
+<!--page 438 indent 4-->
+
+<a name="7.28.3.5" href="#7.28.3.5"><h5>7.28.3.5 The fwide function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int fwide(FILE *stream, int mode);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The fwide function determines the orientation of the stream pointed to by stream. If
+ mode is greater than zero, the function first attempts to make the stream wide oriented. If
+ mode is less than zero, the function first attempts to make the stream byte oriented.<sup><a href="#note329"><b>329)</b></a></sup>
+ Otherwise, mode is zero and the function does not alter the orientation of the stream.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The fwide function returns a value greater than zero if, after the call, the stream has
+ wide orientation, a value less than zero if the stream has byte orientation, or zero if the
+ stream has no orientation.
+
+<h6>footnotes</h6>
+<p><a name="note329">329)</a> If the orientation of the stream has already been determined, fwide does not change it.
+
+
+<a name="7.28.3.6" href="#7.28.3.6"><h5>7.28.3.6 The getwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wint_t getwc(FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The getwc function is equivalent to fgetwc, except that if it is implemented as a
+ macro, it may evaluate stream more than once, so the argument should never be an
+ expression with side effects.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getwc function returns the next wide character from the input stream pointed to by
+ stream, or WEOF.
+
+<a name="7.28.3.7" href="#7.28.3.7"><h5>7.28.3.7 The getwchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wint_t getwchar(void);</pre>
+ 
+ 
+ 
+ 
+<!--page 439 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The getwchar function is equivalent to getwc with the argument stdin.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The getwchar function returns the next wide character from the input stream pointed to
+ by stdin, or WEOF.
+
+<a name="7.28.3.8" href="#7.28.3.8"><h5>7.28.3.8 The putwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wint_t putwc(wchar_t c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putwc function is equivalent to fputwc, except that if it is implemented as a
+ macro, it may evaluate stream more than once, so that argument should never be an
+ expression with side effects.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putwc function returns the wide character written, or WEOF.
+
+<a name="7.28.3.9" href="#7.28.3.9"><h5>7.28.3.9 The putwchar function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wint_t putwchar(wchar_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The putwchar function is equivalent to putwc with the second argument stdout.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The putwchar function returns the character written, or WEOF.
+
+<a name="7.28.3.10" href="#7.28.3.10"><h5>7.28.3.10 The ungetwc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         wint_t ungetwc(wint_t c, FILE *stream);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The ungetwc function pushes the wide character specified by c back onto the input
+ stream pointed to by stream. Pushed-back wide characters will be returned by
+ subsequent reads on that stream in the reverse order of their pushing. A successful
+<!--page 440 indent 4-->
+ intervening call (with the stream pointed to by stream) to a file positioning function
+ (fseek, fsetpos, or rewind) discards any pushed-back wide characters for the
+ stream. The external storage corresponding to the stream is unchanged.
+<p><!--para 3-->
+ One wide character of pushback is guaranteed, even if the call to the ungetwc function
+ follows just after a call to a formatted wide character input function fwscanf,
+ vfwscanf, vwscanf, or wscanf. If the ungetwc function is called too many times
+ on the same stream without an intervening read or file positioning operation on that
+ stream, the operation may fail.
+<p><!--para 4-->
+ If the value of c equals that of the macro WEOF, the operation fails and the input stream is
+ unchanged.
+<p><!--para 5-->
+ A successful call to the ungetwc function clears the end-of-file indicator for the stream.
+ The value of the file position indicator for the stream after reading or discarding all
+ pushed-back wide characters is the same as it was before the wide characters were pushed
+ back. For a text or binary stream, the value of its file position indicator after a successful
+ call to the ungetwc function is unspecified until all pushed-back wide characters are
+ read or discarded.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The ungetwc function returns the wide character pushed back, or WEOF if the operation
+ fails.
+
+<a name="7.28.4" href="#7.28.4"><h4>7.28.4 General wide string utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wchar.h&gt; declares a number of functions useful for wide string
+ manipulation. Various methods are used for determining the lengths of the arrays, but in
+ all cases a wchar_t * argument points to the initial (lowest addressed) element of the
+ array. If an array is accessed beyond the end of an object, the behavior is undefined.
+<p><!--para 2-->
+ Where an argument declared as size_t n determines the length of the array for a
+ function, n can have the value zero on a call to that function. Unless explicitly stated
+ otherwise in the description of a particular function in this subclause, pointer arguments
+ on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+ function that locates a wide character finds no occurrence, a function that compares two
+ wide character sequences returns zero, and a function that copies wide characters copies
+ zero wide characters.
+<!--page 441 indent 4-->
+
+<a name="7.28.4.1" href="#7.28.4.1"><h5>7.28.4.1 Wide string numeric conversion functions</h5></a>
+
+<a name="7.28.4.1.1" href="#7.28.4.1.1"><h5>7.28.4.1.1 The wcstod, wcstof, and wcstold functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         double wcstod(const wchar_t * restrict nptr,
+              wchar_t ** restrict endptr);
+         float wcstof(const wchar_t * restrict nptr,
+              wchar_t ** restrict endptr);
+         long double wcstold(const wchar_t * restrict nptr,
+              wchar_t ** restrict endptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstod, wcstof, and wcstold functions convert the initial portion of the wide
+ string pointed to by nptr to double, float, and long double representation,
+ respectively. First, they decompose the input string into three parts: an initial, possibly
+ empty, sequence of white-space wide characters (as specified by the iswspace
+ function), a subject sequence resembling a floating-point constant or representing an
+ infinity or NaN; and a final wide string of one or more unrecognized wide characters,
+ including the terminating null wide character of the input wide string. Then, they attempt
+ to convert the subject sequence to a floating-point number, and return the result.
+<p><!--para 3-->
+ The expected form of the subject sequence is an optional plus or minus sign, then one of
+ the following:
+<ul>
+<li>  a nonempty sequence of decimal digits optionally containing a decimal-point wide
+ character, then an optional exponent part as defined for the corresponding single-byte
+ characters in <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+ decimal-point wide character, then an optional binary exponent part as defined in
+ <a href="#6.4.4.2">6.4.4.2</a>;
+<li>  INF or INFINITY, or any other wide string equivalent except for case
+<li>  NAN or NAN(n-wchar-sequenceopt), or any other wide string equivalent except for
+ case in the NAN part, where:
+<pre>
+          n-wchar-sequence:
+                digit
+                nondigit
+                n-wchar-sequence digit
+                n-wchar-sequence nondigit</pre>
+</ul>
+ The subject sequence is defined as the longest initial subsequence of the input wide
+ string, starting with the first non-white-space wide character, that is of the expected form.
+<!--page 442 indent 4-->
+ The subject sequence contains no wide characters if the input wide string is not of the
+ expected form.
+<p><!--para 4-->
+ If the subject sequence has the expected form for a floating-point number, the sequence of
+ wide characters starting with the first digit or the decimal-point wide character
+ (whichever occurs first) is interpreted as a floating constant according to the rules of
+ <a href="#6.4.4.2">6.4.4.2</a>, except that the decimal-point wide character is used in place of a period, and that
+ if neither an exponent part nor a decimal-point wide character appears in a decimal
+ floating point number, or if a binary exponent part does not appear in a hexadecimal
+ floating point number, an exponent part of the appropriate type with value zero is
+ assumed to follow the last digit in the string. If the subject sequence begins with a minus
+ sign, the sequence is interpreted as negated.<sup><a href="#note330"><b>330)</b></a></sup> A wide character sequence INF or
+ INFINITY is interpreted as an infinity, if representable in the return type, else like a
+ floating constant that is too large for the range of the return type. A wide character
+ sequence NAN or NAN(n-wchar-sequenceopt) is interpreted as a quiet NaN, if supported
+ in the return type, else like a subject sequence part that does not have the expected form;
+ the meaning of the n-wchar sequences is implementation-defined.<sup><a href="#note331"><b>331)</b></a></sup> A pointer to the
+ final wide string is stored in the object pointed to by endptr, provided that endptr is
+ not a null pointer.
+<p><!--para 5-->
+ If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+ value resulting from the conversion is correctly rounded.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+ Recommended practice
+<p><!--para 8-->
+ If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+ the result is not exactly representable, the result should be one of the two numbers in the
+ appropriate internal format that are adjacent to the hexadecimal floating source value,
+ with the extra stipulation that the error should have a correct sign for the current rounding
+ direction.
+ 
+ 
+ 
+<!--page 443 indent 5-->
+<p><!--para 9-->
+ If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+ &lt;float.h&gt;) significant digits, the result should be correctly rounded. If the subject
+ sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+ consider the two bounding, adjacent decimal strings L and U, both having
+ DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+ The result should be one of the (equal or adjacent) values that would be obtained by
+ correctly rounding L and U according to the current rounding direction, with the extra
+ stipulation that the error with respect to D should have a correct sign for the current
+ rounding direction.<sup><a href="#note332"><b>332)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 10-->
+ The functions return the converted value, if any. If no conversion could be performed,
+ zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
+ plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
+ return type and sign of the value), and the value of the macro ERANGE is stored in
+ errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
+ no greater than the smallest normalized positive number in the return type; whether
+ errno acquires the value ERANGE is implementation-defined.
+ 
+ 
+ 
+ 
+<!--page 444 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note330">330)</a> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+ negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+ methods may yield different results if rounding is toward positive or negative infinity. In either case,
+ the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+
+<p><a name="note331">331)</a> An implementation may use the n-wchar sequence to determine extra information to be represented in
+ the NaN's significand.
+
+<p><a name="note332">332)</a> DECIMAL_DIG, defined in &lt;float.h&gt;, should be sufficiently large that L and U will usually round
+ to the same internal floating value, but if not will round to adjacent values.
+
+
+<a name="7.28.4.1.2" href="#7.28.4.1.2"><h5>7.28.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        long int wcstol(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);
+        long long int wcstoll(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);
+        unsigned long int wcstoul(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);
+        unsigned long long int wcstoull(
+             const wchar_t * restrict nptr,
+             wchar_t ** restrict endptr,
+             int base);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
+ portion of the wide string pointed to by nptr to long int, long long int,
+ unsigned long int, and unsigned long long int representation,
+ respectively. First, they decompose the input string into three parts: an initial, possibly
+ empty, sequence of white-space wide characters (as specified by the iswspace
+ function), a subject sequence resembling an integer represented in some radix determined
+ by the value of base, and a final wide string of one or more unrecognized wide
+ characters, including the terminating null wide character of the input wide string. Then,
+ they attempt to convert the subject sequence to an integer, and return the result.
+<p><!--para 3-->
+ If the value of base is zero, the expected form of the subject sequence is that of an
+ integer constant as described for the corresponding single-byte characters in <a href="#6.4.4.1">6.4.4.1</a>,
+ optionally preceded by a plus or minus sign, but not including an integer suffix. If the
+ value of base is between 2 and 36 (inclusive), the expected form of the subject sequence
+ is a sequence of letters and digits representing an integer with the radix specified by
+ base, optionally preceded by a plus or minus sign, but not including an integer suffix.
+ The letters from a (or A) through z (or Z) are ascribed the values 10 through 35; only
+ letters and digits whose ascribed values are less than that of base are permitted. If the
+ value of base is 16, the wide characters 0x or 0X may optionally precede the sequence
+ of letters and digits, following the sign if present.
+<!--page 445 indent 4-->
+<p><!--para 4-->
+ The subject sequence is defined as the longest initial subsequence of the input wide
+ string, starting with the first non-white-space wide character, that is of the expected form.
+ The subject sequence contains no wide characters if the input wide string is empty or
+ consists entirely of white space, or if the first non-white-space wide character is other
+ than a sign or a permissible letter or digit.
+<p><!--para 5-->
+ If the subject sequence has the expected form and the value of base is zero, the sequence
+ of wide characters starting with the first digit is interpreted as an integer constant
+ according to the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the
+ value of base is between 2 and 36, it is used as the base for conversion, ascribing to each
+ letter its value as given above. If the subject sequence begins with a minus sign, the value
+ resulting from the conversion is negated (in the return type). A pointer to the final wide
+ string is stored in the object pointed to by endptr, provided that endptr is not a null
+ pointer.
+<p><!--para 6-->
+ In other than the "C" locale, additional locale-specific subject sequence forms may be
+ accepted.
+<p><!--para 7-->
+ If the subject sequence is empty or does not have the expected form, no conversion is
+ performed; the value of nptr is stored in the object pointed to by endptr, provided
+ that endptr is not a null pointer.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The wcstol, wcstoll, wcstoul, and wcstoull functions return the converted
+ value, if any. If no conversion could be performed, zero is returned. If the correct value
+ is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+ LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+ sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+
+<a name="7.28.4.2" href="#7.28.4.2"><h5>7.28.4.2 Wide string copying functions</h5></a>
+
+<a name="7.28.4.2.1" href="#7.28.4.2.1"><h5>7.28.4.2.1 The wcscpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wchar_t *wcscpy(wchar_t * restrict s1,
+              const wchar_t * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscpy function copies the wide string pointed to by s2 (including the terminating
+ null wide character) into the array pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscpy function returns the value of s1.
+<!--page 446 indent 4-->
+
+<a name="7.28.4.2.2" href="#7.28.4.2.2"><h5>7.28.4.2.2 The wcsncpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;wchar.h&gt;
+          wchar_t *wcsncpy(wchar_t * restrict s1,
+               const wchar_t * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsncpy function copies not more than n wide characters (those that follow a null
+ wide character are not copied) from the array pointed to by s2 to the array pointed to by
+ s1.<sup><a href="#note333"><b>333)</b></a></sup>
+<p><!--para 3-->
+ If the array pointed to by s2 is a wide string that is shorter than n wide characters, null
+ wide characters are appended to the copy in the array pointed to by s1, until n wide
+ characters in all have been written.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The wcsncpy function returns the value of s1.
+
+<h6>footnotes</h6>
+<p><a name="note333">333)</a> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
+ result will not be null-terminated.
+
+
+<a name="7.28.4.2.3" href="#7.28.4.2.3"><h5>7.28.4.2.3 The wmemcpy function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;wchar.h&gt;
+          wchar_t *wmemcpy(wchar_t * restrict s1,
+               const wchar_t * restrict s2,
+               size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemcpy function copies n wide characters from the object pointed to by s2 to the
+ object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemcpy function returns the value of s1.
+ 
+ 
+ 
+ 
+<!--page 447 indent 4-->
+
+<a name="7.28.4.2.4" href="#7.28.4.2.4"><h5>7.28.4.2.4 The wmemmove function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+              size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemmove function copies n wide characters from the object pointed to by s2 to
+ the object pointed to by s1. Copying takes place as if the n wide characters from the
+ object pointed to by s2 are first copied into a temporary array of n wide characters that
+ does not overlap the objects pointed to by s1 or s2, and then the n wide characters from
+ the temporary array are copied into the object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemmove function returns the value of s1.
+
+<a name="7.28.4.3" href="#7.28.4.3"><h5>7.28.4.3 Wide string concatenation functions</h5></a>
+
+<a name="7.28.4.3.1" href="#7.28.4.3.1"><h5>7.28.4.3.1 The wcscat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wchar_t *wcscat(wchar_t * restrict s1,
+              const wchar_t * restrict s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscat function appends a copy of the wide string pointed to by s2 (including the
+ terminating null wide character) to the end of the wide string pointed to by s1. The initial
+ wide character of s2 overwrites the null wide character at the end of s1.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscat function returns the value of s1.
+
+<a name="7.28.4.3.2" href="#7.28.4.3.2"><h5>7.28.4.3.2 The wcsncat function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wchar_t *wcsncat(wchar_t * restrict s1,
+              const wchar_t * restrict s2,
+              size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsncat function appends not more than n wide characters (a null wide character
+ and those that follow it are not appended) from the array pointed to by s2 to the end of
+<!--page 448 indent 4-->
+ the wide string pointed to by s1. The initial wide character of s2 overwrites the null
+ wide character at the end of s1. A terminating null wide character is always appended to
+ the result.<sup><a href="#note334"><b>334)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsncat function returns the value of s1.
+
+<h6>footnotes</h6>
+<p><a name="note334">334)</a> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
+ wcslen(s1)+n+1.
+
+
+<a name="7.28.4.4" href="#7.28.4.4"><h5>7.28.4.4 Wide string comparison functions</h5></a>
+<p><!--para 1-->
+ Unless explicitly stated otherwise, the functions described in this subclause order two
+ wide characters the same way as two integers of the underlying integer type designated
+ by wchar_t.
+
+<a name="7.28.4.4.1" href="#7.28.4.4.1"><h5>7.28.4.4.1 The wcscmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int wcscmp(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscmp function compares the wide string pointed to by s1 to the wide string
+ pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+ wide string pointed to by s2.
+
+<a name="7.28.4.4.2" href="#7.28.4.4.2"><h5>7.28.4.4.2 The wcscoll function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int wcscoll(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscoll function compares the wide string pointed to by s1 to the wide string
+ pointed to by s2, both interpreted as appropriate to the LC_COLLATE category of the
+ current locale.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscoll function returns an integer greater than, equal to, or less than zero,
+ accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+ 
+ 
+<!--page 449 indent 4-->
+ wide string pointed to by s2 when both are interpreted as appropriate to the current
+ locale.
+
+<a name="7.28.4.4.3" href="#7.28.4.4.3"><h5>7.28.4.4.3 The wcsncmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+              size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsncmp function compares not more than n wide characters (those that follow a
+ null wide character are not compared) from the array pointed to by s1 to the array
+ pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsncmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+ to, or less than the possibly null-terminated array pointed to by s2.
+
+<a name="7.28.4.4.4" href="#7.28.4.4.4"><h5>7.28.4.4.4 The wcsxfrm function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t wcsxfrm(wchar_t * restrict s1,
+              const wchar_t * restrict s2,
+              size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsxfrm function transforms the wide string pointed to by s2 and places the
+ resulting wide string into the array pointed to by s1. The transformation is such that if
+ the wcscmp function is applied to two transformed wide strings, it returns a value greater
+ than, equal to, or less than zero, corresponding to the result of the wcscoll function
+ applied to the same two original wide strings. No more than n wide characters are placed
+ into the resulting array pointed to by s1, including the terminating null wide character. If
+ n is zero, s1 is permitted to be a null pointer.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsxfrm function returns the length of the transformed wide string (not including
+ the terminating null wide character). If the value returned is n or greater, the contents of
+ the array pointed to by s1 are indeterminate.
+<p><!--para 4-->
+ EXAMPLE The value of the following expression is the length of the array needed to hold the
+ transformation of the wide string pointed to by s:
+<!--page 450 indent 4-->
+<pre>
+        1 + wcsxfrm(NULL, s, 0)</pre>
+ 
+
+<a name="7.28.4.4.5" href="#7.28.4.4.5"><h5>7.28.4.4.5 The wmemcmp function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
         int wmemcmp(const wchar_t *s1, const wchar_t *s2,
-             size_t n);
-        wchar_t *wcschr(const wchar_t *s, wchar_t c);
-        size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
-        wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
-        wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
-        size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
-        wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
+             size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemcmp function compares the first n wide characters of the object pointed to by
+ s1 to the first n wide characters of the object pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemcmp function returns an integer greater than, equal to, or less than zero,
+ accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+ pointed to by s2.
+
+<a name="7.28.4.5" href="#7.28.4.5"><h5>7.28.4.5 Wide string search functions</h5></a>
+
+<a name="7.28.4.5.1" href="#7.28.4.5.1"><h5>7.28.4.5.1 The wcschr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcschr(const wchar_t *s, wchar_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcschr function locates the first occurrence of c in the wide string pointed to by s.
+ The terminating null wide character is considered to be part of the wide string.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcschr function returns a pointer to the located wide character, or a null pointer if
+ the wide character does not occur in the wide string.
+
+<a name="7.28.4.5.2" href="#7.28.4.5.2"><h5>7.28.4.5.2 The wcscspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        size_t wcscspn(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcscspn function computes the length of the maximum initial segment of the wide
+ string pointed to by s1 which consists entirely of wide characters not from the wide
+ string pointed to by s2.
+<!--page 451 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcscspn function returns the length of the segment.
+
+<a name="7.28.4.5.3" href="#7.28.4.5.3"><h5>7.28.4.5.3 The wcspbrk function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcspbrk function locates the first occurrence in the wide string pointed to by s1 of
+ any wide character from the wide string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcspbrk function returns a pointer to the wide character in s1, or a null pointer if
+ no wide character from s2 occurs in s1.
+
+<a name="7.28.4.5.4" href="#7.28.4.5.4"><h5>7.28.4.5.4 The wcsrchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wchar_t *wcsrchr(const wchar_t *s, wchar_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsrchr function locates the last occurrence of c in the wide string pointed to by
+ s. The terminating null wide character is considered to be part of the wide string.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsrchr function returns a pointer to the wide character, or a null pointer if c does
+ not occur in the wide string.
+
+<a name="7.28.4.5.5" href="#7.28.4.5.5"><h5>7.28.4.5.5 The wcsspn function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t wcsspn(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsspn function computes the length of the maximum initial segment of the wide
+ string pointed to by s1 which consists entirely of wide characters from the wide string
+ pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsspn function returns the length of the segment.
+<!--page 452 indent 4-->
+
+<a name="7.28.4.5.6" href="#7.28.4.5.6"><h5>7.28.4.5.6 The wcsstr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsstr function locates the first occurrence in the wide string pointed to by s1 of
+ the sequence of wide characters (excluding the terminating null wide character) in the
+ wide string pointed to by s2.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcsstr function returns a pointer to the located wide string, or a null pointer if the
+ wide string is not found. If s2 points to a wide string with zero length, the function
+ returns s1.
+
+<a name="7.28.4.5.7" href="#7.28.4.5.7"><h5>7.28.4.5.7 The wcstok function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
         wchar_t *wcstok(wchar_t * restrict s1,
              const wchar_t * restrict s2,
-             wchar_t ** restrict ptr);
-        wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
-        size_t wcslen(const wchar_t *s);
-        wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
-        size_t wcsftime(wchar_t * restrict s, size_t maxsize,
+             wchar_t ** restrict ptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A sequence of calls to the wcstok function breaks the wide string pointed to by s1 into
+ a sequence of tokens, each of which is delimited by a wide character from the wide string
+ pointed to by s2. The third argument points to a caller-provided wchar_t pointer into
+ which the wcstok function stores information necessary for it to continue scanning the
+ same wide string.
+<p><!--para 3-->
+ The first call in a sequence has a non-null first argument and stores an initial value in the
+ object pointed to by ptr. Subsequent calls in the sequence have a null first argument and
+ the object pointed to by ptr is required to have the value stored by the previous call in
+ the sequence, which is then updated. The separator wide string pointed to by s2 may be
+ different from call to call.
+<p><!--para 4-->
+ The first call in the sequence searches the wide string pointed to by s1 for the first wide
+ character that is not contained in the current separator wide string pointed to by s2. If no
+ such wide character is found, then there are no tokens in the wide string pointed to by s1
+ and the wcstok function returns a null pointer. If such a wide character is found, it is
+ the start of the first token.
+<p><!--para 5-->
+ The wcstok function then searches from there for a wide character that is contained in
+ the current separator wide string. If no such wide character is found, the current token
+<!--page 453 indent 4-->
+ extends to the end of the wide string pointed to by s1, and subsequent searches in the
+ same wide string for a token return a null pointer. If such a wide character is found, it is
+ overwritten by a null wide character, which terminates the current token.
+<p><!--para 6-->
+ In all cases, the wcstok function stores sufficient information in the pointer pointed to
+ by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+ value for ptr, shall start searching just past the element overwritten by a null wide
+ character (if any).
+<h6>Returns</h6>
+<p><!--para 7-->
+ The wcstok function returns a pointer to the first wide character of a token, or a null
+ pointer if there is no token.
+<p><!--para 8-->
+ EXAMPLE
+<pre>
+         #include &lt;wchar.h&gt;
+         static wchar_t str1[] = L"?a???b,,,#c";
+         static wchar_t str2[] = L"\t \t";
+         wchar_t *t, *ptr1, *ptr2;
+         t   =   wcstok(str1,   L"?", &amp;ptr1);         //   t   points to the token L"a"
+         t   =   wcstok(NULL,   L",", &amp;ptr1);         //   t   points to the token L"??b"
+         t   =   wcstok(str2,   L" \t", &amp;ptr2);       //   t   is a null pointer
+         t   =   wcstok(NULL,   L"#,", &amp;ptr1);        //   t   points to the token L"c"
+         t   =   wcstok(NULL,   L"?", &amp;ptr1);         //   t   is a null pointer</pre>
+ 
+
+<a name="7.28.4.5.8" href="#7.28.4.5.8"><h5>7.28.4.5.8 The wmemchr function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         wchar_t *wmemchr(const wchar_t *s, wchar_t c,
+              size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemchr function locates the first occurrence of c in the initial n wide characters of
+ the object pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemchr function returns a pointer to the located wide character, or a null pointer if
+ the wide character does not occur in the object.
+<!--page 454 indent 4-->
+
+<a name="7.28.4.6" href="#7.28.4.6"><h5>7.28.4.6 Miscellaneous functions</h5></a>
+
+<a name="7.28.4.6.1" href="#7.28.4.6.1"><h5>7.28.4.6.1 The wcslen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        size_t wcslen(const wchar_t *s);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcslen function computes the length of the wide string pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wcslen function returns the number of wide characters that precede the terminating
+ null wide character.
+
+<a name="7.28.4.6.2" href="#7.28.4.6.2"><h5>7.28.4.6.2 The wmemset function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wmemset function copies the value of c into each of the first n wide characters of
+ the object pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wmemset function returns the value of s.
+
+<a name="7.28.5" href="#7.28.5"><h4>7.28.5 Wide character time conversion functions</h4></a>
+
+<a name="7.28.5.1" href="#7.28.5.1"><h5>7.28.5.1 The wcsftime function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;time.h&gt;
+        #include &lt;wchar.h&gt;
+        size_t wcsftime(wchar_t * restrict s,
+             size_t maxsize,
              const wchar_t * restrict format,
-             const struct tm * restrict timeptr);
-        wint_t btowc(int c);
-        int wctob(wint_t c);
-        int mbsinit(const mbstate_t *ps);
-        size_t mbrlen(const char * restrict s, size_t n,
-             mbstate_t * restrict ps);
-        size_t mbrtowc(wchar_t * restrict pwc,
-             const char * restrict s, size_t n,
-             mbstate_t * restrict ps);
-
-[<a name="p495" href="#p495">page 495</a>] (<a href="#Contents">Contents</a>)
-
-      size_t wcrtomb(char * restrict s, wchar_t wc,
-           mbstate_t * restrict ps);
-      size_t mbsrtowcs(wchar_t * restrict dst,
-           const char ** restrict src, size_t len,
-           mbstate_t * restrict ps);
-      size_t wcsrtombs(char * restrict dst,
-           const wchar_t ** restrict src, size_t len,
-           mbstate_t * restrict ps);
-      __STDC_WANT_LIB_EXT1__
-      errno_t
-      rsize_t
-      int fwprintf_s(FILE * restrict stream,
-           const wchar_t * restrict format, ...);
-      int fwscanf_s(FILE * restrict stream,
-           const wchar_t * restrict format, ...);
-      int snwprintf_s(wchar_t * restrict s,
-           rsize_t n,
-           const wchar_t * restrict format, ...);
-      int swprintf_s(wchar_t * restrict s, rsize_t n,
-           const wchar_t * restrict format, ...);
-      int swscanf_s(const wchar_t * restrict s,
-           const wchar_t * restrict format, ...);
-      int vfwprintf_s(FILE * restrict stream,
-           const wchar_t * restrict format,
-           va_list arg);
-      int vfwscanf_s(FILE * restrict stream,
-           const wchar_t * restrict format, va_list arg);
-      int vsnwprintf_s(wchar_t * restrict s,
-           rsize_t n,
-           const wchar_t * restrict format,
-           va_list arg);
-      int vswprintf_s(wchar_t * restrict s,
-           rsize_t n,
-           const wchar_t * restrict format,
-           va_list arg);
-      int vswscanf_s(const wchar_t * restrict s,
-           const wchar_t * restrict format,
-           va_list arg);
-
-[<a name="p496" href="#p496">page 496</a>] (<a href="#Contents">Contents</a>)
-
-        int vwprintf_s(const wchar_t * restrict format,
-             va_list arg);
-        int vwscanf_s(const wchar_t * restrict format,
-             va_list arg);
-        int wprintf_s(const wchar_t * restrict format, ...);
-        int wscanf_s(const wchar_t * restrict format, ...);
-        errno_t wcscpy_s(wchar_t * restrict s1,
-             rsize_t s1max,
-             const wchar_t * restrict s2);
-        errno_t wcsncpy_s(wchar_t * restrict s1,
-             rsize_t s1max,
-             const wchar_t * restrict s2,
-             rsize_t n);
-        errno_t wmemcpy_s(wchar_t * restrict s1,
-             rsize_t s1max,
-             const wchar_t * restrict s2,
-             rsize_t n);
+             const struct tm * restrict timeptr);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsftime function is equivalent to the strftime function, except that:
+<ul>
+<li>  The argument s points to the initial element of an array of wide characters into which
+ the generated output is to be placed.
+<!--page 455 indent 4-->
+<li>  The argument maxsize indicates the limiting number of wide characters.
+<li>  The argument format is a wide string and the conversion specifiers are replaced by
+ corresponding sequences of wide characters.
+<li>  The return value indicates the number of wide characters.
+</ul>
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the total number of resulting wide characters including the terminating null wide
+ character is not more than maxsize, the wcsftime function returns the number of
+ wide characters placed into the array pointed to by s not including the terminating null
+ wide character. Otherwise, zero is returned and the contents of the array are
+ indeterminate.
+
+<a name="7.28.6" href="#7.28.6"><h4>7.28.6 Extended multibyte/wide character conversion utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wchar.h&gt; declares an extended set of functions useful for conversion
+ between multibyte characters and wide characters.
+<p><!--para 2-->
+ Most of the following functions -- those that are listed as ''restartable'', <a href="#7.28.6.3">7.28.6.3</a> and
+ <a href="#7.28.6.4">7.28.6.4</a> -- take as a last argument a pointer to an object of type mbstate_t that is used
+ to describe the current conversion state from a particular multibyte character sequence to
+ a wide character sequence (or the reverse) under the rules of a particular setting for the
+ LC_CTYPE category of the current locale.
+<p><!--para 3-->
+ The initial conversion state corresponds, for a conversion in either direction, to the
+ beginning of a new multibyte character in the initial shift state. A zero-valued
+ mbstate_t object is (at least) one way to describe an initial conversion state. A zero-
+ valued mbstate_t object can be used to initiate conversion involving any multibyte
+ character sequence, in any LC_CTYPE category setting. If an mbstate_t object has
+ been altered by any of the functions described in this subclause, and is then used with a
+ different multibyte character sequence, or in the other conversion direction, or with a
+ different LC_CTYPE category setting than on earlier function calls, the behavior is
+ undefined.<sup><a href="#note335"><b>335)</b></a></sup>
+<p><!--para 4-->
+ On entry, each function takes the described conversion state (either internal or pointed to
+ by an argument) as current. The conversion state described by the referenced object is
+ altered as needed to track the shift state, and the position within a multibyte character, for
+ the associated multibyte character sequence.
+ 
+ 
+ 
+ 
+<!--page 456 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note335">335)</a> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
+ mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
+ character string.
+
+
+<a name="7.28.6.1" href="#7.28.6.1"><h5>7.28.6.1 Single-byte/wide character conversion functions</h5></a>
+
+<a name="7.28.6.1.1" href="#7.28.6.1.1"><h5>7.28.6.1.1 The btowc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;                                                                        *
+        wint_t btowc(int c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The btowc function determines whether c constitutes a valid single-byte character in the
+ initial shift state.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The btowc function returns WEOF if c has the value EOF or if (unsigned char)c
+ does not constitute a valid single-byte character in the initial shift state. Otherwise, it
+ returns the wide character representation of that character.
+
+<a name="7.28.6.1.2" href="#7.28.6.1.2"><h5>7.28.6.1.2 The wctob function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;                                                                        *
+        int wctob(wint_t c);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctob function determines whether c corresponds to a member of the extended
+ character set whose multibyte character representation is a single byte when in the initial
+ shift state.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The wctob function returns EOF if c does not correspond to a multibyte character with
+ length one in the initial shift state. Otherwise, it returns the single-byte representation of
+ that character as an unsigned char converted to an int.
+
+<a name="7.28.6.2" href="#7.28.6.2"><h5>7.28.6.2 Conversion state functions</h5></a>
+
+<a name="7.28.6.2.1" href="#7.28.6.2.1"><h5>7.28.6.2.1 The mbsinit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wchar.h&gt;
+        int mbsinit(const mbstate_t *ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If ps is not a null pointer, the mbsinit function determines whether the referenced
+ mbstate_t object describes an initial conversion state.
+<!--page 457 indent 4-->
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mbsinit function returns nonzero if ps is a null pointer or if the referenced object
+ describes an initial conversion state; otherwise, it returns zero.
+
+<a name="7.28.6.3" href="#7.28.6.3"><h5>7.28.6.3 Restartable multibyte/wide character conversion functions</h5></a>
+<p><!--para 1-->
+ These functions differ from the corresponding multibyte character functions of <a href="#7.22.7">7.22.7</a>
+ (mblen, mbtowc, and wctomb) in that they have an extra parameter, ps, of type
+ pointer to mbstate_t that points to an object that can completely describe the current
+ conversion state of the associated multibyte character sequence. If ps is a null pointer,
+ each function uses its own internal mbstate_t object instead, which is initialized at
+ program startup to the initial conversion state; the functions are not required to avoid data
+ races in this case. The implementation behaves as if no library function calls these
+ functions with a null pointer for ps.
+<p><!--para 2-->
+ Also unlike their corresponding functions, the return value does not represent whether the
+ encoding is state-dependent.
+
+<a name="7.28.6.3.1" href="#7.28.6.3.1"><h5>7.28.6.3.1 The mbrlen function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t mbrlen(const char * restrict s,
+              size_t n,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mbrlen function is equivalent to the call:
+<pre>
+         mbrtowc(NULL, s, n, ps != NULL ? ps : &amp;internal)</pre>
+ where internal is the mbstate_t object for the mbrlen function, except that the
+ expression designated by ps is evaluated only once.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
+ or (size_t)(-1).
+ Forward references: the mbrtowc function (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
+<!--page 458 indent 4-->
+
+<a name="7.28.6.3.2" href="#7.28.6.3.2"><h5>7.28.6.3.2 The mbrtowc function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t mbrtowc(wchar_t * restrict pwc,
+              const char * restrict s,
+              size_t n,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the mbrtowc function is equivalent to the call:
+<pre>
+                 mbrtowc(NULL, "", 1, ps)</pre>
+ In this case, the values of the parameters pwc and n are ignored.
+<p><!--para 3-->
+ If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
+ the byte pointed to by s to determine the number of bytes needed to complete the next
+ multibyte character (including any shift sequences). If the function determines that the
+ next multibyte character is complete and valid, it determines the value of the
+ corresponding wide character and then, if pwc is not a null pointer, stores that value in
+ the object pointed to by pwc. If the corresponding wide character is the null wide
+ character, the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The mbrtowc function returns the first of the following that applies (given the current
+ conversion state):
+ 0                     if the next n or fewer bytes complete the multibyte character that
+<pre>
+                       corresponds to the null wide character (which is the value stored).</pre>
+ between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+<pre>
+                    character (which is the value stored); the value returned is the number
+                    of bytes that complete the multibyte character.</pre>
+ (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+<pre>
+              multibyte character, and all n bytes have been processed (no value is
+              stored).<sup><a href="#note336"><b>336)</b></a></sup></pre>
+ (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+<pre>
+              do not contribute to a complete and valid multibyte character (no
+              value is stored); the value of the macro EILSEQ is stored in errno,
+              and the conversion state is unspecified.</pre>
+ 
+<!--page 459 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note336">336)</a> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+ sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+
+<a name="7.28.6.3.3" href="#7.28.6.3.3"><h5>7.28.6.3.3 The wcrtomb function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t wcrtomb(char * restrict s,
+              wchar_t wc,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ If s is a null pointer, the wcrtomb function is equivalent to the call
+<pre>
+                 wcrtomb(buf, L'\0', ps)</pre>
+ where buf is an internal buffer.
+<p><!--para 3-->
+ If s is not a null pointer, the wcrtomb function determines the number of bytes needed
+ to represent the multibyte character that corresponds to the wide character given by wc
+ (including any shift sequences), and stores the multibyte character representation in the
+ array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+ wc is a null wide character, a null byte is stored, preceded by any shift sequence needed
+ to restore the initial shift state; the resulting state described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ The wcrtomb function returns the number of bytes stored in the array object (including
+ any shift sequences). When wc is not a valid wide character, an encoding error occurs:
+ the function stores the value of the macro EILSEQ in errno and returns
+ (size_t)(-1); the conversion state is unspecified.
+
+<a name="7.28.6.4" href="#7.28.6.4"><h5>7.28.6.4 Restartable multibyte/wide string conversion functions</h5></a>
+<p><!--para 1-->
+ These functions differ from the corresponding multibyte string functions of <a href="#7.22.8">7.22.8</a>
+ (mbstowcs and wcstombs) in that they have an extra parameter, ps, of type pointer to
+ mbstate_t that points to an object that can completely describe the current conversion
+ state of the associated multibyte character sequence. If ps is a null pointer, each function
+ uses its own internal mbstate_t object instead, which is initialized at program startup
+ to the initial conversion state; the functions are not required to avoid data races in this
+ case. The implementation behaves as if no library function calls these functions with a
+ null pointer for ps.
+<p><!--para 2-->
+ Also unlike their corresponding functions, the conversion source parameter, src, has a
+ pointer-to-pointer type. When the function is storing the results of conversions (that is,
+ when dst is not a null pointer), the pointer object pointed to by this parameter is updated
+ to reflect the amount of the source processed by that invocation.
+<!--page 460 indent 4-->
+
+<a name="7.28.6.4.1" href="#7.28.6.4.1"><h5>7.28.6.4.1 The mbsrtowcs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;wchar.h&gt;
+          size_t mbsrtowcs(wchar_t * restrict dst,
+               const char ** restrict src,
+               size_t len,
+               mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The mbsrtowcs function converts a sequence of multibyte characters that begins in the
+ conversion state described by the object pointed to by ps, from the array indirectly
+ pointed to by src into a sequence of corresponding wide characters. If dst is not a null
+ pointer, the converted characters are stored into the array pointed to by dst. Conversion
+ continues up to and including a terminating null character, which is also stored.
+ Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
+ not form a valid multibyte character, or (if dst is not a null pointer) when len wide
+ characters have been stored into the array pointed to by dst.<sup><a href="#note337"><b>337)</b></a></sup> Each conversion takes
+ place as if by a call to the mbrtowc function.
+<p><!--para 3-->
+ If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+ pointer (if conversion stopped due to reaching a terminating null character) or the address
+ just past the last multibyte character converted (if any). If conversion stopped due to
+ reaching a terminating null character and if dst is not a null pointer, the resulting state
+ described is the initial conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If the input conversion encounters a sequence of bytes that do not form a valid multibyte
+ character, an encoding error occurs: the mbsrtowcs function stores the value of the
+ macro EILSEQ in errno and returns (size_t)(-1); the conversion state is
+ unspecified. Otherwise, it returns the number of multibyte characters successfully
+ converted, not including the terminating null character (if any).
+ 
+ 
+ 
+ 
+<!--page 461 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note337">337)</a> Thus, the value of len is ignored if dst is a null pointer.
+
+
+<a name="7.28.6.4.2" href="#7.28.6.4.2"><h5>7.28.6.4.2 The wcsrtombs function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wchar.h&gt;
+         size_t wcsrtombs(char * restrict dst,
+              const wchar_t ** restrict src,
+              size_t len,
+              mbstate_t * restrict ps);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsrtombs function converts a sequence of wide characters from the array
+ indirectly pointed to by src into a sequence of corresponding multibyte characters that
+ begins in the conversion state described by the object pointed to by ps. If dst is not a
+ null pointer, the converted characters are then stored into the array pointed to by dst.
+ Conversion continues up to and including a terminating null wide character, which is also
+ stored. Conversion stops earlier in two cases: when a wide character is reached that does
+ not correspond to a valid multibyte character, or (if dst is not a null pointer) when the
+ next multibyte character would exceed the limit of len total bytes to be stored into the
+ array pointed to by dst. Each conversion takes place as if by a call to the wcrtomb
+ function.<sup><a href="#note338"><b>338)</b></a></sup>
+<p><!--para 3-->
+ If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+ pointer (if conversion stopped due to reaching a terminating null wide character) or the
+ address just past the last wide character converted (if any). If conversion stopped due to
+ reaching a terminating null wide character, the resulting state described is the initial
+ conversion state.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If conversion stops because a wide character is reached that does not correspond to a
+ valid multibyte character, an encoding error occurs: the wcsrtombs function stores the
+ value of the macro EILSEQ in errno and returns (size_t)(-1); the conversion
+ state is unspecified. Otherwise, it returns the number of bytes in the resulting multibyte
+ character sequence, not including the terminating null character (if any).
+ 
+ 
+ 
+ 
+<!--page 462 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note338">338)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
+ include those necessary to reach the initial shift state immediately before the null byte.
+
+
+<a name="7.29" href="#7.29"><h3>7.29 Wide character classification and mapping utilities <wctype.h></h3></a>
+
+<a name="7.29.1" href="#7.29.1"><h4>7.29.1 Introduction</h4></a>
+<p><!--para 1-->
+ The header &lt;wctype.h&gt; defines one macro, and declares three data types and many
+ functions.<sup><a href="#note339"><b>339)</b></a></sup>
+<p><!--para 2-->
+ The types declared are
+<pre>
+          wint_t</pre>
+ described in <a href="#7.28.1">7.28.1</a>;
+<pre>
+          wctrans_t</pre>
+ which is a scalar type that can hold values which represent locale-specific character
+ mappings; and
+<pre>
+          wctype_t</pre>
+ which is a scalar type that can hold values which represent locale-specific character
+ classifications.
+<p><!--para 3-->
+ The macro defined is WEOF (described in <a href="#7.28.1">7.28.1</a>).
+<p><!--para 4-->
+ The functions declared are grouped as follows:
+<ul>
+<li>  Functions that provide wide character classification;
+<li>  Extensible functions that provide wide character classification;
+<li>  Functions that provide wide character case mapping;
+<li>  Extensible functions that provide wide character mapping.
+</ul>
+<p><!--para 5-->
+ For all functions described in this subclause that accept an argument of type wint_t, the
+ value shall be representable as a wchar_t or shall equal the value of the macro WEOF. If
+ this argument has any other value, the behavior is undefined.
+<p><!--para 6-->
+ The behavior of these functions is affected by the LC_CTYPE category of the current
+ locale.
+ 
+ 
+ 
+ 
+<!--page 463 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note339">339)</a> See ''future library directions'' (<a href="#7.30.13">7.30.13</a>).
+
+
+<a name="7.29.2" href="#7.29.2"><h4>7.29.2 Wide character classification utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wctype.h&gt; declares several functions useful for classifying wide
+ characters.
+<p><!--para 2-->
+ The term printing wide character refers to a member of a locale-specific set of wide
+ characters, each of which occupies at least one printing position on a display device. The
+ term control wide character refers to a member of a locale-specific set of wide characters
+ that are not printing wide characters.
+
+<a name="7.29.2.1" href="#7.29.2.1"><h5>7.29.2.1 Wide character classification functions</h5></a>
+<p><!--para 1-->
+ The functions in this subclause return nonzero (true) if and only if the value of the
+ argument wc conforms to that in the description of the function.
+<p><!--para 2-->
+ Each of the following functions returns true for each wide character that corresponds (as
+ if by a call to the wctob function) to a single-byte character for which the corresponding
+ character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
+ iswpunct functions may differ with respect to wide characters other than L' ' that are
+ both printing and white-space wide characters.<sup><a href="#note340"><b>340)</b></a></sup>
+ Forward references: the wctob function (<a href="#7.28.6.1.2">7.28.6.1.2</a>).
+
+<h6>footnotes</h6>
+<p><a name="note340">340)</a> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
+ iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
+ (which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
+ &amp;&amp; iswspace(wc) is true, but not both.
+
+
+<a name="7.29.2.1.1" href="#7.29.2.1.1"><h5>7.29.2.1.1 The iswalnum function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswalnum(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswalnum function tests for any wide character for which iswalpha or
+ iswdigit is true.
+
+<a name="7.29.2.1.2" href="#7.29.2.1.2"><h5>7.29.2.1.2 The iswalpha function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswalpha(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswalpha function tests for any wide character for which iswupper or
+ iswlower is true, or any wide character that is one of a locale-specific set of alphabetic
+ 
+<!--page 464 indent 4-->
+ wide characters for which none of iswcntrl, iswdigit, iswpunct, or iswspace
+ is true.<sup><a href="#note341"><b>341)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note341">341)</a> The functions iswlower and iswupper test true or false separately for each of these additional
+ wide characters; all four combinations are possible.
+
+
+<a name="7.29.2.1.3" href="#7.29.2.1.3"><h5>7.29.2.1.3 The iswblank function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswblank(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswblank function tests for any wide character that is a standard blank wide
+ character or is one of a locale-specific set of wide characters for which iswspace is true
+ and that is used to separate words within a line of text. The standard blank wide
+ characters are the following: space (L' '), and horizontal tab (L'\t'). In the "C"
+ locale, iswblank returns true only for the standard blank characters.
+
+<a name="7.29.2.1.4" href="#7.29.2.1.4"><h5>7.29.2.1.4 The iswcntrl function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswcntrl(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswcntrl function tests for any control wide character.
+
+<a name="7.29.2.1.5" href="#7.29.2.1.5"><h5>7.29.2.1.5 The iswdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswdigit(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswdigit function tests for any wide character that corresponds to a decimal-digit
+ character (as defined in <a href="#5.2.1">5.2.1</a>).
+
+<a name="7.29.2.1.6" href="#7.29.2.1.6"><h5>7.29.2.1.6 The iswgraph function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswgraph(wint_t wc);</pre>
+ 
+ 
+ 
+ 
+<!--page 465 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswgraph function tests for any wide character for which iswprint is true and
+ iswspace is false.<sup><a href="#note342"><b>342)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note342">342)</a> Note that the behavior of the iswgraph and iswpunct functions may differ from their
+ corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
+ characters other than ' '.
+
+
+<a name="7.29.2.1.7" href="#7.29.2.1.7"><h5>7.29.2.1.7 The iswlower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswlower(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswlower function tests for any wide character that corresponds to a lowercase
+ letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+ iswdigit, iswpunct, or iswspace is true.
+
+<a name="7.29.2.1.8" href="#7.29.2.1.8"><h5>7.29.2.1.8 The iswprint function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswprint(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswprint function tests for any printing wide character.
+
+<a name="7.29.2.1.9" href="#7.29.2.1.9"><h5>7.29.2.1.9 The iswpunct function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswpunct(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswpunct function tests for any printing wide character that is one of a locale-
+ specific set of punctuation wide characters for which neither iswspace nor iswalnum
+ is true.342)
+
+<a name="7.29.2.1.10" href="#7.29.2.1.10"><h5>7.29.2.1.10 The iswspace function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         int iswspace(wint_t wc);</pre>
+ 
+ 
+ 
+<!--page 466 indent 4-->
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswspace function tests for any wide character that corresponds to a locale-specific
+ set of white-space wide characters for which none of iswalnum, iswgraph, or
+ iswpunct is true.
+
+<a name="7.29.2.1.11" href="#7.29.2.1.11"><h5>7.29.2.1.11 The iswupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswupper(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswupper function tests for any wide character that corresponds to an uppercase
+ letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+ iswdigit, iswpunct, or iswspace is true.
+
+<a name="7.29.2.1.12" href="#7.29.2.1.12"><h5>7.29.2.1.12 The iswxdigit function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswxdigit(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswxdigit function tests for any wide character that corresponds to a
+ hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+
+<a name="7.29.2.2" href="#7.29.2.2"><h5>7.29.2.2 Extensible wide character classification functions</h5></a>
+<p><!--para 1-->
+ The functions wctype and iswctype provide extensible wide character classification
+ as well as testing equivalent to that performed by the functions described in the previous
+ subclause (<a href="#7.29.2.1">7.29.2.1</a>).
+
+<a name="7.29.2.2.1" href="#7.29.2.2.1"><h5>7.29.2.2.1 The iswctype function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        int iswctype(wint_t wc, wctype_t desc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The iswctype function determines whether the wide character wc has the property
+ described by desc. The current setting of the LC_CTYPE category shall be the same as
+ during the call to wctype that returned the value desc.
+<p><!--para 3-->
+ Each of the following expressions has a truth-value equivalent to the call to the wide
+ character classification function (<a href="#7.29.2.1">7.29.2.1</a>) in the comment that follows the expression:
+<!--page 467 indent 4-->
+<pre>
+         iswctype(wc,      wctype("alnum"))              //   iswalnum(wc)
+         iswctype(wc,      wctype("alpha"))              //   iswalpha(wc)
+         iswctype(wc,      wctype("blank"))              //   iswblank(wc)
+         iswctype(wc,      wctype("cntrl"))              //   iswcntrl(wc)
+         iswctype(wc,      wctype("digit"))              //   iswdigit(wc)
+         iswctype(wc,      wctype("graph"))              //   iswgraph(wc)
+         iswctype(wc,      wctype("lower"))              //   iswlower(wc)
+         iswctype(wc,      wctype("print"))              //   iswprint(wc)
+         iswctype(wc,      wctype("punct"))              //   iswpunct(wc)
+         iswctype(wc,      wctype("space"))              //   iswspace(wc)
+         iswctype(wc,      wctype("upper"))              //   iswupper(wc)
+         iswctype(wc,      wctype("xdigit"))             //   iswxdigit(wc)</pre>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The iswctype function returns nonzero (true) if and only if the value of the wide
+ character wc has the property described by desc. If desc is zero, the iswctype
+ function returns zero (false).
+ Forward references: the wctype function (<a href="#7.29.2.2.2">7.29.2.2.2</a>).
+
+<a name="7.29.2.2.2" href="#7.29.2.2.2"><h5>7.29.2.2.2 The wctype function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         wctype_t wctype(const char *property);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctype function constructs a value with type wctype_t that describes a class of
+ wide characters identified by the string argument property.
+<p><!--para 3-->
+ The strings listed in the description of the iswctype function shall be valid in all
+ locales as property arguments to the wctype function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If property identifies a valid class of wide characters according to the LC_CTYPE
+ category of the current locale, the wctype function returns a nonzero value that is valid
+ as the second argument to the iswctype function; otherwise, it returns zero.
+<!--page 468 indent 4-->
+
+<a name="7.29.3" href="#7.29.3"><h4>7.29.3 Wide character case mapping utilities</h4></a>
+<p><!--para 1-->
+ The header &lt;wctype.h&gt; declares several functions useful for mapping wide characters.
+
+<a name="7.29.3.1" href="#7.29.3.1"><h5>7.29.3.1 Wide character case mapping functions</h5></a>
+
+<a name="7.29.3.1.1" href="#7.29.3.1.1"><h5>7.29.3.1.1 The towlower function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        wint_t towlower(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The towlower function converts an uppercase letter to a corresponding lowercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a wide character for which iswupper is true and there are one or
+ more corresponding wide characters, as specified by the current locale, for which
+ iswlower is true, the towlower function returns one of the corresponding wide
+ characters (always the same one for any given locale); otherwise, the argument is
+ returned unchanged.
+
+<a name="7.29.3.1.2" href="#7.29.3.1.2"><h5>7.29.3.1.2 The towupper function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #include &lt;wctype.h&gt;
+        wint_t towupper(wint_t wc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The towupper function converts a lowercase letter to a corresponding uppercase letter.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If the argument is a wide character for which iswlower is true and there are one or
+ more corresponding wide characters, as specified by the current locale, for which
+ iswupper is true, the towupper function returns one of the corresponding wide
+ characters (always the same one for any given locale); otherwise, the argument is
+ returned unchanged.
+
+<a name="7.29.3.2" href="#7.29.3.2"><h5>7.29.3.2 Extensible wide character case mapping functions</h5></a>
+<p><!--para 1-->
+ The functions wctrans and towctrans provide extensible wide character mapping as
+ well as case mapping equivalent to that performed by the functions described in the
+ previous subclause (<a href="#7.29.3.1">7.29.3.1</a>).
+<!--page 469 indent 4-->
+
+<a name="7.29.3.2.1" href="#7.29.3.2.1"><h5>7.29.3.2.1 The towctrans function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         wint_t towctrans(wint_t wc, wctrans_t desc);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The towctrans function maps the wide character wc using the mapping described by
+ desc. The current setting of the LC_CTYPE category shall be the same as during the call
+ to wctrans that returned the value desc.
+<p><!--para 3-->
+ Each of the following expressions behaves the same as the call to the wide character case
+ mapping function (<a href="#7.29.3.1">7.29.3.1</a>) in the comment that follows the expression:
+<pre>
+         towctrans(wc, wctrans("tolower"))                     // towlower(wc)
+         towctrans(wc, wctrans("toupper"))                     // towupper(wc)</pre>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The towctrans function returns the mapped value of wc using the mapping described
+ by desc. If desc is zero, the towctrans function returns the value of wc.
+
+<a name="7.29.3.2.2" href="#7.29.3.2.2"><h5>7.29.3.2.2 The wctrans function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;wctype.h&gt;
+         wctrans_t wctrans(const char *property);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wctrans function constructs a value with type wctrans_t that describes a
+ mapping between wide characters identified by the string argument property.
+<p><!--para 3-->
+ The strings listed in the description of the towctrans function shall be valid in all
+ locales as property arguments to the wctrans function.
+<h6>Returns</h6>
+<p><!--para 4-->
+ If property identifies a valid mapping of wide characters according to the LC_CTYPE
+ category of the current locale, the wctrans function returns a nonzero value that is valid
+ as the second argument to the towctrans function; otherwise, it returns zero.
+<!--page 470 indent 4-->
+
+<a name="7.30" href="#7.30"><h3>7.30 Future library directions</h3></a>
+<p><!--para 1-->
+ The following names are grouped under individual headers for convenience. All external
+ names described below are reserved no matter what headers are included by the program.
+
+<a name="7.30.1" href="#7.30.1"><h4>7.30.1 Complex arithmetic <complex.h></h4></a>
+<p><!--para 1-->
+ The function names
+<pre>
+       cerf               cexpm1              clog2
+       cerfc              clog10              clgamma
+       cexp2              clog1p              ctgamma</pre>
+ and the same names suffixed with f or l may be added to the declarations in the
+ &lt;complex.h&gt; header.
+
+<a name="7.30.2" href="#7.30.2"><h4>7.30.2 Character handling <ctype.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with either is or to, and a lowercase letter may be added to
+ the declarations in the &lt;ctype.h&gt; header.
+
+<a name="7.30.3" href="#7.30.3"><h4>7.30.3 Errors <errno.h></h4></a>
+<p><!--para 1-->
+ Macros that begin with E and a digit or E and an uppercase letter may be added to the
+ declarations in the &lt;errno.h&gt; header.
+
+<a name="7.30.4" href="#7.30.4"><h4>7.30.4 Format conversion of integer types <inttypes.h></h4></a>
+<p><!--para 1-->
+ Macro names beginning with PRI or SCN followed by any lowercase letter or X may be
+ added to the macros defined in the &lt;inttypes.h&gt; header.
+
+<a name="7.30.5" href="#7.30.5"><h4>7.30.5 Localization <locale.h></h4></a>
+<p><!--para 1-->
+ Macros that begin with LC_ and an uppercase letter may be added to the definitions in
+ the &lt;locale.h&gt; header.
+
+<a name="7.30.6" href="#7.30.6"><h4>7.30.6 Signal handling <signal.h></h4></a>
+<p><!--para 1-->
+ Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
+ letter may be added to the definitions in the &lt;signal.h&gt; header.
+
+<a name="7.30.7" href="#7.30.7"><h4>7.30.7 Boolean type and values <stdbool.h></h4></a>
+<p><!--para 1-->
+ The ability to undefine and perhaps then redefine the macros bool, true, and false is
+ an obsolescent feature.
+
+<a name="7.30.8" href="#7.30.8"><h4>7.30.8 Integer types <stdint.h></h4></a>
+<p><!--para 1-->
+ Typedef names beginning with int or uint and ending with _t may be added to the
+ types defined in the &lt;stdint.h&gt; header. Macro names beginning with INT or UINT
+ and ending with _MAX, _MIN, or _C may be added to the macros defined in the
+ &lt;stdint.h&gt; header.
+<!--page 471 indent 4-->
+
+<a name="7.30.9" href="#7.30.9"><h4>7.30.9 Input/output <stdio.h></h4></a>
+<p><!--para 1-->
+ Lowercase letters may be added to the conversion specifiers and length modifiers in
+ fprintf and fscanf. Other characters may be used in extensions.
+<p><!--para 2-->
+ The use of ungetc on a binary stream where the file position indicator is zero prior to *
+ the call is an obsolescent feature.
+
+<a name="7.30.10" href="#7.30.10"><h4>7.30.10 General utilities <stdlib.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with str and a lowercase letter may be added to the
+ declarations in the &lt;stdlib.h&gt; header.
+
+<a name="7.30.11" href="#7.30.11"><h4>7.30.11 String handling <string.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with str, mem, or wcs and a lowercase letter may be added
+ to the declarations in the &lt;string.h&gt; header.
+
+<a name="7.30.12" href="#7.30.12"><h4>7.30.12 Extended multibyte and wide character utilities <wchar.h></h4></a>
+<p><!--para 1-->
+ Function names that begin with wcs and a lowercase letter may be added to the
+ declarations in the &lt;wchar.h&gt; header.
+<p><!--para 2-->
+ Lowercase letters may be added to the conversion specifiers and length modifiers in
+ fwprintf and fwscanf. Other characters may be used in extensions.
+
+<a name="7.30.13" href="#7.30.13"><h4>7.30.13 Wide character classification and mapping utilities</h4></a>
+ &lt;wctype.h&gt;
+<p><!--para 1-->
+ Function names that begin with is or to and a lowercase letter may be added to the
+ declarations in the &lt;wctype.h&gt; header.
+<!--page 472 indent 4-->
+
+<a name="A" href="#A"><h2>Annex A</h2></a>
+<p><!--para 1-->
+<pre>
+                                            (informative)
+                             Language syntax summary</pre>
+ NOTE   The notation is described in <a href="#6.1">6.1</a>.
+ 
+
+<a name="A.1" href="#A.1"><h3>A.1 Lexical grammar</h3></a>
+
+<a name="A.1.1" href="#A.1.1"><h4>A.1.1 Lexical elements</h4></a>
+ (<a href="#6.4">6.4</a>) token:
+<pre>
+                keyword
+                identifier
+                constant
+                string-literal
+                punctuator</pre>
+ (<a href="#6.4">6.4</a>) preprocessing-token:
+<!--page 473 indent 0-->
+<pre>
+               header-name
+               identifier
+               pp-number
+               character-constant
+               string-literal
+               punctuator
+               each non-white-space character that cannot be one of the above</pre>
+
+<a name="A.1.2" href="#A.1.2"><h4>A.1.2 Keywords</h4></a>
+ (<a href="#6.4.1">6.4.1</a>) keyword: one of
+<pre>
+               alignof                     goto                  union
+               auto                        if                    unsigned
+               break                       inline                void
+               case                        int                   volatile
+               char                        long                  while
+               const                       register              _Alignas
+               continue                    restrict              _Atomic
+               default                     return                _Bool
+               do                          short                 _Complex
+               double                      signed                _Generic
+               else                        sizeof                _Imaginary
+               enum                        static                _Noreturn
+               extern                      struct                _Static_assert
+               float                       switch                _Thread_local
+               for                         typedef</pre>
+
+<a name="A.1.3" href="#A.1.3"><h4>A.1.3 Identifiers</h4></a>
+ (<a href="#6.4.2.1">6.4.2.1</a>) identifier:
+<pre>
+                identifier-nondigit
+                identifier identifier-nondigit
+                identifier digit</pre>
+ (<a href="#6.4.2.1">6.4.2.1</a>) identifier-nondigit:
+<pre>
+                nondigit
+                universal-character-name
+                other implementation-defined characters</pre>
+ (<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
+<pre>
+               _ a b          c    d   e    f   g   h    i   j   k   l   m
+                    n o       p    q   r    s   t   u    v   w   x   y   z
+                    A B       C    D   E    F   G   H    I   J   K   L   M
+                    N O       P    Q   R    S   T   U    V   W   X   Y   Z</pre>
+ (<a href="#6.4.2.1">6.4.2.1</a>) digit: one of
+<!--page 474 indent 0-->
+<pre>
+                0 1 2         3    4   5    6   7   8    9</pre>
+
+<a name="A.1.4" href="#A.1.4"><h4>A.1.4 Universal character names</h4></a>
+ (<a href="#6.4.3">6.4.3</a>) universal-character-name:
+<pre>
+               \u hex-quad
+               \U hex-quad hex-quad</pre>
+ (<a href="#6.4.3">6.4.3</a>) hex-quad:
+<pre>
+               hexadecimal-digit hexadecimal-digit
+                            hexadecimal-digit hexadecimal-digit</pre>
+
+<a name="A.1.5" href="#A.1.5"><h4>A.1.5 Constants</h4></a>
+ (<a href="#6.4.4">6.4.4</a>) constant:
+<pre>
+               integer-constant
+               floating-constant
+               enumeration-constant
+               character-constant</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
+<pre>
+                decimal-constant integer-suffixopt
+                octal-constant integer-suffixopt
+                hexadecimal-constant integer-suffixopt</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) decimal-constant:
+<pre>
+               nonzero-digit
+               decimal-constant digit</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) octal-constant:
+<pre>
+                0
+                octal-constant octal-digit</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-constant:
+<pre>
+               hexadecimal-prefix hexadecimal-digit
+               hexadecimal-constant hexadecimal-digit</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-prefix: one of
+<pre>
+               0x 0X</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) nonzero-digit: one of
+<pre>
+               1 2 3 4 5              6      7   8   9</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) octal-digit: one of
+<!--page 475 indent 0-->
+<pre>
+                0 1 2 3           4   5      6   7</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-digit: one of
+<pre>
+               0 1 2 3 4 5                6    7    8   9
+               a b c d e f
+               A B C D E F</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
+<pre>
+                unsigned-suffix long-suffixopt
+                unsigned-suffix long-long-suffix
+                long-suffix unsigned-suffixopt
+                long-long-suffix unsigned-suffixopt</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) unsigned-suffix: one of
+<pre>
+                u U</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) long-suffix: one of
+<pre>
+                l L</pre>
+ (<a href="#6.4.4.1">6.4.4.1</a>) long-long-suffix: one of
+<pre>
+                ll LL</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) floating-constant:
+<pre>
+                decimal-floating-constant
+                hexadecimal-floating-constant</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
+<pre>
+               fractional-constant exponent-partopt floating-suffixopt
+               digit-sequence exponent-part floating-suffixopt</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
+<pre>
+               hexadecimal-prefix hexadecimal-fractional-constant
+                             binary-exponent-part floating-suffixopt
+               hexadecimal-prefix hexadecimal-digit-sequence
+                             binary-exponent-part floating-suffixopt</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) fractional-constant:
+<pre>
+                digit-sequenceopt . digit-sequence
+                digit-sequence .</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) exponent-part:
+<pre>
+               e signopt digit-sequence
+               E signopt digit-sequence</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) sign: one of
+<!--page 476 indent 0-->
+<pre>
+                + -</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) digit-sequence:
+<pre>
+                digit
+                digit-sequence digit</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
+<pre>
+               hexadecimal-digit-sequenceopt .
+                              hexadecimal-digit-sequence
+               hexadecimal-digit-sequence .</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) binary-exponent-part:
+<pre>
+                p signopt digit-sequence
+                P signopt digit-sequence</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-digit-sequence:
+<pre>
+               hexadecimal-digit
+               hexadecimal-digit-sequence hexadecimal-digit</pre>
+ (<a href="#6.4.4.2">6.4.4.2</a>) floating-suffix: one of
+<pre>
+                f l F L</pre>
+ (<a href="#6.4.4.3">6.4.4.3</a>) enumeration-constant:
+<pre>
+               identifier</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) character-constant:
+<pre>
+               ' c-char-sequence '
+               L' c-char-sequence '
+               u' c-char-sequence '
+               U' c-char-sequence '</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) c-char-sequence:
+<pre>
+                c-char
+                c-char-sequence c-char</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) c-char:
+<pre>
+                any member of the source character set except
+                             the single-quote ', backslash \, or new-line character
+                escape-sequence</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) escape-sequence:
+<!--page 477 indent 0-->
+<pre>
+               simple-escape-sequence
+               octal-escape-sequence
+               hexadecimal-escape-sequence
+               universal-character-name</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) simple-escape-sequence: one of
+<pre>
+               \' \" \? \\
+               \a \b \f \n \r \t                   \v</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) octal-escape-sequence:
+<pre>
+                \ octal-digit
+                \ octal-digit octal-digit
+                \ octal-digit octal-digit octal-digit</pre>
+ (<a href="#6.4.4.4">6.4.4.4</a>) hexadecimal-escape-sequence:
+<pre>
+               \x hexadecimal-digit
+               hexadecimal-escape-sequence hexadecimal-digit</pre>
+
+<a name="A.1.6" href="#A.1.6"><h4>A.1.6 String literals</h4></a>
+ (<a href="#6.4.5">6.4.5</a>) string-literal:
+<pre>
+                encoding-prefixopt " s-char-sequenceopt "</pre>
+ (<a href="#6.4.5">6.4.5</a>) encoding-prefix:
+<pre>
+               u8
+               u
+               U
+               L</pre>
+ (<a href="#6.4.5">6.4.5</a>) s-char-sequence:
+<pre>
+                s-char
+                s-char-sequence s-char</pre>
+ (<a href="#6.4.5">6.4.5</a>) s-char:
+<pre>
+                any member of the source character set except
+                             the double-quote ", backslash \, or new-line character
+                escape-sequence</pre>
+
+<a name="A.1.7" href="#A.1.7"><h4>A.1.7 Punctuators</h4></a>
+ (<a href="#6.4.6">6.4.6</a>) punctuator: one of
+<!--page 478 indent 0-->
+<pre>
+               [ ] ( ) { } . -&gt;
+               ++ -- &amp; * + - ~ !
+               / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                      ==    !=    ^    |   &amp;&amp;   ||
+               ? : ; ...
+               = *= /= %= += -= &lt;&lt;=                     &gt;&gt;=    &amp;=       ^=   |=
+               , # ##
+               &lt;: :&gt; &lt;% %&gt; %: %:%:</pre>
+
+<a name="A.1.8" href="#A.1.8"><h4>A.1.8 Header names</h4></a>
+ (<a href="#6.4.7">6.4.7</a>) header-name:
+<pre>
+               &lt; h-char-sequence &gt;
+               " q-char-sequence "</pre>
+ (<a href="#6.4.7">6.4.7</a>) h-char-sequence:
+<pre>
+               h-char
+               h-char-sequence h-char</pre>
+ (<a href="#6.4.7">6.4.7</a>) h-char:
+<pre>
+               any member of the source character set except
+                            the new-line character and &gt;</pre>
+ (<a href="#6.4.7">6.4.7</a>) q-char-sequence:
+<pre>
+               q-char
+               q-char-sequence q-char</pre>
+ (<a href="#6.4.7">6.4.7</a>) q-char:
+<pre>
+               any member of the source character set except
+                            the new-line character and "</pre>
+
+<a name="A.1.9" href="#A.1.9"><h4>A.1.9 Preprocessing numbers</h4></a>
+ (<a href="#6.4.8">6.4.8</a>) pp-number:
+<!--page 479 indent 0-->
+<pre>
+               digit
+               . digit
+               pp-number   digit
+               pp-number   identifier-nondigit
+               pp-number   e sign
+               pp-number   E sign
+               pp-number   p sign
+               pp-number   P sign
+               pp-number   .</pre>
+
+<a name="A.2" href="#A.2"><h3>A.2 Phrase structure grammar</h3></a>
+
+<a name="A.2.1" href="#A.2.1"><h4>A.2.1 Expressions</h4></a>
+ (<a href="#6.5.1">6.5.1</a>) primary-expression:
+<pre>
+               identifier
+               constant
+               string-literal
+               ( expression )
+               generic-selection</pre>
+ (<a href="#6.5.1.1">6.5.1.1</a>) generic-selection:
+<pre>
+               _Generic ( assignment-expression , generic-assoc-list )</pre>
+ (<a href="#6.5.1.1">6.5.1.1</a>) generic-assoc-list:
+<pre>
+               generic-association
+               generic-assoc-list , generic-association</pre>
+ (<a href="#6.5.1.1">6.5.1.1</a>) generic-association:
+<pre>
+               type-name : assignment-expression
+               default : assignment-expression</pre>
+ (<a href="#6.5.2">6.5.2</a>) postfix-expression:
+<pre>
+               primary-expression
+               postfix-expression [ expression ]
+               postfix-expression ( argument-expression-listopt )
+               postfix-expression . identifier
+               postfix-expression -&gt; identifier
+               postfix-expression ++
+               postfix-expression --
+               ( type-name ) { initializer-list }
+               ( type-name ) { initializer-list , }</pre>
+ (<a href="#6.5.2">6.5.2</a>) argument-expression-list:
+<pre>
+              assignment-expression
+              argument-expression-list , assignment-expression</pre>
+ (<a href="#6.5.3">6.5.3</a>) unary-expression:
+<!--page 480 indent 0-->
+<pre>
+               postfix-expression
+               ++ unary-expression
+               -- unary-expression
+               unary-operator cast-expression
+               sizeof unary-expression
+               sizeof ( type-name )
+               alignof ( type-name )</pre>
+ (<a href="#6.5.3">6.5.3</a>) unary-operator: one of
+<pre>
+               &amp; * + - ~                !</pre>
+ (<a href="#6.5.4">6.5.4</a>) cast-expression:
+<pre>
+                unary-expression
+                ( type-name ) cast-expression</pre>
+ (<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
+<pre>
+                cast-expression
+                multiplicative-expression * cast-expression
+                multiplicative-expression / cast-expression
+                multiplicative-expression % cast-expression</pre>
+ (<a href="#6.5.6">6.5.6</a>) additive-expression:
+<pre>
+                multiplicative-expression
+                additive-expression + multiplicative-expression
+                additive-expression - multiplicative-expression</pre>
+ (<a href="#6.5.7">6.5.7</a>) shift-expression:
+<pre>
+                 additive-expression
+                 shift-expression &lt;&lt; additive-expression
+                 shift-expression &gt;&gt; additive-expression</pre>
+ (<a href="#6.5.8">6.5.8</a>) relational-expression:
+<pre>
+                shift-expression
+                relational-expression   &lt;    shift-expression
+                relational-expression   &gt;    shift-expression
+                relational-expression   &lt;=   shift-expression
+                relational-expression   &gt;=   shift-expression</pre>
+ (<a href="#6.5.9">6.5.9</a>) equality-expression:
+<pre>
+                relational-expression
+                equality-expression == relational-expression
+                equality-expression != relational-expression</pre>
+ (<a href="#6.5.10">6.5.10</a>) AND-expression:
+<pre>
+              equality-expression
+              AND-expression &amp; equality-expression</pre>
+ (<a href="#6.5.11">6.5.11</a>) exclusive-OR-expression:
+<!--page 481 indent 0-->
+<pre>
+               AND-expression
+               exclusive-OR-expression ^ AND-expression</pre>
+ (<a href="#6.5.12">6.5.12</a>) inclusive-OR-expression:
+<pre>
+                exclusive-OR-expression
+                inclusive-OR-expression | exclusive-OR-expression</pre>
+ (<a href="#6.5.13">6.5.13</a>) logical-AND-expression:
+<pre>
+               inclusive-OR-expression
+               logical-AND-expression &amp;&amp; inclusive-OR-expression</pre>
+ (<a href="#6.5.14">6.5.14</a>) logical-OR-expression:
+<pre>
+               logical-AND-expression
+               logical-OR-expression || logical-AND-expression</pre>
+ (<a href="#6.5.15">6.5.15</a>) conditional-expression:
+<pre>
+               logical-OR-expression
+               logical-OR-expression ? expression : conditional-expression</pre>
+ (<a href="#6.5.16">6.5.16</a>) assignment-expression:
+<pre>
+               conditional-expression
+               unary-expression assignment-operator assignment-expression</pre>
+ (<a href="#6.5.16">6.5.16</a>) assignment-operator: one of
+<pre>
+               = *= /= %= +=                -=    &lt;&lt;=    &gt;&gt;=      &amp;=    ^=   |=</pre>
+ (<a href="#6.5.17">6.5.17</a>) expression:
+<pre>
+               assignment-expression
+               expression , assignment-expression</pre>
+ (<a href="#6.6">6.6</a>) constant-expression:
+<pre>
+               conditional-expression</pre>
+
+<a name="A.2.2" href="#A.2.2"><h4>A.2.2 Declarations</h4></a>
+ (<a href="#6.7">6.7</a>) declaration:
+<pre>
+                declaration-specifiers init-declarator-listopt ;
+                static_assert-declaration</pre>
+ (<a href="#6.7">6.7</a>) declaration-specifiers:
+<pre>
+                storage-class-specifier declaration-specifiersopt
+                type-specifier declaration-specifiersopt
+                type-qualifier declaration-specifiersopt
+                function-specifier declaration-specifiersopt
+                alignment-specifier declaration-specifiersopt</pre>
+ (<a href="#6.7">6.7</a>) init-declarator-list:
+<!--page 482 indent 0-->
+<pre>
+                init-declarator
+                init-declarator-list , init-declarator</pre>
+ (<a href="#6.7">6.7</a>) init-declarator:
+<pre>
+                declarator
+                declarator = initializer</pre>
+ (<a href="#6.7.1">6.7.1</a>) storage-class-specifier:
+<pre>
+               typedef
+               extern
+               static
+               _Thread_local
+               auto
+               register</pre>
+ (<a href="#6.7.2">6.7.2</a>) type-specifier:
+<pre>
+                void
+                char
+                short
+                int
+                long
+                float
+                double
+                signed
+                unsigned
+                _Bool
+                _Complex
+                atomic-type-specifier
+                struct-or-union-specifier
+                enum-specifier
+                typedef-name</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
+<pre>
+                struct-or-union identifieropt { struct-declaration-list }
+                struct-or-union identifier</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union:
+<pre>
+                struct
+                union</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration-list:
+<pre>
+                struct-declaration
+                struct-declaration-list struct-declaration</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration:
+<!--page 483 indent 0-->
+<pre>
+                specifier-qualifier-list struct-declarator-listopt ;
+                static_assert-declaration</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
+<pre>
+                type-specifier specifier-qualifier-listopt
+                type-qualifier specifier-qualifier-listopt</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator-list:
+<pre>
+                struct-declarator
+                struct-declarator-list , struct-declarator</pre>
+ (<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator:
+<pre>
+                declarator
+                declaratoropt : constant-expression</pre>
+ (<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
+<pre>
+               enum identifieropt { enumerator-list }
+               enum identifieropt { enumerator-list , }
+               enum identifier</pre>
+ (<a href="#6.7.2.2">6.7.2.2</a>) enumerator-list:
+<pre>
+               enumerator
+               enumerator-list , enumerator</pre>
+ (<a href="#6.7.2.2">6.7.2.2</a>) enumerator:
+<pre>
+               enumeration-constant
+               enumeration-constant = constant-expression</pre>
+ (<a href="#6.7.2.4">6.7.2.4</a>) atomic-type-specifier:
+<pre>
+               _Atomic ( type-name )</pre>
+ (<a href="#6.7.3">6.7.3</a>) type-qualifier:
+<pre>
+               const
+               restrict
+               volatile
+               _Atomic</pre>
+ (<a href="#6.7.4">6.7.4</a>) function-specifier:
+<pre>
+                inline
+                _Noreturn</pre>
+ (<a href="#6.7.5">6.7.5</a>) alignment-specifier:
+<pre>
+               _Alignas ( type-name )
+               _Alignas ( constant-expression )</pre>
+ (<a href="#6.7.6">6.7.6</a>) declarator:
+<!--page 484 indent 0-->
+<pre>
+               pointeropt direct-declarator</pre>
+ (<a href="#6.7.6">6.7.6</a>) direct-declarator:
+<pre>
+                identifier
+                ( declarator )
+                direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+                direct-declarator [ static type-qualifier-listopt assignment-expression ]
+                direct-declarator [ type-qualifier-list static assignment-expression ]
+                direct-declarator [ type-qualifier-listopt * ]
+                direct-declarator ( parameter-type-list )
+                direct-declarator ( identifier-listopt )</pre>
+ (<a href="#6.7.6">6.7.6</a>) pointer:
+<pre>
+                * type-qualifier-listopt
+                * type-qualifier-listopt pointer</pre>
+ (<a href="#6.7.6">6.7.6</a>) type-qualifier-list:
+<pre>
+               type-qualifier
+               type-qualifier-list type-qualifier</pre>
+ (<a href="#6.7.6">6.7.6</a>) parameter-type-list:
+<pre>
+              parameter-list
+              parameter-list , ...</pre>
+ (<a href="#6.7.6">6.7.6</a>) parameter-list:
+<pre>
+              parameter-declaration
+              parameter-list , parameter-declaration</pre>
+ (<a href="#6.7.6">6.7.6</a>) parameter-declaration:
+<pre>
+              declaration-specifiers declarator
+              declaration-specifiers abstract-declaratoropt</pre>
+ (<a href="#6.7.6">6.7.6</a>) identifier-list:
+<pre>
+                identifier
+                identifier-list , identifier</pre>
+ (<a href="#6.7.7">6.7.7</a>) type-name:
+<pre>
+               specifier-qualifier-list abstract-declaratoropt</pre>
+ (<a href="#6.7.7">6.7.7</a>) abstract-declarator:
+<!--page 485 indent 0-->
+<pre>
+               pointer
+               pointeropt direct-abstract-declarator</pre>
+ (<a href="#6.7.7">6.7.7</a>) direct-abstract-declarator:
+<pre>
+                ( abstract-declarator )
+                direct-abstract-declaratoropt [ type-qualifier-listopt
+                               assignment-expressionopt ]
+                direct-abstract-declaratoropt [ static type-qualifier-listopt
+                               assignment-expression ]
+                direct-abstract-declaratoropt [ type-qualifier-list static
+                               assignment-expression ]
+                direct-abstract-declaratoropt [ * ]
+                direct-abstract-declaratoropt ( parameter-type-listopt )</pre>
+ (<a href="#6.7.8">6.7.8</a>) typedef-name:
+<pre>
+               identifier</pre>
+ (<a href="#6.7.9">6.7.9</a>) initializer:
+<pre>
+                 assignment-expression
+                 { initializer-list }
+                 { initializer-list , }</pre>
+ (<a href="#6.7.9">6.7.9</a>) initializer-list:
+<pre>
+                 designationopt initializer
+                 initializer-list , designationopt initializer</pre>
+ (<a href="#6.7.9">6.7.9</a>) designation:
+<pre>
+               designator-list =</pre>
+ (<a href="#6.7.9">6.7.9</a>) designator-list:
+<pre>
+               designator
+               designator-list designator</pre>
+ (<a href="#6.7.9">6.7.9</a>) designator:
+<pre>
+               [ constant-expression ]
+               . identifier</pre>
+ (<a href="#6.7.10">6.7.10</a>) static_assert-declaration:
+<!--page 486 indent 0-->
+<pre>
+                _Static_assert ( constant-expression , string-literal ) ;</pre>
+
+<a name="A.2.3" href="#A.2.3"><h4>A.2.3 Statements</h4></a>
+ (<a href="#6.8">6.8</a>) statement:
+<pre>
+               labeled-statement
+               compound-statement
+               expression-statement
+               selection-statement
+               iteration-statement
+               jump-statement</pre>
+ (<a href="#6.8.1">6.8.1</a>) labeled-statement:
+<pre>
+                identifier : statement
+                case constant-expression : statement
+                default : statement</pre>
+ (<a href="#6.8.2">6.8.2</a>) compound-statement:
+<pre>
+              { block-item-listopt }</pre>
+ (<a href="#6.8.2">6.8.2</a>) block-item-list:
+<pre>
+                block-item
+                block-item-list block-item</pre>
+ (<a href="#6.8.2">6.8.2</a>) block-item:
+<pre>
+                declaration
+                statement</pre>
+ (<a href="#6.8.3">6.8.3</a>) expression-statement:
+<pre>
+               expressionopt ;</pre>
+ (<a href="#6.8.4">6.8.4</a>) selection-statement:
+<pre>
+                if ( expression ) statement
+                if ( expression ) statement else statement
+                switch ( expression ) statement</pre>
+ (<a href="#6.8.5">6.8.5</a>) iteration-statement:
+<pre>
+                 while ( expression ) statement
+                 do statement while ( expression ) ;
+                 for ( expressionopt ; expressionopt ; expressionopt ) statement
+                 for ( declaration expressionopt ; expressionopt ) statement</pre>
+ (<a href="#6.8.6">6.8.6</a>) jump-statement:
+<!--page 487 indent 0-->
+<pre>
+               goto identifier ;
+               continue ;
+               break ;
+               return expressionopt ;</pre>
+
+<a name="A.2.4" href="#A.2.4"><h4>A.2.4 External definitions</h4></a>
+ (<a href="#6.9">6.9</a>) translation-unit:
+<pre>
+                external-declaration
+                translation-unit external-declaration</pre>
+ (<a href="#6.9">6.9</a>) external-declaration:
+<pre>
+                function-definition
+                declaration</pre>
+ (<a href="#6.9.1">6.9.1</a>) function-definition:
+<pre>
+                declaration-specifiers declarator declaration-listopt compound-statement</pre>
+ (<a href="#6.9.1">6.9.1</a>) declaration-list:
+<pre>
+               declaration
+               declaration-list declaration</pre>
+
+<a name="A.3" href="#A.3"><h3>A.3 Preprocessing directives</h3></a>
+ (<a href="#6.10">6.10</a>) preprocessing-file:
+<pre>
+               groupopt</pre>
+ (<a href="#6.10">6.10</a>) group:
+<pre>
+                 group-part
+                 group group-part</pre>
+ (<a href="#6.10">6.10</a>) group-part:
+<pre>
+               if-section
+               control-line
+               text-line
+               # non-directive</pre>
+ (<a href="#6.10">6.10</a>) if-section:
+<pre>
+                 if-group elif-groupsopt else-groupopt endif-line</pre>
+ (<a href="#6.10">6.10</a>) if-group:
+<pre>
+                # if     constant-expression new-line groupopt
+                # ifdef identifier new-line groupopt
+                # ifndef identifier new-line groupopt</pre>
+ (<a href="#6.10">6.10</a>) elif-groups:
+<pre>
+                elif-group
+                elif-groups elif-group</pre>
+ (<a href="#6.10">6.10</a>) elif-group:
+<!--page 488 indent 0-->
+<pre>
+                # elif       constant-expression new-line groupopt</pre>
+ (<a href="#6.10">6.10</a>) else-group:
+<pre>
+                # else        new-line groupopt</pre>
+ (<a href="#6.10">6.10</a>) endif-line:
+<pre>
+                # endif       new-line</pre>
+ (<a href="#6.10">6.10</a>) control-line:
+<pre>
+               # include pp-tokens new-line
+               # define identifier replacement-list new-line
+               # define identifier lparen identifier-listopt )
+                                               replacement-list new-line
+               # define identifier lparen ... ) replacement-list new-line
+               # define identifier lparen identifier-list , ... )
+                                               replacement-list new-line
+               # undef   identifier new-line
+               # line    pp-tokens new-line
+               # error   pp-tokensopt new-line
+               # pragma pp-tokensopt new-line
+               #         new-line</pre>
+ (<a href="#6.10">6.10</a>) text-line:
+<pre>
+                pp-tokensopt new-line</pre>
+ (<a href="#6.10">6.10</a>) non-directive:
+<pre>
+               pp-tokens new-line</pre>
+ (<a href="#6.10">6.10</a>) lparen:
+<pre>
+                  a ( character not immediately preceded by white-space</pre>
+ (<a href="#6.10">6.10</a>) replacement-list:
+<pre>
+               pp-tokensopt</pre>
+ (<a href="#6.10">6.10</a>) pp-tokens:
+<pre>
+               preprocessing-token
+               pp-tokens preprocessing-token</pre>
+ (<a href="#6.10">6.10</a>) new-line:
+<!--page 489 indent 0-->
+<pre>
+               the new-line character</pre>
+
+<a name="B" href="#B"><h2>Annex B</h2></a>
+<pre>
+                              (informative)
+                          Library summary</pre>
+
+<a name="B.1" href="#B.1"><h3>B.1 Diagnostics <assert.h></h3></a>
+<pre>
+         NDEBUG
+         static_assert
+         void assert(scalar expression);</pre>
+
+<a name="B.2" href="#B.2"><h3>B.2 Complex <complex.h></h3></a>
+<!--page 490 indent -1-->
+<!--page 491 indent 0-->
+<pre>
+         __STDC_NO_COMPLEX__           imaginary
+         complex                         _Imaginary_I
+         _Complex_I                      I
+         #pragma STDC CX_LIMITED_RANGE on-off-switch
+         double complex cacos(double complex z);
+         float complex cacosf(float complex z);
+         long double complex cacosl(long double complex z);
+         double complex casin(double complex z);
+         float complex casinf(float complex z);
+         long double complex casinl(long double complex z);
+         double complex catan(double complex z);
+         float complex catanf(float complex z);
+         long double complex catanl(long double complex z);
+         double complex ccos(double complex z);
+         float complex ccosf(float complex z);
+         long double complex ccosl(long double complex z);
+         double complex csin(double complex z);
+         float complex csinf(float complex z);
+         long double complex csinl(long double complex z);
+         double complex ctan(double complex z);
+         float complex ctanf(float complex z);
+         long double complex ctanl(long double complex z);
+         double complex cacosh(double complex z);
+         float complex cacoshf(float complex z);
+         long double complex cacoshl(long double complex z);
+         double complex casinh(double complex z);
+         float complex casinhf(float complex z);
+         long double complex casinhl(long double complex z);
+       double complex catanh(double complex z);
+       float complex catanhf(float complex z);
+       long double complex catanhl(long double complex z);
+       double complex ccosh(double complex z);
+       float complex ccoshf(float complex z);
+       long double complex ccoshl(long double complex z);
+       double complex csinh(double complex z);
+       float complex csinhf(float complex z);
+       long double complex csinhl(long double complex z);
+       double complex ctanh(double complex z);
+       float complex ctanhf(float complex z);
+       long double complex ctanhl(long double complex z);
+       double complex cexp(double complex z);
+       float complex cexpf(float complex z);
+       long double complex cexpl(long double complex z);
+       double complex clog(double complex z);
+       float complex clogf(float complex z);
+       long double complex clogl(long double complex z);
+       double cabs(double complex z);
+       float cabsf(float complex z);
+       long double cabsl(long double complex z);
+       double complex cpow(double complex x, double complex y);
+       float complex cpowf(float complex x, float complex y);
+       long double complex cpowl(long double complex x,
+            long double complex y);
+       double complex csqrt(double complex z);
+       float complex csqrtf(float complex z);
+       long double complex csqrtl(long double complex z);
+       double carg(double complex z);
+       float cargf(float complex z);
+       long double cargl(long double complex z);
+       double cimag(double complex z);
+       float cimagf(float complex z);
+       long double cimagl(long double complex z);
+       double complex CMPLX(double x, double y);
+       float complex CMPLXF(float x, float y);
+       long double complex CMPLXL(long double x, long double y);
+       double complex conj(double complex z);
+       float complex conjf(float complex z);
+       long double complex conjl(long double complex z);
+       double complex cproj(double complex z);
+         float complex cprojf(float complex z);
+         long double complex cprojl(long double complex z);
+         double creal(double complex z);
+         float crealf(float complex z);
+         long double creall(long double complex z);</pre>
+
+<a name="B.3" href="#B.3"><h3>B.3 Character handling <ctype.h></h3></a>
+<pre>
+         int   isalnum(int c);
+         int   isalpha(int c);
+         int   isblank(int c);
+         int   iscntrl(int c);
+         int   isdigit(int c);
+         int   isgraph(int c);
+         int   islower(int c);
+         int   isprint(int c);
+         int   ispunct(int c);
+         int   isspace(int c);
+         int   isupper(int c);
+         int   isxdigit(int c);
+         int   tolower(int c);
+         int   toupper(int c);</pre>
+
+<a name="B.4" href="#B.4"><h3>B.4 Errors <errno.h></h3></a>
+<pre>
+         EDOM           EILSEQ            ERANGE           errno
+         __STDC_WANT_LIB_EXT1__
+         errno_t</pre>
+
+<a name="B.5" href="#B.5"><h3>B.5 Floating-point environment <fenv.h></h3></a>
+<!--page 492 indent 0-->
+<pre>
+         fenv_t               FE_OVERFLOW             FE_TOWARDZERO
+         fexcept_t            FE_UNDERFLOW            FE_UPWARD
+         FE_DIVBYZERO         FE_ALL_EXCEPT           FE_DFL_ENV
+         FE_INEXACT           FE_DOWNWARD
+         FE_INVALID           FE_TONEAREST
+         #pragma STDC FENV_ACCESS on-off-switch
+         int feclearexcept(int excepts);
+         int fegetexceptflag(fexcept_t *flagp, int excepts);
+         int feraiseexcept(int excepts);
+         int fesetexceptflag(const fexcept_t *flagp,
+              int excepts);
+         int fetestexcept(int excepts);
+       int   fegetround(void);
+       int   fesetround(int round);
+       int   fegetenv(fenv_t *envp);
+       int   feholdexcept(fenv_t *envp);
+       int   fesetenv(const fenv_t *envp);
+       int   feupdateenv(const fenv_t *envp);</pre>
+
+<a name="B.6" href="#B.6"><h3>B.6 Characteristics of floating types <float.h></h3></a>
+<pre>
+       FLT_ROUNDS              DBL_DIG                 FLT_MAX
+       FLT_EVAL_METHOD         LDBL_DIG                DBL_MAX
+       FLT_HAS_SUBNORM         FLT_MIN_EXP             LDBL_MAX
+       DBL_HAS_SUBNORM         DBL_MIN_EXP             FLT_EPSILON
+       LDBL_HAS_SUBNORM        LDBL_MIN_EXP            DBL_EPSILON
+       FLT_RADIX               FLT_MIN_10_EXP          LDBL_EPSILON
+       FLT_MANT_DIG            DBL_MIN_10_EXP          FLT_MIN
+       DBL_MANT_DIG            LDBL_MIN_10_EXP         DBL_MIN
+       LDBL_MANT_DIG           FLT_MAX_EXP             LDBL_MIN
+       FLT_DECIMAL_DIG         DBL_MAX_EXP             FLT_TRUE_MIN
+       DBL_DECIMAL_DIG         LDBL_MAX_EXP            DBL_TRUE_MIN
+       LDBL_DECIMAL_DIG        FLT_MAX_10_EXP          LDBL_TRUE_MIN
+       DECIMAL_DIG             DBL_MAX_10_EXP
+       FLT_DIG                 LDBL_MAX_10_EXP</pre>
+
+<a name="B.7" href="#B.7"><h3>B.7 Format conversion of integer types <inttypes.h></h3></a>
+<!--page 493 indent 0-->
+<pre>
+       imaxdiv_t
+       PRIdN         PRIdLEASTN       PRIdFASTN        PRIdMAX    PRIdPTR
+       PRIiN         PRIiLEASTN       PRIiFASTN        PRIiMAX    PRIiPTR
+       PRIoN         PRIoLEASTN       PRIoFASTN        PRIoMAX    PRIoPTR
+       PRIuN         PRIuLEASTN       PRIuFASTN        PRIuMAX    PRIuPTR
+       PRIxN         PRIxLEASTN       PRIxFASTN        PRIxMAX    PRIxPTR
+       PRIXN         PRIXLEASTN       PRIXFASTN        PRIXMAX    PRIXPTR
+       SCNdN         SCNdLEASTN       SCNdFASTN        SCNdMAX    SCNdPTR
+       SCNiN         SCNiLEASTN       SCNiFASTN        SCNiMAX    SCNiPTR
+       SCNoN         SCNoLEASTN       SCNoFASTN        SCNoMAX    SCNoPTR
+       SCNuN         SCNuLEASTN       SCNuFASTN        SCNuMAX    SCNuPTR
+       SCNxN         SCNxLEASTN       SCNxFASTN        SCNxMAX    SCNxPTR
+       intmax_t imaxabs(intmax_t j);
+       imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+       intmax_t strtoimax(const char * restrict nptr,
+               char ** restrict endptr, int base);
+         uintmax_t strtoumax(const char * restrict nptr,
+                 char ** restrict endptr, int base);
+         intmax_t wcstoimax(const wchar_t * restrict nptr,
+                 wchar_t ** restrict endptr, int base);
+         uintmax_t wcstoumax(const wchar_t * restrict nptr,
+                 wchar_t ** restrict endptr, int base);</pre>
+
+<a name="B.8" href="#B.8"><h3>B.8 Alternative spellings <iso646.h></h3></a>
+<pre>
+         and            bitor             not_eq           xor
+         and_eq         compl             or               xor_eq
+         bitand         not               or_eq</pre>
+
+<a name="B.9" href="#B.9"><h3>B.9 Sizes of integer types <limits.h></h3></a>
+<pre>
+         CHAR_BIT       CHAR_MAX          INT_MIN          ULONG_MAX
+         SCHAR_MIN      MB_LEN_MAX        INT_MAX          LLONG_MIN
+         SCHAR_MAX      SHRT_MIN          UINT_MAX         LLONG_MAX
+         UCHAR_MAX      SHRT_MAX          LONG_MIN         ULLONG_MAX
+         CHAR_MIN       USHRT_MAX         LONG_MAX</pre>
+
+<a name="B.10" href="#B.10"><h3>B.10 Localization <locale.h></h3></a>
+<pre>
+         struct lconv   LC_ALL            LC_CTYPE         LC_NUMERIC
+         NULL           LC_COLLATE        LC_MONETARY      LC_TIME
+         char *setlocale(int category, const char *locale);
+         struct lconv *localeconv(void);</pre>
+
+<a name="B.11" href="#B.11"><h3>B.11 Mathematics <math.h></h3></a>
+<!--page 494 indent -1-->
+<!--page 495 indent -1-->
+<!--page 496 indent -1-->
+<!--page 497 indent -1-->
+<!--page 498 indent 0-->
+<pre>
+         float_t              FP_INFINITE             FP_FAST_FMAL
+         double_t             FP_NAN                  FP_ILOGB0
+         HUGE_VAL             FP_NORMAL               FP_ILOGBNAN
+         HUGE_VALF            FP_SUBNORMAL            MATH_ERRNO
+         HUGE_VALL            FP_ZERO                 MATH_ERREXCEPT
+         INFINITY             FP_FAST_FMA             math_errhandling
+         NAN                  FP_FAST_FMAF
+         #pragma STDC FP_CONTRACT on-off-switch
+         int fpclassify(real-floating x);
+         int isfinite(real-floating x);
+         int isinf(real-floating x);
+         int isnan(real-floating x);
+         int isnormal(real-floating x);
+         int signbit(real-floating x);
+       double acos(double x);
+       float acosf(float x);
+       long double acosl(long double x);
+       double asin(double x);
+       float asinf(float x);
+       long double asinl(long double x);
+       double atan(double x);
+       float atanf(float x);
+       long double atanl(long double x);
+       double atan2(double y, double x);
+       float atan2f(float y, float x);
+       long double atan2l(long double y, long double x);
+       double cos(double x);
+       float cosf(float x);
+       long double cosl(long double x);
+       double sin(double x);
+       float sinf(float x);
+       long double sinl(long double x);
+       double tan(double x);
+       float tanf(float x);
+       long double tanl(long double x);
+       double acosh(double x);
+       float acoshf(float x);
+       long double acoshl(long double x);
+       double asinh(double x);
+       float asinhf(float x);
+       long double asinhl(long double x);
+       double atanh(double x);
+       float atanhf(float x);
+       long double atanhl(long double x);
+       double cosh(double x);
+       float coshf(float x);
+       long double coshl(long double x);
+       double sinh(double x);
+       float sinhf(float x);
+       long double sinhl(long double x);
+       double tanh(double x);
+       float tanhf(float x);
+       long double tanhl(long double x);
+       double exp(double x);
+       float expf(float x);
+         long double expl(long double x);
+         double exp2(double x);
+         float exp2f(float x);
+         long double exp2l(long double x);
+         double expm1(double x);
+         float expm1f(float x);
+         long double expm1l(long double x);
+         double frexp(double value, int *exp);
+         float frexpf(float value, int *exp);
+         long double frexpl(long double value, int *exp);
+         int ilogb(double x);
+         int ilogbf(float x);
+         int ilogbl(long double x);
+         double ldexp(double x, int exp);
+         float ldexpf(float x, int exp);
+         long double ldexpl(long double x, int exp);
+         double log(double x);
+         float logf(float x);
+         long double logl(long double x);
+         double log10(double x);
+         float log10f(float x);
+         long double log10l(long double x);
+         double log1p(double x);
+         float log1pf(float x);
+         long double log1pl(long double x);
+         double log2(double x);
+         float log2f(float x);
+         long double log2l(long double x);
+         double logb(double x);
+         float logbf(float x);
+         long double logbl(long double x);
+         double modf(double value, double *iptr);
+         float modff(float value, float *iptr);
+         long double modfl(long double value, long double *iptr);
+         double scalbn(double x, int n);
+         float scalbnf(float x, int n);
+         long double scalbnl(long double x, int n);
+         double scalbln(double x, long int n);
+         float scalblnf(float x, long int n);
+         long double scalblnl(long double x, long int n);
+         double cbrt(double x);
+       float cbrtf(float x);
+       long double cbrtl(long double x);
+       double fabs(double x);
+       float fabsf(float x);
+       long double fabsl(long double x);
+       double hypot(double x, double y);
+       float hypotf(float x, float y);
+       long double hypotl(long double x, long double y);
+       double pow(double x, double y);
+       float powf(float x, float y);
+       long double powl(long double x, long double y);
+       double sqrt(double x);
+       float sqrtf(float x);
+       long double sqrtl(long double x);
+       double erf(double x);
+       float erff(float x);
+       long double erfl(long double x);
+       double erfc(double x);
+       float erfcf(float x);
+       long double erfcl(long double x);
+       double lgamma(double x);
+       float lgammaf(float x);
+       long double lgammal(long double x);
+       double tgamma(double x);
+       float tgammaf(float x);
+       long double tgammal(long double x);
+       double ceil(double x);
+       float ceilf(float x);
+       long double ceill(long double x);
+       double floor(double x);
+       float floorf(float x);
+       long double floorl(long double x);
+       double nearbyint(double x);
+       float nearbyintf(float x);
+       long double nearbyintl(long double x);
+       double rint(double x);
+       float rintf(float x);
+       long double rintl(long double x);
+       long int lrint(double x);
+       long int lrintf(float x);
+       long int lrintl(long double x);
+         long long int llrint(double x);
+         long long int llrintf(float x);
+         long long int llrintl(long double x);
+         double round(double x);
+         float roundf(float x);
+         long double roundl(long double x);
+         long int lround(double x);
+         long int lroundf(float x);
+         long int lroundl(long double x);
+         long long int llround(double x);
+         long long int llroundf(float x);
+         long long int llroundl(long double x);
+         double trunc(double x);
+         float truncf(float x);
+         long double truncl(long double x);
+         double fmod(double x, double y);
+         float fmodf(float x, float y);
+         long double fmodl(long double x, long double y);
+         double remainder(double x, double y);
+         float remainderf(float x, float y);
+         long double remainderl(long double x, long double y);
+         double remquo(double x, double y, int *quo);
+         float remquof(float x, float y, int *quo);
+         long double remquol(long double x, long double y,
+              int *quo);
+         double copysign(double x, double y);
+         float copysignf(float x, float y);
+         long double copysignl(long double x, long double y);
+         double nan(const char *tagp);
+         float nanf(const char *tagp);
+         long double nanl(const char *tagp);
+         double nextafter(double x, double y);
+         float nextafterf(float x, float y);
+         long double nextafterl(long double x, long double y);
+         double nexttoward(double x, long double y);
+         float nexttowardf(float x, long double y);
+         long double nexttowardl(long double x, long double y);
+         double fdim(double x, double y);
+         float fdimf(float x, float y);
+         long double fdiml(long double x, long double y);
+         double fmax(double x, double y);
+       float fmaxf(float x, float y);
+       long double fmaxl(long double x, long double y);
+       double fmin(double x, double y);
+       float fminf(float x, float y);
+       long double fminl(long double x, long double y);
+       double fma(double x, double y, double z);
+       float fmaf(float x, float y, float z);
+       long double fmal(long double x, long double y,
+            long double z);
+       int isgreater(real-floating x, real-floating y);
+       int isgreaterequal(real-floating x, real-floating y);
+       int isless(real-floating x, real-floating y);
+       int islessequal(real-floating x, real-floating y);
+       int islessgreater(real-floating x, real-floating y);
+       int isunordered(real-floating x, real-floating y);</pre>
+
+<a name="B.12" href="#B.12"><h3>B.12 Nonlocal jumps <setjmp.h></h3></a>
+<pre>
+       jmp_buf
+       int setjmp(jmp_buf env);
+       _Noreturn void longjmp(jmp_buf env, int val);</pre>
+
+<a name="B.13" href="#B.13"><h3>B.13 Signal handling <signal.h></h3></a>
+<!--page 499 indent 0-->
+<pre>
+       sig_atomic_t    SIG_IGN           SIGILL           SIGTERM
+       SIG_DFL         SIGABRT           SIGINT
+       SIG_ERR         SIGFPE            SIGSEGV
+       void (*signal(int sig, void (*func)(int)))(int);
+       int raise(int sig);</pre>
+
+<a name="B.14" href="#B.14"><h3>B.14 Alignment <stdalign.h></h3></a>
+<pre>
+         alignas
+         __alignas_is_defined</pre>
+
+<a name="B.15" href="#B.15"><h3>B.15 Variable arguments <stdarg.h></h3></a>
+<pre>
+         va_list
+         type va_arg(va_list ap, type);
+         void va_copy(va_list dest, va_list src);
+         void va_end(va_list ap);
+         void va_start(va_list ap, parmN);</pre>
+
+<a name="B.16" href="#B.16"><h3>B.16 Atomics <stdatomic.h></h3></a>
+<!--page 500 indent -1-->
+<!--page 501 indent 0-->
+<pre>
+         ATOMIC_CHAR_LOCK_FREE           atomic_uint
+         ATOMIC_CHAR16_T_LOCK_FREE       atomic_long
+         ATOMIC_CHAR32_T_LOCK_FREE       atomic_ulong
+         ATOMIC_WCHAR_T_LOCK_FREE        atomic_llong
+         ATOMIC_SHORT_LOCK_FREE          atomic_ullong
+         ATOMIC_INT_LOCK_FREE            atomic_char16_t
+         ATOMIC_LONG_LOCK_FREE           atomic_char32_t
+         ATOMIC_LLONG_LOCK_FREE          atomic_wchar_t
+         ATOMIC_ADDRESS_LOCK_FREE        atomic_int_least8_t
+         ATOMIC_FLAG_INIT                atomic_uint_least8_t
+         memory_order                    atomic_int_least16_t
+         atomic_flag                     atomic_uint_least16_t
+         atomic_bool                     atomic_int_least32_t
+         atomic_address                  atomic_uint_least32_t
+         memory_order_relaxed            atomic_int_least64_t
+         memory_order_consume            atomic_uint_least64_t
+         memory_order_acquire            atomic_int_fast8_t
+         memory_order_release            atomic_uint_fast8_t
+         memory_order_acq_rel            atomic_int_fast16_t
+         memory_order_seq_cst            atomic_uint_fast16_t
+         atomic_char                     atomic_int_fast32_t
+         atomic_schar                    atomic_uint_fast32_t
+         atomic_uchar                    atomic_int_fast64_t
+         atomic_short                    atomic_uint_fast64_t
+         atomic_ushort                   atomic_intptr_t
+         atomic_int                      atomic_uintptr_t
+       atomic_size_t                     atomic_intmax_t
+       atomic_ptrdiff_t                  atomic_uintmax_t
+       #define ATOMIC_VAR_INIT(C value)
+       void atomic_init(volatile A *obj, C value);
+       type kill_dependency(type y);
+       void atomic_thread_fence(memory_order order);
+       void atomic_signal_fence(memory_order order);
+       _Bool atomic_is_lock_free(atomic_type const volatile *obj);
+       void atomic_store(volatile A *object, C desired);
+       void atomic_store_explicit(volatile A *object,
+             C desired, memory_order order);
+       C atomic_load(volatile A *object);
+       C atomic_load_explicit(volatile A *object,
+             memory_order order);
+       C atomic_exchange(volatile A *object, C desired);
+       C atomic_exchange_explicit(volatile A *object,
+             C desired, memory_order order);
+       _Bool atomic_compare_exchange_strong(volatile A *object,
+             C *expected, C desired);
+       _Bool atomic_compare_exchange_strong_explicit(
+             volatile A *object, C *expected, C desired,
+             memory_order success, memory_order failure);
+       _Bool atomic_compare_exchange_weak(volatile A *object,
+             C *expected, C desired);
+       _Bool atomic_compare_exchange_weak_explicit(
+             volatile A *object, C *expected, C desired,
+             memory_order success, memory_order failure);
+       C atomic_fetch_key(volatile A *object, M operand);
+       C atomic_fetch_key_explicit(volatile A *object,
+             M operand, memory_order order);
+       bool atomic_flag_test_and_set(
+             volatile atomic_flag *object);
+       bool atomic_flag_test_and_set_explicit(
+             volatile atomic_flag *object, memory_order order);
+       void atomic_flag_clear(volatile atomic_flag *object);
+       void atomic_flag_clear_explicit(
+             volatile atomic_flag *object, memory_order order);</pre>
+
+<a name="B.17" href="#B.17"><h3>B.17 Boolean type and values <stdbool.h></h3></a>
+<pre>
+         bool
+         true
+         false
+         __bool_true_false_are_defined</pre>
+
+<a name="B.18" href="#B.18"><h3>B.18 Common definitions <stddef.h></h3></a>
+<pre>
+         ptrdiff_t       max_align_t       NULL
+         size_t          wchar_t
+         offsetof(type, member-designator)
+         __STDC_WANT_LIB_EXT1__
+         rsize_t</pre>
+
+<a name="B.19" href="#B.19"><h3>B.19 Integer types <stdint.h></h3></a>
+<!--page 502 indent 0-->
+<pre>
+         intN_t                INT_LEASTN_MIN          PTRDIFF_MAX
+         uintN_t               INT_LEASTN_MAX          SIG_ATOMIC_MIN
+         int_leastN_t          UINT_LEASTN_MAX         SIG_ATOMIC_MAX
+         uint_leastN_t         INT_FASTN_MIN           SIZE_MAX
+         int_fastN_t           INT_FASTN_MAX           WCHAR_MIN
+         uint_fastN_t          UINT_FASTN_MAX          WCHAR_MAX
+         intptr_t              INTPTR_MIN              WINT_MIN
+         uintptr_t             INTPTR_MAX              WINT_MAX
+         intmax_t              UINTPTR_MAX             INTN_C(value)
+         uintmax_t             INTMAX_MIN              UINTN_C(value)
+         INTN_MIN              INTMAX_MAX              INTMAX_C(value)
+         INTN_MAX              UINTMAX_MAX             UINTMAX_C(value)
+         UINTN_MAX             PTRDIFF_MIN
+         __STDC_WANT_LIB_EXT1__
+         RSIZE_MAX</pre>
+
+<a name="B.20" href="#B.20"><h3>B.20 Input/output <stdio.h></h3></a>
+<!--page 503 indent -1-->
+<!--page 504 indent -1-->
+<!--page 505 indent 0-->
+<pre>
+       size_t          _IOLBF            FILENAME_MAX     TMP_MAX
+       FILE            _IONBF            L_tmpnam         stderr
+       fpos_t          BUFSIZ            SEEK_CUR         stdin
+       NULL            EOF               SEEK_END         stdout
+       _IOFBF          FOPEN_MAX         SEEK_SET
+       int remove(const char *filename);
+       int rename(const char *old, const char *new);
+       FILE *tmpfile(void);
+       char *tmpnam(char *s);
+       int fclose(FILE *stream);
+       int fflush(FILE *stream);
+       FILE *fopen(const char * restrict filename,
+            const char * restrict mode);
+       FILE *freopen(const char * restrict filename,
+            const char * restrict mode,
+            FILE * restrict stream);
+       void setbuf(FILE * restrict stream,
+            char * restrict buf);
+       int setvbuf(FILE * restrict stream,
+            char * restrict buf,
+            int mode, size_t size);
+       int fprintf(FILE * restrict stream,
+            const char * restrict format, ...);
+       int fscanf(FILE * restrict stream,
+            const char * restrict format, ...);
+       int printf(const char * restrict format, ...);
+       int scanf(const char * restrict format, ...);
+       int snprintf(char * restrict s, size_t n,
+            const char * restrict format, ...);
+       int sprintf(char * restrict s,
+            const char * restrict format, ...);
+       int sscanf(const char * restrict s,
+            const char * restrict format, ...);
+       int vfprintf(FILE * restrict stream,
+            const char * restrict format, va_list arg);
+       int vfscanf(FILE * restrict stream,
+            const char * restrict format, va_list arg);
+       int vprintf(const char * restrict format, va_list arg);
+       int vscanf(const char * restrict format, va_list arg);
+         int vsnprintf(char * restrict s, size_t n,
+              const char * restrict format, va_list arg);
+         int vsprintf(char * restrict s,
+              const char * restrict format, va_list arg);
+         int vsscanf(const char * restrict s,
+              const char * restrict format, va_list arg);
+         int fgetc(FILE *stream);
+         char *fgets(char * restrict s, int n,
+              FILE * restrict stream);
+         int fputc(int c, FILE *stream);
+         int fputs(const char * restrict s,
+              FILE * restrict stream);
+         int getc(FILE *stream);
+         int getchar(void);
+         int putc(int c, FILE *stream);                                       *
+         int putchar(int c);
+         int puts(const char *s);
+         int ungetc(int c, FILE *stream);
+         size_t fread(void * restrict ptr,
+              size_t size, size_t nmemb,
+              FILE * restrict stream);
+         size_t fwrite(const void * restrict ptr,
+              size_t size, size_t nmemb,
+              FILE * restrict stream);
+         int fgetpos(FILE * restrict stream,
+              fpos_t * restrict pos);
+         int fseek(FILE *stream, long int offset, int whence);
+         int fsetpos(FILE *stream, const fpos_t *pos);
+         long int ftell(FILE *stream);
+         void rewind(FILE *stream);
+         void clearerr(FILE *stream);
+         int feof(FILE *stream);
+         int ferror(FILE *stream);
+         void perror(const char *s);
+         __STDC_WANT_LIB_EXT1__
+         L_tmpnam_s    TMP_MAX_S         errno_t          rsize_t
+         errno_t tmpfile_s(FILE * restrict * restrict streamptr);
+         errno_t tmpnam_s(char *s, rsize_t maxsize);
+       errno_t fopen_s(FILE * restrict * restrict streamptr,
+            const char * restrict filename,
+            const char * restrict mode);
+       errno_t freopen_s(FILE * restrict * restrict newstreamptr,
+            const char * restrict filename,
+            const char * restrict mode,
+            FILE * restrict stream);
+       int fprintf_s(FILE * restrict stream,
+            const char * restrict format, ...);
+       int fscanf_s(FILE * restrict stream,
+            const char * restrict format, ...);
+       int printf_s(const char * restrict format, ...);
+       int scanf_s(const char * restrict format, ...);
+       int snprintf_s(char * restrict s, rsize_t n,
+            const char * restrict format, ...);
+       int sprintf_s(char * restrict s, rsize_t n,
+            const char * restrict format, ...);
+       int sscanf_s(const char * restrict s,
+            const char * restrict format, ...);
+       int vfprintf_s(FILE * restrict stream,
+            const char * restrict format,
+            va_list arg);
+       int vfscanf_s(FILE * restrict stream,
+            const char * restrict format,
+            va_list arg);
+       int vprintf_s(const char * restrict format,
+            va_list arg);
+       int vscanf_s(const char * restrict format,
+            va_list arg);
+       int vsnprintf_s(char * restrict s, rsize_t n,
+            const char * restrict format,
+            va_list arg);
+       int vsprintf_s(char * restrict s, rsize_t n,
+            const char * restrict format,
+            va_list arg);
+       int vsscanf_s(const char * restrict s,
+            const char * restrict format,
+            va_list arg);
+       char *gets_s(char *s, rsize_t n);</pre>
+
+<a name="B.21" href="#B.21"><h3>B.21 General utilities <stdlib.h></h3></a>
+<!--page 506 indent -1-->
+<!--page 507 indent 0-->
+<pre>
+         size_t       ldiv_t            EXIT_FAILURE     MB_CUR_MAX
+         wchar_t      lldiv_t           EXIT_SUCCESS
+         div_t        NULL              RAND_MAX
+         double atof(const char *nptr);
+         int atoi(const char *nptr);
+         long int atol(const char *nptr);
+         long long int atoll(const char *nptr);
+         double strtod(const char * restrict nptr,
+              char ** restrict endptr);
+         float strtof(const char * restrict nptr,
+              char ** restrict endptr);
+         long double strtold(const char * restrict nptr,
+              char ** restrict endptr);
+         long int strtol(const char * restrict nptr,
+              char ** restrict endptr, int base);
+         long long int strtoll(const char * restrict nptr,
+              char ** restrict endptr, int base);
+         unsigned long int strtoul(
+              const char * restrict nptr,
+              char ** restrict endptr, int base);
+         unsigned long long int strtoull(
+              const char * restrict nptr,
+              char ** restrict endptr, int base);
+         int rand(void);
+         void srand(unsigned int seed);
+         void *aligned_alloc(size_t alignment, size_t size);
+         void *calloc(size_t nmemb, size_t size);
+         void free(void *ptr);
+         void *malloc(size_t size);
+         void *realloc(void *ptr, size_t size);
+         _Noreturn void abort(void);
+         int atexit(void (*func)(void));
+         int at_quick_exit(void (*func)(void));
+         _Noreturn void exit(int status);
+         _Noreturn void _Exit(int status);
+         char *getenv(const char *name);
+         _Noreturn void quick_exit(int status);
+         int system(const char *string);
+       void *bsearch(const void *key, const void *base,
+            size_t nmemb, size_t size,
+            int (*compar)(const void *, const void *));
+       void qsort(void *base, size_t nmemb, size_t size,
+            int (*compar)(const void *, const void *));
+       int abs(int j);
+       long int labs(long int j);
+       long long int llabs(long long int j);
+       div_t div(int numer, int denom);
+       ldiv_t ldiv(long int numer, long int denom);
+       lldiv_t lldiv(long long int numer,
+            long long int denom);
+       int mblen(const char *s, size_t n);
+       int mbtowc(wchar_t * restrict pwc,
+            const char * restrict s, size_t n);
+       int wctomb(char *s, wchar_t wchar);
+       size_t mbstowcs(wchar_t * restrict pwcs,
+            const char * restrict s, size_t n);
+       size_t wcstombs(char * restrict s,
+            const wchar_t * restrict pwcs, size_t n);
+       __STDC_WANT_LIB_EXT1__
+       errno_t
+       rsize_t
+       constraint_handler_t
+       constraint_handler_t set_constraint_handler_s(
+            constraint_handler_t handler);
+       void abort_handler_s(
+            const char * restrict msg,
+            void * restrict ptr,
+            errno_t error);
+       void ignore_handler_s(
+            const char * restrict msg,
+            void * restrict ptr,
+            errno_t error);
+       errno_t getenv_s(size_t * restrict len,
+                 char * restrict value, rsize_t maxsize,
+                 const char * restrict name);
+         void *bsearch_s(const void *key, const void *base,
+              rsize_t nmemb, rsize_t size,
+              int (*compar)(const void *k, const void *y,
+                              void *context),
+              void *context);
+         errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
+              int (*compar)(const void *x, const void *y,
+                              void *context),
+              void *context);
+         errno_t wctomb_s(int * restrict status,
+              char * restrict s,
+              rsize_t smax,
+              wchar_t wc);
+         errno_t mbstowcs_s(size_t * restrict retval,
+              wchar_t * restrict dst, rsize_t dstmax,
+              const char * restrict src, rsize_t len);
+         errno_t wcstombs_s(size_t * restrict retval,
+              char * restrict dst, rsize_t dstmax,
+              const wchar_t * restrict src, rsize_t len);</pre>
+
+<a name="B.22" href="#B.22"><h3>B.22 String handling <string.h></h3></a>
+<!--page 508 indent -1-->
+<!--page 509 indent 0-->
+<pre>
+         size_t
+         NULL
+         void *memcpy(void * restrict s1,
+              const void * restrict s2, size_t n);
+         void *memmove(void *s1, const void *s2, size_t n);
+         char *strcpy(char * restrict s1,
+              const char * restrict s2);
+         char *strncpy(char * restrict s1,
+              const char * restrict s2, size_t n);
+         char *strcat(char * restrict s1,
+              const char * restrict s2);
+         char *strncat(char * restrict s1,
+              const char * restrict s2, size_t n);
+         int memcmp(const void *s1, const void *s2, size_t n);
+         int strcmp(const char *s1, const char *s2);
+         int strcoll(const char *s1, const char *s2);
+         int strncmp(const char *s1, const char *s2, size_t n);
+         size_t strxfrm(char * restrict s1,
+              const char * restrict s2, size_t n);
+         void *memchr(const void *s, int c, size_t n);
+       char *strchr(const char *s, int c);
+       size_t strcspn(const char *s1, const char *s2);
+       char *strpbrk(const char *s1, const char *s2);
+       char *strrchr(const char *s, int c);
+       size_t strspn(const char *s1, const char *s2);
+       char *strstr(const char *s1, const char *s2);
+       char *strtok(char * restrict s1,
+            const char * restrict s2);
+       void *memset(void *s, int c, size_t n);
+       char *strerror(int errnum);
+       size_t strlen(const char *s);
+       __STDC_WANT_LIB_EXT1__
+       errno_t
+       rsize_t
+       errno_t memcpy_s(void * restrict s1, rsize_t s1max,
+            const void * restrict s2, rsize_t n);
+       errno_t memmove_s(void *s1, rsize_t s1max,
+            const void *s2, rsize_t n);
+       errno_t strcpy_s(char * restrict s1,
+            rsize_t s1max,
+            const char * restrict s2);
+       errno_t strncpy_s(char * restrict s1,
+            rsize_t s1max,
+            const char * restrict s2,
+            rsize_t n);
+       errno_t strcat_s(char * restrict s1,
+            rsize_t s1max,
+            const char * restrict s2);
+       errno_t strncat_s(char * restrict s1,
+            rsize_t s1max,
+            const char * restrict s2,
+            rsize_t n);
+       char *strtok_s(char * restrict s1,
+            rsize_t * restrict s1max,
+            const char * restrict s2,
+            char ** restrict ptr);
+       errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)
+       errno_t strerror_s(char *s, rsize_t maxsize,
+            errno_t errnum);
+       size_t strerrorlen_s(errno_t errnum);
+         size_t strnlen_s(const char *s, size_t maxsize);</pre>
+
+<a name="B.23" href="#B.23"><h3>B.23 Type-generic math <tgmath.h></h3></a>
+<pre>
+         acos         sqrt              fmod             nextafter
+         asin         fabs              frexp            nexttoward
+         atan         atan2             hypot            remainder
+         acosh        cbrt              ilogb            remquo
+         asinh        ceil              ldexp            rint
+         atanh        copysign          lgamma           round
+         cos          erf               llrint           scalbn
+         sin          erfc              llround          scalbln
+         tan          exp2              log10            tgamma
+         cosh         expm1             log1p            trunc
+         sinh         fdim              log2             carg
+         tanh         floor             logb             cimag
+         exp          fma               lrint            conj
+         log          fmax              lround           cproj
+         pow          fmin              nearbyint        creal</pre>
+
+<a name="B.24" href="#B.24"><h3>B.24 Threads <threads.h></h3></a>
+<!--page 510 indent 0-->
+<pre>
+         ONCE_FLAG_INIT                 mtx_plain
+         TSS_DTOR_ITERATIONS            mtx_recursive
+         cnd_t                          mtx_timed
+         thrd_t                         mtx_try
+         tss_t                          thrd_timeout
+         mtx_t                          thrd_success
+         tss_dtor_t                     thrd_busy
+         thrd_start_t                   thrd_error
+         once_flag                      thrd_nomem
+         xtime
+       void call_once(once_flag *flag, void (*func)(void));
+       int cnd_broadcast(cnd_t *cond);
+       void cnd_destroy(cnd_t *cond);
+       int cnd_init(cnd_t *cond);
+       int cnd_signal(cnd_t *cond);
+       int cnd_timedwait(cnd_t *cond, mtx_t *mtx,
+            const xtime *xt);
+       int cnd_wait(cnd_t *cond, mtx_t *mtx);
+       void mtx_destroy(mtx_t *mtx);
+       int mtx_init(mtx_t *mtx, int type);
+       int mtx_lock(mtx_t *mtx);
+       int mtx_timedlock(mtx_t *mtx, const xtime *xt);
+       int mtx_trylock(mtx_t *mtx);
+       int mtx_unlock(mtx_t *mtx);
+       int thrd_create(thrd_t *thr, thrd_start_t func,
+            void *arg);
+       thrd_t thrd_current(void);
+       int thrd_detach(thrd_t thr);
+       int thrd_equal(thrd_t thr0, thrd_t thr1);
+       void thrd_exit(int res);
+       int thrd_join(thrd_t thr, int *res);
+       void thrd_sleep(const xtime *xt);
+       void thrd_yield(void);
+       int tss_create(tss_t *key, tss_dtor_t dtor);
+       void tss_delete(tss_t key);
+       void *tss_get(tss_t key);
+       int tss_set(tss_t key, void *val);
+       int xtime_get(xtime *xt, int base);</pre>
+
+<a name="B.25" href="#B.25"><h3>B.25 Date and time <time.h></h3></a>
+<!--page 511 indent 0-->
+<pre>
+       NULL                  size_t                  time_t
+       CLOCKS_PER_SEC        clock_t                 struct tm
+       clock_t clock(void);
+       double difftime(time_t time1, time_t time0);
+       time_t mktime(struct tm *timeptr);
+       time_t time(time_t *timer);
+       char *asctime(const struct tm *timeptr);
+       char *ctime(const time_t *timer);
+       struct tm *gmtime(const time_t *timer);
+       struct tm *localtime(const time_t *timer);
+       size_t strftime(char * restrict s,
+            size_t maxsize,
+            const char * restrict format,
+            const struct tm * restrict timeptr);
+       __STDC_WANT_LIB_EXT1__
+       errno_t
+       rsize_t
+       errno_t asctime_s(char *s, rsize_t maxsize,
+            const struct tm *timeptr);
+         errno_t ctime_s(char *s, rsize_t maxsize,
+              const time_t *timer);
+         struct tm *gmtime_s(const time_t * restrict timer,
+              struct tm * restrict result);
+         struct tm *localtime_s(const time_t * restrict timer,
+              struct tm * restrict result);</pre>
+
+<a name="B.26" href="#B.26"><h3>B.26 Unicode utilities <uchar.h></h3></a>
+<pre>
+         mbstate_t     size_t            char16_t         char32_t
+         size_t mbrtoc16(char16_t * restrict pc16,
+              const char * restrict s, size_t n,
+              mbstate_t * restrict ps);
+         size_t c16rtomb(char * restrict s, char16_t c16,
+              mbstate_t * restrict ps);
+         size_t mbrtoc32(char32_t * restrict pc32,
+              const char * restrict s, size_t n,
+              mbstate_t * restrict ps);
+         size_t c32rtomb(char * restrict s, char32_t c32,
+              mbstate_t * restrict ps);</pre>
+
+<a name="B.27" href="#B.27"><h3>B.27 Extended multibyte/wide character utilities <wchar.h></h3></a>
+<!--page 512 indent -1-->
+<!--page 513 indent -1-->
+<!--page 514 indent -1-->
+<!--page 515 indent -1-->
+<!--page 516 indent 0-->
+<pre>
+         wchar_t             wint_t                  WCHAR_MAX
+         size_t              struct tm               WCHAR_MIN
+         mbstate_t           NULL                    WEOF
+         int fwprintf(FILE * restrict stream,
+              const wchar_t * restrict format, ...);
+         int fwscanf(FILE * restrict stream,
+              const wchar_t * restrict format, ...);
+         int swprintf(wchar_t * restrict s, size_t n,
+              const wchar_t * restrict format, ...);
+         int swscanf(const wchar_t * restrict s,
+              const wchar_t * restrict format, ...);
+         int vfwprintf(FILE * restrict stream,
+              const wchar_t * restrict format, va_list arg);
+         int vfwscanf(FILE * restrict stream,
+              const wchar_t * restrict format, va_list arg);
+         int vswprintf(wchar_t * restrict s, size_t n,
+              const wchar_t * restrict format, va_list arg);
+       int vswscanf(const wchar_t * restrict s,
+            const wchar_t * restrict format, va_list arg);
+       int vwprintf(const wchar_t * restrict format,
+            va_list arg);
+       int vwscanf(const wchar_t * restrict format,
+            va_list arg);
+       int wprintf(const wchar_t * restrict format, ...);
+       int wscanf(const wchar_t * restrict format, ...);
+       wint_t fgetwc(FILE *stream);
+       wchar_t *fgetws(wchar_t * restrict s, int n,
+            FILE * restrict stream);
+       wint_t fputwc(wchar_t c, FILE *stream);
+       int fputws(const wchar_t * restrict s,
+            FILE * restrict stream);
+       int fwide(FILE *stream, int mode);
+       wint_t getwc(FILE *stream);
+       wint_t getwchar(void);
+       wint_t putwc(wchar_t c, FILE *stream);
+       wint_t putwchar(wchar_t c);
+       wint_t ungetwc(wint_t c, FILE *stream);
+       double wcstod(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr);
+       float wcstof(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr);
+       long double wcstold(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr);
+       long int wcstol(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       long long int wcstoll(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       unsigned long int wcstoul(const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       unsigned long long int wcstoull(
+            const wchar_t * restrict nptr,
+            wchar_t ** restrict endptr, int base);
+       wchar_t *wcscpy(wchar_t * restrict s1,
+            const wchar_t * restrict s2);
+       wchar_t *wcsncpy(wchar_t * restrict s1,
+            const wchar_t * restrict s2, size_t n);
+         wchar_t *wmemcpy(wchar_t * restrict s1,
+              const wchar_t * restrict s2, size_t n);
+         wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+              size_t n);
+         wchar_t *wcscat(wchar_t * restrict s1,
+              const wchar_t * restrict s2);
+         wchar_t *wcsncat(wchar_t * restrict s1,
+              const wchar_t * restrict s2, size_t n);
+         int wcscmp(const wchar_t *s1, const wchar_t *s2);
+         int wcscoll(const wchar_t *s1, const wchar_t *s2);
+         int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+              size_t n);
+         size_t wcsxfrm(wchar_t * restrict s1,
+              const wchar_t * restrict s2, size_t n);
+         int wmemcmp(const wchar_t *s1, const wchar_t *s2,
+              size_t n);
+         wchar_t *wcschr(const wchar_t *s, wchar_t c);
+         size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
+         wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
+         wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
+         size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
+         wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
+         wchar_t *wcstok(wchar_t * restrict s1,
+              const wchar_t * restrict s2,
+              wchar_t ** restrict ptr);
+         wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
+         size_t wcslen(const wchar_t *s);
+         wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
+         size_t wcsftime(wchar_t * restrict s, size_t maxsize,
+              const wchar_t * restrict format,
+              const struct tm * restrict timeptr);
+         wint_t btowc(int c);
+         int wctob(wint_t c);
+         int mbsinit(const mbstate_t *ps);
+         size_t mbrlen(const char * restrict s, size_t n,
+              mbstate_t * restrict ps);
+         size_t mbrtowc(wchar_t * restrict pwc,
+              const char * restrict s, size_t n,
+              mbstate_t * restrict ps);
+       size_t wcrtomb(char * restrict s, wchar_t wc,
+            mbstate_t * restrict ps);
+       size_t mbsrtowcs(wchar_t * restrict dst,
+            const char ** restrict src, size_t len,
+            mbstate_t * restrict ps);
+       size_t wcsrtombs(char * restrict dst,
+            const wchar_t ** restrict src, size_t len,
+            mbstate_t * restrict ps);
+       __STDC_WANT_LIB_EXT1__
+       errno_t
+       rsize_t
+       int fwprintf_s(FILE * restrict stream,
+            const wchar_t * restrict format, ...);
+       int fwscanf_s(FILE * restrict stream,
+            const wchar_t * restrict format, ...);
+       int snwprintf_s(wchar_t * restrict s,
+            rsize_t n,
+            const wchar_t * restrict format, ...);
+       int swprintf_s(wchar_t * restrict s, rsize_t n,
+            const wchar_t * restrict format, ...);
+       int swscanf_s(const wchar_t * restrict s,
+            const wchar_t * restrict format, ...);
+       int vfwprintf_s(FILE * restrict stream,
+            const wchar_t * restrict format,
+            va_list arg);
+       int vfwscanf_s(FILE * restrict stream,
+            const wchar_t * restrict format, va_list arg);
+       int vsnwprintf_s(wchar_t * restrict s,
+            rsize_t n,
+            const wchar_t * restrict format,
+            va_list arg);
+       int vswprintf_s(wchar_t * restrict s,
+            rsize_t n,
+            const wchar_t * restrict format,
+            va_list arg);
+       int vswscanf_s(const wchar_t * restrict s,
+            const wchar_t * restrict format,
+            va_list arg);
+         int vwprintf_s(const wchar_t * restrict format,
+              va_list arg);
+         int vwscanf_s(const wchar_t * restrict format,
+              va_list arg);
+         int wprintf_s(const wchar_t * restrict format, ...);
+         int wscanf_s(const wchar_t * restrict format, ...);
+         errno_t wcscpy_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2);
+         errno_t wcsncpy_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2,
+              rsize_t n);
+         errno_t wmemcpy_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2,
+              rsize_t n);
+         errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
+              const wchar_t *s2, rsize_t n);
+         errno_t wcscat_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2);
+         errno_t wcsncat_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2,
+              rsize_t n);
+         wchar_t *wcstok_s(wchar_t * restrict s1,
+              rsize_t * restrict s1max,
+              const wchar_t * restrict s2,
+              wchar_t ** restrict ptr);
+         size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
+         errno_t wcrtomb_s(size_t * restrict retval,
+              char * restrict s, rsize_t smax,
+              wchar_t wc, mbstate_t * restrict ps);
+         errno_t mbsrtowcs_s(size_t * restrict retval,
+              wchar_t * restrict dst, rsize_t dstmax,
+              const char ** restrict src, rsize_t len,
+              mbstate_t * restrict ps);
+       errno_t wcsrtombs_s(size_t * restrict retval,
+            char * restrict dst, rsize_t dstmax,
+            const wchar_t ** restrict src, rsize_t len,
+            mbstate_t * restrict ps);</pre>
+
+<a name="B.28" href="#B.28"><h3>B.28 Wide character classification and mapping utilities <wctype.h></h3></a>
+<!--page 517 indent 4-->
+<pre>
+       wint_t          wctrans_t         wctype_t         WEOF
+       int iswalnum(wint_t wc);
+       int iswalpha(wint_t wc);
+       int iswblank(wint_t wc);
+       int iswcntrl(wint_t wc);
+       int iswdigit(wint_t wc);
+       int iswgraph(wint_t wc);
+       int iswlower(wint_t wc);
+       int iswprint(wint_t wc);
+       int iswpunct(wint_t wc);
+       int iswspace(wint_t wc);
+       int iswupper(wint_t wc);
+       int iswxdigit(wint_t wc);
+       int iswctype(wint_t wc, wctype_t desc);
+       wctype_t wctype(const char *property);
+       wint_t towlower(wint_t wc);
+       wint_t towupper(wint_t wc);
+       wint_t towctrans(wint_t wc, wctrans_t desc);
+       wctrans_t wctrans(const char *property);</pre>
+
+<a name="C" href="#C"><h2>Annex C</h2></a>
+<p><!--para 1-->
+<pre>
+                                     (informative)
+                                   Sequence points</pre>
+ The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
+<ul>
+<li>  Between the evaluations of the function designator and actual arguments in a function
+ call and the actual call. (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  Between the evaluations of the first and second operands of the following operators:
+ logical AND &amp;&amp; (<a href="#6.5.13">6.5.13</a>); logical OR || (<a href="#6.5.14">6.5.14</a>); comma , (<a href="#6.5.17">6.5.17</a>).                  *
+<li>  Between the evaluations of the first operand of the conditional ? : operator and
+ whichever of the second and third operands is evaluated (<a href="#6.5.15">6.5.15</a>).
+<li>  The end of a full declarator: declarators (<a href="#6.7.6">6.7.6</a>);
+<li>  Between the evaluation of a full expression and the next full expression to be
+ evaluated. The following are full expressions: an initializer that is not part of a
+ compound literal (<a href="#6.7.9">6.7.9</a>); the expression in an expression statement (<a href="#6.8.3">6.8.3</a>); the
+ controlling expression of a selection statement (if or switch) (<a href="#6.8.4">6.8.4</a>); the
+ controlling expression of a while or do statement (<a href="#6.8.5">6.8.5</a>); each of the (optional)
+ expressions of a for statement (<a href="#6.8.5.3">6.8.5.3</a>); the (optional) expression in a return
+ statement (<a href="#6.8.6.4">6.8.6.4</a>).
+<li>  Immediately before a library function returns (<a href="#7.1.4">7.1.4</a>).
+<li>  After the actions associated with each formatted input/output function conversion
+ specifier (<a href="#7.21.6">7.21.6</a>, <a href="#7.28.2">7.28.2</a>).
+<li>  Immediately before and immediately after each call to a comparison function, and
+ also between any call to a comparison function and any movement of the objects
+ passed as arguments to that call (<a href="#7.22.5">7.22.5</a>).
+<!--page 518 indent 4-->
+</ul>
+
+<a name="D" href="#D"><h2>Annex D</h2></a>
+<p><!--para 1-->
+<pre>
+                                     (normative)
+                Universal character names for identifiers</pre>
+ This clause lists the hexadecimal code values that are valid in universal character names
+ in identifiers.
+
+<a name="D.1" href="#D.1"><h3>D.1 Ranges of characters allowed</h3></a>
+<p><!--para 1-->
+ 00A8, 00AA, 00AD, 00AF, 00B2-00B5, 00B7-00BA, 00BC-00BE, 00C0-00D6,
+ 00D8-00F6, 00F8-00FF
+<p><!--para 2-->
+ 0100-167F, 1681-180D, 180F-1FFF
+<p><!--para 3-->
+ 200B-200D, 202A-202E, 203F-2040, 2054, 2060-206F
+<p><!--para 4-->
+ 2070-218F, 2460-24FF, 2776-2793, 2C00-2DFF, 2E80-2FFF
+<p><!--para 5-->
+ 3004-3007, 3021-302F, 3031-303F
+<p><!--para 6-->
+ 3040-D7FF
+<p><!--para 7-->
+ F900-FD3D, FD40-FDCF, FDF0-FE44, FE47-FFFD
+<p><!--para 8-->
+ 10000-1FFFD, 20000-2FFFD, 30000-3FFFD, 40000-4FFFD, 50000-5FFFD,
+ 60000-6FFFD, 70000-7FFFD, 80000-8FFFD, 90000-9FFFD, A0000-AFFFD,
+ B0000-BFFFD, C0000-CFFFD, D0000-DFFFD, E0000-EFFFD
+
+<a name="D.2" href="#D.2"><h3>D.2 Ranges of characters disallowed initially</h3></a>
+<p><!--para 1-->
+ 0300-036F, 1DC0-1DFF, 20D0-20FF, FE20-FE2F
+<!--page 519 indent 4-->
+
+<a name="E" href="#E"><h2>Annex E</h2></a>
+<p><!--para 1-->
+<pre>
+                                    (informative)
+                             Implementation limits</pre>
+ The contents of the header &lt;limits.h&gt; are given below, in alphabetical order. The
+ minimum magnitudes shown shall be replaced by implementation-defined magnitudes
+ with the same sign. The values shall all be constant expressions suitable for use in #if
+ preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+<p><!--para 2-->
+<pre>
+         #define    CHAR_BIT                               8
+         #define    CHAR_MAX          UCHAR_MAX or SCHAR_MAX
+         #define    CHAR_MIN                  0 or SCHAR_MIN
+         #define    INT_MAX                           +32767
+         #define    INT_MIN                           -32767
+         #define    LONG_MAX                     +2147483647
+         #define    LONG_MIN                     -2147483647
+         #define    LLONG_MAX           +9223372036854775807
+         #define    LLONG_MIN           -9223372036854775807
+         #define    MB_LEN_MAX                             1
+         #define    SCHAR_MAX                           +127
+         #define    SCHAR_MIN                           -127
+         #define    SHRT_MAX                          +32767
+         #define    SHRT_MIN                          -32767
+         #define    UCHAR_MAX                            255
+         #define    USHRT_MAX                          65535
+         #define    UINT_MAX                           65535
+         #define    ULONG_MAX                     4294967295
+         #define    ULLONG_MAX          18446744073709551615</pre>
+ The contents of the header &lt;float.h&gt; are given below. All integer values, except
+ FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
+ directives; all floating values shall be constant expressions. The components are
+ described further in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+<p><!--para 3-->
+ The values given in the following list shall be replaced by implementation-defined
+ expressions:
+<p><!--para 4-->
+<pre>
+         #define FLT_EVAL_METHOD
+         #define FLT_ROUNDS</pre>
+ The values given in the following list shall be replaced by implementation-defined
+ constant expressions that are greater or equal in magnitude (absolute value) to those
+ shown, with the same sign:
+<!--page 520 indent 4-->
+<p><!--para 5-->
+<pre>
+        #define    DLB_DECIMAL_DIG                                10
+        #define    DBL_DIG                                        10
+        #define    DBL_MANT_DIG
+        #define    DBL_MAX_10_EXP                               +37
+        #define    DBL_MAX_EXP
+        #define    DBL_MIN_10_EXP                               -37
+        #define    DBL_MIN_EXP
+        #define    DECIMAL_DIG                                    10
+        #define    FLT_DECIMAL_DIG                                 6
+        #define    FLT_DIG                                         6
+        #define    FLT_MANT_DIG
+        #define    FLT_MAX_10_EXP                               +37
+        #define    FLT_MAX_EXP
+        #define    FLT_MIN_10_EXP                               -37
+        #define    FLT_MIN_EXP
+        #define    FLT_RADIX                                       2
+        #define    LDLB_DECIMAL_DIG                               10
+        #define    LDBL_DIG                                       10
+        #define    LDBL_MANT_DIG
+        #define    LDBL_MAX_10_EXP                              +37
+        #define    LDBL_MAX_EXP
+        #define    LDBL_MIN_10_EXP                              -37
+        #define    LDBL_MIN_EXP</pre>
+ The values given in the following list shall be replaced by implementation-defined
+ constant expressions with values that are greater than or equal to those shown:
+<p><!--para 6-->
+<pre>
+        #define DBL_MAX                                      1E+37
+        #define FLT_MAX                                      1E+37
+        #define LDBL_MAX                                     1E+37</pre>
+ The values given in the following list shall be replaced by implementation-defined
+ constant expressions with (positive) values that are less than or equal to those shown:
+<!--page 521 indent 4-->
+<pre>
+        #define    DBL_EPSILON                                1E-9
+        #define    DBL_MIN                                   1E-37
+        #define    FLT_EPSILON                                1E-5
+        #define    FLT_MIN                                   1E-37
+        #define    LDBL_EPSILON                               1E-9
+        #define    LDBL_MIN                                  1E-37</pre>
+
+<a name="F" href="#F"><h2>Annex F</h2></a>
+<pre>
+                                           (normative)
+                       IEC 60559 floating-point arithmetic</pre>
+
+<a name="F.1" href="#F.1"><h3>F.1 Introduction</h3></a>
+<p><!--para 1-->
+ This annex specifies C language support for the IEC 60559 floating-point standard. The
+ IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for
+ microprocessor systems, second edition (IEC 60559:1989), previously designated
+ IEC 559:1989 and as IEEE Standard for Binary Floating-Point Arithmetic
+ (ANSI/IEEE 754-1985). IEEE Standard for Radix-Independent Floating-Point
+ Arithmetic (ANSI/IEEE 854-1987) generalizes the binary standard to remove
+ dependencies on radix and word length. IEC 60559 generally refers to the floating-point
+ standard, as in IEC 60559 operation, IEC 60559 format, etc. An implementation that
+ defines __STDC_IEC_559__ shall conform to the specifications in this annex.<sup><a href="#note343"><b>343)</b></a></sup>
+ Where a binding between the C language and IEC 60559 is indicated, the
+ IEC 60559-specified behavior is adopted by reference, unless stated otherwise. Since
+ negative and positive infinity are representable in IEC 60559 formats, all real numbers lie
+ within the range of representable values.
+
+<h6>footnotes</h6>
+<p><a name="note343">343)</a> Implementations that do not define __STDC_IEC_559__ are not required to conform to these
+ specifications.
+
+
+<a name="F.2" href="#F.2"><h3>F.2 Types</h3></a>
+<p><!--para 1-->
+ The C floating types match the IEC 60559 formats as follows:
+<ul>
+<li>  The float type matches the IEC 60559 single format.
+<li>  The double type matches the IEC 60559 double format.
+<li>  The long double type matches an IEC 60559 extended format,<sup><a href="#note344"><b>344)</b></a></sup> else a
+ non-IEC 60559 extended format, else the IEC 60559 double format.
+</ul>
+ Any non-IEC 60559 extended format used for the long double type shall have more
+ precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note345"><b>345)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 522 indent 4-->
+ Recommended practice
+<p><!--para 2-->
+ The long double type should match an IEC 60559 extended format.
+
+<h6>footnotes</h6>
+<p><a name="note344">344)</a> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
+ and quadruple 128-bit IEC 60559 formats.
+
+<p><a name="note345">345)</a> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
+ all double values.
+
+
+<a name="F.2.1" href="#F.2.1"><h4>F.2.1 Infinities, signed zeros, and NaNs</h4></a>
+<p><!--para 1-->
+ This specification does not define the behavior of signaling NaNs.<sup><a href="#note346"><b>346)</b></a></sup> It generally uses
+ the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
+ functions in &lt;math.h&gt; provide designations for IEC 60559 NaNs and infinities.
+
+<h6>footnotes</h6>
+<p><a name="note346">346)</a> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
+ sufficient for closure of the arithmetic.
+
+
+<a name="F.3" href="#F.3"><h3>F.3 Operators and functions</h3></a>
+<p><!--para 1-->
+ C operators and functions provide IEC 60559 required and recommended facilities as
+ listed below.
+<ul>
+<li>  The +, -, *, and / operators provide the IEC 60559 add, subtract, multiply, and
+ divide operations.
+<li>  The sqrt functions in &lt;math.h&gt; provide the IEC 60559 square root operation.
+<li>  The remainder functions in &lt;math.h&gt; provide the IEC 60559 remainder
+ operation. The remquo functions in &lt;math.h&gt; provide the same operation but
+ with additional information.
+<li>  The rint functions in &lt;math.h&gt; provide the IEC 60559 operation that rounds a
+ floating-point number to an integer value (in the same precision). The nearbyint
+ functions in &lt;math.h&gt; provide the nearbyinteger function recommended in the
+ Appendix to ANSI/IEEE 854.
+<li>  The conversions for floating types provide the IEC 60559 conversions between
+ floating-point precisions.
+<li>  The conversions from integer to floating types provide the IEC 60559 conversions
+ from integer to floating point.
+<li>  The conversions from floating to integer types provide IEC 60559-like conversions
+ but always round toward zero.
+<li>  The lrint and llrint functions in &lt;math.h&gt; provide the IEC 60559
+ conversions, which honor the directed rounding mode, from floating point to the
+ long int and long long int integer formats. The lrint and llrint
+ functions can be used to implement IEC 60559 conversions from floating to other
+ integer formats.
+<li>  The translation time conversion of floating constants and the strtod, strtof,
+ strtold, fprintf, fscanf, and related library functions in &lt;stdlib.h&gt;,
+ 
+ 
+<!--page 523 indent 0-->
+  &lt;stdio.h&gt;, and &lt;wchar.h&gt; provide IEC 60559 binary-decimal conversions. The
+  strtold function in &lt;stdlib.h&gt; provides the conv function recommended in the
+  Appendix to ANSI/IEEE 854.
+<li>  The relational and equality operators provide IEC 60559 comparisons. IEC 60559
+ identifies a need for additional comparison predicates to facilitate writing code that
+ accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
+ isless, islessequal, islessgreater, and isunordered) in &lt;math.h&gt;
+ supplement the language operators to address this need. The islessgreater and
+ isunordered macros provide respectively a quiet version of the &lt;&gt; predicate and
+ the unordered predicate recommended in the Appendix to IEC 60559.
+<li>  The feclearexcept, feraiseexcept, and fetestexcept functions in
+ &lt;fenv.h&gt; provide the facility to test and alter the IEC 60559 floating-point
+ exception status flags. The fegetexceptflag and fesetexceptflag
+ functions in &lt;fenv.h&gt; provide the facility to save and restore all five status flags at
+ one time. These functions are used in conjunction with the type fexcept_t and the
+ floating-point     exception      macros      (FE_INEXACT,         FE_DIVBYZERO,
+ FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in &lt;fenv.h&gt;.
+<li>  The fegetround and fesetround functions in &lt;fenv.h&gt; provide the facility
+ to select among the IEC 60559 directed rounding modes represented by the rounding
+ direction macros in &lt;fenv.h&gt; (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
+ FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the
+ IEC 60559 directed rounding modes.
+<li>  The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
+ &lt;fenv.h&gt; provide a facility to manage the floating-point environment, comprising
+ the IEC 60559 status flags and control modes.
+<li>  The copysign functions in &lt;math.h&gt; provide the copysign function
+ recommended in the Appendix to IEC 60559.
+<li>  The fabs functions in &lt;math.h&gt; provide the abs function recommended in the
+ Appendix to IEC 60559.
+<li>  The unary minus (-) operator provides the unary minus (-) operation recommended
+ in the Appendix to IEC 60559.
+<li>  The scalbn and scalbln functions in &lt;math.h&gt; provide the scalb function
+ recommended in the Appendix to IEC 60559.
+<li>  The logb functions in &lt;math.h&gt; provide the logb function recommended in the
+ Appendix to IEC 60559, but following the newer specifications in ANSI/IEEE 854.
+<li>  The nextafter and nexttoward functions in &lt;math.h&gt; provide the nextafter
+ function recommended in the Appendix to IEC 60559 (but with a minor change to
+<!--page 524 indent 4-->
+   better handle signed zeros).
+<li>  The isfinite macro in &lt;math.h&gt; provides the finite function recommended in
+ the Appendix to IEC 60559.
+<li>  The isnan macro in &lt;math.h&gt; provides the isnan function recommended in the
+ Appendix to IEC 60559.
+<li>  The signbit macro and the fpclassify macro in &lt;math.h&gt;, used in
+ conjunction with the number classification macros (FP_NAN, FP_INFINITE,
+ FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
+ function recommended in the Appendix to IEC 60559 (except that the classification
+ macros defined in <a href="#7.12.3">7.12.3</a> do not distinguish signaling from quiet NaNs).
+</ul>
+
+<a name="F.4" href="#F.4"><h3>F.4 Floating to integer conversion</h3></a>
+<p><!--para 1-->
+ If the integer type is _Bool, <a href="#6.3.1.2">6.3.1.2</a> applies and no floating-point exceptions are raised
+ (even for NaN). Otherwise, if the floating value is infinite or NaN or if the integral part
+ of the floating value exceeds the range of the integer type, then the ''invalid'' floating-
+ point exception is raised and the resulting value is unspecified. Otherwise, the resulting
+ value is determined by <a href="#6.3.1.4">6.3.1.4</a>. Conversion of an integral floating value that does not
+ exceed the range of the integer type raises no floating-point exceptions; whether
+ conversion of a non-integral floating value raises the ''inexact'' floating-point exception is
+ unspecified.<sup><a href="#note347"><b>347)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note347">347)</a> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
+ conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
+ cases where it matters, library functions can be used to effect such conversions with or without raising
+ the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
+ &lt;math.h&gt;.
+
+
+<a name="F.5" href="#F.5"><h3>F.5 Binary-decimal conversion</h3></a>
+<p><!--para 1-->
+ Conversion from the widest supported IEC 60559 format to decimal with
+ DECIMAL_DIG digits and back is the identity function.<sup><a href="#note348"><b>348)</b></a></sup>
+<p><!--para 2-->
+ Conversions involving IEC 60559 formats follow all pertinent recommended practice. In
+ particular, conversion between any supported IEC 60559 format and decimal with
+ DECIMAL_DIG or fewer significant digits is correctly rounded (honoring the current
+ rounding mode), which assures that conversion from the widest supported IEC 60559
+ format to decimal with DECIMAL_DIG digits and back is the identity function.
+ 
+ 
+ 
+<!--page 525 indent 4-->
+<p><!--para 3-->
+ Functions such as strtod that convert character sequences to floating types honor the
+ rounding direction. Hence, if the rounding direction might be upward or downward, the
+ implementation cannot convert a minus-signed sequence by negating the converted
+ unsigned sequence.
+
+<h6>footnotes</h6>
+<p><a name="note348">348)</a> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
+ DECIMAL_DIG shall be at least 21. If IEC 60559 double (53 bits of precision) is the widest
+ IEC 60559 format supported, then DECIMAL_DIG shall be at least 17. (By contrast, LDBL_DIG and
+ DBL_DIG are 18 and 15, respectively, for these formats.)
+
+
+<a name="F.6" href="#F.6"><h3>F.6 The return statement</h3></a>
+ If the return expression is evaluated in a floating-point format different from the return
+ type, the expression is converted as if by assignment<sup><a href="#note349"><b>349)</b></a></sup> to the return type of the function
+ and the resulting value is returned to the caller.
+
+<h6>footnotes</h6>
+<p><a name="note349">349)</a> Assignment removes any extra range and precision.
+
+
+<a name="F.7" href="#F.7"><h3>F.7 Contracted expressions</h3></a>
+<p><!--para 1-->
+ A contracted expression is correctly rounded (once) and treats infinities, NaNs, signed
+ zeros, subnormals, and the rounding directions in a manner consistent with the basic
+ arithmetic operations covered by IEC 60559.
+ Recommended practice
+<p><!--para 2-->
+ A contracted expression should raise floating-point exceptions in a manner generally
+ consistent with the basic arithmetic operations.                                    *
+
+<a name="F.8" href="#F.8"><h3>F.8 Floating-point environment</h3></a>
+<p><!--para 1-->
+ The floating-point environment defined in &lt;fenv.h&gt; includes the IEC 60559 floating-
+ point exception status flags and directed-rounding control modes. It includes also
+ IEC 60559 dynamic rounding precision and trap enablement modes, if the
+ implementation supports them.<sup><a href="#note350"><b>350)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note350">350)</a> This specification does not require dynamic rounding precision nor trap enablement modes.
+
+
+<a name="F.8.1" href="#F.8.1"><h4>F.8.1 Environment management</h4></a>
+<p><!--para 1-->
+ IEC 60559 requires that floating-point operations implicitly raise floating-point exception
+ status flags, and that rounding control modes can be set explicitly to affect result values of
+ floating-point operations. When the state for the FENV_ACCESS pragma (defined in
+ &lt;fenv.h&gt;) is ''on'', these changes to the floating-point state are treated as side effects
+ which respect sequence points.<sup><a href="#note351"><b>351)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 526 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note351">351)</a> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
+ point control modes will be the default ones and the floating-point status flags will not be tested,
+ which allows certain optimizations (see <a href="#F.9">F.9</a>).
+
+
+<a name="F.8.2" href="#F.8.2"><h4>F.8.2 Translation</h4></a>
+<p><!--para 1-->
+ During translation the IEC 60559 default modes are in effect:
+<ul>
+<li>  The rounding direction mode is rounding to nearest.
+<li>  The rounding precision mode (if supported) is set so that results are not shortened.
+<li>  Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+</ul>
+ Recommended practice
+<p><!--para 2-->
+ The implementation should produce a diagnostic message for each translation-time
+ floating-point exception, other than ''inexact'';<sup><a href="#note352"><b>352)</b></a></sup> the implementation should then
+ proceed with the translation of the program.
+
+<h6>footnotes</h6>
+<p><a name="note352">352)</a> As floating constants are converted to appropriate internal representations at translation time, their
+ conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
+ (even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
+ strtod, provide execution-time conversion of numeric strings.
+
+
+<a name="F.8.3" href="#F.8.3"><h4>F.8.3 Execution</h4></a>
+<p><!--para 1-->
+ At program startup the floating-point environment is initialized as prescribed by
+ IEC 60559:
+<ul>
+<li>  All floating-point exception status flags are cleared.
+<li>  The rounding direction mode is rounding to nearest.
+<li>  The dynamic rounding precision mode (if supported) is set so that results are not
+ shortened.
+<li>  Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+</ul>
+
+<a name="F.8.4" href="#F.8.4"><h4>F.8.4 Constant expressions</h4></a>
+<p><!--para 1-->
+ An arithmetic constant expression of floating type, other than one in an initializer for an
+ object that has static or thread storage duration, is evaluated (as if) during execution; thus,
+ it is affected by any operative floating-point control modes and raises floating-point
+ exceptions as required by IEC 60559 (provided the state for the FENV_ACCESS pragma
+ is ''on'').<sup><a href="#note353"><b>353)</b></a></sup>
+<p><!--para 2-->
+ EXAMPLE
+ 
+ 
+ 
+<!--page 527 indent 4-->
+<p><!--para 3-->
+<pre>
+          #include &lt;fenv.h&gt;
+          #pragma STDC FENV_ACCESS ON
+          void f(void)
+          {
+                float w[] = { 0.0/0.0 };                  //   raises an exception
+                static float x = 0.0/0.0;                 //   does not raise an exception
+                float y = 0.0/0.0;                        //   raises an exception
+                double z = 0.0/0.0;                       //   raises an exception
+                /* ... */
+          }</pre>
+ For the static initialization, the division is done at translation time, raising no (execution-time) floating-
+ point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
+ execution time.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note353">353)</a> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
+ are affected by rounding modes set at execution time, and expressions such as 0.0/0.0 and
+ 1.0/0.0 generate execution-time floating-point exceptions. The programmer can achieve the
+ efficiency of translation-time evaluation through static initialization, such as
+
+<pre>
+          const static double one_third = 1.0/3.0;</pre>
+
+
+<a name="F.8.5" href="#F.8.5"><h4>F.8.5 Initialization</h4></a>
+<p><!--para 1-->
+ All computation for automatic initialization is done (as if) at execution time; thus, it is
+ affected by any operative modes and raises floating-point exceptions as required by
+ IEC 60559 (provided the state for the FENV_ACCESS pragma is ''on''). All computation
+ for initialization of objects that have static or thread storage duration is done (as if) at
+ translation time.
+<p><!--para 2-->
+ EXAMPLE
+<p><!--para 3-->
+<pre>
+          #include &lt;fenv.h&gt;
+          #pragma STDC FENV_ACCESS ON
+          void f(void)
+          {
+                float u[] = { 1.1e75 };                  //   raises exceptions
+                static float v = 1.1e75;                 //   does not raise exceptions
+                float w = 1.1e75;                        //   raises exceptions
+                double x = 1.1e75;                       //   may raise exceptions
+                float y = 1.1e75f;                       //   may raise exceptions
+                long double z = 1.1e75;                  //   does not raise exceptions
+                /* ... */
+          }</pre>
+ The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
+ done at translation time. The automatic initialization of u and w require an execution-time conversion to
+ float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
+ of x and y entail execution-time conversion; however, in some expression evaluation methods, the
+ conversions is not to a narrower format, in which case no floating-point exception is raised.<sup><a href="#note354"><b>354)</b></a></sup> The
+ automatic initialization of z entails execution-time conversion, but not to a narrower format, so no floating-
+ point exception is raised. Note that the conversions of the floating constants 1.1e75 and 1.1e75f to
+ 
+ 
+ 
+<!--page 528 indent 4-->
+ their internal representations occur at translation time in all cases.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note354">354)</a> Use of float_t and double_t variables increases the likelihood of translation-time computation.
+ For example, the automatic initialization
+
+<pre>
+          double_t x = 1.1e75;</pre>
+ could be done at translation time, regardless of the expression evaluation method.
+
+
+<a name="F.8.6" href="#F.8.6"><h4>F.8.6 Changing the environment</h4></a>
+<p><!--para 1-->
+ Operations defined in <a href="#6.5">6.5</a> and functions and macros defined for the standard libraries
+ change floating-point status flags and control modes just as indicated by their
+ specifications (including conformance to IEC 60559). They do not change flags or modes
+ (so as to be detectable by the user) in any other cases.
+<p><!--para 2-->
+ If the argument to the feraiseexcept function in &lt;fenv.h&gt; represents IEC 60559
+ valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
+ ''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
+ before ''inexact''.
+
+<a name="F.9" href="#F.9"><h3>F.9 Optimization</h3></a>
+<p><!--para 1-->
+ This section identifies code transformations that might subvert IEC 60559-specified
+ behavior, and others that do not.
+
+<a name="F.9.1" href="#F.9.1"><h4>F.9.1 Global transformations</h4></a>
+<p><!--para 1-->
+ Floating-point arithmetic operations and external function calls may entail side effects
+ which optimization shall honor, at least where the state of the FENV_ACCESS pragma is
+ ''on''. The flags and modes in the floating-point environment may be regarded as global
+ variables; floating-point operations (+, *, etc.) implicitly read the modes and write the
+ flags.
+<p><!--para 2-->
+ Concern about side effects may inhibit code motion and removal of seemingly useless
+ code. For example, in
+<pre>
+          #include &lt;fenv.h&gt;
+          #pragma STDC FENV_ACCESS ON
+          void f(double x)
+          {
+               /* ... */
+               for (i = 0; i &lt; n; i++) x + 1;
+               /* ... */
+          }</pre>
+ x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
+ body might not execute (maybe 0 &gt;= n), x + 1 cannot be moved out of the loop. (Of
+ course these optimizations are valid if the implementation can rule out the nettlesome
+ cases.)
+<p><!--para 3-->
+ This specification does not require support for trap handlers that maintain information
+ about the order or count of floating-point exceptions. Therefore, between function calls,
+ floating-point exceptions need not be precise: the actual order and number of occurrences
+ of floating-point exceptions (&gt; 1) may vary from what the source code expresses. Thus,
+<!--page 529 indent 4-->
+ the preceding loop could be treated as
+<pre>
+          if (0 &lt; n) x + 1;</pre>
+
+<a name="F.9.2" href="#F.9.2"><h4>F.9.2 Expression transformations</h4></a>
+<p><!--para 1-->
+ x/2 &lt;-&gt; x x 0.5          Although similar transformations involving inexact constants
+<pre>
+                        generally do not yield numerically equivalent expressions, if the
+                        constants are exact then such transformations can be made on
+                        IEC 60559 machines and others that round perfectly.</pre>
+ 1 x x and x/1 -&gt; x The expressions 1 x x, x/1, and x are equivalent (on IEC 60559
+<pre>
+                   machines, among others).<sup><a href="#note355"><b>355)</b></a></sup></pre>
+ x/x -&gt; 1.0             The expressions x/x and 1.0 are not equivalent if x can be zero,
+<pre>
+                        infinite, or NaN.</pre>
+ x - y &lt;-&gt; x + (-y)       The expressions x - y, x + (-y), and (-y) + x are equivalent (on
+<pre>
+                        IEC 60559 machines, among others).</pre>
+ x - y &lt;-&gt; -(y - x)       The expressions x - y and -(y - x) are not equivalent because 1 - 1
+<pre>
+                        is +0 but -(1 - 1) is -0 (in the default rounding direction).<sup><a href="#note356"><b>356)</b></a></sup></pre>
+ x - x -&gt; 0.0           The expressions x - x and 0.0 are not equivalent if x is a NaN or
+<pre>
+                        infinite.</pre>
+ 0 x x -&gt; 0.0           The expressions 0 x x and 0.0 are not equivalent if x is a NaN,
+<pre>
+                        infinite, or -0.</pre>
+ x+0-&gt; x                 The expressions x + 0 and x are not equivalent if x is -0, because
+<pre>
+                        (-0) + (+0) yields +0 (in the default rounding direction), not -0.</pre>
+ x-0-&gt; x                 (+0) - (+0) yields -0 when rounding is downward (toward -(inf)), but
+<pre>
+                        +0 otherwise, and (-0) - (+0) always yields -0; so, if the state of the
+                        FENV_ACCESS pragma is ''off'', promising default rounding, then
+                        the implementation can replace x - 0 by x, even if x might be zero.</pre>
+ -x &lt;-&gt; 0 - x             The expressions -x and 0 - x are not equivalent if x is +0, because
+<pre>
+                        -(+0) yields -0, but 0 - (+0) yields +0 (unless rounding is
+                        downward).</pre>
+ 
+<!--page 530 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note355">355)</a> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
+ other transformations that remove arithmetic operators.
+
+<p><a name="note356">356)</a> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
+ Examples include:
+
+<pre>
+    1/(1/ (+-) (inf)) is (+-) (inf)</pre>
+ and
+
+<pre>
+    conj(csqrt(z)) is csqrt(conj(z)),</pre>
+ for complex z.
+
+
+<a name="F.9.3" href="#F.9.3"><h4>F.9.3 Relational operators</h4></a>
+<p><!--para 1-->
+ x != x -&gt; false           The expression x != x is true if x is a NaN.
+ x = x -&gt; true            The expression x = x is false if x is a NaN.
+ x &lt; y -&gt; isless(x,y) (and similarly for &lt;=, &gt;, &gt;=) Though numerically equal, these
+<pre>
+                expressions are not equivalent because of side effects when x or y is a
+                NaN and the state of the FENV_ACCESS pragma is ''on''. This
+                transformation, which would be desirable if extra code were required
+                to cause the ''invalid'' floating-point exception for unordered cases,
+                could be performed provided the state of the FENV_ACCESS pragma
+                is ''off''.</pre>
+ The sense of relational operators shall be maintained. This includes handling unordered
+ cases as expressed by the source code.
+<p><!--para 2-->
+ EXAMPLE
+<pre>
+          // calls g and raises ''invalid'' if a and b are unordered
+          if (a &lt; b)
+                  f();
+          else
+                  g();</pre>
+ is not equivalent to
+<pre>
+          // calls f and raises ''invalid'' if a and b are unordered
+          if (a &gt;= b)
+                  g();
+          else
+                  f();</pre>
+ nor to
+<pre>
+          // calls f without raising ''invalid'' if a and b are unordered
+          if (isgreaterequal(a,b))
+                  g();
+          else
+                  f();</pre>
+ nor, unless the state of the FENV_ACCESS pragma is ''off'', to
+<pre>
+          // calls g without raising ''invalid'' if a and b are unordered
+          if (isless(a,b))
+                  f();
+          else
+                  g();</pre>
+ but is equivalent to
+<!--page 531 indent 4-->
+<pre>
+         if (!(a &lt; b))
+               g();
+         else
+               f();</pre>
+ 
+
+<a name="F.9.4" href="#F.9.4"><h4>F.9.4 Constant arithmetic</h4></a>
+<p><!--para 1-->
+ The implementation shall honor floating-point exceptions raised by execution-time
+ constant arithmetic wherever the state of the FENV_ACCESS pragma is ''on''. (See <a href="#F.8.4">F.8.4</a>
+ and <a href="#F.8.5">F.8.5</a>.) An operation on constants that raises no floating-point exception can be
+ folded during translation, except, if the state of the FENV_ACCESS pragma is ''on'', a
+ further check is required to assure that changing the rounding direction to downward does
+ not alter the sign of the result,<sup><a href="#note357"><b>357)</b></a></sup> and implementations that support dynamic rounding
+ precision modes shall assure further that the result of the operation raises no floating-
+ point exception when converted to the semantic type of the operation.
+
+<h6>footnotes</h6>
+<p><a name="note357">357)</a> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
+
+
+<a name="F.10" href="#F.10"><h3>F.10 Mathematics <math.h></h3></a>
+<p><!--para 1-->
+ This subclause contains specifications of &lt;math.h&gt; facilities that are particularly suited
+ for IEC 60559 implementations.
+<p><!--para 2-->
+ The Standard C macro HUGE_VAL and its float and long double analogs,
+ HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
+ infinities.
+<p><!--para 3-->
+ Special cases for functions in &lt;math.h&gt; are covered directly or indirectly by
+ IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
+ other functions in &lt;math.h&gt; treat infinities, NaNs, signed zeros, subnormals, and
+ (provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
+ in a manner consistent with the basic arithmetic operations covered by IEC 60559.
+<p><!--para 4-->
+ The expression math_errhandling &amp; MATH_ERREXCEPT shall evaluate to a
+ nonzero value.
+<p><!--para 5-->
+ The ''invalid'' and ''divide-by-zero'' floating-point exceptions are raised as specified in
+ subsequent subclauses of this annex.
+<p><!--para 6-->
+ The ''overflow'' floating-point exception is raised whenever an infinity -- or, because of
+ rounding direction, a maximal-magnitude finite number -- is returned in lieu of a value
+ whose magnitude is too large.
+<p><!--para 7-->
+ The ''underflow'' floating-point exception is raised whenever a result is tiny (essentially
+ subnormal or zero) and suffers loss of accuracy.<sup><a href="#note358"><b>358)</b></a></sup>
+ 
+ 
+<!--page 532 indent 5-->
+<p><!--para 8-->
+ Whether or when library functions raise the ''inexact'' floating-point exception is
+ unspecified, unless explicitly specified otherwise.
+<p><!--para 9-->
+ Whether or when library functions raise an undeserved ''underflow'' floating-point
+ exception is unspecified.<sup><a href="#note359"><b>359)</b></a></sup> Otherwise, as implied by <a href="#F.8.6">F.8.6</a>, the &lt;math.h&gt; functions do
+ not raise spurious floating-point exceptions (detectable by the user), other than the
+ ''inexact'' floating-point exception.
+<p><!--para 10-->
+ Whether the functions honor the rounding direction mode is implementation-defined,
+ unless explicitly specified otherwise.
+<p><!--para 11-->
+ Functions with a NaN argument return a NaN result and raise no floating-point exception,
+ except where stated otherwise.
+<p><!--para 12-->
+ The specifications in the following subclauses append to the definitions in &lt;math.h&gt;.
+ For families of functions, the specifications apply to all of the functions even though only
+ the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
+ occurs in both an argument and the result, the result has the same sign as the argument.
+ Recommended practice
+<p><!--para 13-->
+ If a function with one or more NaN arguments returns a NaN result, the result should be
+ the same as one of the NaN arguments (after possible type conversion), except perhaps
+ for the sign.
+
+<h6>footnotes</h6>
+<p><a name="note358">358)</a> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
+ when the floating-point exception is raised.
+
+<p><a name="note359">359)</a> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
+ avoiding them would be too costly.
+
+
+<a name="F.10.1" href="#F.10.1"><h4>F.10.1 Trigonometric functions</h4></a>
+
+<a name="F.10.1.1" href="#F.10.1.1"><h5>F.10.1.1 The acos functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  acos(1) returns +0.
+<li>  acos(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ | x | &gt; 1.
+</ul>
+
+<a name="F.10.1.2" href="#F.10.1.2"><h5>F.10.1.2 The asin functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  asin((+-)0) returns (+-)0.
+<li>  asin(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ | x | &gt; 1.
+ 
+ 
+ 
+ 
+<!--page 533 indent 4-->
+</ul>
+
+<a name="F.10.1.3" href="#F.10.1.3"><h5>F.10.1.3 The atan functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  atan((+-)0) returns (+-)0.
+<li>  atan((+-)(inf)) returns (+-)pi /2.
+</ul>
+
+<a name="F.10.1.4" href="#F.10.1.4"><h5>F.10.1.4 The atan2 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  atan2((+-)0, -0) returns (+-)pi .<sup><a href="#note360"><b>360)</b></a></sup>
+<li>  atan2((+-)0, +0) returns (+-)0.
+<li>  atan2((+-)0, x) returns (+-)pi for x &lt; 0.
+<li>  atan2((+-)0, x) returns (+-)0 for x &gt; 0.
+<li>  atan2(y, (+-)0) returns -pi /2 for y &lt; 0.
+<li>  atan2(y, (+-)0) returns pi /2 for y &gt; 0.
+<li>  atan2((+-)y, -(inf)) returns (+-)pi for finite y &gt; 0.
+<li>  atan2((+-)y, +(inf)) returns (+-)0 for finite y &gt; 0.
+<li>  atan2((+-)(inf), x) returns (+-)pi /2 for finite x.
+<li>  atan2((+-)(inf), -(inf)) returns (+-)3pi /4.
+<li>  atan2((+-)(inf), +(inf)) returns (+-)pi /4.
+</ul>
+
+<h6>footnotes</h6>
+<p><a name="note360">360)</a> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y , 0) raise
+ the ''divide-by-zero'' floating-point exception.
+
+
+<a name="F.10.1.5" href="#F.10.1.5"><h5>F.10.1.5 The cos functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cos((+-)0) returns 1.
+<li>  cos((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+</ul>
+
+<a name="F.10.1.6" href="#F.10.1.6"><h5>F.10.1.6 The sin functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  sin((+-)0) returns (+-)0.
+<li>  sin((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+</ul>
+
+<a name="F.10.1.7" href="#F.10.1.7"><h5>F.10.1.7 The tan functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  tan((+-)0) returns (+-)0.
+<li>  tan((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+ 
+ 
+ 
+ 
+<!--page 534 indent 4-->
+</ul>
+
+<a name="F.10.2" href="#F.10.2"><h4>F.10.2 Hyperbolic functions</h4></a>
+
+<a name="F.10.2.1" href="#F.10.2.1"><h5>F.10.2.1 The acosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  acosh(1) returns +0.
+<li>  acosh(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 1.
+<li>  acosh(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.2.2" href="#F.10.2.2"><h5>F.10.2.2 The asinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  asinh((+-)0) returns (+-)0.
+<li>  asinh((+-)(inf)) returns (+-)(inf).
+</ul>
+
+<a name="F.10.2.3" href="#F.10.2.3"><h5>F.10.2.3 The atanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  atanh((+-)0) returns (+-)0.
+<li>  atanh((+-)1) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  atanh(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ | x | &gt; 1.
+</ul>
+
+<a name="F.10.2.4" href="#F.10.2.4"><h5>F.10.2.4 The cosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cosh((+-)0) returns 1.
+<li>  cosh((+-)(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.2.5" href="#F.10.2.5"><h5>F.10.2.5 The sinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  sinh((+-)0) returns (+-)0.
+<li>  sinh((+-)(inf)) returns (+-)(inf).
+</ul>
+
+<a name="F.10.2.6" href="#F.10.2.6"><h5>F.10.2.6 The tanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  tanh((+-)0) returns (+-)0.
+<li>  tanh((+-)(inf)) returns (+-)1.
+</ul>
+
+<a name="F.10.3" href="#F.10.3"><h4>F.10.3 Exponential and logarithmic functions</h4></a>
+
+<a name="F.10.3.1" href="#F.10.3.1"><h5>F.10.3.1 The exp functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  exp((+-)0) returns 1.
+<li>  exp(-(inf)) returns +0.
+<li>  exp(+(inf)) returns +(inf).
+<!--page 535 indent 4-->
+</ul>
+
+<a name="F.10.3.2" href="#F.10.3.2"><h5>F.10.3.2 The exp2 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  exp2((+-)0) returns 1.
+<li>  exp2(-(inf)) returns +0.
+<li>  exp2(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.3.3" href="#F.10.3.3"><h5>F.10.3.3 The expm1 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  expm1((+-)0) returns (+-)0.
+<li>  expm1(-(inf)) returns -1.
+<li>  expm1(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.3.4" href="#F.10.3.4"><h5>F.10.3.4 The frexp functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  frexp((+-)0, exp) returns (+-)0, and stores 0 in the object pointed to by exp.
+<li>  frexp((+-)(inf), exp) returns (+-)(inf), and stores an unspecified value in the object
+ pointed to by exp.
+<li>  frexp(NaN, exp) stores an unspecified value in the object pointed to by exp
+ (and returns a NaN).
+</ul>
+<p><!--para 2-->
+ frexp raises no floating-point exceptions.
+<p><!--para 3-->
+ When the radix of the argument is a power of 2, the returned value is exact and is
+ independent of the current rounding direction mode.
+<p><!--para 4-->
+ On a binary system, the body of the frexp function might be
+<pre>
+         {
+                *exp = (value == 0) ? 0 : (int)(1 + logb(value));
+                return scalbn(value, -(*exp));
+         }</pre>
+
+<a name="F.10.3.5" href="#F.10.3.5"><h5>F.10.3.5 The ilogb functions</h5></a>
+<p><!--para 1-->
+ When the correct result is representable in the range of the return type, the returned value
+ is exact and is independent of the current rounding direction mode.
+<p><!--para 2-->
+ If the correct result is outside the range of the return type, the numeric result is
+ unspecified and the ''invalid'' floating-point exception is raised.
+<!--page 536 indent 4-->
+
+<a name="F.10.3.6" href="#F.10.3.6"><h5>F.10.3.6 The ldexp functions</h5></a>
+<p><!--para 1-->
+ On a binary system, ldexp(x, exp) is equivalent to scalbn(x, exp).
+
+<a name="F.10.3.7" href="#F.10.3.7"><h5>F.10.3.7 The log functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log(1) returns +0.
+<li>  log(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+<li>  log(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.3.8" href="#F.10.3.8"><h5>F.10.3.8 The log10 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log10((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log10(1) returns +0.
+<li>  log10(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+<li>  log10(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.3.9" href="#F.10.3.9"><h5>F.10.3.9 The log1p functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log1p((+-)0) returns (+-)0.
+<li>  log1p(-1) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log1p(x) returns a NaN and raises the ''invalid'' floating-point exception for
+ x &lt; -1.
+<li>  log1p(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.3.10" href="#F.10.3.10"><h5>F.10.3.10 The log2 functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  log2((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  log2(1) returns +0.
+<li>  log2(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+<li>  log2(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.3.11" href="#F.10.3.11"><h5>F.10.3.11 The logb functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  logb((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  logb((+-)(inf)) returns +(inf).
+</ul>
+<p><!--para 2-->
+ The returned value is exact and is independent of the current rounding direction mode.
+<!--page 537 indent 4-->
+
+<a name="F.10.3.12" href="#F.10.3.12"><h5>F.10.3.12 The modf functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  modf((+-)x, iptr) returns a result with the same sign as x.
+<li>  modf((+-)(inf), iptr) returns (+-)0 and stores (+-)(inf) in the object pointed to by iptr.
+<li>  modf(NaN, iptr) stores a NaN in the object pointed to by iptr (and returns a
+ NaN).
+</ul>
+<p><!--para 2-->
+ The returned values are exact and are independent of the current rounding direction
+ mode.
+<p><!--para 3-->
+ modf behaves as though implemented by
+<pre>
+         #include &lt;math.h&gt;
+         #include &lt;fenv.h&gt;
+         #pragma STDC FENV_ACCESS ON
+         double modf(double value, double *iptr)
+         {
+              int save_round = fegetround();
+              fesetround(FE_TOWARDZERO);
+              *iptr = nearbyint(value);
+              fesetround(save_round);
+              return copysign(
+                   isinf(value) ? 0.0 :
+                        value - (*iptr), value);
+         }</pre>
+
+<a name="F.10.3.13" href="#F.10.3.13"><h5>F.10.3.13 The scalbn and scalbln functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  scalbn((+-)0, n) returns (+-)0.
+<li>  scalbn(x, 0) returns x.
+<li>  scalbn((+-)(inf), n) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ If the calculation does not overflow or underflow, the returned value is exact and
+ independent of the current rounding direction mode.
+<!--page 538 indent 4-->
+
+<a name="F.10.4" href="#F.10.4"><h4>F.10.4 Power and absolute value functions</h4></a>
+
+<a name="F.10.4.1" href="#F.10.4.1"><h5>F.10.4.1 The cbrt functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cbrt((+-)0) returns (+-)0.
+<li>  cbrt((+-)(inf)) returns (+-)(inf).
+</ul>
+
+<a name="F.10.4.2" href="#F.10.4.2"><h5>F.10.4.2 The fabs functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  fabs((+-)0) returns +0.
+<li>  fabs((+-)(inf)) returns +(inf).
+</ul>
+<p><!--para 2-->
+ The returned value is exact and is independent of the current rounding direction mode.
+
+<a name="F.10.4.3" href="#F.10.4.3"><h5>F.10.4.3 The hypot functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  hypot(x, y), hypot(y, x), and hypot(x, -y) are equivalent.
+<li>  hypot(x, (+-)0) is equivalent to fabs(x).
+<li>  hypot((+-)(inf), y) returns +(inf), even if y is a NaN.
+</ul>
+
+<a name="F.10.4.4" href="#F.10.4.4"><h5>F.10.4.4 The pow functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  pow((+-)0, y) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception
+ for y an odd integer &lt; 0.
+<li>  pow((+-)0, y) returns +(inf) and raises the ''divide-by-zero'' floating-point exception
+ for y &lt; 0, finite, and not an odd integer.
+<li>  pow((+-)0, -(inf)) returns +(inf) and may raise the ''divide-by-zero'' floating-point
+ exception.
+<li>  pow((+-)0, y) returns (+-)0 for y an odd integer &gt; 0.
+<li>  pow((+-)0, y) returns +0 for y &gt; 0 and not an odd integer.
+<li>  pow(-1, (+-)(inf)) returns 1.
+<li>  pow(+1, y) returns 1 for any y, even a NaN.
+<li>  pow(x, (+-)0) returns 1 for any x, even a NaN.
+<li>  pow(x, y) returns a NaN and raises the ''invalid'' floating-point exception for
+ finite x &lt; 0 and finite non-integer y.
+<li>  pow(x, -(inf)) returns +(inf) for | x | &lt; 1.
+<li>  pow(x, -(inf)) returns +0 for | x | &gt; 1.
+<li>  pow(x, +(inf)) returns +0 for | x | &lt; 1.
+<li>  pow(x, +(inf)) returns +(inf) for | x | &gt; 1.
+<!--page 539 indent 4-->
+<li>  pow(-(inf), y) returns -0 for y an odd integer &lt; 0.
+<li>  pow(-(inf), y) returns +0 for y &lt; 0 and not an odd integer.
+<li>  pow(-(inf), y) returns -(inf) for y an odd integer &gt; 0.
+<li>  pow(-(inf), y) returns +(inf) for y &gt; 0 and not an odd integer.
+<li>  pow(+(inf), y) returns +0 for y &lt; 0.
+<li>  pow(+(inf), y) returns +(inf) for y &gt; 0.
+</ul>
+
+<a name="F.10.4.5" href="#F.10.4.5"><h5>F.10.4.5 The sqrt functions</h5></a>
+<p><!--para 1-->
+ sqrt is fully specified as a basic arithmetic operation in IEC 60559. The returned value
+ is dependent on the current rounding direction mode.
+
+<a name="F.10.5" href="#F.10.5"><h4>F.10.5 Error and gamma functions</h4></a>
+
+<a name="F.10.5.1" href="#F.10.5.1"><h5>F.10.5.1 The erf functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  erf((+-)0) returns (+-)0.
+<li>  erf((+-)(inf)) returns (+-)1.
+</ul>
+
+<a name="F.10.5.2" href="#F.10.5.2"><h5>F.10.5.2 The erfc functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  erfc(-(inf)) returns 2.
+<li>  erfc(+(inf)) returns +0.
+</ul>
+
+<a name="F.10.5.3" href="#F.10.5.3"><h5>F.10.5.3 The lgamma functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  lgamma(1) returns +0.
+<li>  lgamma(2) returns +0.
+<li>  lgamma(x) returns +(inf) and raises the ''divide-by-zero'' floating-point exception for
+ x a negative integer or zero.
+<li>  lgamma(-(inf)) returns +(inf).
+<li>  lgamma(+(inf)) returns +(inf).
+</ul>
+
+<a name="F.10.5.4" href="#F.10.5.4"><h5>F.10.5.4 The tgamma functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  tgamma((+-)0) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+<li>  tgamma(x) returns a NaN and raises the ''invalid'' floating-point exception for x a
+ negative integer.
+<li>  tgamma(-(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+<li>  tgamma(+(inf)) returns +(inf).
+<!--page 540 indent 4-->
+</ul>
+
+<a name="F.10.6" href="#F.10.6"><h4>F.10.6 Nearest integer functions</h4></a>
+
+<a name="F.10.6.1" href="#F.10.6.1"><h5>F.10.6.1 The ceil functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  ceil((+-)0) returns (+-)0.
+<li>  ceil((+-)(inf)) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ The returned value is independent of the current rounding direction mode.
+<p><!--para 3-->
+ The double version of ceil behaves as though implemented by
+<p><!--para 4-->
+<pre>
+        #include &lt;math.h&gt;
+        #include &lt;fenv.h&gt;
+        #pragma STDC FENV_ACCESS ON
+        double ceil(double x)
+        {
+             double result;
+             int save_round = fegetround();
+             fesetround(FE_UPWARD);
+             result = rint(x); // or nearbyint instead of rint
+             fesetround(save_round);
+             return result;
+        }</pre>
+ The ceil functions may, but are not required to, raise the ''inexact'' floating-point
+ exception for finite non-integer arguments, as this implementation does.
+
+<a name="F.10.6.2" href="#F.10.6.2"><h5>F.10.6.2 The floor functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  floor((+-)0) returns (+-)0.
+<li>  floor((+-)(inf)) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ The returned value and is independent of the current rounding direction mode.
+<p><!--para 3-->
+ See the sample implementation for ceil in <a href="#F.10.6.1">F.10.6.1</a>. The floor functions may, but are
+ not required to, raise the ''inexact'' floating-point exception for finite non-integer
+ arguments, as that implementation does.
+
+<a name="F.10.6.3" href="#F.10.6.3"><h5>F.10.6.3 The nearbyint functions</h5></a>
+<p><!--para 1-->
+ The nearbyint functions use IEC 60559 rounding according to the current rounding
+ direction. They do not raise the ''inexact'' floating-point exception if the result differs in
+ value from the argument.
+<ul>
+<li>  nearbyint((+-)0) returns (+-)0 (for all rounding directions).
+<li>  nearbyint((+-)(inf)) returns (+-)(inf) (for all rounding directions).
+<!--page 541 indent 4-->
+</ul>
+
+<a name="F.10.6.4" href="#F.10.6.4"><h5>F.10.6.4 The rint functions</h5></a>
+<p><!--para 1-->
+ The rint functions differ from the nearbyint functions only in that they do raise the
+ ''inexact'' floating-point exception if the result differs in value from the argument.
+
+<a name="F.10.6.5" href="#F.10.6.5"><h5>F.10.6.5 The lrint and llrint functions</h5></a>
+<p><!--para 1-->
+ The lrint and llrint functions provide floating-to-integer conversion as prescribed
+ by IEC 60559. They round according to the current rounding direction. If the rounded
+ value is outside the range of the return type, the numeric result is unspecified and the
+ ''invalid'' floating-point exception is raised. When they raise no other floating-point
+ exception and the result differs from the argument, they raise the ''inexact'' floating-point
+ exception.
+
+<a name="F.10.6.6" href="#F.10.6.6"><h5>F.10.6.6 The round functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  round((+-)0) returns (+-)0.
+<li>  round((+-)(inf)) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ The returned value is independent of the current rounding direction mode.
+<p><!--para 3-->
+ The double version of round behaves as though implemented by
+<pre>
+         #include &lt;math.h&gt;
+         #include &lt;fenv.h&gt;
+         #pragma STDC FENV_ACCESS ON
+         double round(double x)
+         {
+              double result;
+              fenv_t save_env;
+              feholdexcept(&amp;save_env);
+              result = rint(x);
+              if (fetestexcept(FE_INEXACT)) {
+                   fesetround(FE_TOWARDZERO);
+                   result = rint(copysign(0.5 + fabs(x), x));
+              }
+              feupdateenv(&amp;save_env);
+              return result;
+         }</pre>
+ The round functions may, but are not required to, raise the ''inexact'' floating-point
+ exception for finite non-integer numeric arguments, as this implementation does.
+<!--page 542 indent 4-->
+
+<a name="F.10.6.7" href="#F.10.6.7"><h5>F.10.6.7 The lround and llround functions</h5></a>
+<p><!--para 1-->
+ The lround and llround functions differ from the lrint and llrint functions
+ with the default rounding direction just in that the lround and llround functions
+ round halfway cases away from zero and need not raise the ''inexact'' floating-point
+ exception for non-integer arguments that round to within the range of the return type.
+
+<a name="F.10.6.8" href="#F.10.6.8"><h5>F.10.6.8 The trunc functions</h5></a>
+<p><!--para 1-->
+ The trunc functions use IEC 60559 rounding toward zero (regardless of the current
+ rounding direction). The returned value is exact.
+<ul>
+<li>  trunc((+-)0) returns (+-)0.
+<li>  trunc((+-)(inf)) returns (+-)(inf).
+</ul>
+<p><!--para 2-->
+ The returned value is independent of the current rounding direction mode. The trunc
+ functions may, but are not required to, raise the ''inexact'' floating-point exception for
+ finite non-integer arguments.
+
+<a name="F.10.7" href="#F.10.7"><h4>F.10.7 Remainder functions</h4></a>
+
+<a name="F.10.7.1" href="#F.10.7.1"><h5>F.10.7.1 The fmod functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  fmod((+-)0, y) returns (+-)0 for y not zero.
+<li>  fmod(x, y) returns a NaN and raises the ''invalid'' floating-point exception for x
+ infinite or y zero (and neither is a NaN).
+<li>  fmod(x, (+-)(inf)) returns x for x not infinite.
+</ul>
+<p><!--para 2-->
+ When subnormal results are supported, the returned value is exact and is independent of
+ the current rounding direction mode.
+<p><!--para 3-->
+ The double version of fmod behaves as though implemented by
+<!--page 543 indent 4-->
+<pre>
+        #include &lt;math.h&gt;
+        #include &lt;fenv.h&gt;
+        #pragma STDC FENV_ACCESS ON
+        double fmod(double x, double y)
+        {
+             double result;
+             result = remainder(fabs(x), (y = fabs(y)));
+             if (signbit(result)) result += y;
+             return copysign(result, x);
+        }</pre>
+
+<a name="F.10.7.2" href="#F.10.7.2"><h5>F.10.7.2 The remainder functions</h5></a>
+<p><!--para 1-->
+ The remainder functions are fully specified as a basic arithmetic operation in
+ IEC 60559.
+<p><!--para 2-->
+ When subnormal results are supported, the returned value is exact and is independent of
+ the current rounding direction mode.
+
+<a name="F.10.7.3" href="#F.10.7.3"><h5>F.10.7.3 The remquo functions</h5></a>
+<p><!--para 1-->
+ The remquo functions follow the specifications for the remainder functions. They
+ have no further specifications special to IEC 60559 implementations.
+<p><!--para 2-->
+ When subnormal results are supported, the returned value is exact and is independent of
+ the current rounding direction mode.
+
+<a name="F.10.8" href="#F.10.8"><h4>F.10.8 Manipulation functions</h4></a>
+
+<a name="F.10.8.1" href="#F.10.8.1"><h5>F.10.8.1 The copysign functions</h5></a>
+<p><!--para 1-->
+ copysign is specified in the Appendix to IEC 60559.
+<p><!--para 2-->
+ The returned value is exact and is independent of the current rounding direction mode.
+
+<a name="F.10.8.2" href="#F.10.8.2"><h5>F.10.8.2 The nan functions</h5></a>
+<p><!--para 1-->
+ All IEC 60559 implementations support quiet NaNs, in all floating formats.
+<p><!--para 2-->
+ The returned value is exact and is independent of the current rounding direction mode.
+
+<a name="F.10.8.3" href="#F.10.8.3"><h5>F.10.8.3 The nextafter functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  nextafter(x, y) raises the ''overflow'' and ''inexact'' floating-point exceptions
+ for x finite and the function value infinite.
+<li>  nextafter(x, y) raises the ''underflow'' and ''inexact'' floating-point
+ exceptions for the function value subnormal or zero and x != y.
+</ul>
+<p><!--para 2-->
+ Even though underflow or overflow can occur, the returned value is independent of the
+ current rounding direction mode.
+
+<a name="F.10.8.4" href="#F.10.8.4"><h5>F.10.8.4 The nexttoward functions</h5></a>
+<p><!--para 1-->
+ No additional requirements beyond those on nextafter.
+<p><!--para 2-->
+ Even though underflow or overflow can occur, the returned value is independent of the
+ current rounding direction mode.
+<!--page 544 indent 4-->
+
+<a name="F.10.9" href="#F.10.9"><h4>F.10.9 Maximum, minimum, and positive difference functions</h4></a>
+
+<a name="F.10.9.1" href="#F.10.9.1"><h5>F.10.9.1 The fdim functions</h5></a>
+<p><!--para 1-->
+ No additional requirements.
+
+<a name="F.10.9.2" href="#F.10.9.2"><h5>F.10.9.2 The fmax functions</h5></a>
+<p><!--para 1-->
+ If just one argument is a NaN, the fmax functions return the other argument (if both
+ arguments are NaNs, the functions return a NaN).
+<p><!--para 2-->
+ The returned value is exact and is independent of the current rounding direction mode.
+<p><!--para 3-->
+ The body of the fmax function might be<sup><a href="#note361"><b>361)</b></a></sup>
+<pre>
+        { return (isgreaterequal(x, y) ||
+             isnan(y)) ? x : y; }</pre>
+
+<h6>footnotes</h6>
+<p><a name="note361">361)</a> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
+ return +0; however, implementation in software might be impractical.
+
+
+<a name="F.10.9.3" href="#F.10.9.3"><h5>F.10.9.3 The fmin functions</h5></a>
+<p><!--para 1-->
+ The fmin functions are analogous to the fmax functions (see <a href="#F.10.9.2">F.10.9.2</a>).
+<p><!--para 2-->
+ The returned value is exact and is independent of the current rounding direction mode.
+
+<a name="F.10.10" href="#F.10.10"><h4>F.10.10 Floating multiply-add</h4></a>
+
+<a name="F.10.10.1" href="#F.10.10.1"><h5>F.10.10.1 The fma functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  fma(x, y, z) computes xy + z, correctly rounded once.
+<li>  fma(x, y, z) returns a NaN and optionally raises the ''invalid'' floating-point
+ exception if one of x and y is infinite, the other is zero, and z is a NaN.
+<li>  fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if
+ one of x and y is infinite, the other is zero, and z is not a NaN.
+<li>  fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if x
+ times y is an exact infinity and z is also an infinity but with the opposite sign.
+ 
+ 
+ 
+ 
+<!--page 545 indent 4-->
+</ul>
+
+<a name="F.10.11" href="#F.10.11"><h4>F.10.11 Comparison macros</h4></a>
+<p><!--para 1-->
+ Relational operators and their corresponding comparison macros (<a href="#7.12.14">7.12.14</a>) produce
+ equivalent result values, even if argument values are represented in wider formats. Thus,
+ comparison macro arguments represented in formats wider than their semantic types are
+ not converted to the semantic types, unless the wide evaluation method converts operands
+ of relational operators to their semantic types. The standard wide evaluation methods
+ characterized by FLT_EVAL_METHOD equal to 1 or 2 (<a href="#5.2.4.2.2">5.2.4.2.2</a>), do not convert
+ operands of relational operators to their semantic types.
+<!--page 546 indent 4-->
+
+<a name="G" href="#G"><h2>Annex G</h2></a>
+<pre>
+                                       (normative)
+                IEC 60559-compatible complex arithmetic</pre>
+
+<a name="G.1" href="#G.1"><h3>G.1 Introduction</h3></a>
+<p><!--para 1-->
+ This annex supplements <a href="#F">annex F</a> to specify complex arithmetic for compatibility with
+ IEC 60559 real floating-point arithmetic. An implementation that defines *
+ __STDC_IEC_559_COMPLEX__ shall conform to the specifications in this annex.<sup><a href="#note362"><b>362)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note362">362)</a> Implementations that do not define __STDC_IEC_559_COMPLEX__ are not required to conform
+ to these specifications.
+
+
+<a name="G.2" href="#G.2"><h3>G.2 Types</h3></a>
+<p><!--para 1-->
+ There is a new keyword _Imaginary, which is used to specify imaginary types. It is
+ used as a type specifier within declaration specifiers in the same way as _Complex is
+ (thus, _Imaginary float is a valid type name).
+<p><!--para 2-->
+ There are three imaginary types, designated as float _Imaginary, double
+ _Imaginary, and long double _Imaginary. The imaginary types (along with
+ the real floating and complex types) are floating types.
+<p><!--para 3-->
+ For imaginary types, the corresponding real type is given by deleting the keyword
+ _Imaginary from the type name.
+<p><!--para 4-->
+ Each imaginary type has the same representation and alignment requirements as the
+ corresponding real type. The value of an object of imaginary type is the value of the real
+ representation times the imaginary unit.
+<p><!--para 5-->
+ The imaginary type domain comprises the imaginary types.
+
+<a name="G.3" href="#G.3"><h3>G.3 Conventions</h3></a>
+<p><!--para 1-->
+ A complex or imaginary value with at least one infinite part is regarded as an infinity
+ (even if its other part is a NaN). A complex or imaginary value is a finite number if each
+ of its parts is a finite number (neither infinite nor NaN). A complex or imaginary value is
+ a zero if each of its parts is a zero.
+ 
+ 
+ 
+ 
+<!--page 547 indent 4-->
+
+<a name="G.4" href="#G.4"><h3>G.4 Conversions</h3></a>
+
+<a name="G.4.1" href="#G.4.1"><h4>G.4.1 Imaginary types</h4></a>
+<p><!--para 1-->
+ Conversions among imaginary types follow rules analogous to those for real floating
+ types.
+
+<a name="G.4.2" href="#G.4.2"><h4>G.4.2 Real and imaginary</h4></a>
+<p><!--para 1-->
+ When a value of imaginary type is converted to a real type other than _Bool,<sup><a href="#note363"><b>363)</b></a></sup> the
+ result is a positive zero.
+<p><!--para 2-->
+ When a value of real type is converted to an imaginary type, the result is a positive
+ imaginary zero.
+
+<h6>footnotes</h6>
+<p><a name="note363">363)</a> See <a href="#6.3.1.2">6.3.1.2</a>.
+
+
+<a name="G.4.3" href="#G.4.3"><h4>G.4.3 Imaginary and complex</h4></a>
+<p><!--para 1-->
+ When a value of imaginary type is converted to a complex type, the real part of the
+ complex result value is a positive zero and the imaginary part of the complex result value
+ is determined by the conversion rules for the corresponding real types.
+<p><!--para 2-->
+ When a value of complex type is converted to an imaginary type, the real part of the
+ complex value is discarded and the value of the imaginary part is converted according to
+ the conversion rules for the corresponding real types.
+
+<a name="G.5" href="#G.5"><h3>G.5 Binary operators</h3></a>
+<p><!--para 1-->
+ The following subclauses supplement <a href="#6.5">6.5</a> in order to specify the type of the result for an
+ operation with an imaginary operand.
+<p><!--para 2-->
+ For most operand types, the value of the result of a binary operator with an imaginary or
+ complex operand is completely determined, with reference to real arithmetic, by the usual
+ mathematical formula. For some operand types, the usual mathematical formula is
+ problematic because of its treatment of infinities and because of undue overflow or
+ underflow; in these cases the result satisfies certain properties (specified in <a href="#G.5.1">G.5.1</a>), but is
+ not completely determined.
+ 
+ 
+ 
+ 
+<!--page 548 indent 4-->
+
+<a name="G.5.1" href="#G.5.1"><h4>G.5.1 Multiplicative operators</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If one operand has real type and the other operand has imaginary type, then the result has
+ imaginary type. If both operands have imaginary type, then the result has real type. (If
+ either operand has complex type, then the result has complex type.)
+<p><!--para 2-->
+ If the operands are not both complex, then the result and floating-point exception
+ behavior of the * operator is defined by the usual mathematical formula:
+<pre>
+        *                  u                   iv                 u + iv</pre>
+ 
+<pre>
+        x                  xu                i(xv)            (xu) + i(xv)</pre>
+ 
+<pre>
+        iy               i(yu)                -yv            (-yv) + i(yu)</pre>
+ 
+<p><!--para 3-->
+<pre>
+        x + iy       (xu) + i(yu)        (-yv) + i(xv)</pre>
+ If the second operand is not complex, then the result and floating-point exception
+ behavior of the / operator is defined by the usual mathematical formula:
+<pre>
+        /                   u                       iv</pre>
+ 
+<pre>
+        x                  x/u                 i(-x/v)</pre>
+ 
+<pre>
+        iy               i(y/u)                     y/v</pre>
+ 
+<p><!--para 4-->
+<pre>
+        x + iy       (x/u) + i(y/u)        (y/v) + i(-x/v)</pre>
+ The * and / operators satisfy the following infinity properties for all real, imaginary, and
+ complex operands:<sup><a href="#note364"><b>364)</b></a></sup>
+<ul>
+<li>  if one operand is an infinity and the other operand is a nonzero finite number or an
+ infinity, then the result of the * operator is an infinity;
+<li>  if the first operand is an infinity and the second operand is a finite number, then the
+ result of the / operator is an infinity;
+<li>  if the first operand is a finite number and the second operand is an infinity, then the
+ result of the / operator is a zero;
+ 
+ 
+ 
+ 
+<!--page 549 indent 4-->
+<li>  if the first operand is a nonzero finite number or an infinity and the second operand is
+ a zero, then the result of the / operator is an infinity.
+</ul>
+<p><!--para 5-->
+ If both operands of the * operator are complex or if the second operand of the / operator
+ is complex, the operator raises floating-point exceptions if appropriate for the calculation
+ of the parts of the result, and may raise spurious floating-point exceptions.
+<p><!--para 6-->
+ EXAMPLE 1 Multiplication of double _Complex operands could be implemented as follows. Note
+ that the imaginary unit I has imaginary type (see <a href="#G.6">G.6</a>).
+<!--page 550 indent 4-->
+<p><!--para 7-->
+<pre>
+          #include &lt;math.h&gt;
+          #include &lt;complex.h&gt;
+          /* Multiply z * w ... */
+          double complex _Cmultd(double complex z, double complex w)
+          {
+                 #pragma STDC FP_CONTRACT OFF
+                 double a, b, c, d, ac, bd, ad, bc, x, y;
+                 a = creal(z); b = cimag(z);
+                 c = creal(w); d = cimag(w);
+                 ac = a * c;       bd = b * d;
+                 ad = a * d;       bc = b * c;
+                 x = ac - bd; y = ad + bc;
+                 if (isnan(x) &amp;&amp; isnan(y)) {
+                         /* Recover infinities that computed as NaN+iNaN ... */
+                         int recalc = 0;
+                         if ( isinf(a) || isinf(b) ) { // z is infinite
+                                 /* "Box" the infinity and change NaNs in the other factor to 0 */
+                                 a = copysign(isinf(a) ? 1.0 : 0.0, a);
+                                 b = copysign(isinf(b) ? 1.0 : 0.0, b);
+                                 if (isnan(c)) c = copysign(0.0, c);
+                                 if (isnan(d)) d = copysign(0.0, d);
+                                 recalc = 1;
+                         }
+                         if ( isinf(c) || isinf(d) ) { // w is infinite
+                                 /* "Box" the infinity and change NaNs in the other factor to 0 */
+                                 c = copysign(isinf(c) ? 1.0 : 0.0, c);
+                                 d = copysign(isinf(d) ? 1.0 : 0.0, d);
+                                 if (isnan(a)) a = copysign(0.0, a);
+                                 if (isnan(b)) b = copysign(0.0, b);
+                                 recalc = 1;
+                         }
+                         if (!recalc &amp;&amp; (isinf(ac) || isinf(bd) ||
+                                                isinf(ad) || isinf(bc))) {
+                                 /* Recover infinities from overflow by changing NaNs to 0 ... */
+                                 if (isnan(a)) a = copysign(0.0, a);
+                                 if (isnan(b)) b = copysign(0.0, b);
+                                 if (isnan(c)) c = copysign(0.0, c);
+                                 if (isnan(d)) d = copysign(0.0, d);
+                                 recalc = 1;
+                         }
+                         if (recalc) {
+                                   x = INFINITY * ( a * c - b * d );
+                                   y = INFINITY * ( a * d + b * c );
+                        }
+                  }
+                  return x + I * y;
+         }</pre>
+ This implementation achieves the required treatment of infinities at the cost of only one isnan test in
+ ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
+ 
+<p><!--para 8-->
+ EXAMPLE 2      Division of two double _Complex operands could be implemented as follows.
+<!--page 551 indent 4-->
+<p><!--para 9-->
+<pre>
+         #include &lt;math.h&gt;
+         #include &lt;complex.h&gt;
+         /* Divide z / w ... */
+         double complex _Cdivd(double complex z, double complex w)
+         {
+                #pragma STDC FP_CONTRACT OFF
+                double a, b, c, d, logbw, denom, x, y;
+                int ilogbw = 0;
+                a = creal(z); b = cimag(z);
+                c = creal(w); d = cimag(w);
+                logbw = logb(fmax(fabs(c), fabs(d)));
+                if (logbw == INFINITY) {
+                       ilogbw = (int)logbw;
+                       c = scalbn(c, -ilogbw); d = scalbn(d, -ilogbw);
+                }
+                denom = c * c + d * d;
+                x = scalbn((a * c + b * d) / denom, -ilogbw);
+                y = scalbn((b * c - a * d) / denom, -ilogbw);
+                  /* Recover infinities and zeros that computed as NaN+iNaN;                 */
+                  /* the only cases are nonzero/zero, infinite/finite, and finite/infinite, ... */
+                  if (isnan(x) &amp;&amp; isnan(y)) {
+                        if ((denom == 0.0) &amp;&amp;
+                              (!isnan(a) || !isnan(b))) {
+                              x = copysign(INFINITY, c) * a;
+                              y = copysign(INFINITY, c) * b;
+                        }
+                        else if ((isinf(a) || isinf(b)) &amp;&amp;
+                              isfinite(c) &amp;&amp; isfinite(d)) {
+                              a = copysign(isinf(a) ? 1.0 : 0.0,                        a);
+                              b = copysign(isinf(b) ? 1.0 : 0.0,                        b);
+                              x = INFINITY * ( a * c + b * d );
+                              y = INFINITY * ( b * c - a * d );
+                        }
+                        else if (isinf(logbw) &amp;&amp;
+                              isfinite(a) &amp;&amp; isfinite(b)) {
+                              c = copysign(isinf(c) ? 1.0 : 0.0,                        c);
+                              d = copysign(isinf(d) ? 1.0 : 0.0,                        d);
+                              x = 0.0 * ( a * c + b * d );
+                              y = 0.0 * ( b * c - a * d );
+                        }
+                  }
+                  return x + I * y;
+         }</pre>
+ Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
+ for multiplication. In the spirit of the multiplication example above, this code does not defend against
+ overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
+ with division, provides better roundoff characteristics.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note364">364)</a> These properties are already implied for those cases covered in the tables, but are required for all cases
+ (at least where the state for CX_LIMITED_RANGE is ''off'').
+
+
+<a name="G.5.2" href="#G.5.2"><h4>G.5.2 Additive operators</h4></a>
+<h6>Semantics</h6>
+<p><!--para 1-->
+ If both operands have imaginary type, then the result has imaginary type. (If one operand
+ has real type and the other operand has imaginary type, or if either operand has complex
+ type, then the result has complex type.)
+<p><!--para 2-->
+ In all cases the result and floating-point exception behavior of a + or - operator is defined
+ by the usual mathematical formula:
+<pre>
+        + or -              u                       iv                    u + iv</pre>
+ 
+<pre>
+        x                 x(+-)u                     x (+-) iv              (x (+-) u) (+-) iv</pre>
+ 
+<pre>
+        iy               (+-)u + iy                 i(y (+-) v)             (+-)u + i(y (+-) v)</pre>
+ 
+<pre>
+        x + iy         (x (+-) u) + iy            x + i(y (+-) v)        (x (+-) u) + i(y (+-) v)</pre>
+
+<a name="G.6" href="#G.6"><h3>G.6 Complex arithmetic <complex.h></h3></a>
+<p><!--para 1-->
+ The macros
+<pre>
+         imaginary</pre>
+ and
+<pre>
+         _Imaginary_I</pre>
+ are defined, respectively, as _Imaginary and a constant expression of type const
+ float _Imaginary with the value of the imaginary unit. The macro
+<pre>
+         I</pre>
+ is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
+ the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
+ imaginary.
+<p><!--para 2-->
+ This subclause contains specifications for the &lt;complex.h&gt; functions that are
+ particularly suited to IEC 60559 implementations. For families of functions, the
+ specifications apply to all of the functions even though only the principal function is
+<!--page 552 indent 4-->
+ shown. Unless otherwise specified, where the symbol ''(+-)'' occurs in both an argument
+ and the result, the result has the same sign as the argument.
+<p><!--para 3-->
+ The functions are continuous onto both sides of their branch cuts, taking into account the
+ sign of zero. For example, csqrt(-2 (+-) i0) = (+-)i(sqrt)2.  -
+<p><!--para 4-->
+ Since complex and imaginary values are composed of real values, each function may be
+ regarded as computing real values from real values. Except as noted, the functions treat
+ real infinities, NaNs, signed zeros, subnormals, and the floating-point exception flags in a
+ manner consistent with the specifications for real functions in F.10.<sup><a href="#note365"><b>365)</b></a></sup>
+<p><!--para 5-->
+ The functions cimag, conj, cproj, and creal are fully specified for all
+ implementations, including IEC 60559 ones, in <a href="#7.3.9">7.3.9</a>. These functions raise no floating-
+ point exceptions.
+<p><!--para 6-->
+ Each of the functions cabs and carg is specified by a formula in terms of a real
+ function (whose special cases are covered in <a href="#F">annex F</a>):
+<p><!--para 7-->
+<pre>
+         cabs(x + iy) = hypot(x, y)
+         carg(x + iy) = atan2(y, x)</pre>
+ Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
+ a formula in terms of other complex functions (whose special cases are specified below):
+<p><!--para 8-->
+<pre>
+         casin(z)        =   -i casinh(iz)
+         catan(z)        =   -i catanh(iz)
+         ccos(z)         =   ccosh(iz)
+         csin(z)         =   -i csinh(iz)
+         ctan(z)         =   -i ctanh(iz)</pre>
+ For the other functions, the following subclauses specify behavior for special cases,
+ including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
+ families of functions, the specifications apply to all of the functions even though only the
+ principal function is shown. For a function f satisfying f (conj(z)) = conj( f (z)), the
+ specifications for the upper half-plane imply the specifications for the lower half-plane; if
+ the function f is also either even, f (-z) = f (z), or odd, f (-z) = - f (z), then the
+ specifications for the first quadrant imply the specifications for the other three quadrants.
+<p><!--para 9-->
+ In the following subclauses, cis(y) is defined as cos(y) + i sin(y).
+ 
+ 
+ 
+ 
+<!--page 553 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note365">365)</a> As noted in <a href="#G.3">G.3</a>, a complex value with at least one infinite part is regarded as an infinity even if its
+ other part is a NaN.
+
+
+<a name="G.6.1" href="#G.6.1"><h4>G.6.1 Trigonometric functions</h4></a>
+
+<a name="G.6.1.1" href="#G.6.1.1"><h5>G.6.1.1 The cacos functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cacos(conj(z)) = conj(cacos(z)).
+<li>  cacos((+-)0 + i0) returns pi /2 - i0.
+<li>  cacos((+-)0 + iNaN) returns pi /2 + iNaN.
+<li>  cacos(x + i (inf)) returns pi /2 - i (inf), for finite x.
+<li>  cacos(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for nonzero finite x.
+<li>  cacos(-(inf) + iy) returns pi - i (inf), for positive-signed finite y.
+<li>  cacos(+(inf) + iy) returns +0 - i (inf), for positive-signed finite y.
+<li>  cacos(-(inf) + i (inf)) returns 3pi /4 - i (inf).
+<li>  cacos(+(inf) + i (inf)) returns pi /4 - i (inf).
+<li>  cacos((+-)(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  cacos(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite y.
+<li>  cacos(NaN + i (inf)) returns NaN - i (inf).
+<li>  cacos(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2" href="#G.6.2"><h4>G.6.2 Hyperbolic functions</h4></a>
+
+<a name="G.6.2.1" href="#G.6.2.1"><h5>G.6.2.1 The cacosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cacosh(conj(z)) = conj(cacosh(z)).
+<li>  cacosh((+-)0 + i0) returns +0 + ipi /2.
+<li>  cacosh(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+<li>  cacosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite x.
+<li>  cacosh(-(inf) + iy) returns +(inf) + ipi , for positive-signed finite y.
+<li>  cacosh(+(inf) + iy) returns +(inf) + i0, for positive-signed finite y.
+<li>  cacosh(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+<li>  cacosh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+<li>  cacosh((+-)(inf) + iNaN) returns +(inf) + iNaN.
+<!--page 554 indent 4-->
+<li>  cacosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite y.
+<li>  cacosh(NaN + i (inf)) returns +(inf) + iNaN.
+<li>  cacosh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.2" href="#G.6.2.2"><h5>G.6.2.2 The casinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  casinh(conj(z)) = conj(casinh(z)) and casinh is odd.
+<li>  casinh(+0 + i0) returns 0 + i0.
+<li>  casinh(x + i (inf)) returns +(inf) + ipi /2 for positive-signed finite x.
+<li>  casinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite x.
+<li>  casinh(+(inf) + iy) returns +(inf) + i0 for positive-signed finite y.
+<li>  casinh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+<li>  casinh(+(inf) + iNaN) returns +(inf) + iNaN.
+<li>  casinh(NaN + i0) returns NaN + i0.
+<li>  casinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite nonzero y.
+<li>  casinh(NaN + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+ is unspecified).
+<li>  casinh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.3" href="#G.6.2.3"><h5>G.6.2.3 The catanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  catanh(conj(z)) = conj(catanh(z)) and catanh is odd.
+<li>  catanh(+0 + i0) returns +0 + i0.
+<li>  catanh(+0 + iNaN) returns +0 + iNaN.
+<li>  catanh(+1 + i0) returns +(inf) + i0 and raises the ''divide-by-zero'' floating-point
+ exception.
+<li>  catanh(x + i (inf)) returns +0 + ipi /2, for finite positive-signed x.
+<li>  catanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for nonzero finite x.
+<li>  catanh(+(inf) + iy) returns +0 + ipi /2, for finite positive-signed y.
+<li>  catanh(+(inf) + i (inf)) returns +0 + ipi /2.
+<li>  catanh(+(inf) + iNaN) returns +0 + iNaN.
+<!--page 555 indent 4-->
+<li>  catanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+ floating-point exception, for finite y.
+<li>  catanh(NaN + i (inf)) returns (+-)0 + ipi /2 (where the sign of the real part of the result is
+ unspecified).
+<li>  catanh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.4" href="#G.6.2.4"><h5>G.6.2.4 The ccosh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  ccosh(conj(z)) = conj(ccosh(z)) and ccosh is even.
+<li>  ccosh(+0 + i0) returns 1 + i0.
+<li>  ccosh(+0 + i (inf)) returns NaN (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified) and raises the ''invalid'' floating-point exception.
+<li>  ccosh(+0 + iNaN) returns NaN (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  ccosh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for finite nonzero x.
+<li>  ccosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite nonzero x.
+<li>  ccosh(+(inf) + i0) returns +(inf) + i0.
+<li>  ccosh(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+<li>  ccosh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+ unspecified) and raises the ''invalid'' floating-point exception.
+<li>  ccosh(+(inf) + iNaN) returns +(inf) + iNaN.
+<li>  ccosh(NaN + i0) returns NaN (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  ccosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  ccosh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.5" href="#G.6.2.5"><h5>G.6.2.5 The csinh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  csinh(conj(z)) = conj(csinh(z)) and csinh is odd.
+<li>  csinh(+0 + i0) returns +0 + i0.
+<li>  csinh(+0 + i (inf)) returns (+-)0 + iNaN (where the sign of the real part of the result is
+ unspecified) and raises the ''invalid'' floating-point exception.
+<li>  csinh(+0 + iNaN) returns (+-)0 + iNaN (where the sign of the real part of the result is
+ unspecified).
+<!--page 556 indent 4-->
+<li>  csinh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for positive finite x.
+<li>  csinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite nonzero x.
+<li>  csinh(+(inf) + i0) returns +(inf) + i0.
+<li>  csinh(+(inf) + iy) returns +(inf) cis(y), for positive finite y.
+<li>  csinh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+ unspecified) and raises the ''invalid'' floating-point exception.
+<li>  csinh(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+ is unspecified).
+<li>  csinh(NaN + i0) returns NaN + i0.
+<li>  csinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  csinh(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.2.6" href="#G.6.2.6"><h5>G.6.2.6 The ctanh functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  ctanh(conj(z)) = conj(ctanh(z))and ctanh is odd.
+<li>  ctanh(+0 + i0) returns +0 + i0.
+<li>  ctanh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for finite x.
+<li>  ctanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<li>  ctanh(+(inf) + iy) returns 1 + i0 sin(2y), for positive-signed finite y.
+<li>  ctanh(+(inf) + i (inf)) returns 1 (+-) i0 (where the sign of the imaginary part of the result
+ is unspecified).
+<li>  ctanh(+(inf) + iNaN) returns 1 (+-) i0 (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  ctanh(NaN + i0) returns NaN + i0.
+<li>  ctanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  ctanh(NaN + iNaN) returns NaN + iNaN.
+<!--page 557 indent 4-->
+</ul>
+
+<a name="G.6.3" href="#G.6.3"><h4>G.6.3 Exponential and logarithmic functions</h4></a>
+
+<a name="G.6.3.1" href="#G.6.3.1"><h5>G.6.3.1 The cexp functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  cexp(conj(z)) = conj(cexp(z)).
+<li>  cexp((+-)0 + i0) returns 1 + i0.
+<li>  cexp(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+ exception, for finite x.
+<li>  cexp(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<li>  cexp(+(inf) + i0) returns +(inf) + i0.
+<li>  cexp(-(inf) + iy) returns +0 cis(y), for finite y.
+<li>  cexp(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+<li>  cexp(-(inf) + i (inf)) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts of
+ the result are unspecified).
+<li>  cexp(+(inf) + i (inf)) returns (+-)(inf) + iNaN and raises the ''invalid'' floating-point
+ exception (where the sign of the real part of the result is unspecified).
+<li>  cexp(-(inf) + iNaN) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts
+ of the result are unspecified).
+<li>  cexp(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+ is unspecified).
+<li>  cexp(NaN + i0) returns NaN + i0.
+<li>  cexp(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for all nonzero numbers y.
+<li>  cexp(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.3.2" href="#G.6.3.2"><h5>G.6.3.2 The clog functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  clog(conj(z)) = conj(clog(z)).
+<li>  clog(-0 + i0) returns -(inf) + ipi and raises the ''divide-by-zero'' floating-point
+ exception.
+<li>  clog(+0 + i0) returns -(inf) + i0 and raises the ''divide-by-zero'' floating-point
+ exception.
+<li>  clog(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+<li>  clog(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<!--page 558 indent 4-->
+<li>  clog(-(inf) + iy) returns +(inf) + ipi , for finite positive-signed y.
+<li>  clog(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+<li>  clog(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+<li>  clog(+(inf) + i (inf)) returns +(inf) + ipi /4.
+<li>  clog((+-)(inf) + iNaN) returns +(inf) + iNaN.
+<li>  clog(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite y.
+<li>  clog(NaN + i (inf)) returns +(inf) + iNaN.
+<li>  clog(NaN + iNaN) returns NaN + iNaN.
+</ul>
+
+<a name="G.6.4" href="#G.6.4"><h4>G.6.4 Power and absolute-value functions</h4></a>
+
+<a name="G.6.4.1" href="#G.6.4.1"><h5>G.6.4.1 The cpow functions</h5></a>
+<p><!--para 1-->
+ The cpow functions raise floating-point exceptions if appropriate for the calculation of
+ the parts of the result, and may also raise spurious floating-point exceptions.<sup><a href="#note366"><b>366)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note366">366)</a> This allows cpow( z , c ) to be implemented as cexp(c      clog( z )) without precluding
+ implementations that treat special cases more carefully.
+
+
+<a name="G.6.4.2" href="#G.6.4.2"><h5>G.6.4.2 The csqrt functions</h5></a>
+<p><!--para 1-->
+<ul>
+<li>  csqrt(conj(z)) = conj(csqrt(z)).
+<li>  csqrt((+-)0 + i0) returns +0 + i0.
+<li>  csqrt(x + i (inf)) returns +(inf) + i (inf), for all x (including NaN).
+<li>  csqrt(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite x.
+<li>  csqrt(-(inf) + iy) returns +0 + i (inf), for finite positive-signed y.
+<li>  csqrt(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+<li>  csqrt(-(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+ result is unspecified).
+<li>  csqrt(+(inf) + iNaN) returns +(inf) + iNaN.
+<li>  csqrt(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+ point exception, for finite y.
+<li>  csqrt(NaN + iNaN) returns NaN + iNaN.
+ 
+ 
+ 
+ 
+<!--page 559 indent 4-->
+</ul>
+
+<a name="G.7" href="#G.7"><h3>G.7 Type-generic math <tgmath.h></h3></a>
+<p><!--para 1-->
+ Type-generic macros that accept complex arguments also accept imaginary arguments. If
+ an argument is imaginary, the macro expands to an expression whose type is real,
+ imaginary, or complex, as appropriate for the particular function: if the argument is
+ imaginary, then the types of cos, cosh, fabs, carg, cimag, and creal are real; the
+ types of sin, tan, sinh, tanh, asin, atan, asinh, and atanh are imaginary; and
+ the types of the others are complex.
+<p><!--para 2-->
+ Given an imaginary argument, each of the type-generic macros cos, sin, tan, cosh,
+ sinh, tanh, asin, atan, asinh, atanh is specified by a formula in terms of real
+ functions:
+<!--page 560 indent 4-->
+<pre>
+         cos(iy)     =   cosh(y)
+         sin(iy)     =   i sinh(y)
+         tan(iy)     =   i tanh(y)
+         cosh(iy)    =   cos(y)
+         sinh(iy)    =   i sin(y)
+         tanh(iy)    =   i tan(y)
+         asin(iy)    =   i asinh(y)
+         atan(iy)    =   i atanh(y)
+         asinh(iy)   =   i asin(y)
+         atanh(iy)   =   i atan(y)</pre>
+
+<a name="H" href="#H"><h2>Annex H</h2></a>
+<pre>
+                                     (informative)
+                     Language independent arithmetic</pre>
+
+<a name="H.1" href="#H.1"><h3>H.1 Introduction</h3></a>
+<p><!--para 1-->
+ This annex documents the extent to which the C language supports the ISO/IEC 10967-1
+ standard for language-independent arithmetic (LIA-1). LIA-1 is more general than
+ IEC 60559 (<a href="#F">annex F</a>) in that it covers integer and diverse floating-point arithmetics.
+
+<a name="H.2" href="#H.2"><h3>H.2 Types</h3></a>
+<p><!--para 1-->
+ The relevant C arithmetic types meet the requirements of LIA-1 types if an
+ implementation adds notification of exceptional arithmetic operations and meets the 1
+ unit in the last place (ULP) accuracy requirement (LIA-1 subclause <a href="#5.2.8">5.2.8</a>).
+
+<a name="H.2.1" href="#H.2.1"><h4>H.2.1 Boolean type</h4></a>
+<p><!--para 1-->
+ The LIA-1 data type Boolean is implemented by the C data type bool with values of
+ true and false, all from &lt;stdbool.h&gt;.
+
+<a name="H.2.2" href="#H.2.2"><h4>H.2.2 Integer types</h4></a>
+<p><!--para 1-->
+ The signed C integer types int, long int, long long int, and the corresponding
+ unsigned types are compatible with LIA-1. If an implementation adds support for the
+ LIA-1 exceptional values ''integer_overflow'' and ''undefined'', then those types are
+ LIA-1 conformant types. C's unsigned integer types are ''modulo'' in the LIA-1 sense
+ in that overflows or out-of-bounds results silently wrap. An implementation that defines
+ signed integer types as also being modulo need not detect integer overflow, in which case,
+ only integer divide-by-zero need be detected.
+<p><!--para 2-->
+ The parameters for the integer data types can be accessed by the following:
+ maxint        INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
+<pre>
+               ULLONG_MAX</pre>
+ minint        INT_MIN, LONG_MIN, LLONG_MIN
+<p><!--para 3-->
+ The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
+ is always 0 for the unsigned types, and is not provided for those types.
+<!--page 561 indent 4-->
+
+<a name="H.2.2.1" href="#H.2.2.1"><h5>H.2.2.1 Integer operations</h5></a>
+<p><!--para 1-->
+ The integer operations on integer types are the following:
+ addI           x + y
+ subI           x - y
+ mulI           x * y
+ divI, divtI    x / y
+ remI, remtI    x % y
+ negI           -x
+ absI           abs(x), labs(x), llabs(x)
+ eqI            x == y
+ neqI           x != y
+ lssI           x &lt; y
+ leqI           x &lt;= y
+ gtrI           x &gt; y
+ geqI           x &gt;= y
+ where x and y are expressions of the same integer type.
+
+<a name="H.2.3" href="#H.2.3"><h4>H.2.3 Floating-point types</h4></a>
+<p><!--para 1-->
+ The C floating-point types float, double, and long double are compatible with
+ LIA-1. If an implementation adds support for the LIA-1 exceptional values
+ ''underflow'', ''floating_overflow'', and ''"undefined'', then those types are conformant
+ with LIA-1. An implementation that uses IEC 60559 floating-point formats and
+ operations (see <a href="#F">annex F</a>) along with IEC 60559 status flags and traps has LIA-1
+ conformant types.
+
+<a name="H.2.3.1" href="#H.2.3.1"><h5>H.2.3.1 Floating-point parameters</h5></a>
+<p><!--para 1-->
+ The parameters for a floating point data type can be accessed by the following:
+ r              FLT_RADIX
+ p              FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG
+ emax           FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP
+ emin           FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP
+<p><!--para 2-->
+ The derived constants for the floating point types are accessed by the following:
+<!--page 562 indent 4-->
+ fmax          FLT_MAX, DBL_MAX, LDBL_MAX
+ fminN         FLT_MIN, DBL_MIN, LDBL_MIN
+ epsilon       FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON
+ rnd_style     FLT_ROUNDS
+
+<a name="H.2.3.2" href="#H.2.3.2"><h5>H.2.3.2 Floating-point operations</h5></a>
+<p><!--para 1-->
+ The floating-point operations on floating-point types are the following:
+ addF          x + y
+ subF          x - y
+ mulF          x * y
+ divF          x / y
+ negF          -x
+ absF          fabsf(x), fabs(x), fabsl(x)
+ exponentF     1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
+ scaleF        scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
+<pre>
+               scalblnf(x, li), scalbln(x, li), scalblnl(x, li)</pre>
+ intpartF      modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+ fractpartF    modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+ eqF           x == y
+ neqF          x != y
+ lssF          x &lt; y
+ leqF          x &lt;= y
+ gtrF          x &gt; y
+ geqF          x &gt;= y
+ where x and y are expressions of the same floating point type, n is of type int, and li
+ is of type long int.
+
+<a name="H.2.3.3" href="#H.2.3.3"><h5>H.2.3.3 Rounding styles</h5></a>
+<p><!--para 1-->
+ The C Standard requires all floating types to use the same radix and rounding style, so
+ that only one identifier for each is provided to map to LIA-1.
+<p><!--para 2-->
+ The FLT_ROUNDS parameter can be used to indicate the LIA-1 rounding styles:
+ truncate      FLT_ROUNDS == 0
+<!--page 563 indent 4-->
+ nearest       FLT_ROUNDS == 1
+ other         FLT_ROUNDS != 0 &amp;&amp; FLT_ROUNDS != 1
+ provided that an implementation extends FLT_ROUNDS to cover the rounding style used
+ in all relevant LIA-1 operations, not just addition as in C.
+
+<a name="H.2.4" href="#H.2.4"><h4>H.2.4 Type conversions</h4></a>
+<p><!--para 1-->
+ The LIA-1 type conversions are the following type casts:
+ cvtI' -&gt; I     (int)i, (long int)i, (long long int)i,
+<pre>
+               (unsigned int)i, (unsigned long int)i,
+               (unsigned long long int)i</pre>
+ cvtF -&gt; I      (int)x, (long int)x, (long long int)x,
+<pre>
+               (unsigned int)x, (unsigned long int)x,
+               (unsigned long long int)x</pre>
+ cvtI -&gt; F      (float)i, (double)i, (long double)i
+ cvtF' -&gt; F     (float)x, (double)x, (long double)x
+<p><!--para 2-->
+ In the above conversions from floating to integer, the use of (cast)x can be replaced with
+ (cast)round(x), (cast)rint(x), (cast)nearbyint(x), (cast)trunc(x),
+ (cast)ceil(x), or (cast)floor(x). In addition, C's floating-point to integer
+ conversion functions, lrint(), llrint(), lround(), and llround(), can be
+ used. They all meet LIA-1's requirements on floating to integer rounding for in-range
+ values. For out-of-range values, the conversions shall silently wrap for the modulo types.
+<p><!--para 3-->
+ The fmod() function is useful for doing silent wrapping to unsigned integer types, e.g.,
+ fmod( fabs(rint(x)), 65536.0 ) or (0.0 &lt;= (y = fmod( rint(x),
+ 65536.0 )) ? y : 65536.0 + y) will compute an integer value in the range 0.0
+ to 65535.0 which can then be cast to unsigned short int. But, the
+ remainder() function is not useful for doing silent wrapping to signed integer types,
+ e.g., remainder( rint(x), 65536.0 ) will compute an integer value in the
+ range -32767.0 to +32768.0 which is not, in general, in the range of signed short
+ int.
+<p><!--para 4-->
+ C's conversions (casts) from floating-point to floating-point can meet LIA-1
+ requirements if an implementation uses round-to-nearest (IEC 60559 default).
+<p><!--para 5-->
+ C's conversions (casts) from integer to floating-point can meet LIA-1 requirements if an
+ implementation uses round-to-nearest.
+<!--page 564 indent 4-->
+
+<a name="H.3" href="#H.3"><h3>H.3 Notification</h3></a>
+<p><!--para 1-->
+ Notification is the process by which a user or program is informed that an exceptional
+ arithmetic operation has occurred. C's operations are compatible with LIA-1 in that C
+ allows an implementation to cause a notification to occur when any arithmetic operation
+ returns an exceptional value as defined in LIA-1 clause 5.
+
+<a name="H.3.1" href="#H.3.1"><h4>H.3.1 Notification alternatives</h4></a>
+<p><!--para 1-->
+ LIA-1 requires at least the following two alternatives for handling of notifications:
+ setting indicators or trap-and-terminate. LIA-1 allows a third alternative: trap-and-
+ resume.
+<p><!--para 2-->
+ An implementation need only support a given notification alternative for the entire
+ program. An implementation may support the ability to switch between notification
+ alternatives during execution, but is not required to do so. An implementation can
+ provide separate selection for each kind of notification, but this is not required.
+<p><!--para 3-->
+ C allows an implementation to provide notification. C's SIGFPE (for traps) and
+ FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW (for indicators)
+ can provide LIA-1 notification.
+<p><!--para 4-->
+ C's signal handlers are compatible with LIA-1. Default handling of SIGFPE can
+ provide trap-and-terminate behavior, except for those LIA-1 operations implemented by
+ math library function calls. User-provided signal handlers for SIGFPE allow for trap-
+ and-resume behavior with the same constraint.
+
+<a name="H.3.1.1" href="#H.3.1.1"><h5>H.3.1.1 Indicators</h5></a>
+<p><!--para 1-->
+ C's &lt;fenv.h&gt; status flags are compatible with the LIA-1 indicators.
+<p><!--para 2-->
+ The following mapping is for floating-point types:
+ undefined                FE_INVALID, FE_DIVBYZERO
+ floating_overflow         FE_OVERFLOW
+ underflow                FE_UNDERFLOW
+<p><!--para 3-->
+ The floating-point indicator interrogation and manipulation operations are:
+ set_indicators          feraiseexcept(i)
+ clear_indicators        feclearexcept(i)
+ test_indicators         fetestexcept(i)
+ current_indicators      fetestexcept(FE_ALL_EXCEPT)
+ where i is an expression of type int representing a subset of the LIA-1 indicators.
+<p><!--para 4-->
+ C allows an implementation to provide the following LIA-1 required behavior: at
+ program termination if any indicator is set the implementation shall send an unambiguous
+<!--page 565 indent 4-->
+ and ''hard to ignore'' message (see LIA-1 subclause <a href="#6.1.2">6.1.2</a>)
+<p><!--para 5-->
+ LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
+ This documentation makes that distinction because &lt;fenv.h&gt; covers only the floating-
+ point indicators.
+
+<a name="H.3.1.2" href="#H.3.1.2"><h5>H.3.1.2 Traps</h5></a>
+<p><!--para 1-->
+ C is compatible with LIA-1's trap requirements for arithmetic operations, but not for
+ math library functions (which are not permitted to invoke a user's signal handler for
+ SIGFPE). An implementation can provide an alternative of notification through
+ termination with a ''hard-to-ignore'' message (see LIA-1 subclause <a href="#6.1.3">6.1.3</a>).
+<p><!--para 2-->
+ LIA-1 does not require that traps be precise.
+<p><!--para 3-->
+ C does require that SIGFPE be the signal corresponding to LIA-1 arithmetic exceptions,
+ if there is any signal raised for them.
+<p><!--para 4-->
+ C supports signal handlers for SIGFPE and allows trapping of LIA-1 arithmetic
+ exceptions. When LIA-1 arithmetic exceptions do trap, C's signal-handler mechanism
+ allows trap-and-terminate (either default implementation behavior or user replacement for
+ it) or trap-and-resume, at the programmer's option.
+<!--page 566 indent 4-->
+
+<a name="I" href="#I"><h2>Annex I</h2></a>
+<p><!--para 1-->
+<pre>
+                                     (informative)
+                                Common warnings</pre>
+ An implementation may generate warnings in many situations, none of which are
+ specified as part of this International Standard. The following are a few of the more
+ common situations.
+<p><!--para 2-->
+<ul>
+<li>  A new struct or union type appears in a function prototype (<a href="#6.2.1">6.2.1</a>, <a href="#6.7.2.3">6.7.2.3</a>).
+<li>  A block with initialization of an object that has automatic storage duration is jumped
+ into (<a href="#6.2.4">6.2.4</a>).
+<li>  An implicit narrowing conversion is encountered, such as the assignment of a long
+ int or a double to an int, or a pointer to void to a pointer to any type other than
+ a character type (<a href="#6.3">6.3</a>).
+<li>  A hexadecimal floating constant cannot be represented exactly in its evaluation format
+ (<a href="#6.4.4.2">6.4.4.2</a>).
+<li>  An integer character constant includes more than one character or a wide character
+ constant includes more than one multibyte character (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  The characters /* are found in a comment (<a href="#6.4.7">6.4.7</a>).
+<li>  An ''unordered'' binary operator (not comma, &amp;&amp;, or ||) contains a side effect to an
+ lvalue in one operand, and a side effect to, or an access to the value of, the identical
+ lvalue in the other operand (<a href="#6.5">6.5</a>).
+<li>  A function is called but no prototype has been supplied (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  The arguments in a function call do not agree in number and type with those of the
+ parameters in a function definition that is not a prototype (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  An object is defined but not used (<a href="#6.7">6.7</a>).
+<li>  A value is given to an object of an enumerated type other than by assignment of an
+ enumeration constant that is a member of that type, or an enumeration object that has
+ the same type, or the value of a function that returns the same enumerated type
+ (<a href="#6.7.2.2">6.7.2.2</a>).
+<li>  An aggregate has a partly bracketed initialization (<a href="#6.7.8">6.7.8</a>).
+<li>  A statement cannot be reached (<a href="#6.8">6.8</a>).
+<li>  A statement with no apparent effect is encountered (<a href="#6.8">6.8</a>).
+<li>  A constant expression is used as the controlling expression of a selection statement
+ (<a href="#6.8.4">6.8.4</a>).
+<!--page 567 indent 0-->
+<li>  An incorrectly formed preprocessing group is encountered while skipping a
+ preprocessing group (<a href="#6.10.1">6.10.1</a>).
+<li>  An unrecognized #pragma directive is encountered (<a href="#6.10.6">6.10.6</a>).
+<!--page 568 indent 4-->
+</ul>
+
+<a name="J" href="#J"><h2>Annex J</h2></a>
+<p><!--para 1-->
+<pre>
+                                      (informative)
+                                   Portability issues</pre>
+ This annex collects some information about portability that appears in this International
+ Standard.
+
+<a name="J.1" href="#J.1"><h3>J.1 Unspecified behavior</h3></a>
+<p><!--para 1-->
+ The following are unspecified:
+<ul>
+<li>  The manner and timing of static initialization (<a href="#5.1.2">5.1.2</a>).
+<li>  The termination status returned to the hosted environment if the return type of main
+ is not compatible with int (<a href="#5.1.2.2.3">5.1.2.2.3</a>).
+<li>  The behavior of the display device if a printing character is written when the active
+ position is at the final position of a line (<a href="#5.2.2">5.2.2</a>).
+<li>  The behavior of the display device if a backspace character is written when the active
+ position is at the initial position of a line (<a href="#5.2.2">5.2.2</a>).
+<li>  The behavior of the display device if a horizontal tab character is written when the
+ active position is at or past the last defined horizontal tabulation position (<a href="#5.2.2">5.2.2</a>).
+<li>  The behavior of the display device if a vertical tab character is written when the active
+ position is at or past the last defined vertical tabulation position (<a href="#5.2.2">5.2.2</a>).
+<li>  How an extended source character that does not correspond to a universal character
+ name counts toward the significant initial characters in an external identifier (<a href="#5.2.4.1">5.2.4.1</a>).
+<li>  Many aspects of the representations of types (<a href="#6.2.6">6.2.6</a>).
+<li>  The value of padding bytes when storing values in structures or unions (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The values of bytes that correspond to union members other than the one last stored
+ into (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The representation used when storing a value in an object that has more than one
+ object representation for that value (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The values of any padding bits in integer representations (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  Whether certain operators can generate negative zeros and whether a negative zero
+ becomes a normal zero when stored in an object (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  Whether two string literals result in distinct arrays (<a href="#6.4.5">6.4.5</a>).
+<li>  The order in which subexpressions are evaluated and the order in which side effects
+ take place, except as specified for the function-call (), &amp;&amp;, ||, ? :, and comma
+<!--page 569 indent 0-->
+  operators (<a href="#6.5">6.5</a>).
+<li>  The order in which the function designator, arguments, and subexpressions within the
+ arguments are evaluated in a function call (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  The order of side effects among compound literal initialization list expressions
+ (<a href="#6.5.2.5">6.5.2.5</a>).
+<li>  The order in which the operands of an assignment operator are evaluated (<a href="#6.5.16">6.5.16</a>).
+<li>  The alignment of the addressable storage unit allocated to hold a bit-field (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  Whether a call to an inline function uses the inline definition or the external definition
+ of the function (<a href="#6.7.4">6.7.4</a>).
+<li>  Whether or not a size expression is evaluated when it is part of the operand of a
+ sizeof operator and changing the value of the size expression would not affect the
+ result of the operator (<a href="#6.7.6.2">6.7.6.2</a>).
+<li>  The order in which any side effects occur among the initialization list expressions in
+ an initializer (<a href="#6.7.9">6.7.9</a>).
+<li>  The layout of storage for function parameters (<a href="#6.9.1">6.9.1</a>).
+<li>  When a fully expanded macro replacement list contains a function-like macro name
+ as its last preprocessing token and the next preprocessing token from the source file is
+ a (, and the fully expanded replacement of that macro ends with the name of the first
+ macro and the next preprocessing token from the source file is again a (, whether that
+ is considered a nested replacement (<a href="#6.10.3">6.10.3</a>).
+<li>  The order in which # and ## operations are evaluated during macro substitution
+ (<a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>).
+<li>  The state of the floating-point status flags when execution passes from a part of the *
+ program translated with FENV_ACCESS ''off'' to a part translated with
+ FENV_ACCESS ''on'' (<a href="#7.6.1">7.6.1</a>).
+<li>  The order in which feraiseexcept raises floating-point exceptions, except as
+ stated in <a href="#F.8.6">F.8.6</a> (<a href="#7.6.2.3">7.6.2.3</a>).
+<li>  Whether math_errhandling is a macro or an identifier with external linkage
+ (<a href="#7.12">7.12</a>).
+<li>  The results of the frexp functions when the specified value is not a floating-point
+ number (<a href="#7.12.6.4">7.12.6.4</a>).
+<li>  The numeric result of the ilogb functions when the correct value is outside the
+ range of the return type (<a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>).
+<li>  The result of rounding when the value is out of range (<a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.5">F.10.6.5</a>).
+<!--page 570 indent 0-->
+<li>  The value stored by the remquo functions in the object pointed to by quo when y is
+ zero (<a href="#7.12.10.3">7.12.10.3</a>).
+<li>  Whether a comparison macro argument that is represented in a format wider than its
+ semantic type is converted to the semantic type (<a href="#7.12.14">7.12.14</a>).
+<li>  Whether setjmp is a macro or an identifier with external linkage (<a href="#7.13">7.13</a>).
+<li>  Whether va_copy and va_end are macros or identifiers with external linkage
+ (<a href="#7.16.1">7.16.1</a>).
+<li>  The hexadecimal digit before the decimal point when a non-normalized floating-point
+ number is printed with an a or A conversion specifier (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  The value of the file position indicator after a successful call to the ungetc function
+ for a text stream, or the ungetwc function for any stream, until all pushed-back
+ characters are read or discarded (<a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.28.3.10">7.28.3.10</a>).
+<li>  The details of the value stored by the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>).
+<li>  The details of the value returned by the ftell function for a text stream (<a href="#7.21.9.4">7.21.9.4</a>).
+<li>  Whether the strtod, strtof, strtold, wcstod, wcstof, and wcstold
+ functions convert a minus-signed sequence to a negative number directly or by
+ negating the value resulting from converting the corresponding unsigned sequence
+ (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
+<li>  The order and contiguity of storage allocated by successive calls to the calloc,
+ malloc, and realloc functions (<a href="#7.22.3">7.22.3</a>).
+<li>  The amount of storage allocated by a successful call to the calloc, malloc, or
+ realloc function when 0 bytes was requested (<a href="#7.22.3">7.22.3</a>).
+<li>  Which of two elements that compare as equal is matched by the bsearch function
+ (<a href="#7.22.5.1">7.22.5.1</a>).
+<li>  The order of two elements that compare as equal in an array sorted by the qsort
+ function (<a href="#7.22.5.2">7.22.5.2</a>).
+<li>  The encoding of the calendar time returned by the time function (<a href="#7.26.2.4">7.26.2.4</a>).
+<li>  The characters stored by the strftime or wcsftime function if any of the time
+ values being converted is outside the normal range (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+<li>  The conversion state after an encoding error occurs (<a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>,
+ <a href="#7.28.6.4.2">7.28.6.4.2</a>,
+<li>  The resulting value when the ''invalid'' floating-point exception is raised during
+ IEC 60559 floating to integer conversion (<a href="#F.4">F.4</a>).
+<!--page 571 indent 4-->
+<li>  Whether conversion of non-integer IEC 60559 floating values to integer raises the
+ ''inexact'' floating-point exception (<a href="#F.4">F.4</a>).
+<li>  Whether or when library functions in &lt;math.h&gt; raise the ''inexact'' floating-point
+ exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
+<li>  Whether or when library functions in &lt;math.h&gt; raise an undeserved ''underflow''
+ floating-point exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
+<li>  The exponent value stored by frexp for a NaN or infinity (<a href="#F.10.3.4">F.10.3.4</a>).
+<li>  The numeric result returned by the lrint, llrint, lround, and llround
+ functions if the rounded value is outside the range of the return type (<a href="#F.10.6.5">F.10.6.5</a>,
+ <a href="#F.10.6.7">F.10.6.7</a>).
+<li>  The sign of one part of the complex result of several math functions for certain
+ special cases in IEC 60559 compatible implementations (<a href="#G.6.1.1">G.6.1.1</a>, <a href="#G.6.2.2">G.6.2.2</a>, <a href="#G.6.2.3">G.6.2.3</a>,
+ <a href="#G.6.2.4">G.6.2.4</a>, <a href="#G.6.2.5">G.6.2.5</a>, <a href="#G.6.2.6">G.6.2.6</a>, <a href="#G.6.3.1">G.6.3.1</a>, <a href="#G.6.4.2">G.6.4.2</a>).
+</ul>
+
+<a name="J.2" href="#J.2"><h3>J.2 Undefined behavior</h3></a>
+<p><!--para 1-->
+ The behavior is undefined in the following circumstances:
+<ul>
+<li>  A ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated
+ (clause 4).
+<li>  A nonempty source file does not end in a new-line character which is not immediately
+ preceded by a backslash character or ends in a partial preprocessing token or
+ comment (<a href="#5.1.1.2">5.1.1.2</a>).
+<li>  Token concatenation produces a character sequence matching the syntax of a
+ universal character name (<a href="#5.1.1.2">5.1.1.2</a>).
+<li>  A program in a hosted environment does not define a function named main using one
+ of the specified forms (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<li>  The execution of a program contains a data race (<a href="#5.1.2.4">5.1.2.4</a>).
+<li>  A character not in the basic source character set is encountered in a source file, except
+ in an identifier, a character constant, a string literal, a header name, a comment, or a
+ preprocessing token that is never converted to a token (<a href="#5.2.1">5.2.1</a>).
+<li>  An identifier, comment, string literal, character constant, or header name contains an
+ invalid multibyte character or does not begin and end in the initial shift state (<a href="#5.2.1.2">5.2.1.2</a>).
+<li>  The same identifier has both internal and external linkage in the same translation unit
+ (<a href="#6.2.2">6.2.2</a>).
+<li>  An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
+<!--page 572 indent 0-->
+<li>  The value of a pointer to an object whose lifetime has ended is used (<a href="#6.2.4">6.2.4</a>).
+<li>  The value of an object with automatic storage duration is used while it is
+ indeterminate (<a href="#6.2.4">6.2.4</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8">6.8</a>).
+<li>  A trap representation is read by an lvalue expression that does not have character type
+ (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  A trap representation is produced by a side effect that modifies any part of the object
+ using an lvalue expression that does not have character type (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  The operands to certain operators are such that they could produce a negative zero
+ result, but the implementation does not support negative zeros (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  Two declarations of the same object or function specify types that are not compatible
+ (<a href="#6.2.7">6.2.7</a>).
+<li>  A program requires the formation of a composite type from a variable length array
+ type whose size is specified by an expression that is not evaluated (<a href="#6.2.7">6.2.7</a>).
+<li>  Conversion to or from an integer type produces a value outside the range that can be
+ represented (<a href="#6.3.1.4">6.3.1.4</a>).
+<li>  Demotion of one real floating type to another produces a value outside the range that
+ can be represented (<a href="#6.3.1.5">6.3.1.5</a>).
+<li>  An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  A non-array lvalue with an incomplete type is used in a context that requires the value
+ of the designated object (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  An lvalue designating an object of automatic storage duration that could have been
+ declared with the register storage class is used in a context that requires the value
+ of the designated object, but the object is uninitialized. (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  An lvalue having array type is converted to a pointer to the initial element of the
+ array, and the array object has register storage class (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  An attempt is made to use the value of a void expression, or an implicit or explicit
+ conversion (except to void) is applied to a void expression (<a href="#6.3.2.2">6.3.2.2</a>).
+<li>  Conversion of a pointer to an integer type produces a value outside the range that can
+ be represented (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  Conversion between two pointer types produces a result that is incorrectly aligned
+ (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  A pointer is used to call a function whose type is not compatible with the referenced
+ type (<a href="#6.3.2.3">6.3.2.3</a>).
+<!--page 573 indent 0-->
+<li>  An unmatched ' or " character is encountered on a logical source line during
+ tokenization (<a href="#6.4">6.4</a>).
+<li>  A reserved keyword token is used in translation phase 7 or 8 for some purpose other
+ than as a keyword (<a href="#6.4.1">6.4.1</a>).
+<li>  A universal character name in an identifier does not designate a character whose
+ encoding falls into one of the specified ranges (<a href="#6.4.2.1">6.4.2.1</a>).
+<li>  The initial character of an identifier is a universal character name designating a digit
+ (<a href="#6.4.2.1">6.4.2.1</a>).
+<li>  Two identifiers differ only in nonsignificant characters (<a href="#6.4.2.1">6.4.2.1</a>).
+<li>  The identifier __func__ is explicitly declared (<a href="#6.4.2.2">6.4.2.2</a>).
+<li>  The program attempts to modify a string literal (<a href="#6.4.5">6.4.5</a>).
+<li>  The characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt;
+ delimiters, or the characters ', \, //, or /* occur in the sequence between the "
+ delimiters, in a header name preprocessing token (<a href="#6.4.7">6.4.7</a>).
+<li>  A side effect on a scalar object is unsequenced relative to either a different side effect
+ on the same scalar object or a value computation using the value of the same scalar
+ object (<a href="#6.5">6.5</a>).
+<li>  An exceptional condition occurs during the evaluation of an expression (<a href="#6.5">6.5</a>).
+<li>  An object has its stored value accessed other than by an lvalue of an allowable type
+ (<a href="#6.5">6.5</a>).
+<li>  For a call to a function without a function prototype in scope, the number of *
+ arguments does not equal the number of parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  For call to a function without a function prototype in scope where the function is
+ defined with a function prototype, either the prototype ends with an ellipsis or the
+ types of the arguments after promotion are not compatible with the types of the
+ parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  For a call to a function without a function prototype in scope where the function is not
+ defined with a function prototype, the types of the arguments after promotion are not
+ compatible with those of the parameters after promotion (with certain exceptions)
+ (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  A function is defined with a type that is not compatible with the type (of the
+ expression) pointed to by the expression that denotes the called function (<a href="#6.5.2.2">6.5.2.2</a>).
+<li>  A member of an atomic structure or union is accessed (<a href="#6.5.2.3">6.5.2.3</a>).
+<li>  The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
+<!--page 574 indent 0-->
+<li>  A pointer is converted to other than an integer or pointer type (<a href="#6.5.4">6.5.4</a>).
+<li>  The value of the second operand of the / or % operator is zero (<a href="#6.5.5">6.5.5</a>).
+<li>  Addition or subtraction of a pointer into, or just beyond, an array object and an
+ integer type produces a result that does not point into, or just beyond, the same array
+ object (<a href="#6.5.6">6.5.6</a>).
+<li>  Addition or subtraction of a pointer into, or just beyond, an array object and an
+ integer type produces a result that points just beyond the array object and is used as
+ the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
+<li>  Pointers that do not point into, or just beyond, the same array object are subtracted
+ (<a href="#6.5.6">6.5.6</a>).
+<li>  An array subscript is out of range, even if an object is apparently accessible with the
+ given subscript (as in the lvalue expression a[1][7] given the declaration int
+ a[4][5]) (<a href="#6.5.6">6.5.6</a>).
+<li>  The result of subtracting two pointers is not representable in an object of type
+ ptrdiff_t (<a href="#6.5.6">6.5.6</a>).
+<li>  An expression is shifted by a negative number or by an amount greater than or equal
+ to the width of the promoted expression (<a href="#6.5.7">6.5.7</a>).
+<li>  An expression having signed promoted type is left-shifted and either the value of the
+ expression is negative or the result of shifting would be not be representable in the
+ promoted type (<a href="#6.5.7">6.5.7</a>).
+<li>  Pointers that do not point to the same aggregate or union (nor just beyond the same
+ array object) are compared using relational operators (<a href="#6.5.8">6.5.8</a>).
+<li>  An object is assigned to an inexactly overlapping object or to an exactly overlapping
+ object with incompatible type (<a href="#6.5.16.1">6.5.16.1</a>).
+<li>  An expression that is required to be an integer constant expression does not have an
+ integer type; has operands that are not integer constants, enumeration constants,
+ character constants, sizeof expressions whose results are integer constants, or
+ immediately-cast floating constants; or contains casts (outside operands to sizeof
+ operators) other than conversions of arithmetic types to integer types (<a href="#6.6">6.6</a>).
+<li>  A constant expression in an initializer is not, or does not evaluate to, one of the
+ following: an arithmetic constant expression, a null pointer constant, an address
+ constant, or an address constant for a complete object type plus or minus an integer
+ constant expression (<a href="#6.6">6.6</a>).
+<li>  An arithmetic constant expression does not have arithmetic type; has operands that
+ are not integer constants, floating constants, enumeration constants, character
+ constants, or sizeof expressions; or contains casts (outside operands to sizeof
+<!--page 575 indent 0-->
+  operators) other than conversions of arithmetic types to arithmetic types (<a href="#6.6">6.6</a>).
+<li>  The value of an object is accessed by an array-subscript [], member-access . or -&gt;,
+ address &amp;, or indirection * operator or a pointer cast in creating an address constant
+ (<a href="#6.6">6.6</a>).
+<li>  An identifier for an object is declared with no linkage and the type of the object is
+ incomplete after its declarator, or after its init-declarator if it has an initializer (<a href="#6.7">6.7</a>).
+<li>  A function is declared at block scope with an explicit storage-class specifier other
+ than extern (<a href="#6.7.1">6.7.1</a>).
+<li>  A structure or union is defined as containing no named members, no anonymous
+ structures, and no anonymous unions (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  An attempt is made to access, or generate a pointer to just past, a flexible array
+ member of a structure when the referenced object provides no elements for that array
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  When the complete type is needed, an incomplete structure or union type is not
+ completed in the same scope by another declaration of the tag that defines the content
+ (<a href="#6.7.2.3">6.7.2.3</a>).
+<li>  An attempt is made to modify an object defined with a const-qualified type through
+ use of an lvalue with non-const-qualified type (<a href="#6.7.3">6.7.3</a>).
+<li>  An attempt is made to refer to an object defined with a volatile-qualified type through
+ use of an lvalue with non-volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+<li>  The specification of a function type includes any type qualifiers (<a href="#6.7.3">6.7.3</a>).                        *
+<li>  Two qualified types that are required to be compatible do not have the identically
+ qualified version of a compatible type (<a href="#6.7.3">6.7.3</a>).
+<li>  An object which has been modified is accessed through a restrict-qualified pointer to
+ a const-qualified type, or through a restrict-qualified pointer and another pointer that
+ are not both based on the same object (<a href="#6.7.3.1">6.7.3.1</a>).
+<li>  A restrict-qualified pointer is assigned a value based on another restricted pointer
+ whose associated block neither began execution before the block associated with this
+ pointer, nor ended before the assignment (<a href="#6.7.3.1">6.7.3.1</a>).
+<li>  A function with external linkage is declared with an inline function specifier, but is
+ not also defined in the same translation unit (<a href="#6.7.4">6.7.4</a>).
+<li>  A function declared with a _Noreturn function specifier returns to its caller (<a href="#6.7.4">6.7.4</a>).
+<li>  The definition of an object has an alignment specifier and another declaration of that
+ object has a different alignment specifier (<a href="#6.7.5">6.7.5</a>).
+<!--page 576 indent 0-->
+<li>  Declarations of an object in different translation units have different alignment
+ specifiers (<a href="#6.7.5">6.7.5</a>).
+<li>  Two pointer types that are required to be compatible are not identically qualified, or
+ are not pointers to compatible types (<a href="#6.7.6.1">6.7.6.1</a>).
+<li>  The size expression in an array declaration is not a constant expression and evaluates
+ at program execution time to a nonpositive value (<a href="#6.7.6.2">6.7.6.2</a>).
+<li>  In a context requiring two array types to be compatible, they do not have compatible
+ element types, or their size specifiers evaluate to unequal values (<a href="#6.7.6.2">6.7.6.2</a>).
+<li>  A declaration of an array parameter includes the keyword static within the [ and
+ ] and the corresponding argument does not provide access to the first element of an
+ array with at least the specified number of elements (<a href="#6.7.6.3">6.7.6.3</a>).
+<li>  A storage-class specifier or type qualifier modifies the keyword void as a function
+ parameter type list (<a href="#6.7.6.3">6.7.6.3</a>).
+<li>  In a context requiring two function types to be compatible, they do not have
+ compatible return types, or their parameters disagree in use of the ellipsis terminator
+ or the number and type of parameters (after default argument promotion, when there
+ is no parameter type list or when one type is specified by a function definition with an
+ identifier list) (<a href="#6.7.6.3">6.7.6.3</a>).
+<li>  The value of an unnamed member of a structure or union is used (<a href="#6.7.9">6.7.9</a>).
+<li>  The initializer for a scalar is neither a single expression nor a single expression
+ enclosed in braces (<a href="#6.7.9">6.7.9</a>).
+<li>  The initializer for a structure or union object that has automatic storage duration is
+ neither an initializer list nor a single expression that has compatible structure or union
+ type (<a href="#6.7.9">6.7.9</a>).
+<li>  The initializer for an aggregate or union, other than an array initialized by a string
+ literal, is not a brace-enclosed list of initializers for its elements or members (<a href="#6.7.9">6.7.9</a>).
+<li>  An identifier with external linkage is used, but in the program there does not exist
+ exactly one external definition for the identifier, or the identifier is not used and there
+ exist multiple external definitions for the identifier (<a href="#6.9">6.9</a>).
+<li>  A function definition includes an identifier list, but the types of the parameters are not
+ declared in a following declaration list (<a href="#6.9.1">6.9.1</a>).
+<li>  An adjusted parameter type in a function definition is not a complete object type
+ (<a href="#6.9.1">6.9.1</a>).
+<li>  A function that accepts a variable number of arguments is defined without a
+ parameter type list that ends with the ellipsis notation (<a href="#6.9.1">6.9.1</a>).
+<!--page 577 indent 0-->
+<li>  The } that terminates a function is reached, and the value of the function call is used
+ by the caller (<a href="#6.9.1">6.9.1</a>).
+<li>  An identifier for an object with internal linkage and an incomplete type is declared
+ with a tentative definition (<a href="#6.9.2">6.9.2</a>).
+<li>  The token defined is generated during the expansion of a #if or #elif
+ preprocessing directive, or the use of the defined unary operator does not match
+ one of the two specified forms prior to macro replacement (<a href="#6.10.1">6.10.1</a>).
+<li>  The #include preprocessing directive that results after expansion does not match
+ one of the two header name forms (<a href="#6.10.2">6.10.2</a>).
+<li>  The character sequence in an #include preprocessing directive does not start with a
+ letter (<a href="#6.10.2">6.10.2</a>).
+<li>  There are sequences of preprocessing tokens within the list of macro arguments that
+ would otherwise act as preprocessing directives (<a href="#6.10.3">6.10.3</a>).
+<li>  The result of the preprocessing operator # is not a valid character string literal
+ (<a href="#6.10.3.2">6.10.3.2</a>).
+<li>  The result of the preprocessing operator ## is not a valid preprocessing token
+ (<a href="#6.10.3.3">6.10.3.3</a>).
+<li>  The #line preprocessing directive that results after expansion does not match one of
+ the two well-defined forms, or its digit sequence specifies zero or a number greater
+ than 2147483647 (<a href="#6.10.4">6.10.4</a>).
+<li>  A non-STDC #pragma preprocessing directive that is documented as causing
+ translation failure or some other form of undefined behavior is encountered (<a href="#6.10.6">6.10.6</a>).
+<li>  A #pragma STDC preprocessing directive does not match one of the well-defined
+ forms (<a href="#6.10.6">6.10.6</a>).
+<li>  The name of a predefined macro, or the identifier defined, is the subject of a
+ #define or #undef preprocessing directive (<a href="#6.10.8">6.10.8</a>).
+<li>  An attempt is made to copy an object to an overlapping object by use of a library
+ function, other than as explicitly allowed (e.g., memmove) (clause 7).
+<li>  A file with the same name as one of the standard headers, not provided as part of the
+ implementation, is placed in any of the standard places that are searched for included
+ source files (<a href="#7.1.2">7.1.2</a>).
+<li>  A header is included within an external declaration or definition (<a href="#7.1.2">7.1.2</a>).
+<li>  A function, object, type, or macro that is specified as being declared or defined by
+ some standard header is used before any header that declares or defines it is included
+ (<a href="#7.1.2">7.1.2</a>).
+<!--page 578 indent 0-->
+<li>  A standard header is included while a macro is defined with the same name as a
+ keyword (<a href="#7.1.2">7.1.2</a>).
+<li>  The program attempts to declare a library function itself, rather than via a standard
+ header, but the declaration does not have external linkage (<a href="#7.1.2">7.1.2</a>).
+<li>  The program declares or defines a reserved identifier, other than as allowed by <a href="#7.1.4">7.1.4</a>
+ (<a href="#7.1.3">7.1.3</a>).
+<li>  The program removes the definition of a macro whose name begins with an
+ underscore and either an uppercase letter or another underscore (<a href="#7.1.3">7.1.3</a>).
+<li>  An argument to a library function has an invalid value or a type not expected by a
+ function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
+<li>  The pointer passed to a library function array parameter does not have a value such
+ that all address computations and object accesses are valid (<a href="#7.1.4">7.1.4</a>).
+<li>  The macro definition of assert is suppressed in order to access an actual function
+ (<a href="#7.2">7.2</a>).
+<li>  The argument to the assert macro does not have a scalar type (<a href="#7.2">7.2</a>).
+<li>  The CX_LIMITED_RANGE, FENV_ACCESS, or FP_CONTRACT pragma is used in
+ any context other than outside all external declarations or preceding all explicit
+ declarations and statements inside a compound statement (<a href="#7.3.4">7.3.4</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.12.2">7.12.2</a>).
+<li>  The value of an argument to a character handling function is neither equal to the value
+ of EOF nor representable as an unsigned char (<a href="#7.4">7.4</a>).
+<li>  A macro definition of errno is suppressed in order to access an actual object, or the
+ program defines an identifier with the name errno (<a href="#7.5">7.5</a>).
+<li>  Part of the program tests floating-point status flags, sets floating-point control modes,
+ or runs under non-default mode settings, but was translated with the state for the
+ FENV_ACCESS pragma ''off'' (<a href="#7.6.1">7.6.1</a>).
+<li>  The exception-mask argument for one of the functions that provide access to the
+ floating-point status flags has a nonzero value not obtained by bitwise OR of the
+ floating-point exception macros (<a href="#7.6.2">7.6.2</a>).
+<li>  The fesetexceptflag function is used to set floating-point status flags that were
+ not specified in the call to the fegetexceptflag function that provided the value
+ of the corresponding fexcept_t object (<a href="#7.6.2.4">7.6.2.4</a>).
+<li>  The argument to fesetenv or feupdateenv is neither an object set by a call to
+ fegetenv or feholdexcept, nor is it an environment macro (<a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>).
+<li>  The value of the result of an integer arithmetic or conversion function cannot be
+ represented (<a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.22.6.1">7.22.6.1</a>, <a href="#7.22.6.2">7.22.6.2</a>, <a href="#7.22.1">7.22.1</a>).
+<!--page 579 indent 0-->
+<li>  The program modifies the string pointed to by the value returned by the setlocale
+ function (<a href="#7.11.1.1">7.11.1.1</a>).
+<li>  The program modifies the structure pointed to by the value returned by the
+ localeconv function (<a href="#7.11.2.1">7.11.2.1</a>).
+<li>  A macro definition of math_errhandling is suppressed or the program defines
+ an identifier with the name math_errhandling (<a href="#7.12">7.12</a>).
+<li>  An argument to a floating-point classification or comparison macro is not of real
+ floating type (<a href="#7.12.3">7.12.3</a>, <a href="#7.12.14">7.12.14</a>).
+<li>  A macro definition of setjmp is suppressed in order to access an actual function, or
+ the program defines an external identifier with the name setjmp (<a href="#7.13">7.13</a>).
+<li>  An invocation of the setjmp macro occurs other than in an allowed context
+ (<a href="#7.13.2.1">7.13.2.1</a>).
+<li>  The longjmp function is invoked to restore a nonexistent environment (<a href="#7.13.2.1">7.13.2.1</a>).
+<li>  After a longjmp, there is an attempt to access the value of an object of automatic
+ storage duration that does not have volatile-qualified type, local to the function
+ containing the invocation of the corresponding setjmp macro, that was changed
+ between the setjmp invocation and longjmp call (<a href="#7.13.2.1">7.13.2.1</a>).
+<li>  The program specifies an invalid pointer to a signal handler function (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal handler returns when the signal corresponded to a computational exception
+ (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal occurs as the result of calling the abort or raise function, and the signal
+ handler calls the raise function (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal occurs other than as the result of calling the abort or raise function, and
+ the signal handler refers to an object with static or thread storage duration that is not a
+ lock-free atomic object other than by assigning a value to an object declared as
+ volatile sig_atomic_t, or calls any function in the standard library other
+ than the abort function, the _Exit function, the quick_exit function, or the
+ signal function (for the same signal number) (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  The value of errno is referred to after a signal occurred other than as the result of
+ calling the abort or raise function and the corresponding signal handler obtained
+ a SIG_ERR return from a call to the signal function (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A signal is generated by an asynchronous signal handler (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  A function with a variable number of arguments attempts to access its varying
+ arguments other than through a properly declared and initialized va_list object, or
+ before the va_start macro is invoked (<a href="#7.16">7.16</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.4">7.16.1.4</a>).
+<!--page 580 indent 0-->
+<li>  The macro va_arg is invoked using the parameter ap that was passed to a function
+ that invoked the macro va_arg with the same parameter (<a href="#7.16">7.16</a>).
+<li>  A macro definition of va_start, va_arg, va_copy, or va_end is suppressed in
+ order to access an actual function, or the program defines an external identifier with
+ the name va_copy or va_end (<a href="#7.16.1">7.16.1</a>).
+<li>  The va_start or va_copy macro is invoked without a corresponding invocation
+ of the va_end macro in the same function, or vice versa (<a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>,
+ <a href="#7.16.1.4">7.16.1.4</a>).
+<li>  The type parameter to the va_arg macro is not such that a pointer to an object of
+ that type can be obtained simply by postfixing a * (<a href="#7.16.1.1">7.16.1.1</a>).
+<li>  The va_arg macro is invoked when there is no actual next argument, or with a
+ specified type that is not compatible with the promoted type of the actual next
+ argument, with certain exceptions (<a href="#7.16.1.1">7.16.1.1</a>).
+<li>  The va_copy or va_start macro is called to initialize a va_list that was
+ previously initialized by either macro without an intervening invocation of the
+ va_end macro for the same va_list (<a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.4">7.16.1.4</a>).
+<li>  The parameter parmN of a va_start macro is declared with the register
+ storage class, with a function or array type, or with a type that is not compatible with
+ the type that results after application of the default argument promotions (<a href="#7.16.1.4">7.16.1.4</a>).
+<li>  The member designator parameter of an offsetof macro is an invalid right
+ operand of the . operator for the type parameter, or designates a bit-field (<a href="#7.19">7.19</a>).
+<li>  The argument in an instance of one of the integer-constant macros is not a decimal,
+ octal, or hexadecimal constant, or it has a value that exceeds the limits for the
+ corresponding type (<a href="#7.20.4">7.20.4</a>).
+<li>  A byte input/output function is applied to a wide-oriented stream, or a wide character
+ input/output function is applied to a byte-oriented stream (<a href="#7.21.2">7.21.2</a>).
+<li>  Use is made of any portion of a file beyond the most recent wide character written to
+ a wide-oriented stream (<a href="#7.21.2">7.21.2</a>).
+<li>  The value of a pointer to a FILE object is used after the associated file is closed
+ (<a href="#7.21.3">7.21.3</a>).
+<li>  The stream for the fflush function points to an input stream or to an update stream
+ in which the most recent operation was input (<a href="#7.21.5.2">7.21.5.2</a>).
+<li>  The string pointed to by the mode argument in a call to the fopen function does not
+ exactly match one of the specified character sequences (<a href="#7.21.5.3">7.21.5.3</a>).
+<li>  An output operation on an update stream is followed by an input operation without an
+   intervening call to the fflush function or a file positioning function, or an input
+<!--page 581 indent 0-->
+  operation on an update stream is followed by an output operation with an intervening
+  call to a file positioning function (<a href="#7.21.5.3">7.21.5.3</a>).
+<li>  An attempt is made to use the contents of the array that was supplied in a call to the
+ setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
+<li>  There are insufficient arguments for the format in a call to one of the formatted
+ input/output functions, or an argument does not have an appropriate type (<a href="#7.21.6.1">7.21.6.1</a>,
+ <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  The format in a call to one of the formatted input/output functions or to the
+ strftime or wcsftime function is not a valid multibyte character sequence that
+ begins and ends in its initial shift state (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+ <a href="#7.28.5.1">7.28.5.1</a>).
+<li>  In a call to one of the formatted output functions, a precision appears with a
+ conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  A conversion specification for a formatted output function uses an asterisk to denote
+ an argument-supplied field width or precision, but the corresponding argument is not
+ provided (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  A conversion specification for a formatted output function uses a # or 0 flag with a
+ conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  A conversion specification for one of the formatted input/output functions uses a
+ length modifier with a conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>,
+ <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  An s conversion specifier is encountered by one of the formatted output functions,
+ and the argument is missing the null terminator (unless a precision is specified that
+ does not require null termination) (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  An n conversion specification for one of the formatted input/output functions includes
+ any flags, an assignment-suppressing character, a field width, or a precision (<a href="#7.21.6.1">7.21.6.1</a>,
+ <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  A % conversion specifier is encountered by one of the formatted input/output
+ functions, but the complete conversion specification is not exactly %% (<a href="#7.21.6.1">7.21.6.1</a>,
+ <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  An invalid conversion specification is found in the format for one of the formatted
+ input/output functions, or the strftime or wcsftime function (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+ <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+<li>  The number of characters transmitted by a formatted output function is greater than
+ INT_MAX (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.10">7.21.6.10</a>).
+<!--page 582 indent 0-->
+<li>  The result of a conversion by one of the formatted input functions cannot be
+ represented in the corresponding object, or the receiving object does not have an
+ appropriate type (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  A c, s, or [ conversion specifier is encountered by one of the formatted input
+ functions, and the array pointed to by the corresponding argument is not large enough
+ to accept the input sequence (and a null terminator if the conversion specifier is s or
+ [) (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  A c, s, or [ conversion specifier with an l qualifier is encountered by one of the
+ formatted input functions, but the input is not a valid multibyte character sequence
+ that begins in the initial shift state (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  The input item for a %p conversion by one of the formatted input functions is not a
+ value converted earlier during the same program execution (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  The vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf,
+ vsscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, or
+ vwscanf function is called with an improperly initialized va_list argument, or
+ the argument is used (other than in an invocation of va_end) after the function
+ returns (<a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
+ <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>).
+<li>  The contents of the array supplied in a call to the fgets or fgetws function are
+ used after a read error occurred (<a href="#7.21.7.2">7.21.7.2</a>, <a href="#7.28.3.2">7.28.3.2</a>).
+<li>  The file position indicator for a binary stream is used after a call to the ungetc
+ function where its value was zero before the call (<a href="#7.21.7.10">7.21.7.10</a>).
+<li>  The file position indicator for a stream is used after an error occurred during a call to
+ the fread or fwrite function (<a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>).
+<li>  A partial element read by a call to the fread function is used (<a href="#7.21.8.1">7.21.8.1</a>).
+<li>  The fseek function is called for a text stream with a nonzero offset and either the
+ offset was not returned by a previous successful call to the ftell function on a
+ stream associated with the same file or whence is not SEEK_SET (<a href="#7.21.9.2">7.21.9.2</a>).
+<li>  The fsetpos function is called to set a position that was not returned by a previous
+ successful call to the fgetpos function on a stream associated with the same file
+ (<a href="#7.21.9.3">7.21.9.3</a>).
+<li>  A non-null pointer returned by a call to the calloc, malloc, or realloc function
+ with a zero requested size is used to access an object (<a href="#7.22.3">7.22.3</a>).
+<li>  The value of a pointer that refers to space deallocated by a call to the free or
+ realloc function is used (<a href="#7.22.3">7.22.3</a>).
+<!--page 583 indent 0-->
+<li>  The alignment requested of the aligned_alloc function is not valid or not
+ supported by the implementation, or the size requested is not an integral multiple of
+ the alignment (<a href="#7.22.3.1">7.22.3.1</a>).
+<li>  The pointer argument to the free or realloc function does not match a pointer
+ earlier returned by a memory management function, or the space has been deallocated
+ by a call to free or realloc (<a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>).
+<li>  The value of the object allocated by the malloc function is used (<a href="#7.22.3.4">7.22.3.4</a>).
+<li>  The value of any bytes in a new object allocated by the realloc function beyond
+ the size of the old object are used (<a href="#7.22.3.5">7.22.3.5</a>).
+<li>  The program calls the exit or quick_exit function more than once, or calls both
+ functions (<a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.7">7.22.4.7</a>).
+<li>  During the call to a function registered with the atexit or at_quick_exit
+ function, a call is made to the longjmp function that would terminate the call to the
+ registered function (<a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.7">7.22.4.7</a>).
+<li>  The string set up by the getenv or strerror function is modified by the program
+ (<a href="#7.22.4.6">7.22.4.6</a>, <a href="#7.23.6.2">7.23.6.2</a>).
+<li>  A command is executed through the system function in a way that is documented as
+ causing termination or some other form of undefined behavior (<a href="#7.22.4.8">7.22.4.8</a>).
+<li>  A searching or sorting utility function is called with an invalid pointer argument, even
+ if the number of elements is zero (<a href="#7.22.5">7.22.5</a>).
+<li>  The comparison function called by a searching or sorting utility function alters the
+ contents of the array being searched or sorted, or returns ordering values
+ inconsistently (<a href="#7.22.5">7.22.5</a>).
+<li>  The array being searched by the bsearch function does not have its elements in
+ proper order (<a href="#7.22.5.1">7.22.5.1</a>).
+<li>  The current conversion state is used by a multibyte/wide character conversion
+ function after changing the LC_CTYPE category (<a href="#7.22.7">7.22.7</a>).
+<li>  A string or wide string utility function is instructed to access an array beyond the end
+ of an object (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
+<li>  A string or wide string utility function is called with an invalid pointer argument, even
+ if the length is zero (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
+<li>  The contents of the destination array are used after a call to the strxfrm,
+ strftime, wcsxfrm, or wcsftime function in which the specified length was
+ too small to hold the entire null-terminated result (<a href="#7.23.4.5">7.23.4.5</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>,
+ <a href="#7.28.5.1">7.28.5.1</a>).
+<!--page 584 indent 4-->
+<li>  The first argument in the very first call to the strtok or wcstok is a null pointer
+ (<a href="#7.23.5.8">7.23.5.8</a>, <a href="#7.28.4.5.7">7.28.4.5.7</a>).
+<li>  The type of an argument to a type-generic macro is not compatible with the type of
+ the corresponding parameter of the selected function (<a href="#7.24">7.24</a>).
+<li>  A complex argument is supplied for a generic parameter of a type-generic macro that
+ has no corresponding complex function (<a href="#7.24">7.24</a>).
+<li>  At least one field of the broken-down time passed to asctime contains a value
+ outside its normal range, or the calculated year exceeds four digits or is less than the
+ year 1000 (<a href="#7.26.3.1">7.26.3.1</a>).
+<li>  The argument corresponding to an s specifier without an l qualifier in a call to the
+ fwprintf function does not point to a valid multibyte character sequence that
+ begins in the initial shift state (<a href="#7.28.2.11">7.28.2.11</a>).
+<li>  In a call to the wcstok function, the object pointed to by ptr does not have the
+ value stored by the previous call for the same wide string (<a href="#7.28.4.5.7">7.28.4.5.7</a>).
+<li>  An mbstate_t object is used inappropriately (<a href="#7.28.6">7.28.6</a>).
+<li>  The value of an argument of type wint_t to a wide character classification or case
+ mapping function is neither equal to the value of WEOF nor representable as a
+ wchar_t (<a href="#7.29.1">7.29.1</a>).
+<li>  The iswctype function is called using a different LC_CTYPE category from the
+ one in effect for the call to the wctype function that returned the description
+ (<a href="#7.29.2.2.1">7.29.2.2.1</a>).
+<li>  The towctrans function is called using a different LC_CTYPE category from the
+ one in effect for the call to the wctrans function that returned the description
+ (<a href="#7.29.3.2.1">7.29.3.2.1</a>).
+</ul>
+
+<a name="J.3" href="#J.3"><h3>J.3 Implementation-defined behavior</h3></a>
+<p><!--para 1-->
+ A conforming implementation is required to document its choice of behavior in each of
+ the areas listed in this subclause. The following are implementation-defined:
+<!--page 585 indent 4-->
+
+<a name="J.3.1" href="#J.3.1"><h4>J.3.1 Translation</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  How a diagnostic is identified (<a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>).
+<li>  Whether each nonempty sequence of white-space characters other than new-line is
+ retained or replaced by one space character in translation phase 3 (<a href="#5.1.1.2">5.1.1.2</a>).
+</ul>
+
+<a name="J.3.2" href="#J.3.2"><h4>J.3.2 Environment</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The mapping between physical source file multibyte characters and the source
+ character set in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>).
+<li>  The name and type of the function called at program startup in a freestanding
+ environment (<a href="#5.1.2.1">5.1.2.1</a>).
+<li>  The effect of program termination in a freestanding environment (<a href="#5.1.2.1">5.1.2.1</a>).
+<li>  An alternative manner in which the main function may be defined (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<li>  The values given to the strings pointed to by the argv argument to main (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<li>  What constitutes an interactive device (<a href="#5.1.2.3">5.1.2.3</a>).
+<li>  Whether a program can have more than one thread of execution in a freestanding
+ environment (<a href="#5.1.2.4">5.1.2.4</a>).
+<li>  The set of signals, their semantics, and their default handling (<a href="#7.14">7.14</a>).
+<li>  Signal values other than SIGFPE, SIGILL, and SIGSEGV that correspond to a
+ computational exception (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  Signals for which the equivalent of signal(sig, SIG_IGN); is executed at
+ program startup (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  The set of environment names and the method for altering the environment list used
+ by the getenv function (<a href="#7.22.4.6">7.22.4.6</a>).
+<li>  The manner of execution of the string by the system function (<a href="#7.22.4.8">7.22.4.8</a>).
+</ul>
+
+<a name="J.3.3" href="#J.3.3"><h4>J.3.3 Identifiers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Which additional multibyte characters may appear in identifiers and their
+ correspondence to universal character names (<a href="#6.4.2">6.4.2</a>).
+<li>  The number of significant initial characters in an identifier (<a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2">6.4.2</a>).
+<!--page 586 indent 4-->
+</ul>
+
+<a name="J.3.4" href="#J.3.4"><h4>J.3.4 Characters</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The number of bits in a byte (<a href="#3.6">3.6</a>).
+<li>  The values of the members of the execution character set (<a href="#5.2.1">5.2.1</a>).
+<li>  The unique value of the member of the execution character set produced for each of
+ the standard alphabetic escape sequences (<a href="#5.2.2">5.2.2</a>).
+<li>  The value of a char object into which has been stored any character other than a
+ member of the basic execution character set (<a href="#6.2.5">6.2.5</a>).
+<li>  Which of signed char or unsigned char has the same range, representation,
+ and behavior as ''plain'' char (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>).
+<li>  The mapping of members of the source character set (in character constants and string
+ literals) to members of the execution character set (<a href="#6.4.4.4">6.4.4.4</a>, <a href="#5.1.1.2">5.1.1.2</a>).
+<li>  The value of an integer character constant containing more than one character or
+ containing a character or escape sequence that does not map to a single-byte
+ execution character (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  The value of a wide character constant containing more than one multibyte character
+ or a single multibyte character that maps to multiple members of the extended
+ execution character set, or containing a multibyte character or escape sequence not
+ represented in the extended execution character set (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  The current locale used to convert a wide character constant consisting of a single
+ multibyte character that maps to a member of the extended execution character set
+ into a corresponding wide character code (<a href="#6.4.4.4">6.4.4.4</a>).
+<li>  Whether differently-prefixed wide string literal tokens can be concatenated and, if so,
+ the treatment of the resulting multibyte character sequence (<a href="#6.4.5">6.4.5</a>).
+<li>  The current locale used to convert a wide string literal into corresponding wide
+ character codes (<a href="#6.4.5">6.4.5</a>).
+<li>  The value of a string literal containing a multibyte character or escape sequence not
+ represented in the execution character set (<a href="#6.4.5">6.4.5</a>).
+<li>  The encoding of any of wchar_t, char16_t, and char32_t where the
+ corresponding  standard   encoding macro      (__STDC_ISO_10646__,
+ __STDC_UTF_16__, or __STDC_UTF_32__) is not defined (<a href="#6.10.8.2">6.10.8.2</a>).
+<!--page 587 indent 4-->
+</ul>
+
+<a name="J.3.5" href="#J.3.5"><h4>J.3.5 Integers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Any extended integer types that exist in the implementation (<a href="#6.2.5">6.2.5</a>).
+<li>  Whether signed integer types are represented using sign and magnitude, two's
+ complement, or ones' complement, and whether the extraordinary value is a trap
+ representation or an ordinary value (<a href="#6.2.6.2">6.2.6.2</a>).
+<li>  The rank of any extended integer type relative to another extended integer type with
+ the same precision (<a href="#6.3.1.1">6.3.1.1</a>).
+<li>  The result of, or the signal raised by, converting an integer to a signed integer type
+ when the value cannot be represented in an object of that type (<a href="#6.3.1.3">6.3.1.3</a>).
+<li>  The results of some bitwise operations on signed integers (<a href="#6.5">6.5</a>).
+</ul>
+
+<a name="J.3.6" href="#J.3.6"><h4>J.3.6 Floating point</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The accuracy of the floating-point operations and of the library functions in
+ &lt;math.h&gt; and &lt;complex.h&gt; that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The accuracy of the conversions between floating-point internal representations and
+ string representations performed by the library functions in &lt;stdio.h&gt;,
+ &lt;stdlib.h&gt;, and &lt;wchar.h&gt; (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The rounding behaviors characterized by non-standard values of FLT_ROUNDS
+ (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The evaluation methods characterized by non-standard negative values of
+ FLT_EVAL_METHOD (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+<li>  The direction of rounding when an integer is converted to a floating-point number that
+ cannot exactly represent the original value (<a href="#6.3.1.4">6.3.1.4</a>).
+<li>  The direction of rounding when a floating-point number is converted to a narrower
+ floating-point number (<a href="#6.3.1.5">6.3.1.5</a>).
+<li>  How the nearest representable value or the larger or smaller representable value
+ immediately adjacent to the nearest representable value is chosen for certain floating
+ constants (<a href="#6.4.4.2">6.4.4.2</a>).
+<li>  Whether and how floating expressions are contracted when not disallowed by the
+ FP_CONTRACT pragma (<a href="#6.5">6.5</a>).
+<li>  The default state for the FENV_ACCESS pragma (<a href="#7.6.1">7.6.1</a>).
+<li>  Additional floating-point exceptions, rounding           modes,     environments,   and
+ classifications, and their macro names (<a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>).
+<li>  The default state for the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>).
+<!--page 588 indent 4-->
+</ul>
+
+<a name="J.3.7" href="#J.3.7"><h4>J.3.7 Arrays and pointers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The result of converting a pointer to an integer or vice versa (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  The size of the result of subtracting two pointers to elements of the same array
+ (<a href="#6.5.6">6.5.6</a>).
+</ul>
+
+<a name="J.3.8" href="#J.3.8"><h4>J.3.8 Hints</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The extent to which suggestions made by using the register storage-class
+ specifier are effective (<a href="#6.7.1">6.7.1</a>).
+<li>  The extent to which suggestions made by using the inline function specifier are
+ effective (<a href="#6.7.4">6.7.4</a>).
+</ul>
+
+<a name="J.3.9" href="#J.3.9"><h4>J.3.9 Structures, unions, enumerations, and bit-fields</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Whether a ''plain'' int bit-field is treated as a signed int bit-field or as an
+ unsigned int bit-field (<a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.1">6.7.2.1</a>).
+<li>  Allowable bit-field types other than _Bool, signed int, and unsigned int
+ (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  Whether atomic types are permitted for bit-fields (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  Whether a bit-field can straddle a storage-unit boundary (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  The order of allocation of bit-fields within a unit (<a href="#6.7.2.1">6.7.2.1</a>).
+<li>  The alignment of non-bit-field members of structures (<a href="#6.7.2.1">6.7.2.1</a>). This should present
+ no problem unless binary data written by one implementation is read by another.
+<li>  The integer type compatible with each enumerated type (<a href="#6.7.2.2">6.7.2.2</a>).
+</ul>
+
+<a name="J.3.10" href="#J.3.10"><h4>J.3.10 Qualifiers</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  What constitutes an access to an object that has volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+</ul>
+
+<a name="J.3.11" href="#J.3.11"><h4>J.3.11 Preprocessing directives</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The locations within #pragma directives where header name preprocessing tokens
+ are recognized (<a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>).
+<li>  How sequences in both forms of header names are mapped to headers or external
+ source file names (<a href="#6.4.7">6.4.7</a>).
+<li>  Whether the value of a character constant in a constant expression that controls
+ conditional inclusion matches the value of the same character constant in the
+ execution character set (<a href="#6.10.1">6.10.1</a>).
+<li>  Whether the value of a single-character character constant in a constant expression
+ that controls conditional inclusion may have a negative value (<a href="#6.10.1">6.10.1</a>).
+<!--page 589 indent 4-->
+<li>  The places that are searched for an included &lt; &gt; delimited header, and how the places
+ are specified or the header is identified (<a href="#6.10.2">6.10.2</a>).
+<li>  How the named source file is searched for in an included " " delimited header
+ (<a href="#6.10.2">6.10.2</a>).
+<li>  The method by which preprocessing tokens (possibly resulting from macro
+ expansion) in a #include directive are combined into a header name (<a href="#6.10.2">6.10.2</a>).
+<li>  The nesting limit for #include processing (<a href="#6.10.2">6.10.2</a>).
+<li>  Whether the # operator inserts a \ character before the \ character that begins a
+ universal character name in a character constant or string literal (<a href="#6.10.3.2">6.10.3.2</a>).
+<li>  The behavior on each recognized non-STDC #pragma directive (<a href="#6.10.6">6.10.6</a>).
+<li>  The definitions for __DATE__ and __TIME__ when respectively, the date and
+ time of translation are not available (<a href="#6.10.8.1">6.10.8.1</a>).
+</ul>
+
+<a name="J.3.12" href="#J.3.12"><h4>J.3.12 Library functions</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  Any library facilities available to a freestanding program, other than the minimal set
+ required by clause 4 (<a href="#5.1.2.1">5.1.2.1</a>).
+<li>  The format of the diagnostic printed by the assert macro (<a href="#7.2.1.1">7.2.1.1</a>).
+<li>  The representation of the floating-point               status   flags   stored   by   the
+ fegetexceptflag function (<a href="#7.6.2.2">7.6.2.2</a>).
+<li>  Whether the feraiseexcept function raises the ''inexact'' floating-point
+ exception in addition to the ''overflow'' or ''underflow'' floating-point exception
+ (<a href="#7.6.2.3">7.6.2.3</a>).
+<li>  Strings other than "C" and "" that may be passed as the second argument to the
+ setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+<li>  The types defined for float_t and double_t when the value of the
+ FLT_EVAL_METHOD macro is less than 0 (<a href="#7.12">7.12</a>).
+<li>  Domain errors for the mathematics functions, other than those required by this
+ International Standard (<a href="#7.12.1">7.12.1</a>).
+<li>  The values returned by the mathematics functions on domain errors or pole errors
+ (<a href="#7.12.1">7.12.1</a>).
+<li>  The values returned by the mathematics functions on underflow range errors, whether
+ errno is set to the value of the macro ERANGE when the integer expression
+ math_errhandling &amp; MATH_ERRNO is nonzero, and whether the ''underflow''
+ floating-point exception is raised when the integer expression math_errhandling
+ &amp; MATH_ERREXCEPT is nonzero. (<a href="#7.12.1">7.12.1</a>).
+<!--page 590 indent 0-->
+<li>  Whether a domain error occurs or zero is returned when an fmod function has a
+ second argument of zero (<a href="#7.12.10.1">7.12.10.1</a>).
+<li>  Whether a domain error occurs or zero is returned when a remainder function has
+ a second argument of zero (<a href="#7.12.10.2">7.12.10.2</a>).
+<li>  The base-2 logarithm of the modulus used by the remquo functions in reducing the
+ quotient (<a href="#7.12.10.3">7.12.10.3</a>).
+<li>  Whether a domain error occurs or zero is returned when a remquo function has a
+ second argument of zero (<a href="#7.12.10.3">7.12.10.3</a>).
+<li>  Whether the equivalent of signal(sig, SIG_DFL); is executed prior to the call
+ of a signal handler, and, if not, the blocking of signals that is performed (<a href="#7.14.1.1">7.14.1.1</a>).
+<li>  The null pointer constant to which the macro NULL expands (<a href="#7.19">7.19</a>).
+<li>  Whether the last line of a text stream requires a terminating new-line character
+ (<a href="#7.21.2">7.21.2</a>).
+<li>  Whether space characters that are written out to a text stream immediately before a
+ new-line character appear when read in (<a href="#7.21.2">7.21.2</a>).
+<li>  The number of null characters that may be appended to data written to a binary
+ stream (<a href="#7.21.2">7.21.2</a>).
+<li>  Whether the file position indicator of an append-mode stream is initially positioned at
+ the beginning or end of the file (<a href="#7.21.3">7.21.3</a>).
+<li>  Whether a write on a text stream causes the associated file to be truncated beyond that
+ point (<a href="#7.21.3">7.21.3</a>).
+<li>  The characteristics of file buffering (<a href="#7.21.3">7.21.3</a>).
+<li>  Whether a zero-length file actually exists (<a href="#7.21.3">7.21.3</a>).
+<li>  The rules for composing valid file names (<a href="#7.21.3">7.21.3</a>).
+<li>  Whether the same file can be simultaneously open multiple times (<a href="#7.21.3">7.21.3</a>).
+<li>  The nature and choice of encodings used for multibyte characters in files (<a href="#7.21.3">7.21.3</a>).
+<li>  The effect of the remove function on an open file (<a href="#7.21.4.1">7.21.4.1</a>).
+<li>  The effect if a file with the new name exists prior to a call to the rename function
+ (<a href="#7.21.4.2">7.21.4.2</a>).
+<li>  Whether an open temporary file is removed upon abnormal program termination
+ (<a href="#7.21.4.3">7.21.4.3</a>).
+<li>  Which changes of mode are permitted (if any), and under what circumstances
+ (<a href="#7.21.5.4">7.21.5.4</a>).
+<!--page 591 indent 0-->
+<li>  The style used to print an infinity or NaN, and the meaning of any n-char or n-wchar
+ sequence printed for a NaN (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  The output for %p conversion in the fprintf or fwprintf function (<a href="#7.21.6.1">7.21.6.1</a>,
+ <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  The interpretation of a - character that is neither the first nor the last character, nor
+ the second where a ^ character is the first, in the scanlist for %[ conversion in the
+ fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+<li>  The set of sequences matched by a %p conversion and the interpretation of the
+ corresponding input item in the fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+<li>  The value to which the macro errno is set by the fgetpos, fsetpos, or ftell
+ functions on failure (<a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>).
+<li>  The meaning of any n-char or n-wchar sequence in a string representing a NaN that is
+ converted by the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+ function (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
+<li>  Whether or not the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+ function sets errno to ERANGE when underflow occurs (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
+<li>  Whether the calloc, malloc, and realloc functions return a null pointer or a
+ pointer to an allocated object when the size requested is zero (<a href="#7.22.3">7.22.3</a>).
+<li>  Whether open streams with unwritten buffered data are flushed, open streams are
+ closed, or temporary files are removed when the abort or _Exit function is called
+ (<a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.22.4.5">7.22.4.5</a>).
+<li>  The termination status returned to the host environment by the abort, exit,
+ _Exit, or quick_exit function (<a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>).
+<li>  The value returned by the system function when its argument is not a null pointer
+ (<a href="#7.22.4.8">7.22.4.8</a>).
+<li>  The local time zone and Daylight Saving Time (<a href="#7.26.1">7.26.1</a>).
+<li>  The range and precision of times representable in clock_t and time_t (<a href="#7.26">7.26</a>).
+<li>  The era for the clock function (<a href="#7.26.2.1">7.26.2.1</a>).
+<li>  The replacement string for the %Z specifier to the strftime, and wcsftime
+ functions in the "C" locale (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+<li>  Whether the functions in &lt;math.h&gt; honor the rounding direction mode in an
+ IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.10">F.10</a>).
+<!--page 592 indent 4-->
+</ul>
+
+<a name="J.3.13" href="#J.3.13"><h4>J.3.13 Architecture</h4></a>
+<p><!--para 1-->
+<ul>
+<li>  The values or expressions assigned to the macros specified in the headers
+ &lt;float.h&gt;, &lt;limits.h&gt;, and &lt;stdint.h&gt; (<a href="#5.2.4.2">5.2.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>).
+<li>  The result of attempting to indirectly access an object with automatic or thread
+ storage duration from a thread other than the one with which it is associated (<a href="#6.2.4">6.2.4</a>).
+<li>  The number, order, and encoding of bytes in any object (when not explicitly specified
+ in this International Standard) (<a href="#6.2.6.1">6.2.6.1</a>).
+<li>  Whether any extended alignments are supported and the contexts in which they are
+ supported (<a href="#6.2.8">6.2.8</a>).
+<li>  Valid alignment values other than those returned by an alignof expression for
+ fundamental types, if any (<a href="#6.2.8">6.2.8</a>).
+<li>  The value of the result of the sizeof and alignof operators (<a href="#6.5.3.4">6.5.3.4</a>).
+</ul>
+
+<a name="J.4" href="#J.4"><h3>J.4 Locale-specific behavior</h3></a>
+<p><!--para 1-->
+ The following characteristics of a hosted environment are locale-specific and are required
+ to be documented by the implementation:
+<ul>
+<li>  Additional members of the source and execution character sets beyond the basic
+ character set (<a href="#5.2.1">5.2.1</a>).
+<li>  The presence, meaning, and representation of additional multibyte characters in the
+ execution character set beyond the basic character set (<a href="#5.2.1.2">5.2.1.2</a>).
+<li>  The shift states used for the encoding of multibyte characters (<a href="#5.2.1.2">5.2.1.2</a>).
+<li>  The direction of writing of successive printing characters (<a href="#5.2.2">5.2.2</a>).
+<li>  The decimal-point character (<a href="#7.1.1">7.1.1</a>).
+<li>  The set of printing characters (<a href="#7.4">7.4</a>, <a href="#7.29.2">7.29.2</a>).
+<li>  The set of control characters (<a href="#7.4">7.4</a>, <a href="#7.29.2">7.29.2</a>).
+<li>  The sets of characters tested for by the isalpha, isblank, islower, ispunct,
+ isspace, isupper, iswalpha, iswblank, iswlower, iswpunct,
+ iswspace, or iswupper functions (<a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+ <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>).
+<li>  The native environment (<a href="#7.11.1.1">7.11.1.1</a>).
+<li>  Additional subject sequences accepted by the numeric conversion functions (<a href="#7.22.1">7.22.1</a>,
+ <a href="#7.28.4.1">7.28.4.1</a>).
+<li>  The collation sequence of the execution character set (<a href="#7.23.4.3">7.23.4.3</a>, <a href="#7.28.4.4.2">7.28.4.4.2</a>).
+<!--page 593 indent 4-->
+<li>  The contents of the error message strings set up by the strerror function
+ (<a href="#7.23.6.2">7.23.6.2</a>).
+<li>  The formats for time and date (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+<li>  Character mappings that are supported by the towctrans function (<a href="#7.29.1">7.29.1</a>).
+<li>  Character classifications that are supported by the iswctype function (<a href="#7.29.1">7.29.1</a>).
+</ul>
+
+<a name="J.5" href="#J.5"><h3>J.5 Common extensions</h3></a>
+<p><!--para 1-->
+ The following extensions are widely used in many systems, but are not portable to all
+ implementations. The inclusion of any extension that may cause a strictly conforming
+ program to become invalid renders an implementation nonconforming. Examples of such
+ extensions are new keywords, extra library functions declared in standard headers, or
+ predefined macros with names that do not begin with an underscore.
+
+<a name="J.5.1" href="#J.5.1"><h4>J.5.1 Environment arguments</h4></a>
+<p><!--para 1-->
+ In a hosted environment, the main function receives a third argument, char *envp[],
+ that points to a null-terminated array of pointers to char, each of which points to a string
+ that provides information about the environment for this execution of the program
+ (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+
+<a name="J.5.2" href="#J.5.2"><h4>J.5.2 Specialized identifiers</h4></a>
+<p><!--para 1-->
+ Characters other than the underscore _, letters, and digits, that are not part of the basic
+ source character set (such as the dollar sign $, or characters in national character sets)
+ may appear in an identifier (<a href="#6.4.2">6.4.2</a>).
+
+<a name="J.5.3" href="#J.5.3"><h4>J.5.3 Lengths and cases of identifiers</h4></a>
+<p><!--para 1-->
+ All characters in identifiers (with or without external linkage) are significant (<a href="#6.4.2">6.4.2</a>).
+
+<a name="J.5.4" href="#J.5.4"><h4>J.5.4 Scopes of identifiers</h4></a>
+<p><!--para 1-->
+ A function identifier, or the identifier of an object the declaration of which contains the
+ keyword extern, has file scope (<a href="#6.2.1">6.2.1</a>).
+
+<a name="J.5.5" href="#J.5.5"><h4>J.5.5 Writable string literals</h4></a>
+<p><!--para 1-->
+ String literals are modifiable (in which case, identical string literals should denote distinct
+ objects) (<a href="#6.4.5">6.4.5</a>).
+<!--page 594 indent 4-->
+
+<a name="J.5.6" href="#J.5.6"><h4>J.5.6 Other arithmetic types</h4></a>
+<p><!--para 1-->
+ Additional arithmetic types, such as __int128 or double double, and their
+ appropriate conversions are defined (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1">6.3.1</a>). Additional floating types may have
+ more range or precision than long double, may be used for evaluating expressions of
+ other floating types, and may be used to define float_t or double_t.
+
+<a name="J.5.7" href="#J.5.7"><h4>J.5.7 Function pointer casts</h4></a>
+<p><!--para 1-->
+ A pointer to an object or to void may be cast to a pointer to a function, allowing data to
+ be invoked as a function (<a href="#6.5.4">6.5.4</a>).
+<p><!--para 2-->
+ A pointer to a function may be cast to a pointer to an object or to void, allowing a
+ function to be inspected or modified (for example, by a debugger) (<a href="#6.5.4">6.5.4</a>).
+
+<a name="J.5.8" href="#J.5.8"><h4>J.5.8 Extended bit-field types</h4></a>
+<p><!--para 1-->
+ A bit-field may be declared with a type other than _Bool, unsigned int, or
+ signed int, with an appropriate maximum width (<a href="#6.7.2.1">6.7.2.1</a>).
+
+<a name="J.5.9" href="#J.5.9"><h4>J.5.9 The fortran keyword</h4></a>
+<p><!--para 1-->
+ The fortran function specifier may be used in a function declaration to indicate that
+ calls suitable for FORTRAN should be generated, or that a different representation for the
+ external name is to be generated (<a href="#6.7.4">6.7.4</a>).
+
+<a name="J.5.10" href="#J.5.10"><h4>J.5.10 The asm keyword</h4></a>
+<p><!--para 1-->
+ The asm keyword may be used to insert assembly language directly into the translator
+ output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
+<pre>
+        asm ( character-string-literal );</pre>
+
+<a name="J.5.11" href="#J.5.11"><h4>J.5.11 Multiple external definitions</h4></a>
+<p><!--para 1-->
+ There may be more than one external definition for the identifier of an object, with or
+ without the explicit use of the keyword extern; if the definitions disagree, or more than
+ one is initialized, the behavior is undefined (<a href="#6.9.2">6.9.2</a>).
+
+<a name="J.5.12" href="#J.5.12"><h4>J.5.12 Predefined macro names</h4></a>
+<p><!--para 1-->
+ Macro names that do not begin with an underscore, describing the translation and
+ execution environments, are defined by the implementation before translation begins
+ (<a href="#6.10.8">6.10.8</a>).
+<!--page 595 indent 4-->
+
+<a name="J.5.13" href="#J.5.13"><h4>J.5.13 Floating-point status flags</h4></a>
+<p><!--para 1-->
+ If any floating-point status flags are set on normal termination after all calls to functions
+ registered by the atexit function have been made (see <a href="#7.22.4.4">7.22.4.4</a>), the implementation
+ writes some diagnostics indicating the fact to the stderr stream, if it is still open,
+
+<a name="J.5.14" href="#J.5.14"><h4>J.5.14 Extra arguments for signal handlers</h4></a>
+<p><!--para 1-->
+ Handlers for specific signals are called with extra arguments in addition to the signal
+ number (<a href="#7.14.1.1">7.14.1.1</a>).
+
+<a name="J.5.15" href="#J.5.15"><h4>J.5.15 Additional stream types and file-opening modes</h4></a>
+<p><!--para 1-->
+ Additional mappings from files to streams are supported (<a href="#7.21.2">7.21.2</a>).
+<p><!--para 2-->
+ Additional file-opening modes may be specified by characters appended to the mode
+ argument of the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+
+<a name="J.5.16" href="#J.5.16"><h4>J.5.16 Defined file position indicator</h4></a>
+<p><!--para 1-->
+ The file position indicator is decremented by each successful call to the ungetc or
+ ungetwc function for a text stream, except if its value was zero before a call (<a href="#7.21.7.10">7.21.7.10</a>,
+ <a href="#7.28.3.10">7.28.3.10</a>).
+
+<a name="J.5.17" href="#J.5.17"><h4>J.5.17 Math error reporting</h4></a>
+<p><!--para 1-->
+ Functions declared in &lt;complex.h&gt; and &lt;math.h&gt; raise SIGFPE to report errors
+ instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
+ <a href="#7.12">7.12</a>).
+<!--page 596 indent 4-->
+
+<a name="K" href="#K"><h2>Annex K</h2></a>
+<pre>
+                                       (normative)
+                           Bounds-checking interfaces</pre>
+
+<a name="K.1" href="#K.1"><h3>K.1 Background</h3></a>
+<p><!--para 1-->
+ Traditionally, the C Library has contained many functions that trust the programmer to
+ provide output character arrays big enough to hold the result being produced. Not only
+ do these functions not check that the arrays are big enough, they frequently lack the
+ information needed to perform such checks. While it is possible to write safe, robust, and
+ error-free code using the existing library, the library tends to promote programming styles
+ that lead to mysterious failures if a result is too big for the provided array.
+<p><!--para 2-->
+ A common programming style is to declare character arrays large enough to handle most
+ practical cases. However, if these arrays are not large enough to handle the resulting
+ strings, data can be written past the end of the array overwriting other data and program
+ structures. The program never gets any indication that a problem exists, and so never has
+ a chance to recover or to fail gracefully.
+<p><!--para 3-->
+ Worse, this style of programming has compromised the security of computers and
+ networks. Buffer overflows can often be exploited to run arbitrary code with the
+ permissions of the vulnerable (defective) program.
+<p><!--para 4-->
+ If the programmer writes runtime checks to verify lengths before calling library
+ functions, then those runtime checks frequently duplicate work done inside the library
+ functions, which discover string lengths as a side effect of doing their job.
+<p><!--para 5-->
+ This annex provides alternative library functions that promote safer, more secure
+ programming. The alternative functions verify that output buffers are large enough for
+ the intended result and return a failure indicator if they are not. Data is never written past
+ the end of an array. All string results are null terminated.
+<p><!--para 6-->
+ This annex also addresses another problem that complicates writing robust code:
+ functions that are not reentrant because they return pointers to static objects owned by the
+ function. Such functions can be troublesome since a previously returned result can
+ change if the function is called again, perhaps by another thread.
+<!--page 597 indent 4-->
+
+<a name="K.2" href="#K.2"><h3>K.2 Scope</h3></a>
+<p><!--para 1-->
+ This annex specifies a series of optional extensions that can be useful in the mitigation of
+ security vulnerabilities in programs, and comprise new functions, macros, and types
+ declared or defined in existing standard headers.
+<p><!--para 2-->
+ An implementation that defines __STDC_LIB_EXT1__ shall conform to the
+ specifications in this annex.<sup><a href="#note367"><b>367)</b></a></sup>
+<p><!--para 3-->
+ Subclause <a href="#K.3">K.3</a> should be read as if it were merged into the parallel structure of named
+ subclauses of clause 7.
+
+<h6>footnotes</h6>
+<p><a name="note367">367)</a> Implementations that do not define __STDC_LIB_EXT1__ are not required to conform to these
+ specifications.
+
+
+<a name="K.3" href="#K.3"><h3>K.3 Library</h3></a>
+
+<a name="K.3.1" href="#K.3.1"><h4>K.3.1 Introduction</h4></a>
+
+<a name="K.3.1.1" href="#K.3.1.1"><h5>K.3.1.1 Standard headers</h5></a>
+<p><!--para 1-->
+ The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are not
+ declared or defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
+ defined as a macro which expands to the integer constant 0 at the point in the source file
+ where the appropriate header is first included.
+<p><!--para 2-->
+ The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are
+ declared and defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
+ defined as a macro which expands to the integer constant 1 at the point in the source file
+ where the appropriate header is first included.<sup><a href="#note368"><b>368)</b></a></sup>
+<p><!--para 3-->
+ It is implementation-defined whether the functions, macros, and types declared or defined
+ in <a href="#K.3">K.3</a> and its subclauses are declared or defined by their respective headers if
+ __STDC_WANT_LIB_EXT1__ is not defined as a macro at the point in the source file
+ where the appropriate header is first included.<sup><a href="#note369"><b>369)</b></a></sup>
+<p><!--para 4-->
+ Within a preprocessing translation unit, __STDC_WANT_LIB_EXT1__ shall be
+ defined identically for all inclusions of any headers from subclause <a href="#K.3">K.3</a>. If
+ __STDC_WANT_LIB_EXT1__ is defined differently for any such inclusion, the
+ implementation shall issue a diagnostic as if a preprocessor error directive were used.
+ 
+ 
+<!--page 598 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note368">368)</a> Future revisions of this International Standard may define meanings for other values of
+ __STDC_WANT_LIB_EXT1__.
+
+<p><a name="note369">369)</a> Subclause <a href="#7.1.3">7.1.3</a> reserves certain names and patterns of names that an implementation may use in
+ headers. All other names are not reserved, and a conforming implementation is not permitted to use
+ them. While some of the names defined in <a href="#K.3">K.3</a> and its subclauses are reserved, others are not. If an
+ unreserved name is defined in a header when __STDC_WANT_LIB_EXT1__ is defined as 0, the
+ implementation is not conforming.
+
+
+<a name="K.3.1.2" href="#K.3.1.2"><h5>K.3.1.2 Reserved identifiers</h5></a>
+<p><!--para 1-->
+ Each macro name in any of the following subclauses is reserved for use as specified if it
+ is defined by any of its associated headers when included; unless explicitly stated
+ otherwise (see <a href="#7.1.4">7.1.4</a>).
+<p><!--para 2-->
+ All identifiers with external linkage in any of the following subclauses are reserved for
+ use as identifiers with external linkage if any of them are used by the program. None of
+ them are reserved if none of them are used.
+<p><!--para 3-->
+ Each identifier with file scope listed in any of the following subclauses is reserved for use
+ as a macro name and as an identifier with file scope in the same name space if it is
+ defined by any of its associated headers when included.
+
+<a name="K.3.1.3" href="#K.3.1.3"><h5>K.3.1.3 Use of errno</h5></a>
+<p><!--para 1-->
+ An implementation may set errno for the functions defined in this annex, but is not
+ required to.
+
+<a name="K.3.1.4" href="#K.3.1.4"><h5>K.3.1.4 Runtime-constraint violations</h5></a>
+<p><!--para 1-->
+ Most functions in this annex include as part of their specification a list of runtime-
+ constraints. These runtime-constraints are requirements on the program using the
+ library.<sup><a href="#note370"><b>370)</b></a></sup>
+<p><!--para 2-->
+ Implementations shall verify that the runtime-constraints for a function are not violated
+ by the program. If a runtime-constraint is violated, the implementation shall call the
+ currently registered runtime-constraint handler (see set_constraint_handler_s
+ in &lt;stdlib.h&gt;). Multiple runtime-constraint violations in the same call to a library
+ function result in only one call to the runtime-constraint handler. It is unspecified which
+ one of the multiple runtime-constraint violations cause the handler to be called.
+<p><!--para 3-->
+ If the runtime-constraints section for a function states an action to be performed when a
+ runtime-constraint violation occurs, the function shall perform the action before calling
+ the runtime-constraint handler. If the runtime-constraints section lists actions that are
+ prohibited when a runtime-constraint violation occurs, then such actions are prohibited to
+ the function both before calling the handler and after the handler returns.
+<p><!--para 4-->
+ The runtime-constraint handler might not return. If the handler does return, the library
+ function whose runtime-constraint was violated shall return some indication of failure as
+ given by the returns section in the function's specification.
+ 
+ 
+ 
+<!--page 599 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note370">370)</a> Although runtime-constraints replace many cases of undefined behavior, undefined behavior still
+ exists in this annex. Implementations are free to detect any case of undefined behavior and treat it as a
+ runtime-constraint violation by calling the runtime-constraint handler. This license comes directly
+ from the definition of undefined behavior.
+
+
+<a name="K.3.2" href="#K.3.2"><h4>K.3.2 Errors <errno.h></h4></a>
+<p><!--para 1-->
+ The header &lt;errno.h&gt; defines a type.
+<p><!--para 2-->
+ The type is
+<pre>
+          errno_t</pre>
+ which is type int.<sup><a href="#note371"><b>371)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note371">371)</a> As a matter of programming style, errno_t may be used as the type of something that deals only
+ with the values that might be found in errno. For example, a function which returns the value of
+ errno might be declared as having the return type errno_t.
+
+
+<a name="K.3.3" href="#K.3.3"><h4>K.3.3 Common definitions <stddef.h></h4></a>
+<p><!--para 1-->
+ The header &lt;stddef.h&gt; defines a type.
+<p><!--para 2-->
+ The type is
+<pre>
+          rsize_t</pre>
+ which is the type size_t.<sup><a href="#note372"><b>372)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note372">372)</a> See the description of the RSIZE_MAX macro in &lt;stdint.h&gt;.
+
+
+<a name="K.3.4" href="#K.3.4"><h4>K.3.4 Integer types <stdint.h></h4></a>
+<p><!--para 1-->
+ The header &lt;stdint.h&gt; defines a macro.
+<p><!--para 2-->
+ The macro is
+<pre>
+          RSIZE_MAX</pre>
+ which expands to a value<sup><a href="#note373"><b>373)</b></a></sup> of type size_t. Functions that have parameters of type
+ rsize_t consider it a runtime-constraint violation if the values of those parameters are
+ greater than RSIZE_MAX.
+ Recommended practice
+<p><!--para 3-->
+ Extremely large object sizes are frequently a sign that an object's size was calculated
+ incorrectly. For example, negative numbers appear as very large positive numbers when
+ converted to an unsigned type like size_t. Also, some implementations do not support
+ objects as large as the maximum value that can be represented by type size_t.
+<p><!--para 4-->
+ For those reasons, it is sometimes beneficial to restrict the range of object sizes to detect
+ programming errors. For implementations targeting machines with large address spaces,
+ it is recommended that RSIZE_MAX be defined as the smaller of the size of the largest
+ object supported or (SIZE_MAX &gt;&gt; 1), even if this limit is smaller than the size of
+ some legitimate, but very large, objects. Implementations targeting machines with small
+ address spaces may wish to define RSIZE_MAX as SIZE_MAX, which means that there
+ 
+<!--page 600 indent 4-->
+ is no object size that is considered a runtime-constraint violation.
+
+<h6>footnotes</h6>
+<p><a name="note373">373)</a> The macro RSIZE_MAX need not expand to a constant expression.
+
+
+<a name="K.3.5" href="#K.3.5"><h4>K.3.5 Input/output <stdio.h></h4></a>
+<p><!--para 1-->
+ The header &lt;stdio.h&gt; defines several macros and two types.
+<p><!--para 2-->
+ The macros are
+<pre>
+        L_tmpnam_s</pre>
+ which expands to an integer constant expression that is the size needed for an array of
+ char large enough to hold a temporary file name string generated by the tmpnam_s
+ function;
+<pre>
+        TMP_MAX_S</pre>
+ which expands to an integer constant expression that is the maximum number of unique
+ file names that can be generated by the tmpnam_s function.
+<p><!--para 3-->
+ The types are
+<pre>
+        errno_t</pre>
+ which is type int; and
+<pre>
+        rsize_t</pre>
+ which is the type size_t.
+
+<a name="K.3.5.1" href="#K.3.5.1"><h5>K.3.5.1 Operations on files</h5></a>
+
+<a name="K.3.5.1.1" href="#K.3.5.1.1"><h5>K.3.5.1.1 The tmpfile_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdio.h&gt;
+        errno_t tmpfile_s(FILE * restrict * restrict streamptr);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ streamptr shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, tmpfile_s does not attempt to create a file.
+<h6>Description</h6>
+<p><!--para 4-->
+ The tmpfile_s function creates a temporary binary file that is different from any other
+ existing file and that will automatically be removed when it is closed or at program
+ termination. If the program terminates abnormally, whether an open temporary file is
+ removed is implementation-defined. The file is opened for update with "wb+" mode
+ with the meaning that mode has in the fopen_s function (including the mode's effect
+ on exclusive access and file permissions).
+<!--page 601 indent 4-->
+<p><!--para 5-->
+ If the file was created successfully, then the pointer to FILE pointed to by streamptr
+ will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
+ to FILE pointed to by streamptr will be set to a null pointer.
+ Recommended practice
+ It should be possible to open at least TMP_MAX_S temporary files during the lifetime of
+ the program (this limit may be shared with tmpnam_s) and there should be no limit on
+ the number simultaneously open other than this limit and any limit on the number of open
+ files (FOPEN_MAX).
+<h6>Returns</h6>
+<p><!--para 6-->
+ The tmpfile_s function returns zero if it created the file. If it did not create the file or
+ there was a runtime-constraint violation, tmpfile_s returns a nonzero value.
+
+<a name="K.3.5.1.2" href="#K.3.5.1.2"><h5>K.3.5.1.2 The tmpnam_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdio.h&gt;
+         errno_t tmpnam_s(char *s, rsize_t maxsize);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ s shall not be a null pointer. maxsize shall be less than or equal to RSIZE_MAX.
+ maxsize shall be greater than the length of the generated file name string.
+<h6>Description</h6>
+<p><!--para 3-->
+ The tmpnam_s function generates a string that is a valid file name and that is not the
+ same as the name of an existing file.<sup><a href="#note374"><b>374)</b></a></sup> The function is potentially capable of generating
+ TMP_MAX_S different strings, but any or all of them may already be in use by existing
+ files and thus not be suitable return values. The lengths of these strings shall be less than
+ the value of the L_tmpnam_s macro.
+<p><!--para 4-->
+ The tmpnam_s function generates a different string each time it is called.
+<p><!--para 5-->
+ It is assumed that s points to an array of at least maxsize characters. This array will be
+ set to generated string, as specified below.
+ 
+ 
+ 
+<!--page 602 indent 5-->
+<p><!--para 6-->
+ The implementation shall behave as if no library function except tmpnam calls the
+ tmpnam_s function.<sup><a href="#note375"><b>375)</b></a></sup>
+ Recommended practice
+<p><!--para 7-->
+ After a program obtains a file name using the tmpnam_s function and before the
+ program creates a file with that name, the possibility exists that someone else may create
+ a file with that same name. To avoid this race condition, the tmpfile_s function
+ should be used instead of tmpnam_s when possible. One situation that requires the use
+ of the tmpnam_s function is when the program needs to create a temporary directory
+ rather than a temporary file.
+<h6>Returns</h6>
+<p><!--para 8-->
+ If no suitable string can be generated, or if there is a runtime-constraint violation, the
+ tmpnam_s function writes a null character to s[0] (only if s is not null and maxsize
+ is greater than zero) and returns a nonzero value.
+<p><!--para 9-->
+ Otherwise, the tmpnam_s function writes the string in the array pointed to by s and
+ returns zero.
+ Environmental limits
+<p><!--para 10-->
+ The value of the macro TMP_MAX_S shall be at least 25.
+
+<h6>footnotes</h6>
+<p><a name="note374">374)</a> Files created using strings generated by the tmpnam_s function are temporary only in the sense that
+ their names should not collide with those generated by conventional naming rules for the
+ implementation. It is still necessary to use the remove function to remove such files when their use
+ is ended, and before program termination. Implementations should take care in choosing the patterns
+ used for names returned by tmpnam_s. For example, making a thread id part of the names avoids the
+ race condition and possible conflict when multiple programs run simultaneously by the same user
+ generate the same temporary file names.
+
+<p><a name="note375">375)</a> An implementation may have tmpnam call tmpnam_s (perhaps so there is only one naming
+ convention for temporary files), but this is not required.
+
+
+<a name="K.3.5.2" href="#K.3.5.2"><h5>K.3.5.2 File access functions</h5></a>
+
+<a name="K.3.5.2.1" href="#K.3.5.2.1"><h5>K.3.5.2.1 The fopen_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdio.h&gt;
+        errno_t fopen_s(FILE * restrict * restrict streamptr,
+             const char * restrict filename,
+             const char * restrict mode);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ None of streamptr, filename, or mode shall be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, fopen_s does not attempt to open a file.
+ Furthermore, if streamptr is not a null pointer, fopen_s sets *streamptr to the
+ null pointer.
+ 
+ 
+ 
+ 
+<!--page 603 indent 4-->
+<h6>Description</h6>
+<p><!--para 4-->
+ The fopen_s function opens the file whose name is the string pointed to by
+ filename, and associates a stream with it.
+<p><!--para 5-->
+ The mode string shall be as described for fopen, with the addition that modes starting
+ with the character 'w' or 'a' may be preceded by the character 'u', see below:
+ uw             truncate to zero length or create text file for writing, default
+<pre>
+                permissions</pre>
+ uwx            create text file for writing, default permissions
+ ua             append; open or create text file for writing at end-of-file, default
+<pre>
+                permissions</pre>
+ uwb            truncate to zero length or create binary file for writing, default
+<pre>
+                permissions</pre>
+ uwbx           create binary file for writing, default permissions
+ uab            append; open or create binary file for writing at end-of-file, default
+<pre>
+                permissions</pre>
+ uw+            truncate to zero length or create text file for update, default
+<pre>
+                permissions</pre>
+ uw+x           create text file for update, default permissions
+ ua+            append; open or create text file for update, writing at end-of-file,
+<pre>
+                default permissions</pre>
+ uw+b or uwb+   truncate to zero length or create binary file for update, default
+<pre>
+                permissions</pre>
+ uw+bx or uwb+x create binary file for update, default permissions
+ ua+b or uab+   append; open or create binary file for update, writing at end-of-file,
+<p><!--para 6-->
+<pre>
+                default permissions</pre>
+ Opening a file with exclusive mode ('x' as the last character in the mode argument)
+ fails if the file already exists or cannot be created.
+<p><!--para 7-->
+ To the extent that the underlying system supports the concepts, files opened for writing
+ shall be opened with exclusive (also known as non-shared) access. If the file is being
+ created, and the first character of the mode string is not 'u', to the extent that the
+ underlying system supports it, the file shall have a file permission that prevents other
+ users on the system from accessing the file. If the file is being created and first character
+ of the mode string is 'u', then by the time the file has been closed, it shall have the
+ system default file access permissions.<sup><a href="#note376"><b>376)</b></a></sup>
+<p><!--para 8-->
+ If the file was opened successfully, then the pointer to FILE pointed to by streamptr
+ will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
+ 
+ 
+<!--page 604 indent 4-->
+ to FILE pointed to by streamptr will be set to a null pointer.
+<h6>Returns</h6>
+<p><!--para 9-->
+ The fopen_s function returns zero if it opened the file. If it did not open the file or if
+ there was a runtime-constraint violation, fopen_s returns a nonzero value.
+
+<h6>footnotes</h6>
+<p><a name="note376">376)</a> These are the same permissions that the file would have been created with by fopen.
+
+
+<a name="K.3.5.2.2" href="#K.3.5.2.2"><h5>K.3.5.2.2 The freopen_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdio.h&gt;
+        errno_t freopen_s(FILE * restrict * restrict newstreamptr,
+             const char * restrict filename,
+             const char * restrict mode,
+             FILE * restrict stream);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ None of newstreamptr, mode, and stream shall be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, freopen_s neither attempts to close any file
+ associated with stream nor attempts to open a file. Furthermore, if newstreamptr is
+ not a null pointer, fopen_s sets *newstreamptr to the null pointer.
+<h6>Description</h6>
+<p><!--para 4-->
+ The freopen_s function opens the file whose name is the string pointed to by
+ filename and associates the stream pointed to by stream with it. The mode
+ argument has the same meaning as in the fopen_s function (including the mode's effect
+ on exclusive access and file permissions).
+<p><!--para 5-->
+ If filename is a null pointer, the freopen_s function attempts to change the mode of
+ the stream to that specified by mode, as if the name of the file currently associated with
+ the stream had been used. It is implementation-defined which changes of mode are
+ permitted (if any), and under what circumstances.
+<p><!--para 6-->
+ The freopen_s function first attempts to close any file that is associated with stream.
+ Failure to close the file is ignored. The error and end-of-file indicators for the stream are
+ cleared.
+<p><!--para 7-->
+ If the file was opened successfully, then the pointer to FILE pointed to by
+ newstreamptr will be set to the value of stream. Otherwise, the pointer to FILE
+ pointed to by newstreamptr will be set to a null pointer.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The freopen_s function returns zero if it opened the file. If it did not open the file or
+ there was a runtime-constraint violation, freopen_s returns a nonzero value.
+<!--page 605 indent 4-->
+
+<a name="K.3.5.3" href="#K.3.5.3"><h5>K.3.5.3 Formatted input/output functions</h5></a>
+<p><!--para 1-->
+ Unless explicitly stated otherwise, if the execution of a function described in this
+ subclause causes copying to take place between objects that overlap, the objects take on
+ unspecified values.
+
+<a name="K.3.5.3.1" href="#K.3.5.3.1"><h5>K.3.5.3.1 The fprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdio.h&gt;
+          int fprintf_s(FILE * restrict stream,
+               const char * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note377"><b>377)</b></a></sup> (modified or
+ not by flags, field width, or precision) shall not appear in the string pointed to by
+ format. Any argument to fprintf_s corresponding to a %s specifier shall not be a
+ null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation,<sup><a href="#note378"><b>378)</b></a></sup> the fprintf_s function does not attempt
+ to produce further output, and it is unspecified to what extent fprintf_s produced
+ output before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The fprintf_s function is equivalent to the fprintf function except for the explicit
+ runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The fprintf_s function returns the number of characters transmitted, or a negative
+ value if an output error, encoding error, or runtime-constraint violation occurred.
+ 
+ 
+ 
+ 
+<!--page 606 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note377">377)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+<p><a name="note378">378)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
+ implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
+ constraint violation.
+
+
+<a name="K.3.5.3.2" href="#K.3.5.3.2"><h5>K.3.5.3.2 The fscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdio.h&gt;
+         int fscanf_s(FILE * restrict stream,
+              const char * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. Any argument indirected though in
+ order to store converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation,<sup><a href="#note379"><b>379)</b></a></sup> the fscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent fscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The fscanf_s function is equivalent to fscanf except that the c, s, and [ conversion
+ specifiers apply to a pair of arguments (unless assignment suppression is indicated by a
+ *). The first of these arguments is the same as for fscanf. That argument is
+ immediately followed in the argument list by the second argument, which has type
+ rsize_t and gives the number of elements in the array pointed to by the first argument
+ of the pair. If the first argument points to a scalar object, it is considered to be an array of
+ one element.<sup><a href="#note380"><b>380)</b></a></sup>
+<p><!--para 5-->
+ A matching failure occurs if the number of elements in a receiving object is insufficient to
+ hold the converted input (including any trailing null character).
+<h6>Returns</h6>
+<p><!--para 6-->
+ The fscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ 
+<!--page 607 indent 4-->
+ fscanf_s function returns the number of input items assigned, which can be fewer than
+ provided for, or even zero, in the event of an early matching failure.
+<p><!--para 7-->
+ EXAMPLE 1        The call:
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int n, i; float x; char name[50];
+          n = fscanf_s(stdin, "%d%f%s", &amp;i, &amp;x, name, (rsize_t) 50);</pre>
+ with the input line:
+<pre>
+          25 54.32E-1 thompson</pre>
+ will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+ thompson\0.
+ 
+<p><!--para 8-->
+ EXAMPLE 2        The call:
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdio.h&gt;
+          /* ... */
+          int n; char s[5];
+          n = fscanf_s(stdin, "%s", s, sizeof s);</pre>
+ with the input line:
+<pre>
+          hello</pre>
+ will assign to n the value 0 since a matching failure occurred because the sequence hello\0 requires an
+ array of six characters to store it.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note379">379)</a> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
+ implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
+ constraint violation.
+
+<p><a name="note380">380)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
+ used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
+ argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
+ the format is not known at translation time. For example, an implementation may issue a diagnostic
+ for each argument after format that has of type pointer to one of char, signed char,
+ unsigned char, or void that is not followed by an argument of a type compatible with
+ rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
+ using the hh length modifier, a length argument must follow the pointer argument. Another useful
+ diagnostic could flag any non-pointer argument following format that did not have a type
+ compatible with rsize_t.
+
+
+<a name="K.3.5.3.3" href="#K.3.5.3.3"><h5>K.3.5.3.3 The printf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdio.h&gt;
+          int printf_s(const char * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. The %n specifier<sup><a href="#note381"><b>381)</b></a></sup> (modified or not by flags, field
+ width, or precision) shall not appear in the string pointed to by format. Any argument
+ to printf_s corresponding to a %s specifier shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the printf_s function does not attempt to
+ produce further output, and it is unspecified to what extent printf_s produced output
+ before discovering the runtime-constraint violation.
+ 
+ 
+<!--page 608 indent 4-->
+<h6>Description</h6>
+<p><!--para 4-->
+ The printf_s function is equivalent to the printf function except for the explicit
+ runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The printf_s function returns the number of characters transmitted, or a negative
+ value if an output error, encoding error, or runtime-constraint violation occurred.
+
+<h6>footnotes</h6>
+<p><a name="note381">381)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+
+<a name="K.3.5.3.4" href="#K.3.5.3.4"><h5>K.3.5.3.4 The scanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdio.h&gt;
+        int scanf_s(const char * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. Any argument indirected though in order to store
+ converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the scanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent scanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The scanf_s function is equivalent to fscanf_s with the argument stdin
+ interposed before the arguments to scanf_s.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The scanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ scanf_s function returns the number of input items assigned, which can be fewer than
+ provided for, or even zero, in the event of an early matching failure.
+
+<a name="K.3.5.3.5" href="#K.3.5.3.5"><h5>K.3.5.3.5 The snprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdio.h&gt;
+        int snprintf_s(char * restrict s, rsize_t n,
+             const char * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The %n specifier<sup><a href="#note382"><b>382)</b></a></sup> (modified or not by flags, field width, or
+ precision) shall not appear in the string pointed to by format. Any argument to
+<!--page 609 indent 4-->
+ snprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
+ error shall occur.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the snprintf_s function sets s[0] to the
+ null character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The snprintf_s function is equivalent to the snprintf function except for the
+ explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The snprintf_s function, unlike sprintf_s, will truncate the result to fit within the
+ array pointed to by s.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The snprintf_s function returns the number of characters that would have been
+ written had n been sufficiently large, not counting the terminating null character, or a
+ negative value if a runtime-constraint violation occurred. Thus, the null-terminated
+ output has been completely written if and only if the returned value is nonnegative and
+ less than n.
+
+<h6>footnotes</h6>
+<p><a name="note382">382)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+
+<a name="K.3.5.3.6" href="#K.3.5.3.6"><h5>K.3.5.3.6 The sprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdio.h&gt;
+          int sprintf_s(char * restrict s, rsize_t n,
+               const char * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The number of characters (including the trailing null) required for the
+ result to be written to the array pointed to by s shall not be greater than n. The %n
+ specifier<sup><a href="#note383"><b>383)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+ string pointed to by format. Any argument to sprintf_s corresponding to a %s
+ specifier shall not be a null pointer. No encoding error shall occur.
+ 
+ 
+ 
+<!--page 610 indent 4-->
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the sprintf_s function sets s[0] to the
+ null character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The sprintf_s function is equivalent to the sprintf function except for the
+ parameter n and the explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The sprintf_s function, unlike snprintf_s, treats a result too big for the array
+ pointed to by s as a runtime-constraint violation.
+<h6>Returns</h6>
+<p><!--para 6-->
+ If no runtime-constraint violation occurred, the sprintf_s function returns the number
+ of characters written in the array, not counting the terminating null character. If an
+ encoding error occurred, sprintf_s returns a negative value. If any other runtime-
+ constraint violation occurred, sprintf_s returns zero.
+
+<h6>footnotes</h6>
+<p><a name="note383">383)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+
+<a name="K.3.5.3.7" href="#K.3.5.3.7"><h5>K.3.5.3.7 The sscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdio.h&gt;
+        int sscanf_s(const char * restrict s,
+             const char * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. Any argument indirected though in order
+ to store converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the sscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent sscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The sscanf_s function is equivalent to fscanf_s, except that input is obtained from
+ a string (specified by the argument s) rather than from a stream. Reaching the end of the
+ string is equivalent to encountering end-of-file for the fscanf_s function. If copying
+ takes place between objects that overlap, the objects take on unspecified values.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The sscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ sscanf_s function returns the number of input items assigned, which can be fewer than
+ provided for, or even zero, in the event of an early matching failure.
+<!--page 611 indent 4-->
+
+<a name="K.3.5.3.8" href="#K.3.5.3.8"><h5>K.3.5.3.8 The vfprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdarg.h&gt;
+          #include &lt;stdio.h&gt;
+          int vfprintf_s(FILE * restrict stream,
+               const char * restrict format,
+               va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note384"><b>384)</b></a></sup> (modified or
+ not by flags, field width, or precision) shall not appear in the string pointed to by
+ format. Any argument to vfprintf_s corresponding to a %s specifier shall not be a
+ null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vfprintf_s function does not attempt to
+ produce further output, and it is unspecified to what extent vfprintf_s produced
+ output before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vfprintf_s function is equivalent to the vfprintf function except for the
+ explicit runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vfprintf_s function returns the number of characters transmitted, or a negative
+ value if an output error, encoding error, or runtime-constraint violation occurred.
+
+<h6>footnotes</h6>
+<p><a name="note384">384)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+
+<a name="K.3.5.3.9" href="#K.3.5.3.9"><h5>K.3.5.3.9 The vfscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdarg.h&gt;
+          #include &lt;stdio.h&gt;
+          int vfscanf_s(FILE * restrict stream,
+               const char * restrict format,
+               va_list arg);</pre>
+ 
+ 
+ 
+ 
+<!--page 612 indent 4-->
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. Any argument indirected though in
+ order to store converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vfscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent vfscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vfscanf_s function is equivalent to fscanf_s, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfscanf_s function does not invoke the
+ va_end macro.<sup><a href="#note385"><b>385)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vfscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ vfscanf_s function returns the number of input items assigned, which can be fewer
+ than provided for, or even zero, in the event of an early matching failure.
+
+<h6>footnotes</h6>
+<p><a name="note385">385)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+ vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
+ indeterminate.
+
+
+<a name="K.3.5.3.10" href="#K.3.5.3.10"><h5>K.3.5.3.10 The vprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdarg.h&gt;
+          #include &lt;stdio.h&gt;
+          int vprintf_s(const char * restrict format,
+               va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. The %n specifier<sup><a href="#note386"><b>386)</b></a></sup> (modified or not by flags, field
+ width, or precision) shall not appear in the string pointed to by format. Any argument
+ to vprintf_s corresponding to a %s specifier shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vprintf_s function does not attempt to
+ produce further output, and it is unspecified to what extent vprintf_s produced output
+ before discovering the runtime-constraint violation.
+ 
+<!--page 613 indent 4-->
+<h6>Description</h6>
+<p><!--para 4-->
+ The vprintf_s function is equivalent to the vprintf function except for the explicit
+ runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vprintf_s function returns the number of characters transmitted, or a negative
+ value if an output error, encoding error, or runtime-constraint violation occurred.
+
+<h6>footnotes</h6>
+<p><a name="note386">386)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+
+<a name="K.3.5.3.11" href="#K.3.5.3.11"><h5>K.3.5.3.11 The vscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         int vscanf_s(const char * restrict format,
+              va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. Any argument indirected though in order to store
+ converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent vscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vscanf_s function is equivalent to scanf_s, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vscanf_s function does not invoke the
+ va_end macro.<sup><a href="#note387"><b>387)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ vscanf_s function returns the number of input items assigned, which can be fewer than
+ provided for, or even zero, in the event of an early matching failure.
+ 
+ 
+ 
+ 
+<!--page 614 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note387">387)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+ vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
+ indeterminate.
+
+
+<a name="K.3.5.3.12" href="#K.3.5.3.12"><h5>K.3.5.3.12 The vsnprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdarg.h&gt;
+          #include &lt;stdio.h&gt;
+          int vsnprintf_s(char * restrict s, rsize_t n,
+               const char * restrict format,
+               va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The %n specifier<sup><a href="#note388"><b>388)</b></a></sup> (modified or not by flags, field width, or
+ precision) shall not appear in the string pointed to by format. Any argument to
+ vsnprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
+ error shall occur.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the vsnprintf_s function sets s[0] to the
+ null character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vsnprintf_s function is equivalent to the vsnprintf function except for the
+ explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The vsnprintf_s function, unlike vsprintf_s, will truncate the result to fit within
+ the array pointed to by s.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The vsnprintf_s function returns the number of characters that would have been
+ written had n been sufficiently large, not counting the terminating null character, or a
+ negative value if a runtime-constraint violation occurred. Thus, the null-terminated
+ output has been completely written if and only if the returned value is nonnegative and
+ less than n.
+ 
+ 
+ 
+ 
+<!--page 615 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note388">388)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+
+<a name="K.3.5.3.13" href="#K.3.5.3.13"><h5>K.3.5.3.13 The vsprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdarg.h&gt;
+          #include &lt;stdio.h&gt;
+          int vsprintf_s(char * restrict s, rsize_t n,
+               const char * restrict format,
+               va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The number of characters (including the trailing null) required for the
+ result to be written to the array pointed to by s shall not be greater than n. The %n
+ specifier<sup><a href="#note389"><b>389)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+ string pointed to by format. Any argument to vsprintf_s corresponding to a %s
+ specifier shall not be a null pointer. No encoding error shall occur.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the vsprintf_s function sets s[0] to the
+ null character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vsprintf_s function is equivalent to the vsprintf function except for the
+ parameter n and the explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The vsprintf_s function, unlike vsnprintf_s, treats a result too big for the array
+ pointed to by s as a runtime-constraint violation.
+<h6>Returns</h6>
+<p><!--para 6-->
+ If no runtime-constraint violation occurred, the vsprintf_s function returns the
+ number of characters written in the array, not counting the terminating null character. If
+ an encoding error occurred, vsprintf_s returns a negative value. If any other
+ runtime-constraint violation occurred, vsprintf_s returns zero.
+ 
+ 
+ 
+ 
+<!--page 616 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note389">389)</a> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+ at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+ format string was %%n.
+
+
+<a name="K.3.5.3.14" href="#K.3.5.3.14"><h5>K.3.5.3.14 The vsscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdarg.h&gt;
+        #include &lt;stdio.h&gt;
+        int vsscanf_s(const char * restrict s,
+             const char * restrict format,
+             va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. Any argument indirected though in order
+ to store converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vsscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent vsscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vsscanf_s function is equivalent to sscanf_s, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vsscanf_s function does not invoke the
+ va_end macro.<sup><a href="#note390"><b>390)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vsscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ vscanf_s function returns the number of input items assigned, which can be fewer than
+ provided for, or even zero, in the event of an early matching failure.
+
+<h6>footnotes</h6>
+<p><a name="note390">390)</a> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+ vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
+ indeterminate.
+
+
+<a name="K.3.5.4" href="#K.3.5.4"><h5>K.3.5.4 Character input/output functions</h5></a>
+
+<a name="K.3.5.4.1" href="#K.3.5.4.1"><h5>K.3.5.4.1 The gets_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;stdio.h&gt;
+        char *gets_s(char *s, rsize_t n);</pre>
+ 
+ 
+ 
+ 
+<!--page 617 indent 4-->
+ Runtime-constraints
+<p><!--para 2-->
+ s shall not be a null pointer. n shall neither be equal to zero nor be greater than
+ RSIZE_MAX. A new-line character, end-of-file, or read error shall occur within reading
+ n-1 characters from stdin.<sup><a href="#note391"><b>391)</b></a></sup>
+<p><!--para 3-->
+ If there is a runtime-constraint violation, s[0] is set to the null character, and characters
+ are read and discarded from stdin until a new-line character is read, or end-of-file or a
+ read error occurs.
+<h6>Description</h6>
+<p><!--para 4-->
+ The gets_s function reads at most one less than the number of characters specified by n
+ from the stream pointed to by stdin, into the array pointed to by s. No additional
+ characters are read after a new-line character (which is discarded) or after end-of-file.
+ The discarded new-line character does not count towards number of characters read. A
+ null character is written immediately after the last character read into the array.
+<p><!--para 5-->
+ If end-of-file is encountered and no characters have been read into the array, or if a read
+ error occurs during the operation, then s[0] is set to the null character, and the other
+ elements of s take unspecified values.
+ Recommended practice
+<p><!--para 6-->
+ The fgets function allows properly-written programs to safely process input lines too
+ long to store in the result array. In general this requires that callers of fgets pay
+ attention to the presence or absence of a new-line character in the result array. Consider
+ using fgets (along with any needed processing based on new-line characters) instead of
+ gets_s.
+<h6>Returns</h6>
+<p><!--para 7-->
+ The gets_s function returns s if successful. If there was a runtime-constraint violation,
+ or if end-of-file is encountered and no characters have been read into the array, or if a
+ read error occurs during the operation, then a null pointer is returned.
+ 
+ 
+ 
+ 
+<!--page 618 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note391">391)</a> The gets_s function, unlike the historical gets function, makes it a runtime-constraint violation for
+ a line of input to overflow the buffer to store it. Unlike the fgets function, gets_s maintains a
+ one-to-one relationship between input lines and successful calls to gets_s. Programs that use gets
+ expect such a relationship.
+
+
+<a name="K.3.6" href="#K.3.6"><h4>K.3.6 General utilities <stdlib.h></h4></a>
+<p><!--para 1-->
+ The header &lt;stdlib.h&gt; defines three types.
+<p><!--para 2-->
+ The types are
+<pre>
+         errno_t</pre>
+ which is type int; and
+<pre>
+         rsize_t</pre>
+ which is the type size_t; and
+<pre>
+         constraint_handler_t</pre>
+ which has the following definition
+<pre>
+         typedef void (*constraint_handler_t)(
+              const char * restrict msg,
+              void * restrict ptr,
+              errno_t error);</pre>
+
+<a name="K.3.6.1" href="#K.3.6.1"><h5>K.3.6.1 Runtime-constraint handling</h5></a>
+
+<a name="K.3.6.1.1" href="#K.3.6.1.1"><h5>K.3.6.1.1 The set_constraint_handler_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdlib.h&gt;
+         constraint_handler_t set_constraint_handler_s(
+              constraint_handler_t handler);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The set_constraint_handler_s function sets the runtime-constraint handler to
+ be handler. The runtime-constraint handler is the function to be called when a library
+ function detects a runtime-constraint violation. Only the most recent handler registered
+ with set_constraint_handler_s is called when a runtime-constraint violation
+ occurs.
+<p><!--para 3-->
+ When the handler is called, it is passed the following arguments in the following order:
+<ol>
+<li>  A pointer to a character string describing the runtime-constraint violation.
+<li>  A null pointer or a pointer to an implementation defined object.
+<li>  If the function calling the handler has a return type declared as errno_t, the
+ return value of the function is passed. Otherwise, a positive value of type
+ errno_t is passed.
+<!--page 619 indent 4-->
+</ol>
+<p><!--para 4-->
+ The implementation has a default constraint handler that is used if no calls to the
+ set_constraint_handler_s function have been made. The behavior of the
+ default handler is implementation-defined, and it may cause the program to exit or abort.
+<p><!--para 5-->
+ If the handler argument to set_constraint_handler_s is a null pointer, the
+ implementation default handler becomes the current constraint handler.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The set_constraint_handler_s function returns a pointer to the previously
+ registered handler.<sup><a href="#note392"><b>392)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note392">392)</a> If the previous handler was registered by calling set_constraint_handler_s with a null
+ pointer argument, a pointer to the implementation default handler is returned (not NULL).
+
+
+<a name="K.3.6.1.2" href="#K.3.6.1.2"><h5>K.3.6.1.2 The abort_handler_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdlib.h&gt;
+         void abort_handler_s(
+              const char * restrict msg,
+              void * restrict ptr,
+              errno_t error);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A pointer to the abort_handler_s function shall be a suitable argument to the
+ set_constraint_handler_s function.
+<p><!--para 3-->
+ The abort_handler_s function writes a message on the standard error stream in an
+ implementation-defined format. The message shall include the string pointed to by msg.
+ The abort_handler_s function then calls the abort function.<sup><a href="#note393"><b>393)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The abort_handler_s function does not return to its caller.
+ 
+ 
+ 
+ 
+<!--page 620 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note393">393)</a> Many implementations invoke a debugger when the abort function is called.
+
+
+<a name="K.3.6.1.3" href="#K.3.6.1.3"><h5>K.3.6.1.3 The ignore_handler_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdlib.h&gt;
+         void ignore_handler_s(
+              const char * restrict msg,
+              void * restrict ptr,
+              errno_t error);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ A pointer to the ignore_handler_s function shall be a suitable argument to the
+ set_constraint_handler_s function.
+<p><!--para 3-->
+ The ignore_handler_s function simply returns to its caller.<sup><a href="#note394"><b>394)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 4-->
+ The ignore_handler_s function returns no value.
+
+<h6>footnotes</h6>
+<p><a name="note394">394)</a> If the runtime-constraint handler is set to the ignore_handler_s function, any library function in
+ which a runtime-constraint violation occurs will return to its caller. The caller can determine whether
+ a runtime-constraint violation occurred based on the library function's specification (usually, the
+ library function returns a nonzero errno_t).
+
+
+<a name="K.3.6.2" href="#K.3.6.2"><h5>K.3.6.2 Communication with the environment</h5></a>
+
+<a name="K.3.6.2.1" href="#K.3.6.2.1"><h5>K.3.6.2.1 The getenv_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdlib.h&gt;
+         errno_t getenv_s(size_t * restrict len,
+                    char * restrict value, rsize_t maxsize,
+                    const char * restrict name);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ name shall not be a null pointer. maxsize shall neither equal zero nor be greater than
+ RSIZE_MAX. If maxsize is not equal to zero, then value shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the integer pointed to by len is set to 0 (if len
+ is not null), and the environment list is not searched.
+<h6>Description</h6>
+<p><!--para 4-->
+ The getenv_s function searches an environment list, provided by the host environment,
+ for a string that matches the string pointed to by name.
+ 
+ 
+<!--page 621 indent 4-->
+<p><!--para 5-->
+ If that name is found then getenv_s performs the following actions. If len is not a
+ null pointer, the length of the string associated with the matched list member is stored in
+ the integer pointed to by len. If the length of the associated string is less than maxsize,
+ then the associated string is copied to the array pointed to by value.
+<p><!--para 6-->
+ If that name is not found then getenv_s performs the following actions. If len is not
+ a null pointer, zero is stored in the integer pointed to by len. If maxsize is greater than
+ zero, then value[0] is set to the null character.
+<p><!--para 7-->
+ The set of environment names and the method for altering the environment list are
+ implementation-defined.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The getenv_s function returns zero if the specified name is found and the associated
+ string was successfully stored in value. Otherwise, a nonzero value is returned.
+
+<a name="K.3.6.3" href="#K.3.6.3"><h5>K.3.6.3 Searching and sorting utilities</h5></a>
+<p><!--para 1-->
+ These utilities make use of a comparison function to search or sort arrays of unspecified
+ type. Where an argument declared as size_t nmemb specifies the length of the array
+ for a function, if nmemb has the value zero on a call to that function, then the comparison
+ function is not called, a search finds no matching element, sorting performs no
+ rearrangement, and the pointer to the array may be null.
+<p><!--para 2-->
+ The implementation shall ensure that the second argument of the comparison function
+ (when called from bsearch_s), or both arguments (when called from qsort_s), are
+ pointers to elements of the array.<sup><a href="#note395"><b>395)</b></a></sup> The first argument when called from bsearch_s
+ shall equal key.
+<p><!--para 3-->
+ The comparison function shall not alter the contents of either the array or search key. The
+ implementation may reorder elements of the array between calls to the comparison
+ function, but shall not otherwise alter the contents of any individual element.
+<p><!--para 4-->
+ When the same objects (consisting of size bytes, irrespective of their current positions
+ in the array) are passed more than once to the comparison function, the results shall be
+ consistent with one another. That is, for qsort_s they shall define a total ordering on
+ the array, and for bsearch_s the same object shall always compare the same way with
+ the key.
+ 
+ 
+ 
+ 
+<!--page 622 indent 4-->
+<p><!--para 5-->
+ A sequence point occurs immediately before and immediately after each call to the
+ comparison function, and also between any call to the comparison function and any
+ movement of the objects passed as arguments to that call.
+
+<h6>footnotes</h6>
+<p><a name="note395">395)</a> That is, if the value passed is p, then the following expressions are always valid and nonzero:
+
+<pre>
+          ((char *)p - (char *)base) % size == 0
+          (char *)p &gt;= (char *)base
+          (char *)p &lt; (char *)base + nmemb * size</pre>
+
+
+<a name="K.3.6.3.1" href="#K.3.6.3.1"><h5>K.3.6.3.1 The bsearch_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;stdlib.h&gt;
+          void *bsearch_s(const void *key, const void *base,
+               rsize_t nmemb, rsize_t size,
+               int (*compar)(const void *k, const void *y,
+                               void *context),
+               void *context);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
+ zero, then none of key, base, or compar shall be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the bsearch_s function does not search the
+ array.
+<h6>Description</h6>
+<p><!--para 4-->
+ The bsearch_s function searches an array of nmemb objects, the initial element of
+ which is pointed to by base, for an element that matches the object pointed to by key.
+ The size of each element of the array is specified by size.
+<p><!--para 5-->
+ The comparison function pointed to by compar is called with three arguments. The first
+ two point to the key object and to an array element, in that order. The function shall
+ return an integer less than, equal to, or greater than zero if the key object is considered,
+ respectively, to be less than, to match, or to be greater than the array element. The array
+ shall consist of: all the elements that compare less than, all the elements that compare
+ equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note396"><b>396)</b></a></sup>
+ The third argument to the comparison function is the context argument passed to
+ bsearch_s. The sole use of context by bsearch_s is to pass it to the comparison
+ function.<sup><a href="#note397"><b>397)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 623 indent 4-->
+<h6>Returns</h6>
+<p><!--para 6-->
+ The bsearch_s function returns a pointer to a matching element of the array, or a null
+ pointer if no match is found or there is a runtime-constraint violation. If two elements
+ compare as equal, which element is matched is unspecified.
+
+<h6>footnotes</h6>
+<p><a name="note396">396)</a> In practice, this means that the entire array has been sorted according to the comparison function.
+
+<p><a name="note397">397)</a> The context argument is for the use of the comparison function in performing its duties. For
+ example, it might specify a collating sequence used by the comparison function.
+
+
+<a name="K.3.6.3.2" href="#K.3.6.3.2"><h5>K.3.6.3.2 The qsort_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdlib.h&gt;
+         errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
+              int (*compar)(const void *x, const void *y,
+                              void *context),
+              void *context);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
+ zero, then neither base nor compar shall be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the qsort_s function does not sort the array.
+<h6>Description</h6>
+<p><!--para 4-->
+ The qsort_s function sorts an array of nmemb objects, the initial element of which is
+ pointed to by base. The size of each object is specified by size.
+<p><!--para 5-->
+ The contents of the array are sorted into ascending order according to a comparison
+ function pointed to by compar, which is called with three arguments. The first two
+ point to the objects being compared. The function shall return an integer less than, equal
+ to, or greater than zero if the first argument is considered to be respectively less than,
+ equal to, or greater than the second. The third argument to the comparison function is the
+ context argument passed to qsort_s. The sole use of context by qsort_s is to
+ pass it to the comparison function.<sup><a href="#note398"><b>398)</b></a></sup>
+<p><!--para 6-->
+ If two elements compare as equal, their relative order in the resulting sorted array is
+ unspecified.
+<h6>Returns</h6>
+<p><!--para 7-->
+ The qsort_s function returns zero if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+ 
+ 
+ 
+ 
+<!--page 624 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note398">398)</a> The context argument is for the use of the comparison function in performing its duties. For
+ example, it might specify a collating sequence used by the comparison function.
+
+
+<a name="K.3.6.4" href="#K.3.6.4"><h5>K.3.6.4 Multibyte/wide character conversion functions</h5></a>
+<p><!--para 1-->
+ The behavior of the multibyte character functions is affected by the LC_CTYPE category
+ of the current locale. For a state-dependent encoding, each function is placed into its
+ initial conversion state by a call for which its character pointer argument, s, is a null
+ pointer. Subsequent calls with s as other than a null pointer cause the internal conversion
+ state of the function to be altered as necessary. A call with s as a null pointer causes
+ these functions to set the int pointed to by their status argument to a nonzero value if
+ encodings have state dependency, and zero otherwise.<sup><a href="#note399"><b>399)</b></a></sup> Changing the LC_CTYPE
+ category causes the conversion state of these functions to be indeterminate.
+
+<h6>footnotes</h6>
+<p><a name="note399">399)</a> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+ character codes, but are grouped with an adjacent multibyte character.
+
+
+<a name="K.3.6.4.1" href="#K.3.6.4.1"><h5>K.3.6.4.1 The wctomb_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdlib.h&gt;
+         errno_t wctomb_s(int * restrict status,
+              char * restrict s,
+              rsize_t smax,
+              wchar_t wc);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Let n denote the number of bytes needed to represent the multibyte character
+ corresponding to the wide character given by wc (including any shift sequences).
+<p><!--para 3-->
+ If s is not a null pointer, then smax shall not be less than n, and smax shall not be
+ greater than RSIZE_MAX. If s is a null pointer, then smax shall equal zero.
+<p><!--para 4-->
+ If there is a runtime-constraint violation, wctomb_s does not modify the int pointed to
+ by status, and if s is not a null pointer, no more than smax elements in the array
+ pointed to by s will be accessed.
+<h6>Description</h6>
+<p><!--para 5-->
+ The wctomb_s function determines n and stores the multibyte character representation
+ of wc in the array whose first element is pointed to by s (if s is not a null pointer). The
+ number of characters stored never exceeds MB_CUR_MAX or smax. If wc is a null wide
+ character, a null byte is stored, preceded by any shift sequence needed to restore the
+ initial shift state, and the function is left in the initial conversion state.
+<p><!--para 6-->
+ The implementation shall behave as if no library function calls the wctomb_s function.
+ 
+ 
+ 
+ 
+<!--page 625 indent 5-->
+<p><!--para 7-->
+ If s is a null pointer, the wctomb_s function stores into the int pointed to by status a
+ nonzero or zero value, if multibyte character encodings, respectively, do or do not have
+ state-dependent encodings.
+<p><!--para 8-->
+ If s is not a null pointer, the wctomb_s function stores into the int pointed to by
+ status either n or -1 if wc, respectively, does or does not correspond to a valid
+ multibyte character.
+<p><!--para 9-->
+ In no case will the int pointed to by status be set to a value greater than the
+ MB_CUR_MAX macro.
+<h6>Returns</h6>
+<p><!--para 10-->
+ The wctomb_s function returns zero if successful, and a nonzero value if there was a
+ runtime-constraint violation or wc did not correspond to a valid multibyte character.
+
+<a name="K.3.6.5" href="#K.3.6.5"><h5>K.3.6.5 Multibyte/wide string conversion functions</h5></a>
+<p><!--para 1-->
+ The behavior of the multibyte string functions is affected by the LC_CTYPE category of
+ the current locale.
+
+<a name="K.3.6.5.1" href="#K.3.6.5.1"><h5>K.3.6.5.1 The mbstowcs_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #include &lt;stdlib.h&gt;
+         errno_t mbstowcs_s(size_t * restrict retval,
+              wchar_t * restrict dst, rsize_t dstmax,
+              const char * restrict src, rsize_t len);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
+ neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
+ then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
+ zero. If dst is not a null pointer and len is not less than dstmax, then a null character
+ shall occur within the first dstmax multibyte characters of the array pointed to by src.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then mbstowcs_s does the following. If
+ retval is not a null pointer, then mbstowcs_s sets *retval to (size_t)(-1). If
+ dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+ then mbstowcs_s sets dst[0] to the null wide character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The mbstowcs_s function converts a sequence of multibyte characters that begins in
+ the initial shift state from the array pointed to by src into a sequence of corresponding
+ wide characters. If dst is not a null pointer, the converted characters are stored into the
+ array pointed to by dst. Conversion continues up to and including a terminating null
+ character, which is also stored. Conversion stops earlier in two cases: when a sequence of
+<!--page 626 indent 4-->
+ bytes is encountered that does not form a valid multibyte character, or (if dst is not a
+ null pointer) when len wide characters have been stored into the array pointed to by
+ dst.<sup><a href="#note400"><b>400)</b></a></sup> If dst is not a null pointer and no null wide character was stored into the array
+ pointed to by dst, then dst[len] is set to the null wide character. Each conversion
+ takes place as if by a call to the mbrtowc function.
+<p><!--para 5-->
+ Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+ sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
+ the mbstowcs_s function stores the value (size_t)(-1) into *retval.
+ Otherwise, the mbstowcs_s function stores into *retval the number of multibyte
+ characters successfully converted, not including the terminating null character (if any).
+<p><!--para 6-->
+ All elements following the terminating null wide character (if any) written by
+ mbstowcs_s in the array of dstmax wide characters pointed to by dst take
+ unspecified values when mbstowcs_s returns.<sup><a href="#note401"><b>401)</b></a></sup>
+<p><!--para 7-->
+ If copying takes place between objects that overlap, the objects take on unspecified
+ values.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The mbstowcs_s function returns zero if no runtime-constraint violation and no
+ encoding error occurred. Otherwise, a nonzero value is returned.
+
+<h6>footnotes</h6>
+<p><a name="note400">400)</a> Thus, the value of len is ignored if dst is a null pointer.
+
+<p><a name="note401">401)</a> This allows an implementation to attempt converting the multibyte string before discovering a
+ terminating null character did not occur where required.
+
+
+<a name="K.3.6.5.2" href="#K.3.6.5.2"><h5>K.3.6.5.2 The wcstombs_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #include &lt;stdlib.h&gt;
+          errno_t wcstombs_s(size_t * restrict retval,
+               char * restrict dst, rsize_t dstmax,
+               const wchar_t * restrict src, rsize_t len);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
+ neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
+ then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
+ zero. If dst is not a null pointer and len is not less than dstmax, then the conversion
+ shall have been stopped (see below) because a terminating null wide character was
+ reached or because an encoding error occurred.
+ 
+ 
+ 
+ 
+<!--page 627 indent 4-->
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then wcstombs_s does the following. If
+ retval is not a null pointer, then wcstombs_s sets *retval to (size_t)(-1). If
+ dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+ then wcstombs_s sets dst[0] to the null character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The wcstombs_s function converts a sequence of wide characters from the array
+ pointed to by src into a sequence of corresponding multibyte characters that begins in
+ the initial shift state. If dst is not a null pointer, the converted characters are then stored
+ into the array pointed to by dst. Conversion continues up to and including a terminating
+ null wide character, which is also stored. Conversion stops earlier in two cases:
+<ul>
+<li>  when a wide character is reached that does not correspond to a valid multibyte
+ character;
+<li>  (if dst is not a null pointer) when the next multibyte character would exceed the
+   limit of n total bytes to be stored into the array pointed to by dst. If the wide
+   character being converted is the null wide character, then n is the lesser of len or
+   dstmax. Otherwise, n is the lesser of len or dstmax-1.
+</ul>
+ If the conversion stops without converting a null wide character and dst is not a null
+ pointer, then a null character is stored into the array pointed to by dst immediately
+ following any multibyte characters already stored. Each conversion takes place as if by a
+ call to the wcrtomb function.<sup><a href="#note402"><b>402)</b></a></sup>
+<p><!--para 5-->
+ Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+ wide character that does not correspond to a valid multibyte character, an encoding error
+ occurs: the wcstombs_s function stores the value (size_t)(-1) into *retval.
+ Otherwise, the wcstombs_s function stores into *retval the number of bytes in the
+ resulting multibyte character sequence, not including the terminating null character (if
+ any).
+<p><!--para 6-->
+ All elements following the terminating null character (if any) written by wcstombs_s
+ in the array of dstmax elements pointed to by dst take unspecified values when
+ wcstombs_s returns.<sup><a href="#note403"><b>403)</b></a></sup>
+<p><!--para 7-->
+ If copying takes place between objects that overlap, the objects take on unspecified
+ values.
+ 
+ 
+<!--page 628 indent 4-->
+<h6>Returns</h6>
+<p><!--para 8-->
+ The wcstombs_s function returns zero if no runtime-constraint violation and no
+ encoding error occurred. Otherwise, a nonzero value is returned.
+
+<h6>footnotes</h6>
+<p><a name="note402">402)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
+ include those necessary to reach the initial shift state immediately before the null byte. However, if
+ the conversion stops before a terminating null wide character has been reached, the result will be null
+ terminated, but might not end in the initial shift state.
+
+<p><a name="note403">403)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
+ runtime-constraint violation.
+
+
+<a name="K.3.7" href="#K.3.7"><h4>K.3.7 String handling <string.h></h4></a>
+<p><!--para 1-->
+ The header &lt;string.h&gt; defines two types.
+<p><!--para 2-->
+ The types are
+<pre>
+        errno_t</pre>
+ which is type int; and
+<pre>
+        rsize_t</pre>
+ which is the type size_t.
+
+<a name="K.3.7.1" href="#K.3.7.1"><h5>K.3.7.1 Copying functions</h5></a>
+
+<a name="K.3.7.1.1" href="#K.3.7.1.1"><h5>K.3.7.1.1 The memcpy_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;string.h&gt;
+        errno_t memcpy_s(void * restrict s1, rsize_t s1max,
+             const void * restrict s2, rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
+ objects that overlap.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the memcpy_s function stores zeros in the first
+ s1max characters of the object pointed to by s1 if s1 is not a null pointer and s1max is
+ not greater than RSIZE_MAX.
+<h6>Description</h6>
+<p><!--para 4-->
+ The memcpy_s function copies n characters from the object pointed to by s2 into the
+ object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The memcpy_s function returns zero if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+<!--page 629 indent 4-->
+
+<a name="K.3.7.1.2" href="#K.3.7.1.2"><h5>K.3.7.1.2 The memmove_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         errno_t memmove_s(void *s1, rsize_t s1max,
+              const void *s2, rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. n shall not be greater than s1max.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the memmove_s function stores zeros in the
+ first s1max characters of the object pointed to by s1 if s1 is not a null pointer and
+ s1max is not greater than RSIZE_MAX.
+<h6>Description</h6>
+<p><!--para 4-->
+ The memmove_s function copies n characters from the object pointed to by s2 into the
+ object pointed to by s1. This copying takes place as if the n characters from the object
+ pointed to by s2 are first copied into a temporary array of n characters that does not
+ overlap the objects pointed to by s1 or s2, and then the n characters from the temporary
+ array are copied into the object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The memmove_s function returns zero if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+
+<a name="K.3.7.1.3" href="#K.3.7.1.3"><h5>K.3.7.1.3 The strcpy_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         errno_t strcpy_s(char * restrict s1,
+              rsize_t s1max,
+              const char * restrict s2);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+ s1max shall not equal zero. s1max shall be greater than strnlen_s(s2, s1max).
+ Copying shall not take place between objects that overlap.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then strcpy_s sets s1[0] to the
+ null character.
+<!--page 630 indent 4-->
+<h6>Description</h6>
+<p><!--para 4-->
+ The strcpy_s function copies the string pointed to by s2 (including the terminating
+ null character) into the array pointed to by s1.
+<p><!--para 5-->
+ All elements following the terminating null character (if any) written by strcpy_s in
+ the array of s1max characters pointed to by s1 take unspecified values when
+ strcpy_s returns.<sup><a href="#note404"><b>404)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 6-->
+ The strcpy_s function returns zero<sup><a href="#note405"><b>405)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+
+<h6>footnotes</h6>
+<p><a name="note404">404)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
+ any of those characters are null. Such an approach might write a character to every element of s1
+ before discovering that the first element should be set to the null character.
+
+<p><a name="note405">405)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
+ within the array pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.7.1.4" href="#K.3.7.1.4"><h5>K.3.7.1.4 The strncpy_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         errno_t strncpy_s(char * restrict s1,
+              rsize_t s1max,
+              const char * restrict s2,
+              rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
+ shall be greater than strnlen_s(s2, s1max). Copying shall not take place between
+ objects that overlap.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then strncpy_s sets s1[0] to the
+ null character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The strncpy_s function copies not more than n successive characters (characters that
+ follow a null character are not copied) from the array pointed to by s2 to the array
+ pointed to by s1. If no null character was copied from s2, then s1[n] is set to a null
+ character.
+ 
+ 
+<!--page 631 indent 4-->
+<p><!--para 5-->
+ All elements following the terminating null character (if any) written by strncpy_s in
+ the array of s1max characters pointed to by s1 take unspecified values when
+ strncpy_s returns.<sup><a href="#note406"><b>406)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 6-->
+ The strncpy_s function returns zero<sup><a href="#note407"><b>407)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+<p><!--para 7-->
+ EXAMPLE 1 The strncpy_s function can be used to copy a string without the danger that the result
+ will not be null terminated or that characters will be written past the end of the destination array.
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         /* ... */
+         char src1[100] = "hello";
+         char src2[7] = {'g', 'o', 'o', 'd', 'b', 'y', 'e'};
+         char dst1[6], dst2[5], dst3[5];
+         int r1, r2, r3;
+         r1 = strncpy_s(dst1, 6, src1, 100);
+         r2 = strncpy_s(dst2, 5, src2, 7);
+         r3 = strncpy_s(dst3, 5, src2, 4);</pre>
+ The first call will assign to r1 the value zero and to dst1 the sequence hello\0.
+ The second call will assign to r2 a nonzero value and to dst2 the sequence \0.
+ The third call will assign to r3 the value zero and to dst3 the sequence good\0.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note406">406)</a> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
+ any of those characters are null. Such an approach might write a character to every element of s1
+ before discovering that the first element should be set to the null character.
+
+<p><a name="note407">407)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
+ within the array pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.7.2" href="#K.3.7.2"><h5>K.3.7.2 Concatenation functions</h5></a>
+
+<a name="K.3.7.2.1" href="#K.3.7.2.1"><h5>K.3.7.2.1 The strcat_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         errno_t strcat_s(char * restrict s1,
+              rsize_t s1max,
+              const char * restrict s2);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
+ strcat_s.
+ 
+ 
+ 
+ 
+<!--page 632 indent 4-->
+<p><!--para 3-->
+ Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+ s1max shall not equal zero. m shall not equal zero.<sup><a href="#note408"><b>408)</b></a></sup> m shall be greater than
+ strnlen_s(s2, m). Copying shall not take place between objects that overlap.
+<p><!--para 4-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then strcat_s sets s1[0] to the
+ null character.
+<h6>Description</h6>
+<p><!--para 5-->
+ The strcat_s function appends a copy of the string pointed to by s2 (including the
+ terminating null character) to the end of the string pointed to by s1. The initial character
+ from s2 overwrites the null character at the end of s1.
+<p><!--para 6-->
+ All elements following the terminating null character (if any) written by strcat_s in
+ the array of s1max characters pointed to by s1 take unspecified values when
+ strcat_s returns.<sup><a href="#note409"><b>409)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 7-->
+ The strcat_s function returns zero<sup><a href="#note410"><b>410)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+
+<h6>footnotes</h6>
+<p><a name="note408">408)</a> Zero means that s1 was not null terminated upon entry to strcat_s.
+
+<p><a name="note409">409)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
+ any of those characters are null. Such an approach might write a character to every element of s1
+ before discovering that the first element should be set to the null character.
+
+<p><a name="note410">410)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
+ appended to the string pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.7.2.2" href="#K.3.7.2.2"><h5>K.3.7.2.2 The strncat_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         errno_t strncat_s(char * restrict s1,
+              rsize_t s1max,
+              const char * restrict s2,
+              rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
+ strncat_s.
+<p><!--para 3-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note411"><b>411)</b></a></sup> If n is not less
+ 
+ 
+<!--page 633 indent 4-->
+ than m, then m shall be greater than strnlen_s(s2, m). Copying shall not take
+ place between objects that overlap.
+<p><!--para 4-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then strncat_s sets s1[0] to the
+ null character.
+<h6>Description</h6>
+<p><!--para 5-->
+ The strncat_s function appends not more than n successive characters (characters
+ that follow a null character are not copied) from the array pointed to by s2 to the end of
+ the string pointed to by s1. The initial character from s2 overwrites the null character at
+ the end of s1. If no null character was copied from s2, then s1[s1max-m+n] is set to
+ a null character.
+<p><!--para 6-->
+ All elements following the terminating null character (if any) written by strncat_s in
+ the array of s1max characters pointed to by s1 take unspecified values when
+ strncat_s returns.<sup><a href="#note412"><b>412)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 7-->
+ The strncat_s function returns zero<sup><a href="#note413"><b>413)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+<p><!--para 8-->
+ EXAMPLE 1 The strncat_s function can be used to copy a string without the danger that the result
+ will not be null terminated or that characters will be written past the end of the destination array.
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         /* ... */
+         char s1[100] = "good";
+         char s2[6] = "hello";
+         char s3[6] = "hello";
+         char s4[7] = "abc";
+         char s5[1000] = "bye";
+         int r1, r2, r3, r4;
+         r1 = strncat_s(s1, 100, s5, 1000);
+         r2 = strncat_s(s2, 6, "", 1);
+         r3 = strncat_s(s3, 6, "X", 2);
+         r4 = strncat_s(s4, 7, "defghijklmn", 3);</pre>
+ After the first call r1 will have the value zero and s1 will contain the sequence goodbye\0.
+ 
+ 
+ 
+<!--page 634 indent 4-->
+ After the second call r2 will have the value zero and s2 will contain the sequence hello\0.
+ After the third call r3 will have a nonzero value and s3 will contain the sequence \0.
+ After the fourth call r4 will have the value zero and s4 will contain the sequence abcdef\0.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note411">411)</a> Zero means that s1 was not null terminated upon entry to strncat_s.
+
+<p><a name="note412">412)</a> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
+ any of those characters are null. Such an approach might write a character to every element of s1
+ before discovering that the first element should be set to the null character.
+
+<p><a name="note413">413)</a> A zero return value implies that all of the requested characters from the string pointed to by s2 were
+ appended to the string pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.7.3" href="#K.3.7.3"><h5>K.3.7.3 Search functions</h5></a>
+
+<a name="K.3.7.3.1" href="#K.3.7.3.1"><h5>K.3.7.3.1 The strtok_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         char *strtok_s(char * restrict s1,
+              rsize_t * restrict s1max,
+              const char * restrict s2,
+              char ** restrict ptr);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
+ shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
+ The end of the token found shall occur within the first *s1max characters of s1 for the
+ first call, and shall occur within the first *s1max characters of where searching resumes
+ on subsequent calls.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the strtok_s function does not indirect
+ through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
+<h6>Description</h6>
+<p><!--para 4-->
+ A sequence of calls to the strtok_s function breaks the string pointed to by s1 into a
+ sequence of tokens, each of which is delimited by a character from the string pointed to
+ by s2. The fourth argument points to a caller-provided char pointer into which the
+ strtok_s function stores information necessary for it to continue scanning the same
+ string.
+<p><!--para 5-->
+ The first call in a sequence has a non-null first argument and s1max points to an object
+ whose value is the number of elements in the character array pointed to by the first
+ argument. The first call stores an initial value in the object pointed to by ptr and
+ updates the value pointed to by s1max to reflect the number of elements that remain in
+ relation to ptr. Subsequent calls in the sequence have a null first argument and the
+ objects pointed to by s1max and ptr are required to have the values stored by the
+ previous call in the sequence, which are then updated. The separator string pointed to by
+ s2 may be different from call to call.
+<p><!--para 6-->
+ The first call in the sequence searches the string pointed to by s1 for the first character
+ that is not contained in the current separator string pointed to by s2. If no such character
+ is found, then there are no tokens in the string pointed to by s1 and the strtok_s
+ function returns a null pointer. If such a character is found, it is the start of the first token.
+<!--page 635 indent 5-->
+<p><!--para 7-->
+ The strtok_s function then searches from there for the first character in s1 that is
+ contained in the current separator string. If no such character is found, the current token
+ extends to the end of the string pointed to by s1, and subsequent searches in the same
+ string for a token return a null pointer. If such a character is found, it is overwritten by a
+ null character, which terminates the current token.
+<p><!--para 8-->
+ In all cases, the strtok_s function stores sufficient information in the pointer pointed
+ to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+ value for ptr, shall start searching just past the element overwritten by a null character
+ (if any).
+<h6>Returns</h6>
+<p><!--para 9-->
+ The strtok_s function returns a pointer to the first character of a token, or a null
+ pointer if there is no token or there is a runtime-constraint violation.
+<p><!--para 10-->
+ EXAMPLE
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         static char str1[] = "?a???b,,,#c";
+         static char str2[] = "\t \t";
+         char *t, *ptr1, *ptr2;
+         rsize_t max1 = sizeof(str1);
+         rsize_t max2 = sizeof(str2);
+         t   =   strtok_s(str1,   &amp;max1,   "?", &amp;ptr1);        //   t   points to the token "a"
+         t   =   strtok_s(NULL,   &amp;max1,   ",", &amp;ptr1);        //   t   points to the token "??b"
+         t   =   strtok_s(str2,   &amp;max2,   " \t", &amp;ptr2);      //   t   is a null pointer
+         t   =   strtok_s(NULL,   &amp;max1,   "#,", &amp;ptr1);       //   t   points to the token "c"
+         t   =   strtok_s(NULL,   &amp;max1,   "?", &amp;ptr1);        //   t   is a null pointer</pre>
+ 
+
+<a name="K.3.7.4" href="#K.3.7.4"><h5>K.3.7.4 Miscellaneous functions</h5></a>
+
+<a name="K.3.7.4.1" href="#K.3.7.4.1"><h5>K.3.7.4.1 The memset_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ s shall not be a null pointer. Neither smax nor n shall be greater than RSIZE_MAX. n
+ shall not be greater than smax.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and smax is not
+ greater than RSIZE_MAX, the memset_s function stores the value of c (converted to an
+ unsigned char) into each of the first smax characters of the object pointed to by s.
+<!--page 636 indent 4-->
+<h6>Description</h6>
+<p><!--para 4-->
+ The memset_s function copies the value of c (converted to an unsigned char) into
+ each of the first n characters of the object pointed to by s. Unlike memset, any call to
+ the memset_s function shall be evaluated strictly according to the rules of the abstract
+ machine as described in (<a href="#5.1.2.3">5.1.2.3</a>). That is, any call to the memset_s function shall
+ assume that the memory indicated by s and n may be accessible in the future and thus
+ must contain the values indicated by c.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The memset_s function returns zero if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+
+<a name="K.3.7.4.2" href="#K.3.7.4.2"><h5>K.3.7.4.2 The strerror_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;string.h&gt;
+        errno_t strerror_s(char *s, rsize_t maxsize,
+             errno_t errnum);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ s shall not be a null pointer. maxsize shall not be greater than RSIZE_MAX.
+ maxsize shall not equal zero.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then the array (if any) pointed to by s is not
+ modified.
+<h6>Description</h6>
+<p><!--para 4-->
+ The strerror_s function maps the number in errnum to a locale-specific message
+ string. Typically, the values for errnum come from errno, but strerror_s shall
+ map any value of type int to a message.
+<p><!--para 5-->
+ If the length of the desired string is less than maxsize, then the string is copied to the
+ array pointed to by s.
+<p><!--para 6-->
+ Otherwise, if maxsize is greater than zero, then maxsize-1 characters are copied
+ from the string to the array pointed to by s and then s[maxsize-1] is set to the null
+ character. Then, if maxsize is greater than 3, then s[maxsize-2],
+ s[maxsize-3], and s[maxsize-4] are set to the character period (.).
+<h6>Returns</h6>
+<p><!--para 7-->
+ The strerror_s function returns zero if the length of the desired string was less than
+ maxsize and there was no runtime-constraint violation. Otherwise, the strerror_s
+ function returns a nonzero value.
+<!--page 637 indent 4-->
+
+<a name="K.3.7.4.3" href="#K.3.7.4.3"><h5>K.3.7.4.3 The strerrorlen_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         size_t strerrorlen_s(errno_t errnum);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strerrorlen_s function calculates the length of the (untruncated) locale-specific
+ message string that the strerror_s function maps to errnum.
+<h6>Returns</h6>
+<p><!--para 3-->
+ The strerrorlen_s function returns the number of characters (not including the null
+ character) in the full message string.
+
+<a name="K.3.7.4.4" href="#K.3.7.4.4"><h5>K.3.7.4.4 The strnlen_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;string.h&gt;
+         size_t strnlen_s(const char *s, size_t maxsize);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The strnlen_s function computes the length of the string pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If s is a null pointer,<sup><a href="#note414"><b>414)</b></a></sup> then the strnlen_s function returns zero.
+<p><!--para 4-->
+ Otherwise, the strnlen_s function returns the number of characters that precede the
+ terminating null character. If there is no null character in the first maxsize characters of
+ s then strnlen_s returns maxsize. At most the first maxsize characters of s shall
+ be accessed by strnlen_s.
+ 
+ 
+ 
+ 
+<!--page 638 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note414">414)</a> Note that the strnlen_s function has no runtime-constraints. This lack of runtime-constraints
+ along with the values returned for a null pointer or an unterminated string argument make
+ strnlen_s useful in algorithms that gracefully handle such exceptional data.
+
+
+<a name="K.3.8" href="#K.3.8"><h4>K.3.8 Date and time <time.h></h4></a>
+<p><!--para 1-->
+ The header &lt;time.h&gt; defines two types.
+<p><!--para 2-->
+ The types are
+<pre>
+         errno_t</pre>
+ which is type int; and
+<pre>
+         rsize_t</pre>
+ which is the type size_t.
+
+<a name="K.3.8.1" href="#K.3.8.1"><h5>K.3.8.1 Components of time</h5></a>
+<p><!--para 1-->
+ A broken-down time is normalized if the values of the members of the tm structure are in
+ their normal rages.<sup><a href="#note415"><b>415)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note415">415)</a> The normal ranges are defined in <a href="#7.26.1">7.26.1</a>.
+
+
+<a name="K.3.8.2" href="#K.3.8.2"><h5>K.3.8.2 Time conversion functions</h5></a>
+<p><!--para 1-->
+ Like the strftime function, the asctime_s and ctime_s functions do not return a
+ pointer to a static object, and other library functions are permitted to call them.
+
+<a name="K.3.8.2.1" href="#K.3.8.2.1"><h5>K.3.8.2.1 The asctime_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;time.h&gt;
+         errno_t asctime_s(char *s, rsize_t maxsize,
+              const struct tm *timeptr);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor timeptr shall be a null pointer. maxsize shall not be less than 26 and
+ shall not be greater than RSIZE_MAX. The broken-down time pointed to by timeptr
+ shall be normalized. The calendar year represented by the broken-down time pointed to
+ by timeptr shall not be less than calendar year 0 and shall not be greater than calendar
+ year 9999.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, there is no attempt to convert the time, and
+ s[0] is set to a null character if s is not a null pointer and maxsize is not zero and is
+ not greater than RSIZE_MAX.
+<h6>Description</h6>
+<p><!--para 4-->
+ The asctime_s function converts the normalized broken-down time in the structure
+ pointed to by timeptr into a 26 character (including the null character) string in the
+ 
+ 
+<!--page 639 indent 4-->
+ form
+<pre>
+         Sun Sep 16 01:03:52 1973\n\0</pre>
+ The fields making up this string are (in order):
+<ol>
+<li>  The name of the day of the week represented by timeptr-&gt;tm_wday using the
+ following three character weekday names: Sun, Mon, Tue, Wed, Thu, Fri, and Sat.
+<li>  The character space.
+<li>  The name of the month represented by timeptr-&gt;tm_mon using the following
+ three character month names: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct,
+ Nov, and Dec.
+<li>  The character space.
+<li>  The value of timeptr-&gt;tm_mday as if printed using the fprintf format
+ "%2d".
+<li>  The character space.
+<li>  The value of timeptr-&gt;tm_hour as if printed using the fprintf format
+ "%.2d".
+<li>  The character colon.
+<li>  The value of timeptr-&gt;tm_min as if printed using the fprintf format
+ "%.2d".
+<li>  The character colon.
+<li>  The value of timeptr-&gt;tm_sec as if printed using the fprintf format
+ "%.2d".
+<li>  The character space.
+<li>  The value of timeptr-&gt;tm_year + 1900 as if printed using the fprintf
+ format "%4d".
+<li>  The character new line.
+<li>  The null character.
+</ol>
+ Recommended practice
+ The strftime function allows more flexible formatting and supports locale-specific
+ behavior. If you do not require the exact form of the result string produced by the
+ asctime_s function, consider using the strftime function instead.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The asctime_s function returns zero if the time was successfully converted and stored
+ into the array pointed to by s. Otherwise, it returns a nonzero value.
+<!--page 640 indent 4-->
+
+<a name="K.3.8.2.2" href="#K.3.8.2.2"><h5>K.3.8.2.2 The ctime_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;time.h&gt;
+        errno_t ctime_s(char *s, rsize_t maxsize,
+             const time_t *timer);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor timer shall be a null pointer. maxsize shall not be less than 26 and
+ shall not be greater than RSIZE_MAX.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, s[0] is set to a null character if s is not a null
+ pointer and maxsize is not equal zero and is not greater than RSIZE_MAX.
+<h6>Description</h6>
+<p><!--para 4-->
+ The ctime_s function converts the calendar time pointed to by timer to local time in
+ the form of a string. It is equivalent to
+<pre>
+        asctime_s(s, maxsize, localtime_s(timer))</pre>
+ Recommended practice
+ The strftime function allows more flexible formatting and supports locale-specific
+ behavior. If you do not require the exact form of the result string produced by the
+ ctime_s function, consider using the strftime function instead.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The ctime_s function returns zero if the time was successfully converted and stored
+ into the array pointed to by s. Otherwise, it returns a nonzero value.
+
+<a name="K.3.8.2.3" href="#K.3.8.2.3"><h5>K.3.8.2.3 The gmtime_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;time.h&gt;
+        struct tm *gmtime_s(const time_t * restrict timer,
+             struct tm * restrict result);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither timer nor result shall be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, there is no attempt to convert the time.
+<h6>Description</h6>
+<p><!--para 4-->
+ The gmtime_s function converts the calendar time pointed to by timer into a broken-
+ down time, expressed as UTC. The broken-down time is stored in the structure pointed
+<!--page 641 indent 4-->
+ to by result.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The gmtime_s function returns result, or a null pointer if the specified time cannot
+ be converted to UTC or there is a runtime-constraint violation.
+
+<a name="K.3.8.2.4" href="#K.3.8.2.4"><h5>K.3.8.2.4 The localtime_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;time.h&gt;
+          struct tm *localtime_s(const time_t * restrict timer,
+               struct tm * restrict result);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither timer nor result shall be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, there is no attempt to convert the time.
+<h6>Description</h6>
+<p><!--para 4-->
+ The localtime_s function converts the calendar time pointed to by timer into a
+ broken-down time, expressed as local time. The broken-down time is stored in the
+ structure pointed to by result.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The localtime_s function returns result, or a null pointer if the specified time
+ cannot be converted to local time or there is a runtime-constraint violation.
+
+<a name="K.3.9" href="#K.3.9"><h4>K.3.9 Extended multibyte and wide character utilities <wchar.h></h4></a>
+<p><!--para 1-->
+ The header &lt;wchar.h&gt; defines two types.
+<p><!--para 2-->
+ The types are
+<pre>
+          errno_t</pre>
+ which is type int; and
+<pre>
+          rsize_t</pre>
+ which is the type size_t.
+<p><!--para 3-->
+ Unless explicitly stated otherwise, if the execution of a function described in this
+ subclause causes copying to take place between objects that overlap, the objects take on
+ unspecified values.
+<!--page 642 indent 4-->
+
+<a name="K.3.9.1" href="#K.3.9.1"><h5>K.3.9.1 Formatted wide character input/output functions</h5></a>
+
+<a name="K.3.9.1.1" href="#K.3.9.1.1"><h5>K.3.9.1.1 The fwprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         int fwprintf_s(FILE * restrict stream,
+              const wchar_t * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note416"><b>416)</b></a></sup> (modified or
+ not by flags, field width, or precision) shall not appear in the wide string pointed to by
+ format. Any argument to fwprintf_s corresponding to a %s specifier shall not be a
+ null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the fwprintf_s function does not attempt to
+ produce further output, and it is unspecified to what extent fwprintf_s produced
+ output before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The fwprintf_s function is equivalent to the fwprintf function except for the
+ explicit runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The fwprintf_s function returns the number of wide characters transmitted, or a
+ negative value if an output error, encoding error, or runtime-constraint violation occurred.
+
+<h6>footnotes</h6>
+<p><a name="note416">416)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.2" href="#K.3.9.1.2"><h5>K.3.9.1.2 The fwscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int fwscanf_s(FILE * restrict stream,
+              const wchar_t * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. Any argument indirected though in
+ order to store converted input shall not be a null pointer.
+ 
+ 
+<!--page 643 indent 4-->
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the fwscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent fwscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The fwscanf_s function is equivalent to fwscanf except that the c, s, and [
+ conversion specifiers apply to a pair of arguments (unless assignment suppression is
+ indicated by a *). The first of these arguments is the same as for fwscanf. That
+ argument is immediately followed in the argument list by the second argument, which has
+ type size_t and gives the number of elements in the array pointed to by the first
+ argument of the pair. If the first argument points to a scalar object, it is considered to be
+ an array of one element.<sup><a href="#note417"><b>417)</b></a></sup>
+<p><!--para 5-->
+ A matching failure occurs if the number of elements in a receiving object is insufficient to
+ hold the converted input (including any trailing null character).
+<h6>Returns</h6>
+<p><!--para 6-->
+ The fwscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ fwscanf_s function returns the number of input items assigned, which can be fewer
+ than provided for, or even zero, in the event of an early matching failure.
+
+<h6>footnotes</h6>
+<p><a name="note417">417)</a> If the format is known at translation time, an implementation may issue a diagnostic for any argument
+ used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
+ argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
+ the format is not known at translation time. For example, an implementation may issue a diagnostic
+ for each argument after format that has of type pointer to one of char, signed char,
+ unsigned char, or void that is not followed by an argument of a type compatible with
+ rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
+ using the hh length modifier, a length argument must follow the pointer argument. Another useful
+ diagnostic could flag any non-pointer argument following format that did not have a type
+ compatible with rsize_t.
+
+
+<a name="K.3.9.1.3" href="#K.3.9.1.3"><h5>K.3.9.1.3 The snwprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         int snwprintf_s(wchar_t * restrict s,
+              rsize_t n,
+              const wchar_t * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The %n specifier<sup><a href="#note418"><b>418)</b></a></sup> (modified or not by flags, field width, or
+ 
+<!--page 644 indent 4-->
+ precision) shall not appear in the wide string pointed to by format. Any argument to
+ snwprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
+ error shall occur.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the snwprintf_s function sets s[0] to the
+ null wide character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The snwprintf_s function is equivalent to the swprintf function except for the
+ explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The snwprintf_s function, unlike swprintf_s, will truncate the result to fit within
+ the array pointed to by s.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The snwprintf_s function returns the number of wide characters that would have
+ been written had n been sufficiently large, not counting the terminating wide null
+ character, or a negative value if a runtime-constraint violation occurred. Thus, the null-
+ terminated output has been completely written if and only if the returned value is
+ nonnegative and less than n.
+
+<h6>footnotes</h6>
+<p><a name="note418">418)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.4" href="#K.3.9.1.4"><h5>K.3.9.1.4 The swprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         int swprintf_s(wchar_t * restrict s, rsize_t n,
+              const wchar_t * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The number of wide characters (including the trailing null) required
+ for the result to be written to the array pointed to by s shall not be greater than n. The %n
+ specifier<sup><a href="#note419"><b>419)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+ wide string pointed to by format. Any argument to swprintf_s corresponding to a
+ %s specifier shall not be a null pointer. No encoding error shall occur.
+ 
+ 
+<!--page 645 indent 4-->
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the swprintf_s function sets s[0] to the
+ null wide character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The swprintf_s function is equivalent to the swprintf function except for the
+ explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The swprintf_s function, unlike snwprintf_s, treats a result too big for the array
+ pointed to by s as a runtime-constraint violation.
+<h6>Returns</h6>
+<p><!--para 6-->
+ If no runtime-constraint violation occurred, the swprintf_s function returns the
+ number of wide characters written in the array, not counting the terminating null wide
+ character. If an encoding error occurred or if n or more wide characters are requested to
+ be written, swprintf_s returns a negative value. If any other runtime-constraint
+ violation occurred, swprintf_s returns zero.
+
+<h6>footnotes</h6>
+<p><a name="note419">419)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.5" href="#K.3.9.1.5"><h5>K.3.9.1.5 The swscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         int swscanf_s(const wchar_t * restrict s,
+              const wchar_t * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. Any argument indirected though in order
+ to store converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the swscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent swscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The swscanf_s function is equivalent to fwscanf_s, except that the argument s
+ specifies a wide string from which the input is to be obtained, rather than from a stream.
+ Reaching the end of the wide string is equivalent to encountering end-of-file for the
+ fwscanf_s function.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The swscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ swscanf_s function returns the number of input items assigned, which can be fewer
+ than provided for, or even zero, in the event of an early matching failure.
+<!--page 646 indent 4-->
+
+<a name="K.3.9.1.6" href="#K.3.9.1.6"><h5>K.3.9.1.6 The vfwprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int vfwprintf_s(FILE * restrict stream,
+              const wchar_t * restrict format,
+              va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note420"><b>420)</b></a></sup> (modified or
+ not by flags, field width, or precision) shall not appear in the wide string pointed to by
+ format. Any argument to vfwprintf_s corresponding to a %s specifier shall not be
+ a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vfwprintf_s function does not attempt
+ to produce further output, and it is unspecified to what extent vfwprintf_s produced
+ output before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vfwprintf_s function is equivalent to the vfwprintf function except for the
+ explicit runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vfwprintf_s function returns the number of wide characters transmitted, or a
+ negative value if an output error, encoding error, or runtime-constraint violation occurred.
+
+<h6>footnotes</h6>
+<p><a name="note420">420)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.7" href="#K.3.9.1.7"><h5>K.3.9.1.7 The vfwscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;stdio.h&gt;
+         #include &lt;wchar.h&gt;
+         int vfwscanf_s(FILE * restrict stream,
+              const wchar_t * restrict format, va_list arg);</pre>
+ 
+ 
+ 
+<!--page 647 indent 4-->
+ Runtime-constraints
+<p><!--para 2-->
+ Neither stream nor format shall be a null pointer. Any argument indirected though in
+ order to store converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vfwscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent vfwscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vfwscanf_s function is equivalent to fwscanf_s, with the variable argument
+ list replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vfwscanf_s function does not invoke the
+ va_end macro.<sup><a href="#note421"><b>421)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vfwscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ vfwscanf_s function returns the number of input items assigned, which can be fewer
+ than provided for, or even zero, in the event of an early matching failure.
+
+<h6>footnotes</h6>
+<p><a name="note421">421)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+ value of arg after the return is indeterminate.
+
+
+<a name="K.3.9.1.8" href="#K.3.9.1.8"><h5>K.3.9.1.8 The vsnwprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;wchar.h&gt;
+         int vsnwprintf_s(wchar_t * restrict s,
+              rsize_t n,
+              const wchar_t * restrict format,
+              va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The %n specifier<sup><a href="#note422"><b>422)</b></a></sup> (modified or not by flags, field width, or
+ precision) shall not appear in the wide string pointed to by format. Any argument to
+ vsnwprintf_s corresponding to a %s specifier shall not be a null pointer. No
+ encoding error shall occur.
+ 
+<!--page 648 indent 4-->
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the vsnwprintf_s function sets s[0] to
+ the null wide character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vsnwprintf_s function is equivalent to the vswprintf function except for the
+ explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The vsnwprintf_s function, unlike vswprintf_s, will truncate the result to fit
+ within the array pointed to by s.
+<h6>Returns</h6>
+<p><!--para 6-->
+ The vsnwprintf_s function returns the number of wide characters that would have
+ been written had n been sufficiently large, not counting the terminating null character, or
+ a negative value if a runtime-constraint violation occurred. Thus, the null-terminated
+ output has been completely written if and only if the returned value is nonnegative and
+ less than n.
+
+<h6>footnotes</h6>
+<p><a name="note422">422)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.9" href="#K.3.9.1.9"><h5>K.3.9.1.9 The vswprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;wchar.h&gt;
+         int vswprintf_s(wchar_t * restrict s,
+              rsize_t n,
+              const wchar_t * restrict format,
+              va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+ than RSIZE_MAX. The number of wide characters (including the trailing null) required
+ for the result to be written to the array pointed to by s shall not be greater than n. The %n
+ specifier<sup><a href="#note423"><b>423)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+ wide string pointed to by format. Any argument to vswprintf_s corresponding to a
+ %s specifier shall not be a null pointer. No encoding error shall occur.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+ than zero and less than RSIZE_MAX, then the vswprintf_s function sets s[0] to the
+ null wide character.
+ 
+<!--page 649 indent 4-->
+<h6>Description</h6>
+<p><!--para 4-->
+ The vswprintf_s function is equivalent to the vswprintf function except for the
+ explicit runtime-constraints listed above.
+<p><!--para 5-->
+ The vswprintf_s function, unlike vsnwprintf_s, treats a result too big for the
+ array pointed to by s as a runtime-constraint violation.
+<h6>Returns</h6>
+<p><!--para 6-->
+ If no runtime-constraint violation occurred, the vswprintf_s function returns the
+ number of wide characters written in the array, not counting the terminating null wide
+ character. If an encoding error occurred or if n or more wide characters are requested to
+ be written, vswprintf_s returns a negative value. If any other runtime-constraint
+ violation occurred, vswprintf_s returns zero.
+
+<h6>footnotes</h6>
+<p><a name="note423">423)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.10" href="#K.3.9.1.10"><h5>K.3.9.1.10 The vswscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;wchar.h&gt;
+         int vswscanf_s(const wchar_t * restrict s,
+              const wchar_t * restrict format,
+              va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s nor format shall be a null pointer. Any argument indirected though in order
+ to store converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vswscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent vswscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vswscanf_s function is equivalent to swscanf_s, with the variable argument
+ list replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vswscanf_s function does not invoke the
+ va_end macro.<sup><a href="#note424"><b>424)</b></a></sup>
+ 
+ 
+ 
+ 
+<!--page 650 indent 4-->
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vswscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ vswscanf_s function returns the number of input items assigned, which can be fewer
+ than provided for, or even zero, in the event of an early matching failure.
+
+<h6>footnotes</h6>
+<p><a name="note424">424)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+ value of arg after the return is indeterminate.
+
+
+<a name="K.3.9.1.11" href="#K.3.9.1.11"><h5>K.3.9.1.11 The vwprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;wchar.h&gt;
+         int vwprintf_s(const wchar_t * restrict format,
+              va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. The %n specifier<sup><a href="#note425"><b>425)</b></a></sup> (modified or not by flags, field
+ width, or precision) shall not appear in the wide string pointed to by format. Any
+ argument to vwprintf_s corresponding to a %s specifier shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vwprintf_s function does not attempt to
+ produce further output, and it is unspecified to what extent vwprintf_s produced
+ output before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vwprintf_s function is equivalent to the vwprintf function except for the
+ explicit runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vwprintf_s function returns the number of wide characters transmitted, or a
+ negative value if an output error, encoding error, or runtime-constraint violation occurred.
+ 
+ 
+ 
+ 
+<!--page 651 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note425">425)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.12" href="#K.3.9.1.12"><h5>K.3.9.1.12 The vwscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;stdarg.h&gt;
+         #include &lt;wchar.h&gt;
+         int vwscanf_s(const wchar_t * restrict format,
+              va_list arg);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. Any argument indirected though in order to store
+ converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the vwscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent vwscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The vwscanf_s function is equivalent to wscanf_s, with the variable argument list
+ replaced by arg, which shall have been initialized by the va_start macro (and
+ possibly subsequent va_arg calls). The vwscanf_s function does not invoke the
+ va_end macro.<sup><a href="#note426"><b>426)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 5-->
+ The vwscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ vwscanf_s function returns the number of input items assigned, which can be fewer
+ than provided for, or even zero, in the event of an early matching failure.
+
+<h6>footnotes</h6>
+<p><a name="note426">426)</a> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+ value of arg after the return is indeterminate.
+
+
+<a name="K.3.9.1.13" href="#K.3.9.1.13"><h5>K.3.9.1.13 The wprintf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         int wprintf_s(const wchar_t * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. The %n specifier<sup><a href="#note427"><b>427)</b></a></sup> (modified or not by flags, field
+ 
+<!--page 652 indent 4-->
+ width, or precision) shall not appear in the wide string pointed to by format. Any
+ argument to wprintf_s corresponding to a %s specifier shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the wprintf_s function does not attempt to
+ produce further output, and it is unspecified to what extent wprintf_s produced output
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The wprintf_s function is equivalent to the wprintf function except for the explicit
+ runtime-constraints listed above.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The wprintf_s function returns the number of wide characters transmitted, or a
+ negative value if an output error, encoding error, or runtime-constraint violation occurred.
+
+<h6>footnotes</h6>
+<p><a name="note427">427)</a> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+ string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+ example, if the entire format string was L"%%n".
+
+
+<a name="K.3.9.1.14" href="#K.3.9.1.14"><h5>K.3.9.1.14 The wscanf_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;wchar.h&gt;
+        int wscanf_s(const wchar_t * restrict format, ...);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ format shall not be a null pointer. Any argument indirected though in order to store
+ converted input shall not be a null pointer.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the wscanf_s function does not attempt to
+ perform further input, and it is unspecified to what extent wscanf_s performed input
+ before discovering the runtime-constraint violation.
+<h6>Description</h6>
+<p><!--para 4-->
+ The wscanf_s function is equivalent to fwscanf_s with the argument stdin
+ interposed before the arguments to wscanf_s.
+<h6>Returns</h6>
+<p><!--para 5-->
+ The wscanf_s function returns the value of the macro EOF if an input failure occurs
+ before any conversion or if there is a runtime-constraint violation. Otherwise, the
+ wscanf_s function returns the number of input items assigned, which can be fewer than
+ provided for, or even zero, in the event of an early matching failure.
+<!--page 653 indent 4-->
+
+<a name="K.3.9.2" href="#K.3.9.2"><h5>K.3.9.2 General wide string utilities</h5></a>
+
+<a name="K.3.9.2.1" href="#K.3.9.2.1"><h5>K.3.9.2.1 Wide string copying functions</h5></a>
+
+<a name="K.3.9.2.1.1" href="#K.3.9.2.1.1"><h5>K.3.9.2.1.1 The wcscpy_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         errno_t wcscpy_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+ s1max shall not equal zero. s1max shall be greater than wcsnlen_s(s2, s1max).
+ Copying shall not take place between objects that overlap.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then wcscpy_s sets s1[0] to the
+ null wide character.
+<h6>Description</h6>
+<p><!--para 4-->
+ The wcscpy_s function copies the wide string pointed to by s2 (including the
+ terminating null wide character) into the array pointed to by s1.
+<p><!--para 5-->
+ All elements following the terminating null wide character (if any) written by
+ wcscpy_s in the array of s1max wide characters pointed to by s1 take unspecified
+ values when wcscpy_s returns.<sup><a href="#note428"><b>428)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 6-->
+ The wcscpy_s function returns zero<sup><a href="#note429"><b>429)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+ 
+ 
+ 
+ 
+<!--page 654 indent 5-->
+
+<h6>footnotes</h6>
+<p><a name="note428">428)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
+ if any of those wide characters are null. Such an approach might write a wide character to every
+ element of s1 before discovering that the first element should be set to the null wide character.
+
+<p><a name="note429">429)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
+ fit within the array pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.9.2.1.2" href="#K.3.9.2.1.2"><h5>K.3.9.2.1.2 The wcsncpy_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 7-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         errno_t wcsncpy_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2,
+              rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 8-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
+ shall be greater than wcsnlen_s(s2, s1max). Copying shall not take place between
+ objects that overlap.
+<p><!--para 9-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then wcsncpy_s sets s1[0] to the
+ null wide character.
+<h6>Description</h6>
+<p><!--para 10-->
+ The wcsncpy_s function copies not more than n successive wide characters (wide
+ characters that follow a null wide character are not copied) from the array pointed to by
+ s2 to the array pointed to by s1. If no null wide character was copied from s2, then
+ s1[n] is set to a null wide character.
+<p><!--para 11-->
+ All elements following the terminating null wide character (if any) written by
+ wcsncpy_s in the array of s1max wide characters pointed to by s1 take unspecified
+ values when wcsncpy_s returns.<sup><a href="#note430"><b>430)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 12-->
+ The wcsncpy_s function returns zero<sup><a href="#note431"><b>431)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+<p><!--para 13-->
+ EXAMPLE 1 The wcsncpy_s function can be used to copy a wide string without the danger that the
+ result will not be null terminated or that wide characters will be written past the end of the destination
+ array.
+ 
+ 
+ 
+ 
+<!--page 655 indent 5-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         /* ... */
+         wchar_t src1[100] = L"hello";
+         wchar_t src2[7] = {L'g', L'o', L'o', L'd', L'b', L'y', L'e'};
+         wchar_t dst1[6], dst2[5], dst3[5];
+         int r1, r2, r3;
+         r1 = wcsncpy_s(dst1, 6, src1, 100);
+         r2 = wcsncpy_s(dst2, 5, src2, 7);
+         r3 = wcsncpy_s(dst3, 5, src2, 4);</pre>
+ The first call will assign to r1 the value zero and to dst1 the sequence of wide characters hello\0.
+ The second call will assign to r2 a nonzero value and to dst2 the sequence of wide characters \0.
+ The third call will assign to r3 the value zero and to dst3 the sequence of wide characters good\0.
+ 
+
+<h6>footnotes</h6>
+<p><a name="note430">430)</a> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
+ if any of those wide characters are null. Such an approach might write a wide character to every
+ element of s1 before discovering that the first element should be set to the null wide character.
+
+<p><a name="note431">431)</a> A zero return value implies that all of the requested wide characters from the string pointed to by s2
+ fit within the array pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.9.2.1.3" href="#K.3.9.2.1.3"><h5>K.3.9.2.1.3 The wmemcpy_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 14-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         errno_t wmemcpy_s(wchar_t * restrict s1,
+              rsize_t s1max,
+              const wchar_t * restrict s2,
+              rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 15-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
+ objects that overlap.
+<p><!--para 16-->
+ If there is a runtime-constraint violation, the wmemcpy_s function stores zeros in the
+ first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
+ s1max is not greater than RSIZE_MAX.
+<h6>Description</h6>
+<p><!--para 17-->
+ The wmemcpy_s function copies n successive wide characters from the object pointed
+ to by s2 into the object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 18-->
+ The wmemcpy_s function returns zero if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+<!--page 656 indent 5-->
+
+<a name="K.3.9.2.1.4" href="#K.3.9.2.1.4"><h5>K.3.9.2.1.4 The wmemmove_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 19-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;wchar.h&gt;
         errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
-             const wchar_t *s2, rsize_t n);
+             const wchar_t *s2, rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 20-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. n shall not be greater than s1max.
+<p><!--para 21-->
+ If there is a runtime-constraint violation, the wmemmove_s function stores zeros in the
+ first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
+ s1max is not greater than RSIZE_MAX.
+<h6>Description</h6>
+<p><!--para 22-->
+ The wmemmove_s function copies n successive wide characters from the object pointed
+ to by s2 into the object pointed to by s1. This copying takes place as if the n wide
+ characters from the object pointed to by s2 are first copied into a temporary array of n
+ wide characters that does not overlap the objects pointed to by s1 or s2, and then the n
+ wide characters from the temporary array are copied into the object pointed to by s1.
+<h6>Returns</h6>
+<p><!--para 23-->
+ The wmemmove_s function returns zero if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+
+<a name="K.3.9.2.2" href="#K.3.9.2.2"><h5>K.3.9.2.2 Wide string concatenation functions</h5></a>
+
+<a name="K.3.9.2.2.1" href="#K.3.9.2.2.1"><h5>K.3.9.2.2.1 The wcscat_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;wchar.h&gt;
         errno_t wcscat_s(wchar_t * restrict s1,
              rsize_t s1max,
-             const wchar_t * restrict s2);
-        errno_t wcsncat_s(wchar_t * restrict s1,
-             rsize_t s1max,
-             const wchar_t * restrict s2,
-             rsize_t n);
-        wchar_t *wcstok_s(wchar_t * restrict s1,
-             rsize_t * restrict s1max,
-             const wchar_t * restrict s2,
-             wchar_t ** restrict ptr);
-        size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
-        errno_t wcrtomb_s(size_t * restrict retval,
-             char * restrict s, rsize_t smax,
-             wchar_t wc, mbstate_t * restrict ps);
+             const wchar_t * restrict s2);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
+ wcscat_s.
+<p><!--para 3-->
+ Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+ s1max shall not equal zero. m shall not equal zero.<sup><a href="#note432"><b>432)</b></a></sup> m shall be greater than
+ wcsnlen_s(s2, m). Copying shall not take place between objects that overlap.
+<!--page 657 indent 5-->
+<p><!--para 4-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then wcscat_s sets s1[0] to the
+ null wide character.
+<h6>Description</h6>
+<p><!--para 5-->
+ The wcscat_s function appends a copy of the wide string pointed to by s2 (including
+ the terminating null wide character) to the end of the wide string pointed to by s1. The
+ initial wide character from s2 overwrites the null wide character at the end of s1.
+<p><!--para 6-->
+ All elements following the terminating null wide character (if any) written by
+ wcscat_s in the array of s1max wide characters pointed to by s1 take unspecified
+ values when wcscat_s returns.<sup><a href="#note433"><b>433)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 7-->
+ The wcscat_s function returns zero<sup><a href="#note434"><b>434)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+
+<h6>footnotes</h6>
+<p><a name="note432">432)</a> Zero means that s1 was not null terminated upon entry to wcscat_s.
+
+<p><a name="note433">433)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
+ checking if any of those wide characters are null. Such an approach might write a wide character to
+ every element of s1 before discovering that the first element should be set to the null wide character.
+
+<p><a name="note434">434)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
+ s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.9.2.2.2" href="#K.3.9.2.2.2"><h5>K.3.9.2.2.2 The wcsncat_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 8-->
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;wchar.h&gt;
+          errno_t wcsncat_s(wchar_t * restrict s1,
+               rsize_t s1max,
+               const wchar_t * restrict s2,
+               rsize_t n);</pre>
+ Runtime-constraints
+<p><!--para 9-->
+ Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
+ wcsncat_s.
+<p><!--para 10-->
+ Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+ RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note435"><b>435)</b></a></sup> If n is not less
+ than m, then m shall be greater than wcsnlen_s(s2, m). Copying shall not take
+ place between objects that overlap.
+ 
+ 
+<!--page 658 indent 5-->
+<p><!--para 11-->
+ If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+ greater than zero and not greater than RSIZE_MAX, then wcsncat_s sets s1[0] to the
+ null wide character.
+<h6>Description</h6>
+<p><!--para 12-->
+ The wcsncat_s function appends not more than n successive wide characters (wide
+ characters that follow a null wide character are not copied) from the array pointed to by
+ s2 to the end of the wide string pointed to by s1. The initial wide character from s2
+ overwrites the null wide character at the end of s1. If no null wide character was copied
+ from s2, then s1[s1max-m+n] is set to a null wide character.
+<p><!--para 13-->
+ All elements following the terminating null wide character (if any) written by
+ wcsncat_s in the array of s1max wide characters pointed to by s1 take unspecified
+ values when wcsncat_s returns.<sup><a href="#note436"><b>436)</b></a></sup>
+<h6>Returns</h6>
+<p><!--para 14-->
+ The wcsncat_s function returns zero<sup><a href="#note437"><b>437)</b></a></sup> if there was no runtime-constraint violation.
+ Otherwise, a nonzero value is returned.
+<p><!--para 15-->
+ EXAMPLE 1 The wcsncat_s function can be used to copy a wide string without the danger that the
+ result will not be null terminated or that wide characters will be written past the end of the destination
+ array.
+<pre>
+          #define __STDC_WANT_LIB_EXT1__ 1
+          #include &lt;wchar.h&gt;
+          /* ... */
+          wchar_t s1[100] = L"good";
+          wchar_t s2[6] = L"hello";
+          wchar_t s3[6] = L"hello";
+          wchar_t s4[7] = L"abc";
+          wchar_t s5[1000] = L"bye";
+          int r1, r2, r3, r4;
+          r1 = wcsncat_s(s1, 100, s5, 1000);
+          r2 = wcsncat_s(s2, 6, L"", 1);
+          r3 = wcsncat_s(s3, 6, L"X", 2);
+          r4 = wcsncat_s(s4, 7, L"defghijklmn", 3);</pre>
+ After the first call r1 will have the value zero and s1 will be the wide character sequence goodbye\0.
+ After the second call r2 will have the value zero and s2 will be the wide character sequence hello\0.
+ After the third call r3 will have a nonzero value and s3 will be the wide character sequence \0.
+ After the fourth call r4 will have the value zero and s4 will be the wide character sequence abcdef\0.
+ 
+ 
+ 
+ 
+<!--page 659 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note435">435)</a> Zero means that s1 was not null terminated upon entry to wcsncat_s.
+
+<p><a name="note436">436)</a> This allows an implementation to append wide characters from s2 to s1 while simultaneously
+ checking if any of those wide characters are null. Such an approach might write a wide character to
+ every element of s1 before discovering that the first element should be set to the null wide character.
+
+<p><a name="note437">437)</a> A zero return value implies that all of the requested wide characters from the wide string pointed to by
+ s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
+
+
+<a name="K.3.9.2.3" href="#K.3.9.2.3"><h5>K.3.9.2.3 Wide string search functions</h5></a>
+
+<a name="K.3.9.2.3.1" href="#K.3.9.2.3.1"><h5>K.3.9.2.3.1 The wcstok_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+         #define __STDC_WANT_LIB_EXT1__ 1
+         #include &lt;wchar.h&gt;
+         wchar_t *wcstok_s(wchar_t * restrict s1,
+              rsize_t * restrict s1max,
+              const wchar_t * restrict s2,
+              wchar_t ** restrict ptr);</pre>
+ Runtime-constraints
+<p><!--para 2-->
+ None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
+ shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
+ The end of the token found shall occur within the first *s1max wide characters of s1 for
+ the first call, and shall occur within the first *s1max wide characters of where searching
+ resumes on subsequent calls.
+<p><!--para 3-->
+ If there is a runtime-constraint violation, the wcstok_s function does not indirect
+ through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
+<h6>Description</h6>
+<p><!--para 4-->
+ A sequence of calls to the wcstok_s function breaks the wide string pointed to by s1
+ into a sequence of tokens, each of which is delimited by a wide character from the wide
+ string pointed to by s2. The fourth argument points to a caller-provided wchar_t
+ pointer into which the wcstok_s function stores information necessary for it to
+ continue scanning the same wide string.
+<p><!--para 5-->
+ The first call in a sequence has a non-null first argument and s1max points to an object
+ whose value is the number of elements in the wide character array pointed to by the first
+ argument. The first call stores an initial value in the object pointed to by ptr and
+ updates the value pointed to by s1max to reflect the number of elements that remain in
+ relation to ptr. Subsequent calls in the sequence have a null first argument and the
+ objects pointed to by s1max and ptr are required to have the values stored by the
+ previous call in the sequence, which are then updated. The separator wide string pointed
+ to by s2 may be different from call to call.
+<p><!--para 6-->
+ The first call in the sequence searches the wide string pointed to by s1 for the first wide
+ character that is not contained in the current separator wide string pointed to by s2. If no
+ such wide character is found, then there are no tokens in the wide string pointed to by s1
+ and the wcstok_s function returns a null pointer. If such a wide character is found, it is
+ the start of the first token.
+<!--page 660 indent 5-->
+<p><!--para 7-->
+ The wcstok_s function then searches from there for the first wide character in s1 that
+ is contained in the current separator wide string. If no such wide character is found, the
+ current token extends to the end of the wide string pointed to by s1, and subsequent
+ searches in the same wide string for a token return a null pointer. If such a wide character
+ is found, it is overwritten by a null wide character, which terminates the current token.
+<p><!--para 8-->
+ In all cases, the wcstok_s function stores sufficient information in the pointer pointed
+ to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+ value for ptr, shall start searching just past the element overwritten by a null wide
+ character (if any).
+<h6>Returns</h6>
+<p><!--para 9-->
+ The wcstok_s function returns a pointer to the first wide character of a token, or a null
+ pointer if there is no token or there is a runtime-constraint violation.
+<p><!--para 10-->
+ EXAMPLE
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;wchar.h&gt;
+        static wchar_t str1[] = L"?a???b,,,#c";
+        static wchar_t str2[] = L"\t \t";
+        wchar_t *t, *ptr1, *ptr2;
+        rsize_t max1 = wcslen(str1)+1;
+        rsize_t max2 = wcslen(str2)+1;
+        t   =   wcstok_s(str1,   &amp;max1,   "?", &amp;ptr1);        //   t   points to the token "a"
+        t   =   wcstok_s(NULL,   &amp;max1,   ",", &amp;ptr1);        //   t   points to the token "??b"
+        t   =   wcstok_s(str2,   &amp;max2,   " \t", &amp;ptr2);      //   t   is a null pointer
+        t   =   wcstok_s(NULL,   &amp;max1,   "#,", &amp;ptr1);       //   t   points to the token "c"
+        t   =   wcstok_s(NULL,   &amp;max1,   "?", &amp;ptr1);        //   t   is a null pointer</pre>
+ 
+
+<a name="K.3.9.2.4" href="#K.3.9.2.4"><h5>K.3.9.2.4 Miscellaneous functions</h5></a>
+
+<a name="K.3.9.2.4.1" href="#K.3.9.2.4.1"><h5>K.3.9.2.4.1 The wcsnlen_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 1-->
+<pre>
+        #define __STDC_WANT_LIB_EXT1__ 1
+        #include &lt;wchar.h&gt;
+        size_t wcsnlen_s(const wchar_t *s, size_t maxsize);</pre>
+<h6>Description</h6>
+<p><!--para 2-->
+ The wcsnlen_s function computes the length of the wide string pointed to by s.
+<h6>Returns</h6>
+<p><!--para 3-->
+ If s is a null pointer,<sup><a href="#note438"><b>438)</b></a></sup> then the wcsnlen_s function returns zero.
+<p><!--para 4-->
+ Otherwise, the wcsnlen_s function returns the number of wide characters that precede
+ the terminating null wide character. If there is no null wide character in the first
+ maxsize wide characters of s then wcsnlen_s returns maxsize. At most the first
+<!--page 661 indent 4-->
+ maxsize wide characters of s shall be accessed by wcsnlen_s.
+
+<h6>footnotes</h6>
+<p><a name="note438">438)</a> Note that the wcsnlen_s function has no runtime-constraints. This lack of runtime-constraints
+ along with the values returned for a null pointer or an unterminated wide string argument make
+ wcsnlen_s useful in algorithms that gracefully handle such exceptional data.
+
+
+<a name="K.3.9.3" href="#K.3.9.3"><h5>K.3.9.3 Extended multibyte/wide character conversion utilities</h5></a>
+
+<a name="K.3.9.3.1" href="#K.3.9.3.1"><h5>K.3.9.3.1 Restartable multibyte/wide character conversion functions</h5></a>
+<p><!--para 1-->
+ Unlike wcrtomb, wcrtomb_s does not permit the ps parameter (the pointer to the
+ conversion state) to be a null pointer.
+
+<a name="K.3.9.3.1.1" href="#K.3.9.3.1.1"><h5>K.3.9.3.1.1 The wcrtomb_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 2-->
+<pre>
+         #include &lt;wchar.h&gt;
+         errno_t wcrtomb_s(size_t * restrict retval,
+              char * restrict s, rsize_t smax,
+              wchar_t wc, mbstate_t * restrict ps);</pre>
+ Runtime-constraints
+<p><!--para 3-->
+ Neither retval nor ps shall be a null pointer. If s is not a null pointer, then smax
+ shall not equal zero and shall not be greater than RSIZE_MAX. If s is not a null pointer,
+ then smax shall be not be less than the number of bytes to be stored in the array pointed
+ to by s. If s is a null pointer, then smax shall equal zero.
+<p><!--para 4-->
+ If there is a runtime-constraint violation, then wcrtomb_s does the following. If s is
+ not a null pointer and smax is greater than zero and not greater than RSIZE_MAX, then
+ wcrtomb_s sets s[0] to the null character. If retval is not a null pointer, then
+ wcrtomb_s sets *retval to (size_t)(-1).
+<h6>Description</h6>
+<p><!--para 5-->
+ If s is a null pointer, the wcrtomb_s function is equivalent to the call
+<pre>
+                 wcrtomb_s(&amp;retval, buf, sizeof buf, L'\0', ps)</pre>
+ where retval and buf are internal variables of the appropriate types, and the size of
+ buf is greater than MB_CUR_MAX.
+<p><!--para 6-->
+ If s is not a null pointer, the wcrtomb_s function determines the number of bytes
+ needed to represent the multibyte character that corresponds to the wide character given
+ by wc (including any shift sequences), and stores the multibyte character representation
+ in the array whose first element is pointed to by s. At most MB_CUR_MAX bytes are
+ stored. If wc is a null wide character, a null byte is stored, preceded by any shift
+ sequence needed to restore the initial shift state; the resulting state described is the initial
+ conversion state.
+ 
+<!--page 662 indent 4-->
+<p><!--para 7-->
+ If wc does not correspond to a valid multibyte character, an encoding error occurs: the
+ wcrtomb_s function stores the value (size_t)(-1) into *retval and the
+ conversion state is unspecified. Otherwise, the wcrtomb_s function stores into
+ *retval the number of bytes (including any shift sequences) stored in the array pointed
+ to by s.
+<h6>Returns</h6>
+<p><!--para 8-->
+ The wcrtomb_s function returns zero if no runtime-constraint violation and no
+ encoding error occurred. Otherwise, a nonzero value is returned.
+
+<a name="K.3.9.3.2" href="#K.3.9.3.2"><h5>K.3.9.3.2 Restartable multibyte/wide string conversion functions</h5></a>
+<p><!--para 1-->
+ Unlike mbsrtowcs and wcsrtombs, mbsrtowcs_s and wcsrtombs_s do not
+ permit the ps parameter (the pointer to the conversion state) to be a null pointer.
+
+<a name="K.3.9.3.2.1" href="#K.3.9.3.2.1"><h5>K.3.9.3.2.1 The mbsrtowcs_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 2-->
+<pre>
+        #include &lt;wchar.h&gt;
         errno_t mbsrtowcs_s(size_t * restrict retval,
              wchar_t * restrict dst, rsize_t dstmax,
              const char ** restrict src, rsize_t len,
-             mbstate_t * restrict ps);
-
-[<a name="p497" href="#p497">page 497</a>] (<a href="#Contents">Contents</a>)
-
-      errno_t wcsrtombs_s(size_t * restrict retval,
-           char * restrict dst, rsize_t dstmax,
-           const wchar_t ** restrict src, rsize_t len,
-           mbstate_t * restrict ps);
-<a name="B.28" href="#B.28"><b>B.28 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
-      wint_t          wctrans_t         wctype_t         WEOF
-      int iswalnum(wint_t wc);
-      int iswalpha(wint_t wc);
-      int iswblank(wint_t wc);
-      int iswcntrl(wint_t wc);
-      int iswdigit(wint_t wc);
-      int iswgraph(wint_t wc);
-      int iswlower(wint_t wc);
-      int iswprint(wint_t wc);
-      int iswpunct(wint_t wc);
-      int iswspace(wint_t wc);
-      int iswupper(wint_t wc);
-      int iswxdigit(wint_t wc);
-      int iswctype(wint_t wc, wctype_t desc);
-      wctype_t wctype(const char *property);
-      wint_t towlower(wint_t wc);
-      wint_t towupper(wint_t wc);
-      wint_t towctrans(wint_t wc, wctrans_t desc);
-      wctrans_t wctrans(const char *property);
-
-[<a name="p498" href="#p498">page 498</a>] (<a href="#Contents">Contents</a>)
-
-<a name="C" href="#C"><b>                                          Annex C</b></a>
-                                        (informative)
-                                      Sequence points
-1   The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
-    -- Between the evaluations of the function designator and actual arguments in a function
-      call and the actual call. (<a href="#6.5.2.2">6.5.2.2</a>).
-    -- Between the evaluations of the first and second operands of the following operators:
-      logical AND &amp;&amp; (<a href="#6.5.13">6.5.13</a>); logical OR || (<a href="#6.5.14">6.5.14</a>); comma , (<a href="#6.5.17">6.5.17</a>).                  *
-    -- Between the evaluations of the first operand of the conditional ? : operator and
-      whichever of the second and third operands is evaluated (<a href="#6.5.15">6.5.15</a>).
-    -- The end of a full declarator: declarators (<a href="#6.7.6">6.7.6</a>);
-    -- Between the evaluation of a full expression and the next full expression to be
-      evaluated. The following are full expressions: an initializer that is not part of a
-      compound literal (<a href="#6.7.9">6.7.9</a>); the expression in an expression statement (<a href="#6.8.3">6.8.3</a>); the
-      controlling expression of a selection statement (if or switch) (<a href="#6.8.4">6.8.4</a>); the
-      controlling expression of a while or do statement (<a href="#6.8.5">6.8.5</a>); each of the (optional)
-      expressions of a for statement (<a href="#6.8.5.3">6.8.5.3</a>); the (optional) expression in a return
-      statement (<a href="#6.8.6.4">6.8.6.4</a>).
-    -- Immediately before a library function returns (<a href="#7.1.4">7.1.4</a>).
-    -- After the actions associated with each formatted input/output function conversion
-      specifier (<a href="#7.21.6">7.21.6</a>, <a href="#7.28.2">7.28.2</a>).
-    -- Immediately before and immediately after each call to a comparison function, and
-      also between any call to a comparison function and any movement of the objects
-      passed as arguments to that call (<a href="#7.22.5">7.22.5</a>).
-
-[<a name="p499" href="#p499">page 499</a>] (<a href="#Contents">Contents</a>)
-
-<a name="D" href="#D"><b>                                         Annex D</b></a>
-                                        (normative)
-                   Universal character names for identifiers
-1   This clause lists the hexadecimal code values that are valid in universal character names
-    in identifiers.
-<a name="D.1" href="#D.1"><b>    D.1 Ranges of characters allowed</b></a>
-1   00A8, 00AA, 00AD, 00AF, 00B2-00B5, 00B7-00BA, 00BC-00BE, 00C0-00D6,
-    00D8-00F6, 00F8-00FF
-2   0100-167F, 1681-180D, 180F-1FFF
-3   200B-200D, 202A-202E, 203F-2040, 2054, 2060-206F
-4   2070-218F, 2460-24FF, 2776-2793, 2C00-2DFF, 2E80-2FFF
-5   3004-3007, 3021-302F, 3031-303F
-6   3040-D7FF
-7   F900-FD3D, FD40-FDCF, FDF0-FE44, FE47-FFFD
-8   10000-1FFFD, 20000-2FFFD, 30000-3FFFD, 40000-4FFFD, 50000-5FFFD,
-    60000-6FFFD, 70000-7FFFD, 80000-8FFFD, 90000-9FFFD, A0000-AFFFD,
-    B0000-BFFFD, C0000-CFFFD, D0000-DFFFD, E0000-EFFFD
-<a name="D.2" href="#D.2"><b>    D.2 Ranges of characters disallowed initially</b></a>
-1   0300-036F, 1DC0-1DFF, 20D0-20FF, FE20-FE2F
-
-[<a name="p500" href="#p500">page 500</a>] (<a href="#Contents">Contents</a>)
-
-<a name="E" href="#E"><b>                                         Annex E</b></a>
-                                       (informative)
-                                Implementation limits
-1   The contents of the header <a href="#7.10">&lt;limits.h&gt;</a> are given below, in alphabetical order. The
-    minimum magnitudes shown shall be replaced by implementation-defined magnitudes
-    with the same sign. The values shall all be constant expressions suitable for use in #if
-    preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
-            #define    CHAR_BIT                               8
-            #define    CHAR_MAX          UCHAR_MAX or SCHAR_MAX
-            #define    CHAR_MIN                  0 or SCHAR_MIN
-            #define    INT_MAX                           +32767
-            #define    INT_MIN                           -32767
-            #define    LONG_MAX                     +2147483647
-            #define    LONG_MIN                     -2147483647
-            #define    LLONG_MAX           +9223372036854775807
-            #define    LLONG_MIN           -9223372036854775807
-            #define    MB_LEN_MAX                             1
-            #define    SCHAR_MAX                           +127
-            #define    SCHAR_MIN                           -127
-            #define    SHRT_MAX                          +32767
-            #define    SHRT_MIN                          -32767
-            #define    UCHAR_MAX                            255
-            #define    USHRT_MAX                          65535
-            #define    UINT_MAX                           65535
-            #define    ULONG_MAX                     4294967295
-            #define    ULLONG_MAX          18446744073709551615
-2   The contents of the header <a href="#7.7">&lt;float.h&gt;</a> are given below. All integer values, except
-    FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
-    directives; all floating values shall be constant expressions. The components are
-    described further in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
-3   The values given in the following list shall be replaced by implementation-defined
-    expressions:
-            #define FLT_EVAL_METHOD
-            #define FLT_ROUNDS
-4   The values given in the following list shall be replaced by implementation-defined
-    constant expressions that are greater or equal in magnitude (absolute value) to those
-    shown, with the same sign:
-
-[<a name="p501" href="#p501">page 501</a>] (<a href="#Contents">Contents</a>)
-
-           #define    DLB_DECIMAL_DIG                                10
-           #define    DBL_DIG                                        10
-           #define    DBL_MANT_DIG
-           #define    DBL_MAX_10_EXP                               +37
-           #define    DBL_MAX_EXP
-           #define    DBL_MIN_10_EXP                               -37
-           #define    DBL_MIN_EXP
-           #define    DECIMAL_DIG                                    10
-           #define    FLT_DECIMAL_DIG                                 6
-           #define    FLT_DIG                                         6
-           #define    FLT_MANT_DIG
-           #define    FLT_MAX_10_EXP                               +37
-           #define    FLT_MAX_EXP
-           #define    FLT_MIN_10_EXP                               -37
-           #define    FLT_MIN_EXP
-           #define    FLT_RADIX                                       2
-           #define    LDLB_DECIMAL_DIG                               10
-           #define    LDBL_DIG                                       10
-           #define    LDBL_MANT_DIG
-           #define    LDBL_MAX_10_EXP                              +37
-           #define    LDBL_MAX_EXP
-           #define    LDBL_MIN_10_EXP                              -37
-           #define    LDBL_MIN_EXP
-5   The values given in the following list shall be replaced by implementation-defined
-    constant expressions with values that are greater than or equal to those shown:
-           #define DBL_MAX                                      1E+37
-           #define FLT_MAX                                      1E+37
-           #define LDBL_MAX                                     1E+37
-6   The values given in the following list shall be replaced by implementation-defined
-    constant expressions with (positive) values that are less than or equal to those shown:
-           #define    DBL_EPSILON                                1E-9
-           #define    DBL_MIN                                   1E-37
-           #define    FLT_EPSILON                                1E-5
-           #define    FLT_MIN                                   1E-37
-           #define    LDBL_EPSILON                               1E-9
-           #define    LDBL_MIN                                  1E-37
-
-[<a name="p502" href="#p502">page 502</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F" href="#F"><b>                                               Annex F</b></a>
-                                              (normative)
-                          IEC 60559 floating-point arithmetic
-<a name="F.1" href="#F.1"><b>    F.1 Introduction</b></a>
-1   This annex specifies C language support for the IEC 60559 floating-point standard. The
-    IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for
-    microprocessor systems, second edition (IEC 60559:1989), previously designated
-    IEC 559:1989 and as IEEE Standard for Binary Floating-Point Arithmetic
-    (ANSI/IEEE 754-1985). IEEE Standard for Radix-Independent Floating-Point
-    Arithmetic (ANSI/IEEE 854-1987) generalizes the binary standard to remove
-    dependencies on radix and word length. IEC 60559 generally refers to the floating-point
-    standard, as in IEC 60559 operation, IEC 60559 format, etc. An implementation that
-    defines __STDC_IEC_559__ shall conform to the specifications in this annex.<sup><a href="#note343"><b>343)</b></a></sup>
-    Where a binding between the C language and IEC 60559 is indicated, the
-    IEC 60559-specified behavior is adopted by reference, unless stated otherwise. Since
-    negative and positive infinity are representable in IEC 60559 formats, all real numbers lie
-    within the range of representable values.
-<a name="F.2" href="#F.2"><b>    F.2 Types</b></a>
-1   The C floating types match the IEC 60559 formats as follows:
-    -- The float type matches the IEC 60559 single format.
-    -- The double type matches the IEC 60559 double format.
-    -- The long double type matches an IEC 60559 extended format,<sup><a href="#note344"><b>344)</b></a></sup> else a
-      non-IEC 60559 extended format, else the IEC 60559 double format.
-    Any non-IEC 60559 extended format used for the long double type shall have more
-    precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note345"><b>345)</b></a></sup>
-
-
-
-
-    <sup><a name="note343" href="#note343"><b>343)</b></a></sup> Implementations that do not define __STDC_IEC_559__ are not required to conform to these
-         specifications.
-    <sup><a name="note344" href="#note344"><b>344)</b></a></sup> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
-         and quadruple 128-bit IEC 60559 formats.
-    <sup><a name="note345" href="#note345"><b>345)</b></a></sup> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
-         all double values.
-
-[<a name="p503" href="#p503">page 503</a>] (<a href="#Contents">Contents</a>)
-
-    Recommended practice
-2   The long double type should match an IEC 60559 extended format.
-<a name="F.2.1" href="#F.2.1"><b>    F.2.1 Infinities, signed zeros, and NaNs</b></a>
-1   This specification does not define the behavior of signaling NaNs.<sup><a href="#note346"><b>346)</b></a></sup> It generally uses
-    the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
-    functions in <a href="#7.12">&lt;math.h&gt;</a> provide designations for IEC 60559 NaNs and infinities.
-<a name="F.3" href="#F.3"><b>    F.3 Operators and functions</b></a>
-1   C operators and functions provide IEC 60559 required and recommended facilities as
-    listed below.
-    -- The +, -, *, and / operators provide the IEC 60559 add, subtract, multiply, and
-      divide operations.
-    -- The sqrt functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 square root operation.
-    -- The remainder functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 remainder
-      operation. The remquo functions in <a href="#7.12">&lt;math.h&gt;</a> provide the same operation but
-      with additional information.
-    -- The rint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 operation that rounds a
-      floating-point number to an integer value (in the same precision). The nearbyint
-      functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nearbyinteger function recommended in the
-      Appendix to ANSI/IEEE 854.
-    -- The conversions for floating types provide the IEC 60559 conversions between
-      floating-point precisions.
-    -- The conversions from integer to floating types provide the IEC 60559 conversions
-      from integer to floating point.
-    -- The conversions from floating to integer types provide IEC 60559-like conversions
-      but always round toward zero.
-    -- The lrint and llrint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559
-      conversions, which honor the directed rounding mode, from floating point to the
-      long int and long long int integer formats. The lrint and llrint
-      functions can be used to implement IEC 60559 conversions from floating to other
-      integer formats.
-    -- The translation time conversion of floating constants and the strtod, strtof,
-      strtold, fprintf, fscanf, and related library functions in <a href="#7.22">&lt;stdlib.h&gt;</a>,
-
-
-    <sup><a name="note346" href="#note346"><b>346)</b></a></sup> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
-         sufficient for closure of the arithmetic.
-
-[<a name="p504" href="#p504">page 504</a>] (<a href="#Contents">Contents</a>)
-
-   <a href="#7.21">&lt;stdio.h&gt;</a>, and <a href="#7.28">&lt;wchar.h&gt;</a> provide IEC 60559 binary-decimal conversions. The
-   strtold function in <a href="#7.22">&lt;stdlib.h&gt;</a> provides the conv function recommended in the
-   Appendix to ANSI/IEEE 854.
--- The relational and equality operators provide IEC 60559 comparisons. IEC 60559
-  identifies a need for additional comparison predicates to facilitate writing code that
-  accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
-  isless, islessequal, islessgreater, and isunordered) in <a href="#7.12">&lt;math.h&gt;</a>
-  supplement the language operators to address this need. The islessgreater and
-  isunordered macros provide respectively a quiet version of the &lt;&gt; predicate and
-  the unordered predicate recommended in the Appendix to IEC 60559.
--- The feclearexcept, feraiseexcept, and fetestexcept functions in
-  <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to test and alter the IEC 60559 floating-point
-  exception status flags. The fegetexceptflag and fesetexceptflag
-  functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to save and restore all five status flags at
-  one time. These functions are used in conjunction with the type fexcept_t and the
-  floating-point     exception      macros      (FE_INEXACT,         FE_DIVBYZERO,
-  FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in <a href="#7.6">&lt;fenv.h&gt;</a>.
--- The fegetround and fesetround functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility
-  to select among the IEC 60559 directed rounding modes represented by the rounding
-  direction macros in <a href="#7.6">&lt;fenv.h&gt;</a> (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
-  FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the
-  IEC 60559 directed rounding modes.
--- The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
-  <a href="#7.6">&lt;fenv.h&gt;</a> provide a facility to manage the floating-point environment, comprising
-  the IEC 60559 status flags and control modes.
--- The copysign functions in <a href="#7.12">&lt;math.h&gt;</a> provide the copysign function
-  recommended in the Appendix to IEC 60559.
--- The fabs functions in <a href="#7.12">&lt;math.h&gt;</a> provide the abs function recommended in the
-  Appendix to IEC 60559.
--- The unary minus (-) operator provides the unary minus (-) operation recommended
-  in the Appendix to IEC 60559.
--- The scalbn and scalbln functions in <a href="#7.12">&lt;math.h&gt;</a> provide the scalb function
-  recommended in the Appendix to IEC 60559.
--- The logb functions in <a href="#7.12">&lt;math.h&gt;</a> provide the logb function recommended in the
-  Appendix to IEC 60559, but following the newer specifications in ANSI/IEEE 854.
--- The nextafter and nexttoward functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nextafter
-  function recommended in the Appendix to IEC 60559 (but with a minor change to
-
-[<a name="p505" href="#p505">page 505</a>] (<a href="#Contents">Contents</a>)
-
-        better handle signed zeros).
-    -- The isfinite macro in <a href="#7.12">&lt;math.h&gt;</a> provides the finite function recommended in
-      the Appendix to IEC 60559.
-    -- The isnan macro in <a href="#7.12">&lt;math.h&gt;</a> provides the isnan function recommended in the
-      Appendix to IEC 60559.
-    -- The signbit macro and the fpclassify macro in <a href="#7.12">&lt;math.h&gt;</a>, used in
-      conjunction with the number classification macros (FP_NAN, FP_INFINITE,
-      FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
-      function recommended in the Appendix to IEC 60559 (except that the classification
-      macros defined in <a href="#7.12.3">7.12.3</a> do not distinguish signaling from quiet NaNs).
-<a name="F.4" href="#F.4"><b>    F.4 Floating to integer conversion</b></a>
-1   If the integer type is _Bool, <a href="#6.3.1.2">6.3.1.2</a> applies and no floating-point exceptions are raised
-    (even for NaN). Otherwise, if the floating value is infinite or NaN or if the integral part
-    of the floating value exceeds the range of the integer type, then the ''invalid'' floating-
-    point exception is raised and the resulting value is unspecified. Otherwise, the resulting
-    value is determined by <a href="#6.3.1.4">6.3.1.4</a>. Conversion of an integral floating value that does not
-    exceed the range of the integer type raises no floating-point exceptions; whether
-    conversion of a non-integral floating value raises the ''inexact'' floating-point exception is
-    unspecified.<sup><a href="#note347"><b>347)</b></a></sup>
-<a name="F.5" href="#F.5"><b>    F.5 Binary-decimal conversion</b></a>
-1   Conversion from the widest supported IEC 60559 format to decimal with
-    DECIMAL_DIG digits and back is the identity function.<sup><a href="#note348"><b>348)</b></a></sup>
-2   Conversions involving IEC 60559 formats follow all pertinent recommended practice. In
-    particular, conversion between any supported IEC 60559 format and decimal with
-    DECIMAL_DIG or fewer significant digits is correctly rounded (honoring the current
-    rounding mode), which assures that conversion from the widest supported IEC 60559
-    format to decimal with DECIMAL_DIG digits and back is the identity function.
-
-
-
-    <sup><a name="note347" href="#note347"><b>347)</b></a></sup> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
-         conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
-         cases where it matters, library functions can be used to effect such conversions with or without raising
-         the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
-         <a href="#7.12">&lt;math.h&gt;</a>.
-    <sup><a name="note348" href="#note348"><b>348)</b></a></sup> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
-         DECIMAL_DIG shall be at least 21. If IEC 60559 double (53 bits of precision) is the widest
-         IEC 60559 format supported, then DECIMAL_DIG shall be at least 17. (By contrast, LDBL_DIG and
-         DBL_DIG are 18 and 15, respectively, for these formats.)
-
-[<a name="p506" href="#p506">page 506</a>] (<a href="#Contents">Contents</a>)
-
-3   Functions such as strtod that convert character sequences to floating types honor the
-    rounding direction. Hence, if the rounding direction might be upward or downward, the
-    implementation cannot convert a minus-signed sequence by negating the converted
-    unsigned sequence.
-<a name="F.6" href="#F.6"><b>    F.6 The return statement</b></a>
-    If the return expression is evaluated in a floating-point format different from the return
-    type, the expression is converted as if by assignment<sup><a href="#note349"><b>349)</b></a></sup> to the return type of the function
-    and the resulting value is returned to the caller.
-<a name="F.7" href="#F.7"><b>    F.7 Contracted expressions</b></a>
-1   A contracted expression is correctly rounded (once) and treats infinities, NaNs, signed
-    zeros, subnormals, and the rounding directions in a manner consistent with the basic
-    arithmetic operations covered by IEC 60559.
-    Recommended practice
-2   A contracted expression should raise floating-point exceptions in a manner generally
-    consistent with the basic arithmetic operations.                                    *
-<a name="F.8" href="#F.8"><b>    F.8 Floating-point environment</b></a>
-1   The floating-point environment defined in <a href="#7.6">&lt;fenv.h&gt;</a> includes the IEC 60559 floating-
-    point exception status flags and directed-rounding control modes. It includes also
-    IEC 60559 dynamic rounding precision and trap enablement modes, if the
-    implementation supports them.<sup><a href="#note350"><b>350)</b></a></sup>
-<a name="F.8.1" href="#F.8.1"><b>    F.8.1 Environment management</b></a>
-1   IEC 60559 requires that floating-point operations implicitly raise floating-point exception
-    status flags, and that rounding control modes can be set explicitly to affect result values of
-    floating-point operations. When the state for the FENV_ACCESS pragma (defined in
-    <a href="#7.6">&lt;fenv.h&gt;</a>) is ''on'', these changes to the floating-point state are treated as side effects
-    which respect sequence points.<sup><a href="#note351"><b>351)</b></a></sup>
-
-
-
-
-    <sup><a name="note349" href="#note349"><b>349)</b></a></sup> Assignment removes any extra range and precision.
-    <sup><a name="note350" href="#note350"><b>350)</b></a></sup> This specification does not require dynamic rounding precision nor trap enablement modes.
-    <sup><a name="note351" href="#note351"><b>351)</b></a></sup> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
-         point control modes will be the default ones and the floating-point status flags will not be tested,
-         which allows certain optimizations (see <a href="#F.9">F.9</a>).
-
-[<a name="p507" href="#p507">page 507</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.8.2" href="#F.8.2"><b>    F.8.2 Translation</b></a>
-1   During translation the IEC 60559 default modes are in effect:
-    -- The rounding direction mode is rounding to nearest.
-    -- The rounding precision mode (if supported) is set so that results are not shortened.
-    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
-    Recommended practice
-2   The implementation should produce a diagnostic message for each translation-time
-    floating-point exception, other than ''inexact'';<sup><a href="#note352"><b>352)</b></a></sup> the implementation should then
-    proceed with the translation of the program.
-<a name="F.8.3" href="#F.8.3"><b>    F.8.3 Execution</b></a>
-1   At program startup the floating-point environment is initialized as prescribed by
-    IEC 60559:
-    -- All floating-point exception status flags are cleared.
-    -- The rounding direction mode is rounding to nearest.
-    -- The dynamic rounding precision mode (if supported) is set so that results are not
-      shortened.
-    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
-<a name="F.8.4" href="#F.8.4"><b>    F.8.4 Constant expressions</b></a>
-1   An arithmetic constant expression of floating type, other than one in an initializer for an
-    object that has static or thread storage duration, is evaluated (as if) during execution; thus,
-    it is affected by any operative floating-point control modes and raises floating-point
-    exceptions as required by IEC 60559 (provided the state for the FENV_ACCESS pragma
-    is ''on'').<sup><a href="#note353"><b>353)</b></a></sup>
-2   EXAMPLE
-
-
-
-    <sup><a name="note352" href="#note352"><b>352)</b></a></sup> As floating constants are converted to appropriate internal representations at translation time, their
-         conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
-         (even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
-         strtod, provide execution-time conversion of numeric strings.
-    <sup><a name="note353" href="#note353"><b>353)</b></a></sup> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
-         are affected by rounding modes set at execution time, and expressions such as 0.0/0.0 and
-         1.0/0.0 generate execution-time floating-point exceptions. The programmer can achieve the
-         efficiency of translation-time evaluation through static initialization, such as
-                  const static double one_third = 1.0/3.0;
-
-[<a name="p508" href="#p508">page 508</a>] (<a href="#Contents">Contents</a>)
-
-             #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             #pragma STDC FENV_ACCESS ON
-             void f(void)
-             {
-                   float w[] = { 0.0/0.0 };                  //   raises an exception
-                   static float x = 0.0/0.0;                 //   does not raise an exception
-                   float y = 0.0/0.0;                        //   raises an exception
-                   double z = 0.0/0.0;                       //   raises an exception
-                   /* ... */
-             }
-3   For the static initialization, the division is done at translation time, raising no (execution-time) floating-
-    point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
-    execution time.
-
-<a name="F.8.5" href="#F.8.5"><b>    F.8.5 Initialization</b></a>
-1   All computation for automatic initialization is done (as if) at execution time; thus, it is
-    affected by any operative modes and raises floating-point exceptions as required by
-    IEC 60559 (provided the state for the FENV_ACCESS pragma is ''on''). All computation
-    for initialization of objects that have static or thread storage duration is done (as if) at
-    translation time.
-2   EXAMPLE
-             #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             #pragma STDC FENV_ACCESS ON
-             void f(void)
-             {
-                   float u[] = { 1.1e75 };                  //   raises exceptions
-                   static float v = 1.1e75;                 //   does not raise exceptions
-                   float w = 1.1e75;                        //   raises exceptions
-                   double x = 1.1e75;                       //   may raise exceptions
-                   float y = 1.1e75f;                       //   may raise exceptions
-                   long double z = 1.1e75;                  //   does not raise exceptions
-                   /* ... */
-             }
-3   The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
-    done at translation time. The automatic initialization of u and w require an execution-time conversion to
-    float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
-    of x and y entail execution-time conversion; however, in some expression evaluation methods, the
-    conversions is not to a narrower format, in which case no floating-point exception is raised.<sup><a href="#note354"><b>354)</b></a></sup> The
-    automatic initialization of z entails execution-time conversion, but not to a narrower format, so no floating-
-    point exception is raised. Note that the conversions of the floating constants 1.1e75 and 1.1e75f to
-
-
-
-    <sup><a name="note354" href="#note354"><b>354)</b></a></sup> Use of float_t and double_t variables increases the likelihood of translation-time computation.
-         For example, the automatic initialization
-                  double_t x = 1.1e75;
-         could be done at translation time, regardless of the expression evaluation method.
-
-[<a name="p509" href="#p509">page 509</a>] (<a href="#Contents">Contents</a>)
-
-    their internal representations occur at translation time in all cases.
-
-<a name="F.8.6" href="#F.8.6"><b>    F.8.6 Changing the environment</b></a>
-1   Operations defined in <a href="#6.5">6.5</a> and functions and macros defined for the standard libraries
-    change floating-point status flags and control modes just as indicated by their
-    specifications (including conformance to IEC 60559). They do not change flags or modes
-    (so as to be detectable by the user) in any other cases.
-2   If the argument to the feraiseexcept function in <a href="#7.6">&lt;fenv.h&gt;</a> represents IEC 60559
-    valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
-    ''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
-    before ''inexact''.
-<a name="F.9" href="#F.9"><b>    F.9 Optimization</b></a>
-1   This section identifies code transformations that might subvert IEC 60559-specified
-    behavior, and others that do not.
-<a name="F.9.1" href="#F.9.1"><b>    F.9.1 Global transformations</b></a>
-1   Floating-point arithmetic operations and external function calls may entail side effects
-    which optimization shall honor, at least where the state of the FENV_ACCESS pragma is
-    ''on''. The flags and modes in the floating-point environment may be regarded as global
-    variables; floating-point operations (+, *, etc.) implicitly read the modes and write the
-    flags.
-2   Concern about side effects may inhibit code motion and removal of seemingly useless
-    code. For example, in
-             #include <a href="#7.6">&lt;fenv.h&gt;</a>
-             #pragma STDC FENV_ACCESS ON
-             void f(double x)
-             {
-                  /* ... */
-                  for (i = 0; i &lt; n; i++) x + 1;
-                  /* ... */
-             }
-    x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
-    body might not execute (maybe 0 &gt;= n), x + 1 cannot be moved out of the loop. (Of
-    course these optimizations are valid if the implementation can rule out the nettlesome
-    cases.)
-3   This specification does not require support for trap handlers that maintain information
-    about the order or count of floating-point exceptions. Therefore, between function calls,
-    floating-point exceptions need not be precise: the actual order and number of occurrences
-    of floating-point exceptions (&gt; 1) may vary from what the source code expresses. Thus,
-
-[<a name="p510" href="#p510">page 510</a>] (<a href="#Contents">Contents</a>)
-
-    the preceding loop could be treated as
-             if (0 &lt; n) x + 1;
-<a name="F.9.2" href="#F.9.2"><b>    F.9.2 Expression transformations</b></a>
-1   x/2 &lt;-&gt; x x 0.5          Although similar transformations involving inexact constants
-                           generally do not yield numerically equivalent expressions, if the
-                           constants are exact then such transformations can be made on
-                           IEC 60559 machines and others that round perfectly.
-    1 x x and x/1 -&gt; x The expressions 1 x x, x/1, and x are equivalent (on IEC 60559
-                      machines, among others).<sup><a href="#note355"><b>355)</b></a></sup>
-    x/x -&gt; 1.0             The expressions x/x and 1.0 are not equivalent if x can be zero,
-                           infinite, or NaN.
-    x - y &lt;-&gt; x + (-y)       The expressions x - y, x + (-y), and (-y) + x are equivalent (on
-                           IEC 60559 machines, among others).
-    x - y &lt;-&gt; -(y - x)       The expressions x - y and -(y - x) are not equivalent because 1 - 1
-                           is +0 but -(1 - 1) is -0 (in the default rounding direction).<sup><a href="#note356"><b>356)</b></a></sup>
-    x - x -&gt; 0.0           The expressions x - x and 0.0 are not equivalent if x is a NaN or
-                           infinite.
-    0 x x -&gt; 0.0           The expressions 0 x x and 0.0 are not equivalent if x is a NaN,
-                           infinite, or -0.
-    x+0-&gt; x                 The expressions x + 0 and x are not equivalent if x is -0, because
-                           (-0) + (+0) yields +0 (in the default rounding direction), not -0.
-    x-0-&gt; x                 (+0) - (+0) yields -0 when rounding is downward (toward -(inf)), but
-                           +0 otherwise, and (-0) - (+0) always yields -0; so, if the state of the
-                           FENV_ACCESS pragma is ''off'', promising default rounding, then
-                           the implementation can replace x - 0 by x, even if x might be zero.
-    -x &lt;-&gt; 0 - x             The expressions -x and 0 - x are not equivalent if x is +0, because
-                           -(+0) yields -0, but 0 - (+0) yields +0 (unless rounding is
-                           downward).
-
-    <sup><a name="note355" href="#note355"><b>355)</b></a></sup> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
-         other transformations that remove arithmetic operators.
-    <sup><a name="note356" href="#note356"><b>356)</b></a></sup> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
-         Examples include:
-            1/(1/ (+-) (inf)) is (+-) (inf)
-         and
-            conj(csqrt(z)) is csqrt(conj(z)),
-         for complex z.
-
-[<a name="p511" href="#p511">page 511</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.9.3" href="#F.9.3"><b>    F.9.3 Relational operators</b></a>
-1   x != x -&gt; false           The expression x != x is true if x is a NaN.
-    x = x -&gt; true            The expression x = x is false if x is a NaN.
-    x &lt; y -&gt; isless(x,y) (and similarly for &lt;=, &gt;, &gt;=) Though numerically equal, these
-                   expressions are not equivalent because of side effects when x or y is a
-                   NaN and the state of the FENV_ACCESS pragma is ''on''. This
-                   transformation, which would be desirable if extra code were required
-                   to cause the ''invalid'' floating-point exception for unordered cases,
-                   could be performed provided the state of the FENV_ACCESS pragma
-                   is ''off''.
-    The sense of relational operators shall be maintained. This includes handling unordered
-    cases as expressed by the source code.
-2   EXAMPLE
-             // calls g and raises ''invalid'' if a and b are unordered
-             if (a &lt; b)
-                     f();
-             else
-                     g();
-    is not equivalent to
-             // calls f and raises ''invalid'' if a and b are unordered
-             if (a &gt;= b)
-                     g();
-             else
-                     f();
-    nor to
-             // calls f without raising ''invalid'' if a and b are unordered
-             if (isgreaterequal(a,b))
-                     g();
-             else
-                     f();
-    nor, unless the state of the FENV_ACCESS pragma is ''off'', to
-             // calls g without raising ''invalid'' if a and b are unordered
-             if (isless(a,b))
-                     f();
-             else
-                     g();
-    but is equivalent to
-
-[<a name="p512" href="#p512">page 512</a>] (<a href="#Contents">Contents</a>)
-
-            if (!(a &lt; b))
-                  g();
-            else
-                  f();
-
-<a name="F.9.4" href="#F.9.4"><b>    F.9.4 Constant arithmetic</b></a>
-1   The implementation shall honor floating-point exceptions raised by execution-time
-    constant arithmetic wherever the state of the FENV_ACCESS pragma is ''on''. (See <a href="#F.8.4">F.8.4</a>
-    and <a href="#F.8.5">F.8.5</a>.) An operation on constants that raises no floating-point exception can be
-    folded during translation, except, if the state of the FENV_ACCESS pragma is ''on'', a
-    further check is required to assure that changing the rounding direction to downward does
-    not alter the sign of the result,<sup><a href="#note357"><b>357)</b></a></sup> and implementations that support dynamic rounding
-    precision modes shall assure further that the result of the operation raises no floating-
-    point exception when converted to the semantic type of the operation.
-<a name="F.10" href="#F.10"><b>    F.10 Mathematics &lt;math.h&gt;</b></a>
-1   This subclause contains specifications of <a href="#7.12">&lt;math.h&gt;</a> facilities that are particularly suited
-    for IEC 60559 implementations.
-2   The Standard C macro HUGE_VAL and its float and long double analogs,
-    HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
-    infinities.
-3   Special cases for functions in <a href="#7.12">&lt;math.h&gt;</a> are covered directly or indirectly by
-    IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
-    other functions in <a href="#7.12">&lt;math.h&gt;</a> treat infinities, NaNs, signed zeros, subnormals, and
-    (provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
-    in a manner consistent with the basic arithmetic operations covered by IEC 60559.
-4   The expression math_errhandling &amp; MATH_ERREXCEPT shall evaluate to a
-    nonzero value.
-5   The ''invalid'' and ''divide-by-zero'' floating-point exceptions are raised as specified in
-    subsequent subclauses of this annex.
-6   The ''overflow'' floating-point exception is raised whenever an infinity -- or, because of
-    rounding direction, a maximal-magnitude finite number -- is returned in lieu of a value
-    whose magnitude is too large.
-7   The ''underflow'' floating-point exception is raised whenever a result is tiny (essentially
-    subnormal or zero) and suffers loss of accuracy.<sup><a href="#note358"><b>358)</b></a></sup>
-
-
-    <sup><a name="note357" href="#note357"><b>357)</b></a></sup> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
-    <sup><a name="note358" href="#note358"><b>358)</b></a></sup> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
-         when the floating-point exception is raised.
-
-[<a name="p513" href="#p513">page 513</a>] (<a href="#Contents">Contents</a>)
-
-8    Whether or when library functions raise the ''inexact'' floating-point exception is
-     unspecified, unless explicitly specified otherwise.
-9    Whether or when library functions raise an undeserved ''underflow'' floating-point
-     exception is unspecified.<sup><a href="#note359"><b>359)</b></a></sup> Otherwise, as implied by <a href="#F.8.6">F.8.6</a>, the <a href="#7.12">&lt;math.h&gt;</a> functions do
-     not raise spurious floating-point exceptions (detectable by the user), other than the
-     ''inexact'' floating-point exception.
-10   Whether the functions honor the rounding direction mode is implementation-defined,
-     unless explicitly specified otherwise.
-11   Functions with a NaN argument return a NaN result and raise no floating-point exception,
-     except where stated otherwise.
-12   The specifications in the following subclauses append to the definitions in <a href="#7.12">&lt;math.h&gt;</a>.
-     For families of functions, the specifications apply to all of the functions even though only
-     the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
-     occurs in both an argument and the result, the result has the same sign as the argument.
-     Recommended practice
-13   If a function with one or more NaN arguments returns a NaN result, the result should be
-     the same as one of the NaN arguments (after possible type conversion), except perhaps
-     for the sign.
-<a name="F.10.1" href="#F.10.1"><b>     F.10.1 Trigonometric functions</b></a>
-<a name="F.10.1.1" href="#F.10.1.1"><b>     F.10.1.1 The acos functions</b></a>
-1    -- acos(1) returns +0.
-     -- acos(x) returns a NaN and raises the ''invalid'' floating-point exception for
-       | x | &gt; 1.
-<a name="F.10.1.2" href="#F.10.1.2"><b>     F.10.1.2 The asin functions</b></a>
-1    -- asin((+-)0) returns (+-)0.
-     -- asin(x) returns a NaN and raises the ''invalid'' floating-point exception for
-       | x | &gt; 1.
-
-
-
-
-     <sup><a name="note359" href="#note359"><b>359)</b></a></sup> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
-          avoiding them would be too costly.
-
-[<a name="p514" href="#p514">page 514</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.1.3" href="#F.10.1.3"><b>    F.10.1.3 The atan functions</b></a>
-1   -- atan((+-)0) returns (+-)0.
-    -- atan((+-)(inf)) returns (+-)pi /2.
-<a name="F.10.1.4" href="#F.10.1.4"><b>    F.10.1.4 The atan2 functions</b></a>
-1   -- atan2((+-)0, -0) returns (+-)pi .<sup><a href="#note360"><b>360)</b></a></sup>
-    -- atan2((+-)0, +0) returns (+-)0.
-    -- atan2((+-)0, x) returns (+-)pi for x &lt; 0.
-    -- atan2((+-)0, x) returns (+-)0 for x &gt; 0.
-    -- atan2(y, (+-)0) returns -pi /2 for y &lt; 0.
-    -- atan2(y, (+-)0) returns pi /2 for y &gt; 0.
-    -- atan2((+-)y, -(inf)) returns (+-)pi for finite y &gt; 0.
-    -- atan2((+-)y, +(inf)) returns (+-)0 for finite y &gt; 0.
-    -- atan2((+-)(inf), x) returns (+-)pi /2 for finite x.
-    -- atan2((+-)(inf), -(inf)) returns (+-)3pi /4.
-    -- atan2((+-)(inf), +(inf)) returns (+-)pi /4.
-<a name="F.10.1.5" href="#F.10.1.5"><b>    F.10.1.5 The cos functions</b></a>
-1   -- cos((+-)0) returns 1.
-    -- cos((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-<a name="F.10.1.6" href="#F.10.1.6"><b>    F.10.1.6 The sin functions</b></a>
-1   -- sin((+-)0) returns (+-)0.
-    -- sin((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-<a name="F.10.1.7" href="#F.10.1.7"><b>    F.10.1.7 The tan functions</b></a>
-1   -- tan((+-)0) returns (+-)0.
-    -- tan((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-
-
-
-
-    <sup><a name="note360" href="#note360"><b>360)</b></a></sup> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y , 0) raise
-         the ''divide-by-zero'' floating-point exception.
-
-[<a name="p515" href="#p515">page 515</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.2" href="#F.10.2"><b>    F.10.2 Hyperbolic functions</b></a>
-<a name="F.10.2.1" href="#F.10.2.1"><b>    F.10.2.1 The acosh functions</b></a>
-1   -- acosh(1) returns +0.
-    -- acosh(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 1.
-    -- acosh(+(inf)) returns +(inf).
-<a name="F.10.2.2" href="#F.10.2.2"><b>    F.10.2.2 The asinh functions</b></a>
-1   -- asinh((+-)0) returns (+-)0.
-    -- asinh((+-)(inf)) returns (+-)(inf).
-<a name="F.10.2.3" href="#F.10.2.3"><b>    F.10.2.3 The atanh functions</b></a>
-1   -- atanh((+-)0) returns (+-)0.
-    -- atanh((+-)1) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- atanh(x) returns a NaN and raises the ''invalid'' floating-point exception for
-      | x | &gt; 1.
-<a name="F.10.2.4" href="#F.10.2.4"><b>    F.10.2.4 The cosh functions</b></a>
-1   -- cosh((+-)0) returns 1.
-    -- cosh((+-)(inf)) returns +(inf).
-<a name="F.10.2.5" href="#F.10.2.5"><b>    F.10.2.5 The sinh functions</b></a>
-1   -- sinh((+-)0) returns (+-)0.
-    -- sinh((+-)(inf)) returns (+-)(inf).
-<a name="F.10.2.6" href="#F.10.2.6"><b>    F.10.2.6 The tanh functions</b></a>
-1   -- tanh((+-)0) returns (+-)0.
-    -- tanh((+-)(inf)) returns (+-)1.
-<a name="F.10.3" href="#F.10.3"><b>    F.10.3 Exponential and logarithmic functions</b></a>
-<a name="F.10.3.1" href="#F.10.3.1"><b>    F.10.3.1 The exp functions</b></a>
-1   -- exp((+-)0) returns 1.
-    -- exp(-(inf)) returns +0.
-    -- exp(+(inf)) returns +(inf).
-
-[<a name="p516" href="#p516">page 516</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.3.2" href="#F.10.3.2"><b>    F.10.3.2 The exp2 functions</b></a>
-1   -- exp2((+-)0) returns 1.
-    -- exp2(-(inf)) returns +0.
-    -- exp2(+(inf)) returns +(inf).
-<a name="F.10.3.3" href="#F.10.3.3"><b>    F.10.3.3 The expm1 functions</b></a>
-1   -- expm1((+-)0) returns (+-)0.
-    -- expm1(-(inf)) returns -1.
-    -- expm1(+(inf)) returns +(inf).
-<a name="F.10.3.4" href="#F.10.3.4"><b>    F.10.3.4 The frexp functions</b></a>
-1   -- frexp((+-)0, exp) returns (+-)0, and stores 0 in the object pointed to by exp.
-    -- frexp((+-)(inf), exp) returns (+-)(inf), and stores an unspecified value in the object
-      pointed to by exp.
-    -- frexp(NaN, exp) stores an unspecified value in the object pointed to by exp
-      (and returns a NaN).
-2   frexp raises no floating-point exceptions.
-3   When the radix of the argument is a power of 2, the returned value is exact and is
-    independent of the current rounding direction mode.
-4   On a binary system, the body of the frexp function might be
-            {
-                   *exp = (value == 0) ? 0 : (int)(1 + logb(value));
-                   return scalbn(value, -(*exp));
-            }
-<a name="F.10.3.5" href="#F.10.3.5"><b>    F.10.3.5 The ilogb functions</b></a>
-1   When the correct result is representable in the range of the return type, the returned value
-    is exact and is independent of the current rounding direction mode.
-2   If the correct result is outside the range of the return type, the numeric result is
-    unspecified and the ''invalid'' floating-point exception is raised.
-
-[<a name="p517" href="#p517">page 517</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.3.6" href="#F.10.3.6"><b>    F.10.3.6 The ldexp functions</b></a>
-1   On a binary system, ldexp(x, exp) is equivalent to scalbn(x, exp).
-<a name="F.10.3.7" href="#F.10.3.7"><b>    F.10.3.7 The log functions</b></a>
-1   -- log((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log(1) returns +0.
-    -- log(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
-    -- log(+(inf)) returns +(inf).
-<a name="F.10.3.8" href="#F.10.3.8"><b>    F.10.3.8 The log10 functions</b></a>
-1   -- log10((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log10(1) returns +0.
-    -- log10(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
-    -- log10(+(inf)) returns +(inf).
-<a name="F.10.3.9" href="#F.10.3.9"><b>    F.10.3.9 The log1p functions</b></a>
-1   -- log1p((+-)0) returns (+-)0.
-    -- log1p(-1) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log1p(x) returns a NaN and raises the ''invalid'' floating-point exception for
-      x &lt; -1.
-    -- log1p(+(inf)) returns +(inf).
-<a name="F.10.3.10" href="#F.10.3.10"><b>    F.10.3.10 The log2 functions</b></a>
-1   -- log2((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- log2(1) returns +0.
-    -- log2(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
-    -- log2(+(inf)) returns +(inf).
-<a name="F.10.3.11" href="#F.10.3.11"><b>    F.10.3.11 The logb functions</b></a>
-1   -- logb((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- logb((+-)(inf)) returns +(inf).
-2   The returned value is exact and is independent of the current rounding direction mode.
-
-[<a name="p518" href="#p518">page 518</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.3.12" href="#F.10.3.12"><b>    F.10.3.12 The modf functions</b></a>
-1   -- modf((+-)x, iptr) returns a result with the same sign as x.
-    -- modf((+-)(inf), iptr) returns (+-)0 and stores (+-)(inf) in the object pointed to by iptr.
-    -- modf(NaN, iptr) stores a NaN in the object pointed to by iptr (and returns a
-      NaN).
-2   The returned values are exact and are independent of the current rounding direction
-    mode.
-3   modf behaves as though implemented by
-            #include <a href="#7.12">&lt;math.h&gt;</a>
-            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            #pragma STDC FENV_ACCESS ON
-            double modf(double value, double *iptr)
-            {
-                 int save_round = fegetround();
-                 fesetround(FE_TOWARDZERO);
-                 *iptr = nearbyint(value);
-                 fesetround(save_round);
-                 return copysign(
-                      isinf(value) ? 0.0 :
-                           value - (*iptr), value);
-            }
-<a name="F.10.3.13" href="#F.10.3.13"><b>    F.10.3.13 The scalbn and scalbln functions</b></a>
-1   -- scalbn((+-)0, n) returns (+-)0.
-    -- scalbn(x, 0) returns x.
-    -- scalbn((+-)(inf), n) returns (+-)(inf).
-2   If the calculation does not overflow or underflow, the returned value is exact and
-    independent of the current rounding direction mode.
-
-[<a name="p519" href="#p519">page 519</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.4" href="#F.10.4"><b>    F.10.4 Power and absolute value functions</b></a>
-<a name="F.10.4.1" href="#F.10.4.1"><b>    F.10.4.1 The cbrt functions</b></a>
-1   -- cbrt((+-)0) returns (+-)0.
-    -- cbrt((+-)(inf)) returns (+-)(inf).
-<a name="F.10.4.2" href="#F.10.4.2"><b>    F.10.4.2 The fabs functions</b></a>
-1   -- fabs((+-)0) returns +0.
-    -- fabs((+-)(inf)) returns +(inf).
-2   The returned value is exact and is independent of the current rounding direction mode.
-<a name="F.10.4.3" href="#F.10.4.3"><b>    F.10.4.3 The hypot functions</b></a>
-1   -- hypot(x, y), hypot(y, x), and hypot(x, -y) are equivalent.
-    -- hypot(x, (+-)0) is equivalent to fabs(x).
-    -- hypot((+-)(inf), y) returns +(inf), even if y is a NaN.
-<a name="F.10.4.4" href="#F.10.4.4"><b>    F.10.4.4 The pow functions</b></a>
-1   -- pow((+-)0, y) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception
-      for y an odd integer &lt; 0.
-    -- pow((+-)0, y) returns +(inf) and raises the ''divide-by-zero'' floating-point exception
-      for y &lt; 0, finite, and not an odd integer.
-    -- pow((+-)0, -(inf)) returns +(inf) and may raise the ''divide-by-zero'' floating-point
-      exception.
-    -- pow((+-)0, y) returns (+-)0 for y an odd integer &gt; 0.
-    -- pow((+-)0, y) returns +0 for y &gt; 0 and not an odd integer.
-    -- pow(-1, (+-)(inf)) returns 1.
-    -- pow(+1, y) returns 1 for any y, even a NaN.
-    -- pow(x, (+-)0) returns 1 for any x, even a NaN.
-    -- pow(x, y) returns a NaN and raises the ''invalid'' floating-point exception for
-      finite x &lt; 0 and finite non-integer y.
-    -- pow(x, -(inf)) returns +(inf) for | x | &lt; 1.
-    -- pow(x, -(inf)) returns +0 for | x | &gt; 1.
-    -- pow(x, +(inf)) returns +0 for | x | &lt; 1.
-    -- pow(x, +(inf)) returns +(inf) for | x | &gt; 1.
-
-[<a name="p520" href="#p520">page 520</a>] (<a href="#Contents">Contents</a>)
-
-    -- pow(-(inf), y) returns -0 for y an odd integer &lt; 0.
-    -- pow(-(inf), y) returns +0 for y &lt; 0 and not an odd integer.
-    -- pow(-(inf), y) returns -(inf) for y an odd integer &gt; 0.
-    -- pow(-(inf), y) returns +(inf) for y &gt; 0 and not an odd integer.
-    -- pow(+(inf), y) returns +0 for y &lt; 0.
-    -- pow(+(inf), y) returns +(inf) for y &gt; 0.
-<a name="F.10.4.5" href="#F.10.4.5"><b>    F.10.4.5 The sqrt functions</b></a>
-1   sqrt is fully specified as a basic arithmetic operation in IEC 60559. The returned value
-    is dependent on the current rounding direction mode.
-<a name="F.10.5" href="#F.10.5"><b>    F.10.5 Error and gamma functions</b></a>
-<a name="F.10.5.1" href="#F.10.5.1"><b>    F.10.5.1 The erf functions</b></a>
-1   -- erf((+-)0) returns (+-)0.
-    -- erf((+-)(inf)) returns (+-)1.
-<a name="F.10.5.2" href="#F.10.5.2"><b>    F.10.5.2 The erfc functions</b></a>
-1   -- erfc(-(inf)) returns 2.
-    -- erfc(+(inf)) returns +0.
-<a name="F.10.5.3" href="#F.10.5.3"><b>    F.10.5.3 The lgamma functions</b></a>
-1   -- lgamma(1) returns +0.
-    -- lgamma(2) returns +0.
-    -- lgamma(x) returns +(inf) and raises the ''divide-by-zero'' floating-point exception for
-      x a negative integer or zero.
-    -- lgamma(-(inf)) returns +(inf).
-    -- lgamma(+(inf)) returns +(inf).
-<a name="F.10.5.4" href="#F.10.5.4"><b>    F.10.5.4 The tgamma functions</b></a>
-1   -- tgamma((+-)0) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
-    -- tgamma(x) returns a NaN and raises the ''invalid'' floating-point exception for x a
-      negative integer.
-    -- tgamma(-(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
-    -- tgamma(+(inf)) returns +(inf).
-
-[<a name="p521" href="#p521">page 521</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.6" href="#F.10.6"><b>    F.10.6 Nearest integer functions</b></a>
-<a name="F.10.6.1" href="#F.10.6.1"><b>    F.10.6.1 The ceil functions</b></a>
-1   -- ceil((+-)0) returns (+-)0.
-    -- ceil((+-)(inf)) returns (+-)(inf).
-2   The returned value is independent of the current rounding direction mode.
-3   The double version of ceil behaves as though implemented by
-           #include <a href="#7.12">&lt;math.h&gt;</a>
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           #pragma STDC FENV_ACCESS ON
-           double ceil(double x)
-           {
-                double result;
-                int save_round = fegetround();
-                fesetround(FE_UPWARD);
-                result = rint(x); // or nearbyint instead of rint
-                fesetround(save_round);
-                return result;
-           }
-4   The ceil functions may, but are not required to, raise the ''inexact'' floating-point
-    exception for finite non-integer arguments, as this implementation does.
-<a name="F.10.6.2" href="#F.10.6.2"><b>    F.10.6.2 The floor functions</b></a>
-1   -- floor((+-)0) returns (+-)0.
-    -- floor((+-)(inf)) returns (+-)(inf).
-2   The returned value and is independent of the current rounding direction mode.
-3   See the sample implementation for ceil in <a href="#F.10.6.1">F.10.6.1</a>. The floor functions may, but are
-    not required to, raise the ''inexact'' floating-point exception for finite non-integer
-    arguments, as that implementation does.
-<a name="F.10.6.3" href="#F.10.6.3"><b>    F.10.6.3 The nearbyint functions</b></a>
-1   The nearbyint functions use IEC 60559 rounding according to the current rounding
-    direction. They do not raise the ''inexact'' floating-point exception if the result differs in
-    value from the argument.
-    -- nearbyint((+-)0) returns (+-)0 (for all rounding directions).
-    -- nearbyint((+-)(inf)) returns (+-)(inf) (for all rounding directions).
-
-[<a name="p522" href="#p522">page 522</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.6.4" href="#F.10.6.4"><b>    F.10.6.4 The rint functions</b></a>
-1   The rint functions differ from the nearbyint functions only in that they do raise the
-    ''inexact'' floating-point exception if the result differs in value from the argument.
-<a name="F.10.6.5" href="#F.10.6.5"><b>    F.10.6.5 The lrint and llrint functions</b></a>
-1   The lrint and llrint functions provide floating-to-integer conversion as prescribed
-    by IEC 60559. They round according to the current rounding direction. If the rounded
-    value is outside the range of the return type, the numeric result is unspecified and the
-    ''invalid'' floating-point exception is raised. When they raise no other floating-point
-    exception and the result differs from the argument, they raise the ''inexact'' floating-point
-    exception.
-<a name="F.10.6.6" href="#F.10.6.6"><b>    F.10.6.6 The round functions</b></a>
-1   -- round((+-)0) returns (+-)0.
-    -- round((+-)(inf)) returns (+-)(inf).
-2   The returned value is independent of the current rounding direction mode.
-3   The double version of round behaves as though implemented by
-            #include <a href="#7.12">&lt;math.h&gt;</a>
-            #include <a href="#7.6">&lt;fenv.h&gt;</a>
-            #pragma STDC FENV_ACCESS ON
-            double round(double x)
-            {
-                 double result;
-                 fenv_t save_env;
-                 feholdexcept(&amp;save_env);
-                 result = rint(x);
-                 if (fetestexcept(FE_INEXACT)) {
-                      fesetround(FE_TOWARDZERO);
-                      result = rint(copysign(0.5 + fabs(x), x));
-                 }
-                 feupdateenv(&amp;save_env);
-                 return result;
-            }
-    The round functions may, but are not required to, raise the ''inexact'' floating-point
-    exception for finite non-integer numeric arguments, as this implementation does.
-
-[<a name="p523" href="#p523">page 523</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.6.7" href="#F.10.6.7"><b>    F.10.6.7 The lround and llround functions</b></a>
-1   The lround and llround functions differ from the lrint and llrint functions
-    with the default rounding direction just in that the lround and llround functions
-    round halfway cases away from zero and need not raise the ''inexact'' floating-point
-    exception for non-integer arguments that round to within the range of the return type.
-<a name="F.10.6.8" href="#F.10.6.8"><b>    F.10.6.8 The trunc functions</b></a>
-1   The trunc functions use IEC 60559 rounding toward zero (regardless of the current
-    rounding direction). The returned value is exact.
-    -- trunc((+-)0) returns (+-)0.
-    -- trunc((+-)(inf)) returns (+-)(inf).
-2   The returned value is independent of the current rounding direction mode. The trunc
-    functions may, but are not required to, raise the ''inexact'' floating-point exception for
-    finite non-integer arguments.
-<a name="F.10.7" href="#F.10.7"><b>    F.10.7 Remainder functions</b></a>
-<a name="F.10.7.1" href="#F.10.7.1"><b>    F.10.7.1 The fmod functions</b></a>
-1   -- fmod((+-)0, y) returns (+-)0 for y not zero.
-    -- fmod(x, y) returns a NaN and raises the ''invalid'' floating-point exception for x
-      infinite or y zero (and neither is a NaN).
-    -- fmod(x, (+-)(inf)) returns x for x not infinite.
-2   When subnormal results are supported, the returned value is exact and is independent of
-    the current rounding direction mode.
-3   The double version of fmod behaves as though implemented by
-           #include <a href="#7.12">&lt;math.h&gt;</a>
-           #include <a href="#7.6">&lt;fenv.h&gt;</a>
-           #pragma STDC FENV_ACCESS ON
-           double fmod(double x, double y)
-           {
-                double result;
-                result = remainder(fabs(x), (y = fabs(y)));
-                if (signbit(result)) result += y;
-                return copysign(result, x);
-           }
-
-[<a name="p524" href="#p524">page 524</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.7.2" href="#F.10.7.2"><b>    F.10.7.2 The remainder functions</b></a>
-1   The remainder functions are fully specified as a basic arithmetic operation in
-    IEC 60559.
-2   When subnormal results are supported, the returned value is exact and is independent of
-    the current rounding direction mode.
-<a name="F.10.7.3" href="#F.10.7.3"><b>    F.10.7.3 The remquo functions</b></a>
-1   The remquo functions follow the specifications for the remainder functions. They
-    have no further specifications special to IEC 60559 implementations.
-2   When subnormal results are supported, the returned value is exact and is independent of
-    the current rounding direction mode.
-<a name="F.10.8" href="#F.10.8"><b>    F.10.8 Manipulation functions</b></a>
-<a name="F.10.8.1" href="#F.10.8.1"><b>    F.10.8.1 The copysign functions</b></a>
-1   copysign is specified in the Appendix to IEC 60559.
-2   The returned value is exact and is independent of the current rounding direction mode.
-<a name="F.10.8.2" href="#F.10.8.2"><b>    F.10.8.2 The nan functions</b></a>
-1   All IEC 60559 implementations support quiet NaNs, in all floating formats.
-2   The returned value is exact and is independent of the current rounding direction mode.
-<a name="F.10.8.3" href="#F.10.8.3"><b>    F.10.8.3 The nextafter functions</b></a>
-1   -- nextafter(x, y) raises the ''overflow'' and ''inexact'' floating-point exceptions
-      for x finite and the function value infinite.
-    -- nextafter(x, y) raises the ''underflow'' and ''inexact'' floating-point
-      exceptions for the function value subnormal or zero and x != y.
-2   Even though underflow or overflow can occur, the returned value is independent of the
-    current rounding direction mode.
-<a name="F.10.8.4" href="#F.10.8.4"><b>    F.10.8.4 The nexttoward functions</b></a>
-1   No additional requirements beyond those on nextafter.
-2   Even though underflow or overflow can occur, the returned value is independent of the
-    current rounding direction mode.
-
-[<a name="p525" href="#p525">page 525</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.9" href="#F.10.9"><b>    F.10.9 Maximum, minimum, and positive difference functions</b></a>
-<a name="F.10.9.1" href="#F.10.9.1"><b>    F.10.9.1 The fdim functions</b></a>
-1   No additional requirements.
-<a name="F.10.9.2" href="#F.10.9.2"><b>    F.10.9.2 The fmax functions</b></a>
-1   If just one argument is a NaN, the fmax functions return the other argument (if both
-    arguments are NaNs, the functions return a NaN).
-2   The returned value is exact and is independent of the current rounding direction mode.
-3   The body of the fmax function might be<sup><a href="#note361"><b>361)</b></a></sup>
-           { return (isgreaterequal(x, y) ||
-                isnan(y)) ? x : y; }
-<a name="F.10.9.3" href="#F.10.9.3"><b>    F.10.9.3 The fmin functions</b></a>
-1   The fmin functions are analogous to the fmax functions (see <a href="#F.10.9.2">F.10.9.2</a>).
-2   The returned value is exact and is independent of the current rounding direction mode.
-<a name="F.10.10" href="#F.10.10"><b>    F.10.10 Floating multiply-add</b></a>
-<a name="F.10.10.1" href="#F.10.10.1"><b>    F.10.10.1 The fma functions</b></a>
-1   -- fma(x, y, z) computes xy + z, correctly rounded once.
-    -- fma(x, y, z) returns a NaN and optionally raises the ''invalid'' floating-point
-      exception if one of x and y is infinite, the other is zero, and z is a NaN.
-    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if
-      one of x and y is infinite, the other is zero, and z is not a NaN.
-    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if x
-      times y is an exact infinity and z is also an infinity but with the opposite sign.
-
-
-
-
-    <sup><a name="note361" href="#note361"><b>361)</b></a></sup> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
-         return +0; however, implementation in software might be impractical.
-
-[<a name="p526" href="#p526">page 526</a>] (<a href="#Contents">Contents</a>)
-
-<a name="F.10.11" href="#F.10.11"><b>    F.10.11 Comparison macros</b></a>
-1   Relational operators and their corresponding comparison macros (<a href="#7.12.14">7.12.14</a>) produce
-    equivalent result values, even if argument values are represented in wider formats. Thus,
-    comparison macro arguments represented in formats wider than their semantic types are
-    not converted to the semantic types, unless the wide evaluation method converts operands
-    of relational operators to their semantic types. The standard wide evaluation methods
-    characterized by FLT_EVAL_METHOD equal to 1 or 2 (<a href="#5.2.4.2.2">5.2.4.2.2</a>), do not convert
-    operands of relational operators to their semantic types.
-
-[<a name="p527" href="#p527">page 527</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G" href="#G"><b>                                           Annex G</b></a>
-                                          (normative)
-                   IEC 60559-compatible complex arithmetic
-<a name="G.1" href="#G.1"><b>    G.1 Introduction</b></a>
-1   This annex supplements <a href="#F">annex F</a> to specify complex arithmetic for compatibility with
-    IEC 60559 real floating-point arithmetic. An implementation that defines *
-    __STDC_IEC_559_COMPLEX__ shall conform to the specifications in this annex.<sup><a href="#note362"><b>362)</b></a></sup>
-<a name="G.2" href="#G.2"><b>    G.2 Types</b></a>
-1   There is a new keyword _Imaginary, which is used to specify imaginary types. It is
-    used as a type specifier within declaration specifiers in the same way as _Complex is
-    (thus, _Imaginary float is a valid type name).
-2   There are three imaginary types, designated as float _Imaginary, double
-    _Imaginary, and long double _Imaginary. The imaginary types (along with
-    the real floating and complex types) are floating types.
-3   For imaginary types, the corresponding real type is given by deleting the keyword
-    _Imaginary from the type name.
-4   Each imaginary type has the same representation and alignment requirements as the
-    corresponding real type. The value of an object of imaginary type is the value of the real
-    representation times the imaginary unit.
-5   The imaginary type domain comprises the imaginary types.
-<a name="G.3" href="#G.3"><b>    G.3 Conventions</b></a>
-1   A complex or imaginary value with at least one infinite part is regarded as an infinity
-    (even if its other part is a NaN). A complex or imaginary value is a finite number if each
-    of its parts is a finite number (neither infinite nor NaN). A complex or imaginary value is
-    a zero if each of its parts is a zero.
-
-
-
-
-    <sup><a name="note362" href="#note362"><b>362)</b></a></sup> Implementations that do not define __STDC_IEC_559_COMPLEX__ are not required to conform
-         to these specifications.
-
-[<a name="p528" href="#p528">page 528</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.4" href="#G.4"><b>    G.4 Conversions</b></a>
-<a name="G.4.1" href="#G.4.1"><b>    G.4.1 Imaginary types</b></a>
-1   Conversions among imaginary types follow rules analogous to those for real floating
-    types.
-<a name="G.4.2" href="#G.4.2"><b>    G.4.2 Real and imaginary</b></a>
-1   When a value of imaginary type is converted to a real type other than _Bool,<sup><a href="#note363"><b>363)</b></a></sup> the
-    result is a positive zero.
-2   When a value of real type is converted to an imaginary type, the result is a positive
-    imaginary zero.
-<a name="G.4.3" href="#G.4.3"><b>    G.4.3 Imaginary and complex</b></a>
-1   When a value of imaginary type is converted to a complex type, the real part of the
-    complex result value is a positive zero and the imaginary part of the complex result value
-    is determined by the conversion rules for the corresponding real types.
-2   When a value of complex type is converted to an imaginary type, the real part of the
-    complex value is discarded and the value of the imaginary part is converted according to
-    the conversion rules for the corresponding real types.
-<a name="G.5" href="#G.5"><b>    G.5 Binary operators</b></a>
-1   The following subclauses supplement <a href="#6.5">6.5</a> in order to specify the type of the result for an
-    operation with an imaginary operand.
-2   For most operand types, the value of the result of a binary operator with an imaginary or
-    complex operand is completely determined, with reference to real arithmetic, by the usual
-    mathematical formula. For some operand types, the usual mathematical formula is
-    problematic because of its treatment of infinities and because of undue overflow or
-    underflow; in these cases the result satisfies certain properties (specified in <a href="#G.5.1">G.5.1</a>), but is
-    not completely determined.
-
-
-
-
-    <sup><a name="note363" href="#note363"><b>363)</b></a></sup> See <a href="#6.3.1.2">6.3.1.2</a>.
-
-[<a name="p529" href="#p529">page 529</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.5.1" href="#G.5.1"><b>    G.5.1 Multiplicative operators</b></a>
-<b>    Semantics</b>
-1   If one operand has real type and the other operand has imaginary type, then the result has
-    imaginary type. If both operands have imaginary type, then the result has real type. (If
-    either operand has complex type, then the result has complex type.)
-2   If the operands are not both complex, then the result and floating-point exception
-    behavior of the * operator is defined by the usual mathematical formula:
-           *                  u                   iv                 u + iv
-
-           x                  xu                i(xv)            (xu) + i(xv)
-
-           iy               i(yu)                -yv            (-yv) + i(yu)
-
-           x + iy       (xu) + i(yu)        (-yv) + i(xv)
-3   If the second operand is not complex, then the result and floating-point exception
-    behavior of the / operator is defined by the usual mathematical formula:
-           /                   u                       iv
-
-           x                  x/u                 i(-x/v)
-
-           iy               i(y/u)                     y/v
-
-           x + iy       (x/u) + i(y/u)        (y/v) + i(-x/v)
-4   The * and / operators satisfy the following infinity properties for all real, imaginary, and
-    complex operands:<sup><a href="#note364"><b>364)</b></a></sup>
-    -- if one operand is an infinity and the other operand is a nonzero finite number or an
-      infinity, then the result of the * operator is an infinity;
-    -- if the first operand is an infinity and the second operand is a finite number, then the
-      result of the / operator is an infinity;
-    -- if the first operand is a finite number and the second operand is an infinity, then the
-      result of the / operator is a zero;
-
-
-
-
-    <sup><a name="note364" href="#note364"><b>364)</b></a></sup> These properties are already implied for those cases covered in the tables, but are required for all cases
-         (at least where the state for CX_LIMITED_RANGE is ''off'').
-
-[<a name="p530" href="#p530">page 530</a>] (<a href="#Contents">Contents</a>)
-
-    -- if the first operand is a nonzero finite number or an infinity and the second operand is
-      a zero, then the result of the / operator is an infinity.
-5   If both operands of the * operator are complex or if the second operand of the / operator
-    is complex, the operator raises floating-point exceptions if appropriate for the calculation
-    of the parts of the result, and may raise spurious floating-point exceptions.
-6   EXAMPLE 1 Multiplication of double _Complex operands could be implemented as follows. Note
-    that the imaginary unit I has imaginary type (see <a href="#G.6">G.6</a>).
-             #include <a href="#7.12">&lt;math.h&gt;</a>
-             #include <a href="#7.3">&lt;complex.h&gt;</a>
-             /* Multiply z * w ... */
-             double complex _Cmultd(double complex z, double complex w)
-             {
-                    #pragma STDC FP_CONTRACT OFF
-                    double a, b, c, d, ac, bd, ad, bc, x, y;
-                    a = creal(z); b = cimag(z);
-                    c = creal(w); d = cimag(w);
-                    ac = a * c;       bd = b * d;
-                    ad = a * d;       bc = b * c;
-                    x = ac - bd; y = ad + bc;
-                    if (isnan(x) &amp;&amp; isnan(y)) {
-                            /* Recover infinities that computed as NaN+iNaN ... */
-                            int recalc = 0;
-                            if ( isinf(a) || isinf(b) ) { // z is infinite
-                                    /* "Box" the infinity and change NaNs in the other factor to 0 */
-                                    a = copysign(isinf(a) ? 1.0 : 0.0, a);
-                                    b = copysign(isinf(b) ? 1.0 : 0.0, b);
-                                    if (isnan(c)) c = copysign(0.0, c);
-                                    if (isnan(d)) d = copysign(0.0, d);
-                                    recalc = 1;
-                            }
-                            if ( isinf(c) || isinf(d) ) { // w is infinite
-                                    /* "Box" the infinity and change NaNs in the other factor to 0 */
-                                    c = copysign(isinf(c) ? 1.0 : 0.0, c);
-                                    d = copysign(isinf(d) ? 1.0 : 0.0, d);
-                                    if (isnan(a)) a = copysign(0.0, a);
-                                    if (isnan(b)) b = copysign(0.0, b);
-                                    recalc = 1;
-                            }
-                            if (!recalc &amp;&amp; (isinf(ac) || isinf(bd) ||
-                                                   isinf(ad) || isinf(bc))) {
-                                    /* Recover infinities from overflow by changing NaNs to 0 ... */
-                                    if (isnan(a)) a = copysign(0.0, a);
-                                    if (isnan(b)) b = copysign(0.0, b);
-                                    if (isnan(c)) c = copysign(0.0, c);
-                                    if (isnan(d)) d = copysign(0.0, d);
-                                    recalc = 1;
-                            }
-                            if (recalc) {
-
-[<a name="p531" href="#p531">page 531</a>] (<a href="#Contents">Contents</a>)
-
-                                      x = INFINITY * ( a * c - b * d );
-                                      y = INFINITY * ( a * d + b * c );
-                           }
-                     }
-                     return x + I * y;
-            }
-7   This implementation achieves the required treatment of infinities at the cost of only one isnan test in
-    ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
-
-8   EXAMPLE 2      Division of two double _Complex operands could be implemented as follows.
-            #include <a href="#7.12">&lt;math.h&gt;</a>
-            #include <a href="#7.3">&lt;complex.h&gt;</a>
-            /* Divide z / w ... */
-            double complex _Cdivd(double complex z, double complex w)
-            {
-                   #pragma STDC FP_CONTRACT OFF
-                   double a, b, c, d, logbw, denom, x, y;
-                   int ilogbw = 0;
-                   a = creal(z); b = cimag(z);
-                   c = creal(w); d = cimag(w);
-                   logbw = logb(fmax(fabs(c), fabs(d)));
-                   if (logbw == INFINITY) {
-                          ilogbw = (int)logbw;
-                          c = scalbn(c, -ilogbw); d = scalbn(d, -ilogbw);
-                   }
-                   denom = c * c + d * d;
-                   x = scalbn((a * c + b * d) / denom, -ilogbw);
-                   y = scalbn((b * c - a * d) / denom, -ilogbw);
-                     /* Recover infinities and zeros that computed as NaN+iNaN;                 */
-                     /* the only cases are nonzero/zero, infinite/finite, and finite/infinite, ... */
-                     if (isnan(x) &amp;&amp; isnan(y)) {
-                           if ((denom == 0.0) &amp;&amp;
-                                 (!isnan(a) || !isnan(b))) {
-                                 x = copysign(INFINITY, c) * a;
-                                 y = copysign(INFINITY, c) * b;
-                           }
-                           else if ((isinf(a) || isinf(b)) &amp;&amp;
-                                 isfinite(c) &amp;&amp; isfinite(d)) {
-                                 a = copysign(isinf(a) ? 1.0 : 0.0,                        a);
-                                 b = copysign(isinf(b) ? 1.0 : 0.0,                        b);
-                                 x = INFINITY * ( a * c + b * d );
-                                 y = INFINITY * ( b * c - a * d );
-                           }
-                           else if (isinf(logbw) &amp;&amp;
-                                 isfinite(a) &amp;&amp; isfinite(b)) {
-                                 c = copysign(isinf(c) ? 1.0 : 0.0,                        c);
-                                 d = copysign(isinf(d) ? 1.0 : 0.0,                        d);
-                                 x = 0.0 * ( a * c + b * d );
-                                 y = 0.0 * ( b * c - a * d );
-
-[<a name="p532" href="#p532">page 532</a>] (<a href="#Contents">Contents</a>)
-
-                           }
-                     }
-                     return x + I * y;
-            }
-9   Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
-    for multiplication. In the spirit of the multiplication example above, this code does not defend against
-    overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
-    with division, provides better roundoff characteristics.
-
-<a name="G.5.2" href="#G.5.2"><b>    G.5.2 Additive operators</b></a>
-<b>    Semantics</b>
-1   If both operands have imaginary type, then the result has imaginary type. (If one operand
-    has real type and the other operand has imaginary type, or if either operand has complex
-    type, then the result has complex type.)
-2   In all cases the result and floating-point exception behavior of a + or - operator is defined
-    by the usual mathematical formula:
-           + or -              u                       iv                    u + iv
-
-           x                 x(+-)u                     x (+-) iv              (x (+-) u) (+-) iv
-
-           iy               (+-)u + iy                 i(y (+-) v)             (+-)u + i(y (+-) v)
-
-           x + iy         (x (+-) u) + iy            x + i(y (+-) v)        (x (+-) u) + i(y (+-) v)
-<a name="G.6" href="#G.6"><b>    G.6 Complex arithmetic &lt;complex.h&gt;</b></a>
-1   The macros
-            imaginary
-    and
-            _Imaginary_I
-    are defined, respectively, as _Imaginary and a constant expression of type const
-    float _Imaginary with the value of the imaginary unit. The macro
-            I
-    is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
-    the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
-    imaginary.
-2   This subclause contains specifications for the <a href="#7.3">&lt;complex.h&gt;</a> functions that are
-    particularly suited to IEC 60559 implementations. For families of functions, the
-    specifications apply to all of the functions even though only the principal function is
-
-[<a name="p533" href="#p533">page 533</a>] (<a href="#Contents">Contents</a>)
-
-    shown. Unless otherwise specified, where the symbol ''(+-)'' occurs in both an argument
-    and the result, the result has the same sign as the argument.
-3   The functions are continuous onto both sides of their branch cuts, taking into account the
-    sign of zero. For example, csqrt(-2 (+-) i0) = (+-)i(sqrt)2.  -
-4   Since complex and imaginary values are composed of real values, each function may be
-    regarded as computing real values from real values. Except as noted, the functions treat
-    real infinities, NaNs, signed zeros, subnormals, and the floating-point exception flags in a
-    manner consistent with the specifications for real functions in F.10.<sup><a href="#note365"><b>365)</b></a></sup>
-5   The functions cimag, conj, cproj, and creal are fully specified for all
-    implementations, including IEC 60559 ones, in <a href="#7.3.9">7.3.9</a>. These functions raise no floating-
-    point exceptions.
-6   Each of the functions cabs and carg is specified by a formula in terms of a real
-    function (whose special cases are covered in <a href="#F">annex F</a>):
-            cabs(x + iy) = hypot(x, y)
-            carg(x + iy) = atan2(y, x)
-7   Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
-    a formula in terms of other complex functions (whose special cases are specified below):
-            casin(z)        =   -i casinh(iz)
-            catan(z)        =   -i catanh(iz)
-            ccos(z)         =   ccosh(iz)
-            csin(z)         =   -i csinh(iz)
-            ctan(z)         =   -i ctanh(iz)
-8   For the other functions, the following subclauses specify behavior for special cases,
-    including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
-    families of functions, the specifications apply to all of the functions even though only the
-    principal function is shown. For a function f satisfying f (conj(z)) = conj( f (z)), the
-    specifications for the upper half-plane imply the specifications for the lower half-plane; if
-    the function f is also either even, f (-z) = f (z), or odd, f (-z) = - f (z), then the
-    specifications for the first quadrant imply the specifications for the other three quadrants.
-9   In the following subclauses, cis(y) is defined as cos(y) + i sin(y).
-
-
-
-
-    <sup><a name="note365" href="#note365"><b>365)</b></a></sup> As noted in <a href="#G.3">G.3</a>, a complex value with at least one infinite part is regarded as an infinity even if its
-         other part is a NaN.
-
-[<a name="p534" href="#p534">page 534</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.6.1" href="#G.6.1"><b>    G.6.1 Trigonometric functions</b></a>
-<a name="G.6.1.1" href="#G.6.1.1"><b>    G.6.1.1 The cacos functions</b></a>
-1   -- cacos(conj(z)) = conj(cacos(z)).
-    -- cacos((+-)0 + i0) returns pi /2 - i0.
-    -- cacos((+-)0 + iNaN) returns pi /2 + iNaN.
-    -- cacos(x + i (inf)) returns pi /2 - i (inf), for finite x.
-    -- cacos(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for nonzero finite x.
-    -- cacos(-(inf) + iy) returns pi - i (inf), for positive-signed finite y.
-    -- cacos(+(inf) + iy) returns +0 - i (inf), for positive-signed finite y.
-    -- cacos(-(inf) + i (inf)) returns 3pi /4 - i (inf).
-    -- cacos(+(inf) + i (inf)) returns pi /4 - i (inf).
-    -- cacos((+-)(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
-      result is unspecified).
-    -- cacos(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite y.
-    -- cacos(NaN + i (inf)) returns NaN - i (inf).
-    -- cacos(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2" href="#G.6.2"><b>    G.6.2 Hyperbolic functions</b></a>
-<a name="G.6.2.1" href="#G.6.2.1"><b>    G.6.2.1 The cacosh functions</b></a>
-1   -- cacosh(conj(z)) = conj(cacosh(z)).
-    -- cacosh((+-)0 + i0) returns +0 + ipi /2.
-    -- cacosh(x + i (inf)) returns +(inf) + ipi /2, for finite x.
-    -- cacosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite x.
-    -- cacosh(-(inf) + iy) returns +(inf) + ipi , for positive-signed finite y.
-    -- cacosh(+(inf) + iy) returns +(inf) + i0, for positive-signed finite y.
-    -- cacosh(-(inf) + i (inf)) returns +(inf) + i3pi /4.
-    -- cacosh(+(inf) + i (inf)) returns +(inf) + ipi /4.
-    -- cacosh((+-)(inf) + iNaN) returns +(inf) + iNaN.
-
-[<a name="p535" href="#p535">page 535</a>] (<a href="#Contents">Contents</a>)
-
-    -- cacosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite y.
-    -- cacosh(NaN + i (inf)) returns +(inf) + iNaN.
-    -- cacosh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.2" href="#G.6.2.2"><b>    G.6.2.2 The casinh functions</b></a>
-1   -- casinh(conj(z)) = conj(casinh(z)) and casinh is odd.
-    -- casinh(+0 + i0) returns 0 + i0.
-    -- casinh(x + i (inf)) returns +(inf) + ipi /2 for positive-signed finite x.
-    -- casinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite x.
-    -- casinh(+(inf) + iy) returns +(inf) + i0 for positive-signed finite y.
-    -- casinh(+(inf) + i (inf)) returns +(inf) + ipi /4.
-    -- casinh(+(inf) + iNaN) returns +(inf) + iNaN.
-    -- casinh(NaN + i0) returns NaN + i0.
-    -- casinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite nonzero y.
-    -- casinh(NaN + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result
-      is unspecified).
-    -- casinh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.3" href="#G.6.2.3"><b>    G.6.2.3 The catanh functions</b></a>
-1   -- catanh(conj(z)) = conj(catanh(z)) and catanh is odd.
-    -- catanh(+0 + i0) returns +0 + i0.
-    -- catanh(+0 + iNaN) returns +0 + iNaN.
-    -- catanh(+1 + i0) returns +(inf) + i0 and raises the ''divide-by-zero'' floating-point
-      exception.
-    -- catanh(x + i (inf)) returns +0 + ipi /2, for finite positive-signed x.
-    -- catanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for nonzero finite x.
-    -- catanh(+(inf) + iy) returns +0 + ipi /2, for finite positive-signed y.
-    -- catanh(+(inf) + i (inf)) returns +0 + ipi /2.
-    -- catanh(+(inf) + iNaN) returns +0 + iNaN.
-
-[<a name="p536" href="#p536">page 536</a>] (<a href="#Contents">Contents</a>)
-
-    -- catanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
-      floating-point exception, for finite y.
-    -- catanh(NaN + i (inf)) returns (+-)0 + ipi /2 (where the sign of the real part of the result is
-      unspecified).
-    -- catanh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.4" href="#G.6.2.4"><b>    G.6.2.4 The ccosh functions</b></a>
-1   -- ccosh(conj(z)) = conj(ccosh(z)) and ccosh is even.
-    -- ccosh(+0 + i0) returns 1 + i0.
-    -- ccosh(+0 + i (inf)) returns NaN (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified) and raises the ''invalid'' floating-point exception.
-    -- ccosh(+0 + iNaN) returns NaN (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified).
-    -- ccosh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for finite nonzero x.
-    -- ccosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite nonzero x.
-    -- ccosh(+(inf) + i0) returns +(inf) + i0.
-    -- ccosh(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
-    -- ccosh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
-      unspecified) and raises the ''invalid'' floating-point exception.
-    -- ccosh(+(inf) + iNaN) returns +(inf) + iNaN.
-    -- ccosh(NaN + i0) returns NaN (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified).
-    -- ccosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- ccosh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.5" href="#G.6.2.5"><b>    G.6.2.5 The csinh functions</b></a>
-1   -- csinh(conj(z)) = conj(csinh(z)) and csinh is odd.
-    -- csinh(+0 + i0) returns +0 + i0.
-    -- csinh(+0 + i (inf)) returns (+-)0 + iNaN (where the sign of the real part of the result is
-      unspecified) and raises the ''invalid'' floating-point exception.
-    -- csinh(+0 + iNaN) returns (+-)0 + iNaN (where the sign of the real part of the result is
-      unspecified).
-
-[<a name="p537" href="#p537">page 537</a>] (<a href="#Contents">Contents</a>)
-
-    -- csinh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for positive finite x.
-    -- csinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite nonzero x.
-    -- csinh(+(inf) + i0) returns +(inf) + i0.
-    -- csinh(+(inf) + iy) returns +(inf) cis(y), for positive finite y.
-    -- csinh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
-      unspecified) and raises the ''invalid'' floating-point exception.
-    -- csinh(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
-      is unspecified).
-    -- csinh(NaN + i0) returns NaN + i0.
-    -- csinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- csinh(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.2.6" href="#G.6.2.6"><b>    G.6.2.6 The ctanh functions</b></a>
-1   -- ctanh(conj(z)) = conj(ctanh(z))and ctanh is odd.
-    -- ctanh(+0 + i0) returns +0 + i0.
-    -- ctanh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for finite x.
-    -- ctanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-    -- ctanh(+(inf) + iy) returns 1 + i0 sin(2y), for positive-signed finite y.
-    -- ctanh(+(inf) + i (inf)) returns 1 (+-) i0 (where the sign of the imaginary part of the result
-      is unspecified).
-    -- ctanh(+(inf) + iNaN) returns 1 (+-) i0 (where the sign of the imaginary part of the
-      result is unspecified).
-    -- ctanh(NaN + i0) returns NaN + i0.
-    -- ctanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- ctanh(NaN + iNaN) returns NaN + iNaN.
-
-[<a name="p538" href="#p538">page 538</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.6.3" href="#G.6.3"><b>    G.6.3 Exponential and logarithmic functions</b></a>
-<a name="G.6.3.1" href="#G.6.3.1"><b>    G.6.3.1 The cexp functions</b></a>
-1   -- cexp(conj(z)) = conj(cexp(z)).
-    -- cexp((+-)0 + i0) returns 1 + i0.
-    -- cexp(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
-      exception, for finite x.
-    -- cexp(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-    -- cexp(+(inf) + i0) returns +(inf) + i0.
-    -- cexp(-(inf) + iy) returns +0 cis(y), for finite y.
-    -- cexp(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
-    -- cexp(-(inf) + i (inf)) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts of
-      the result are unspecified).
-    -- cexp(+(inf) + i (inf)) returns (+-)(inf) + iNaN and raises the ''invalid'' floating-point
-      exception (where the sign of the real part of the result is unspecified).
-    -- cexp(-(inf) + iNaN) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts
-      of the result are unspecified).
-    -- cexp(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
-      is unspecified).
-    -- cexp(NaN + i0) returns NaN + i0.
-    -- cexp(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for all nonzero numbers y.
-    -- cexp(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.3.2" href="#G.6.3.2"><b>    G.6.3.2 The clog functions</b></a>
-1   -- clog(conj(z)) = conj(clog(z)).
-    -- clog(-0 + i0) returns -(inf) + ipi and raises the ''divide-by-zero'' floating-point
-      exception.
-    -- clog(+0 + i0) returns -(inf) + i0 and raises the ''divide-by-zero'' floating-point
-      exception.
-    -- clog(x + i (inf)) returns +(inf) + ipi /2, for finite x.
-    -- clog(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-
-[<a name="p539" href="#p539">page 539</a>] (<a href="#Contents">Contents</a>)
-
-    -- clog(-(inf) + iy) returns +(inf) + ipi , for finite positive-signed y.
-    -- clog(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
-    -- clog(-(inf) + i (inf)) returns +(inf) + i3pi /4.
-    -- clog(+(inf) + i (inf)) returns +(inf) + ipi /4.
-    -- clog((+-)(inf) + iNaN) returns +(inf) + iNaN.
-    -- clog(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite y.
-    -- clog(NaN + i (inf)) returns +(inf) + iNaN.
-    -- clog(NaN + iNaN) returns NaN + iNaN.
-<a name="G.6.4" href="#G.6.4"><b>    G.6.4 Power and absolute-value functions</b></a>
-<a name="G.6.4.1" href="#G.6.4.1"><b>    G.6.4.1 The cpow functions</b></a>
-1   The cpow functions raise floating-point exceptions if appropriate for the calculation of
-    the parts of the result, and may also raise spurious floating-point exceptions.<sup><a href="#note366"><b>366)</b></a></sup>
-<a name="G.6.4.2" href="#G.6.4.2"><b>    G.6.4.2 The csqrt functions</b></a>
-1   -- csqrt(conj(z)) = conj(csqrt(z)).
-    -- csqrt((+-)0 + i0) returns +0 + i0.
-    -- csqrt(x + i (inf)) returns +(inf) + i (inf), for all x (including NaN).
-    -- csqrt(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite x.
-    -- csqrt(-(inf) + iy) returns +0 + i (inf), for finite positive-signed y.
-    -- csqrt(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
-    -- csqrt(-(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
-      result is unspecified).
-    -- csqrt(+(inf) + iNaN) returns +(inf) + iNaN.
-    -- csqrt(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
-      point exception, for finite y.
-    -- csqrt(NaN + iNaN) returns NaN + iNaN.
-
-
-
-
-    <sup><a name="note366" href="#note366"><b>366)</b></a></sup> This allows cpow( z , c ) to be implemented as cexp(c      clog( z )) without precluding
-         implementations that treat special cases more carefully.
-
-[<a name="p540" href="#p540">page 540</a>] (<a href="#Contents">Contents</a>)
-
-<a name="G.7" href="#G.7"><b>    G.7 Type-generic math &lt;tgmath.h&gt;</b></a>
-1   Type-generic macros that accept complex arguments also accept imaginary arguments. If
-    an argument is imaginary, the macro expands to an expression whose type is real,
-    imaginary, or complex, as appropriate for the particular function: if the argument is
-    imaginary, then the types of cos, cosh, fabs, carg, cimag, and creal are real; the
-    types of sin, tan, sinh, tanh, asin, atan, asinh, and atanh are imaginary; and
-    the types of the others are complex.
-2   Given an imaginary argument, each of the type-generic macros cos, sin, tan, cosh,
-    sinh, tanh, asin, atan, asinh, atanh is specified by a formula in terms of real
-    functions:
-            cos(iy)     =   cosh(y)
-            sin(iy)     =   i sinh(y)
-            tan(iy)     =   i tanh(y)
-            cosh(iy)    =   cos(y)
-            sinh(iy)    =   i sin(y)
-            tanh(iy)    =   i tan(y)
-            asin(iy)    =   i asinh(y)
-            atan(iy)    =   i atanh(y)
-            asinh(iy)   =   i asin(y)
-            atanh(iy)   =   i atan(y)
-
-[<a name="p541" href="#p541">page 541</a>] (<a href="#Contents">Contents</a>)
-
-<a name="H" href="#H"><b>                                          Annex H</b></a>
-                                        (informative)
-                        Language independent arithmetic
-<a name="H.1" href="#H.1"><b>    H.1 Introduction</b></a>
-1   This annex documents the extent to which the C language supports the ISO/IEC 10967-1
-    standard for language-independent arithmetic (LIA-1). LIA-1 is more general than
-    IEC 60559 (<a href="#F">annex F</a>) in that it covers integer and diverse floating-point arithmetics.
-<a name="H.2" href="#H.2"><b>    H.2 Types</b></a>
-1   The relevant C arithmetic types meet the requirements of LIA-1 types if an
-    implementation adds notification of exceptional arithmetic operations and meets the 1
-    unit in the last place (ULP) accuracy requirement (LIA-1 subclause <a href="#5.2.8">5.2.8</a>).
-<a name="H.2.1" href="#H.2.1"><b>    H.2.1 Boolean type</b></a>
-1   The LIA-1 data type Boolean is implemented by the C data type bool with values of
-    true and false, all from <a href="#7.18">&lt;stdbool.h&gt;</a>.
-<a name="H.2.2" href="#H.2.2"><b>    H.2.2 Integer types</b></a>
-1   The signed C integer types int, long int, long long int, and the corresponding
-    unsigned types are compatible with LIA-1. If an implementation adds support for the
-    LIA-1 exceptional values ''integer_overflow'' and ''undefined'', then those types are
-    LIA-1 conformant types. C's unsigned integer types are ''modulo'' in the LIA-1 sense
-    in that overflows or out-of-bounds results silently wrap. An implementation that defines
-    signed integer types as also being modulo need not detect integer overflow, in which case,
-    only integer divide-by-zero need be detected.
-2   The parameters for the integer data types can be accessed by the following:
-    maxint        INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
-                  ULLONG_MAX
-    minint        INT_MIN, LONG_MIN, LLONG_MIN
-3   The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
-    is always 0 for the unsigned types, and is not provided for those types.
-
-[<a name="p542" href="#p542">page 542</a>] (<a href="#Contents">Contents</a>)
-
-<a name="H.2.2.1" href="#H.2.2.1"><b>    H.2.2.1 Integer operations</b></a>
-1   The integer operations on integer types are the following:
-    addI           x + y
-    subI           x - y
-    mulI           x * y
-    divI, divtI    x / y
-    remI, remtI    x % y
-    negI           -x
-    absI           abs(x), labs(x), llabs(x)
-    eqI            x == y
-    neqI           x != y
-    lssI           x &lt; y
-    leqI           x &lt;= y
-    gtrI           x &gt; y
-    geqI           x &gt;= y
-    where x and y are expressions of the same integer type.
-<a name="H.2.3" href="#H.2.3"><b>    H.2.3 Floating-point types</b></a>
-1   The C floating-point types float, double, and long double are compatible with
-    LIA-1. If an implementation adds support for the LIA-1 exceptional values
-    ''underflow'', ''floating_overflow'', and ''"undefined'', then those types are conformant
-    with LIA-1. An implementation that uses IEC 60559 floating-point formats and
-    operations (see <a href="#F">annex F</a>) along with IEC 60559 status flags and traps has LIA-1
-    conformant types.
-<a name="H.2.3.1" href="#H.2.3.1"><b>    H.2.3.1 Floating-point parameters</b></a>
-1   The parameters for a floating point data type can be accessed by the following:
-    r              FLT_RADIX
-    p              FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG
-    emax           FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP
-    emin           FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP
-2   The derived constants for the floating point types are accessed by the following:
-
-[<a name="p543" href="#p543">page 543</a>] (<a href="#Contents">Contents</a>)
-
-    fmax          FLT_MAX, DBL_MAX, LDBL_MAX
-    fminN         FLT_MIN, DBL_MIN, LDBL_MIN
-    epsilon       FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON
-    rnd_style     FLT_ROUNDS
-<a name="H.2.3.2" href="#H.2.3.2"><b>    H.2.3.2 Floating-point operations</b></a>
-1   The floating-point operations on floating-point types are the following:
-    addF          x + y
-    subF          x - y
-    mulF          x * y
-    divF          x / y
-    negF          -x
-    absF          fabsf(x), fabs(x), fabsl(x)
-    exponentF     1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
-    scaleF        scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
-                  scalblnf(x, li), scalbln(x, li), scalblnl(x, li)
-    intpartF      modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
-    fractpartF    modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
-    eqF           x == y
-    neqF          x != y
-    lssF          x &lt; y
-    leqF          x &lt;= y
-    gtrF          x &gt; y
-    geqF          x &gt;= y
-    where x and y are expressions of the same floating point type, n is of type int, and li
-    is of type long int.
-<a name="H.2.3.3" href="#H.2.3.3"><b>    H.2.3.3 Rounding styles</b></a>
-1   The C Standard requires all floating types to use the same radix and rounding style, so
-    that only one identifier for each is provided to map to LIA-1.
-2   The FLT_ROUNDS parameter can be used to indicate the LIA-1 rounding styles:
-    truncate      FLT_ROUNDS == 0
-
-[<a name="p544" href="#p544">page 544</a>] (<a href="#Contents">Contents</a>)
-
-    nearest       FLT_ROUNDS == 1
-    other         FLT_ROUNDS != 0 &amp;&amp; FLT_ROUNDS != 1
-    provided that an implementation extends FLT_ROUNDS to cover the rounding style used
-    in all relevant LIA-1 operations, not just addition as in C.
-<a name="H.2.4" href="#H.2.4"><b>    H.2.4 Type conversions</b></a>
-1   The LIA-1 type conversions are the following type casts:
-    cvtI' -&gt; I     (int)i, (long int)i, (long long int)i,
-                  (unsigned int)i, (unsigned long int)i,
-                  (unsigned long long int)i
-    cvtF -&gt; I      (int)x, (long int)x, (long long int)x,
-                  (unsigned int)x, (unsigned long int)x,
-                  (unsigned long long int)x
-    cvtI -&gt; F      (float)i, (double)i, (long double)i
-    cvtF' -&gt; F     (float)x, (double)x, (long double)x
-2   In the above conversions from floating to integer, the use of (cast)x can be replaced with
-    (cast)round(x), (cast)rint(x), (cast)nearbyint(x), (cast)trunc(x),
-    (cast)ceil(x), or (cast)floor(x). In addition, C's floating-point to integer
-    conversion functions, lrint(), llrint(), lround(), and llround(), can be
-    used. They all meet LIA-1's requirements on floating to integer rounding for in-range
-    values. For out-of-range values, the conversions shall silently wrap for the modulo types.
-3   The fmod() function is useful for doing silent wrapping to unsigned integer types, e.g.,
-    fmod( fabs(rint(x)), 65536.0 ) or (0.0 &lt;= (y = fmod( rint(x),
-    65536.0 )) ? y : 65536.0 + y) will compute an integer value in the range 0.0
-    to 65535.0 which can then be cast to unsigned short int. But, the
-    remainder() function is not useful for doing silent wrapping to signed integer types,
-    e.g., remainder( rint(x), 65536.0 ) will compute an integer value in the
-    range -32767.0 to +32768.0 which is not, in general, in the range of signed short
-    int.
-4   C's conversions (casts) from floating-point to floating-point can meet LIA-1
-    requirements if an implementation uses round-to-nearest (IEC 60559 default).
-5   C's conversions (casts) from integer to floating-point can meet LIA-1 requirements if an
-    implementation uses round-to-nearest.
-
-[<a name="p545" href="#p545">page 545</a>] (<a href="#Contents">Contents</a>)
-
-<a name="H.3" href="#H.3"><b>    H.3 Notification</b></a>
-1   Notification is the process by which a user or program is informed that an exceptional
-    arithmetic operation has occurred. C's operations are compatible with LIA-1 in that C
-    allows an implementation to cause a notification to occur when any arithmetic operation
-    returns an exceptional value as defined in LIA-1 clause 5.
-<a name="H.3.1" href="#H.3.1"><b>    H.3.1 Notification alternatives</b></a>
-1   LIA-1 requires at least the following two alternatives for handling of notifications:
-    setting indicators or trap-and-terminate. LIA-1 allows a third alternative: trap-and-
-    resume.
-2   An implementation need only support a given notification alternative for the entire
-    program. An implementation may support the ability to switch between notification
-    alternatives during execution, but is not required to do so. An implementation can
-    provide separate selection for each kind of notification, but this is not required.
-3   C allows an implementation to provide notification. C's SIGFPE (for traps) and
-    FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW (for indicators)
-    can provide LIA-1 notification.
-4   C's signal handlers are compatible with LIA-1. Default handling of SIGFPE can
-    provide trap-and-terminate behavior, except for those LIA-1 operations implemented by
-    math library function calls. User-provided signal handlers for SIGFPE allow for trap-
-    and-resume behavior with the same constraint.
-<a name="H.3.1.1" href="#H.3.1.1"><b>    H.3.1.1 Indicators</b></a>
-1   C's <a href="#7.6">&lt;fenv.h&gt;</a> status flags are compatible with the LIA-1 indicators.
-2   The following mapping is for floating-point types:
-    undefined                FE_INVALID, FE_DIVBYZERO
-    floating_overflow         FE_OVERFLOW
-    underflow                FE_UNDERFLOW
-3   The floating-point indicator interrogation and manipulation operations are:
-    set_indicators          feraiseexcept(i)
-    clear_indicators        feclearexcept(i)
-    test_indicators         fetestexcept(i)
-    current_indicators      fetestexcept(FE_ALL_EXCEPT)
-    where i is an expression of type int representing a subset of the LIA-1 indicators.
-4   C allows an implementation to provide the following LIA-1 required behavior: at
-    program termination if any indicator is set the implementation shall send an unambiguous
-
-[<a name="p546" href="#p546">page 546</a>] (<a href="#Contents">Contents</a>)
-
-    and ''hard to ignore'' message (see LIA-1 subclause <a href="#6.1.2">6.1.2</a>)
-5   LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
-    This documentation makes that distinction because <a href="#7.6">&lt;fenv.h&gt;</a> covers only the floating-
-    point indicators.
-<a name="H.3.1.2" href="#H.3.1.2"><b>    H.3.1.2 Traps</b></a>
-1   C is compatible with LIA-1's trap requirements for arithmetic operations, but not for
-    math library functions (which are not permitted to invoke a user's signal handler for
-    SIGFPE). An implementation can provide an alternative of notification through
-    termination with a ''hard-to-ignore'' message (see LIA-1 subclause <a href="#6.1.3">6.1.3</a>).
-2   LIA-1 does not require that traps be precise.
-3   C does require that SIGFPE be the signal corresponding to LIA-1 arithmetic exceptions,
-    if there is any signal raised for them.
-4   C supports signal handlers for SIGFPE and allows trapping of LIA-1 arithmetic
-    exceptions. When LIA-1 arithmetic exceptions do trap, C's signal-handler mechanism
-    allows trap-and-terminate (either default implementation behavior or user replacement for
-    it) or trap-and-resume, at the programmer's option.
-
-[<a name="p547" href="#p547">page 547</a>] (<a href="#Contents">Contents</a>)
-
-<a name="I" href="#I"><b>                                           Annex I</b></a>
-                                        (informative)
-                                   Common warnings
-1   An implementation may generate warnings in many situations, none of which are
-    specified as part of this International Standard. The following are a few of the more
-    common situations.
-2   -- A new struct or union type appears in a function prototype (<a href="#6.2.1">6.2.1</a>, <a href="#6.7.2.3">6.7.2.3</a>).
-    -- A block with initialization of an object that has automatic storage duration is jumped
-      into (<a href="#6.2.4">6.2.4</a>).
-    -- An implicit narrowing conversion is encountered, such as the assignment of a long
-      int or a double to an int, or a pointer to void to a pointer to any type other than
-      a character type (<a href="#6.3">6.3</a>).
-    -- A hexadecimal floating constant cannot be represented exactly in its evaluation format
-      (<a href="#6.4.4.2">6.4.4.2</a>).
-    -- An integer character constant includes more than one character or a wide character
-      constant includes more than one multibyte character (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- The characters /* are found in a comment (<a href="#6.4.7">6.4.7</a>).
-    -- An ''unordered'' binary operator (not comma, &amp;&amp;, or ||) contains a side effect to an
-      lvalue in one operand, and a side effect to, or an access to the value of, the identical
-      lvalue in the other operand (<a href="#6.5">6.5</a>).
-    -- A function is called but no prototype has been supplied (<a href="#6.5.2.2">6.5.2.2</a>).
-    -- The arguments in a function call do not agree in number and type with those of the
-      parameters in a function definition that is not a prototype (<a href="#6.5.2.2">6.5.2.2</a>).
-    -- An object is defined but not used (<a href="#6.7">6.7</a>).
-    -- A value is given to an object of an enumerated type other than by assignment of an
-      enumeration constant that is a member of that type, or an enumeration object that has
-      the same type, or the value of a function that returns the same enumerated type
-      (<a href="#6.7.2.2">6.7.2.2</a>).
-    -- An aggregate has a partly bracketed initialization (<a href="#6.7.8">6.7.8</a>).
-    -- A statement cannot be reached (<a href="#6.8">6.8</a>).
-    -- A statement with no apparent effect is encountered (<a href="#6.8">6.8</a>).
-    -- A constant expression is used as the controlling expression of a selection statement
-      (<a href="#6.8.4">6.8.4</a>).
-
-[<a name="p548" href="#p548">page 548</a>] (<a href="#Contents">Contents</a>)
-
--- An incorrectly formed preprocessing group is encountered while skipping a
-  preprocessing group (<a href="#6.10.1">6.10.1</a>).
--- An unrecognized #pragma directive is encountered (<a href="#6.10.6">6.10.6</a>).
-
-[<a name="p549" href="#p549">page 549</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J" href="#J"><b>                                            Annex J</b></a>
-                                         (informative)
-                                      Portability issues
-1   This annex collects some information about portability that appears in this International
-    Standard.
-<a name="J.1" href="#J.1"><b>    J.1 Unspecified behavior</b></a>
-1   The following are unspecified:
-    -- The manner and timing of static initialization (<a href="#5.1.2">5.1.2</a>).
-    -- The termination status returned to the hosted environment if the return type of main
-      is not compatible with int (<a href="#5.1.2.2.3">5.1.2.2.3</a>).
-    -- The behavior of the display device if a printing character is written when the active
-      position is at the final position of a line (<a href="#5.2.2">5.2.2</a>).
-    -- The behavior of the display device if a backspace character is written when the active
-      position is at the initial position of a line (<a href="#5.2.2">5.2.2</a>).
-    -- The behavior of the display device if a horizontal tab character is written when the
-      active position is at or past the last defined horizontal tabulation position (<a href="#5.2.2">5.2.2</a>).
-    -- The behavior of the display device if a vertical tab character is written when the active
-      position is at or past the last defined vertical tabulation position (<a href="#5.2.2">5.2.2</a>).
-    -- How an extended source character that does not correspond to a universal character
-      name counts toward the significant initial characters in an external identifier (<a href="#5.2.4.1">5.2.4.1</a>).
-    -- Many aspects of the representations of types (<a href="#6.2.6">6.2.6</a>).
-    -- The value of padding bytes when storing values in structures or unions (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- The values of bytes that correspond to union members other than the one last stored
-      into (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- The representation used when storing a value in an object that has more than one
-      object representation for that value (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- The values of any padding bits in integer representations (<a href="#6.2.6.2">6.2.6.2</a>).
-    -- Whether certain operators can generate negative zeros and whether a negative zero
-      becomes a normal zero when stored in an object (<a href="#6.2.6.2">6.2.6.2</a>).
-    -- Whether two string literals result in distinct arrays (<a href="#6.4.5">6.4.5</a>).
-    -- The order in which subexpressions are evaluated and the order in which side effects
-      take place, except as specified for the function-call (), &amp;&amp;, ||, ? :, and comma
-
-[<a name="p550" href="#p550">page 550</a>] (<a href="#Contents">Contents</a>)
-
-   operators (<a href="#6.5">6.5</a>).
--- The order in which the function designator, arguments, and subexpressions within the
-  arguments are evaluated in a function call (<a href="#6.5.2.2">6.5.2.2</a>).
--- The order of side effects among compound literal initialization list expressions
-  (<a href="#6.5.2.5">6.5.2.5</a>).
--- The order in which the operands of an assignment operator are evaluated (<a href="#6.5.16">6.5.16</a>).
--- The alignment of the addressable storage unit allocated to hold a bit-field (<a href="#6.7.2.1">6.7.2.1</a>).
--- Whether a call to an inline function uses the inline definition or the external definition
-  of the function (<a href="#6.7.4">6.7.4</a>).
--- Whether or not a size expression is evaluated when it is part of the operand of a
-  sizeof operator and changing the value of the size expression would not affect the
-  result of the operator (<a href="#6.7.6.2">6.7.6.2</a>).
--- The order in which any side effects occur among the initialization list expressions in
-  an initializer (<a href="#6.7.9">6.7.9</a>).
--- The layout of storage for function parameters (<a href="#6.9.1">6.9.1</a>).
--- When a fully expanded macro replacement list contains a function-like macro name
-  as its last preprocessing token and the next preprocessing token from the source file is
-  a (, and the fully expanded replacement of that macro ends with the name of the first
-  macro and the next preprocessing token from the source file is again a (, whether that
-  is considered a nested replacement (<a href="#6.10.3">6.10.3</a>).
--- The order in which # and ## operations are evaluated during macro substitution
-  (<a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>).
--- The state of the floating-point status flags when execution passes from a part of the *
-  program translated with FENV_ACCESS ''off'' to a part translated with
-  FENV_ACCESS ''on'' (<a href="#7.6.1">7.6.1</a>).
--- The order in which feraiseexcept raises floating-point exceptions, except as
-  stated in <a href="#F.8.6">F.8.6</a> (<a href="#7.6.2.3">7.6.2.3</a>).
--- Whether math_errhandling is a macro or an identifier with external linkage
-  (<a href="#7.12">7.12</a>).
--- The results of the frexp functions when the specified value is not a floating-point
-  number (<a href="#7.12.6.4">7.12.6.4</a>).
--- The numeric result of the ilogb functions when the correct value is outside the
-  range of the return type (<a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>).
--- The result of rounding when the value is out of range (<a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.5">F.10.6.5</a>).
-
-[<a name="p551" href="#p551">page 551</a>] (<a href="#Contents">Contents</a>)
-
--- The value stored by the remquo functions in the object pointed to by quo when y is
-  zero (<a href="#7.12.10.3">7.12.10.3</a>).
--- Whether a comparison macro argument that is represented in a format wider than its
-  semantic type is converted to the semantic type (<a href="#7.12.14">7.12.14</a>).
--- Whether setjmp is a macro or an identifier with external linkage (<a href="#7.13">7.13</a>).
--- Whether va_copy and va_end are macros or identifiers with external linkage
-  (<a href="#7.16.1">7.16.1</a>).
--- The hexadecimal digit before the decimal point when a non-normalized floating-point
-  number is printed with an a or A conversion specifier (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
--- The value of the file position indicator after a successful call to the ungetc function
-  for a text stream, or the ungetwc function for any stream, until all pushed-back
-  characters are read or discarded (<a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.28.3.10">7.28.3.10</a>).
--- The details of the value stored by the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>).
--- The details of the value returned by the ftell function for a text stream (<a href="#7.21.9.4">7.21.9.4</a>).
--- Whether the strtod, strtof, strtold, wcstod, wcstof, and wcstold
-  functions convert a minus-signed sequence to a negative number directly or by
-  negating the value resulting from converting the corresponding unsigned sequence
-  (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
--- The order and contiguity of storage allocated by successive calls to the calloc,
-  malloc, and realloc functions (<a href="#7.22.3">7.22.3</a>).
--- The amount of storage allocated by a successful call to the calloc, malloc, or
-  realloc function when 0 bytes was requested (<a href="#7.22.3">7.22.3</a>).
--- Which of two elements that compare as equal is matched by the bsearch function
-  (<a href="#7.22.5.1">7.22.5.1</a>).
--- The order of two elements that compare as equal in an array sorted by the qsort
-  function (<a href="#7.22.5.2">7.22.5.2</a>).
--- The encoding of the calendar time returned by the time function (<a href="#7.26.2.4">7.26.2.4</a>).
--- The characters stored by the strftime or wcsftime function if any of the time
-  values being converted is outside the normal range (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
--- The conversion state after an encoding error occurs (<a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>,
-  <a href="#7.28.6.4.2">7.28.6.4.2</a>,
--- The resulting value when the ''invalid'' floating-point exception is raised during
-  IEC 60559 floating to integer conversion (<a href="#F.4">F.4</a>).
-
-[<a name="p552" href="#p552">page 552</a>] (<a href="#Contents">Contents</a>)
-
-    -- Whether conversion of non-integer IEC 60559 floating values to integer raises the
-      ''inexact'' floating-point exception (<a href="#F.4">F.4</a>).
-    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise the ''inexact'' floating-point
-      exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
-    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise an undeserved ''underflow''
-      floating-point exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
-    -- The exponent value stored by frexp for a NaN or infinity (<a href="#F.10.3.4">F.10.3.4</a>).
-    -- The numeric result returned by the lrint, llrint, lround, and llround
-      functions if the rounded value is outside the range of the return type (<a href="#F.10.6.5">F.10.6.5</a>,
-      <a href="#F.10.6.7">F.10.6.7</a>).
-    -- The sign of one part of the complex result of several math functions for certain
-      special cases in IEC 60559 compatible implementations (<a href="#G.6.1.1">G.6.1.1</a>, <a href="#G.6.2.2">G.6.2.2</a>, <a href="#G.6.2.3">G.6.2.3</a>,
-      <a href="#G.6.2.4">G.6.2.4</a>, <a href="#G.6.2.5">G.6.2.5</a>, <a href="#G.6.2.6">G.6.2.6</a>, <a href="#G.6.3.1">G.6.3.1</a>, <a href="#G.6.4.2">G.6.4.2</a>).
-<a name="J.2" href="#J.2"><b>    J.2 Undefined behavior</b></a>
-1   The behavior is undefined in the following circumstances:
-    -- A ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated
-      (clause 4).
-    -- A nonempty source file does not end in a new-line character which is not immediately
-      preceded by a backslash character or ends in a partial preprocessing token or
-      comment (<a href="#5.1.1.2">5.1.1.2</a>).
-    -- Token concatenation produces a character sequence matching the syntax of a
-      universal character name (<a href="#5.1.1.2">5.1.1.2</a>).
-    -- A program in a hosted environment does not define a function named main using one
-      of the specified forms (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-    -- The execution of a program contains a data race (<a href="#5.1.2.4">5.1.2.4</a>).
-    -- A character not in the basic source character set is encountered in a source file, except
-      in an identifier, a character constant, a string literal, a header name, a comment, or a
-      preprocessing token that is never converted to a token (<a href="#5.2.1">5.2.1</a>).
-    -- An identifier, comment, string literal, character constant, or header name contains an
-      invalid multibyte character or does not begin and end in the initial shift state (<a href="#5.2.1.2">5.2.1.2</a>).
-    -- The same identifier has both internal and external linkage in the same translation unit
-      (<a href="#6.2.2">6.2.2</a>).
-    -- An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
-
-[<a name="p553" href="#p553">page 553</a>] (<a href="#Contents">Contents</a>)
-
--- The value of a pointer to an object whose lifetime has ended is used (<a href="#6.2.4">6.2.4</a>).
--- The value of an object with automatic storage duration is used while it is
-  indeterminate (<a href="#6.2.4">6.2.4</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8">6.8</a>).
--- A trap representation is read by an lvalue expression that does not have character type
-  (<a href="#6.2.6.1">6.2.6.1</a>).
--- A trap representation is produced by a side effect that modifies any part of the object
-  using an lvalue expression that does not have character type (<a href="#6.2.6.1">6.2.6.1</a>).
--- The operands to certain operators are such that they could produce a negative zero
-  result, but the implementation does not support negative zeros (<a href="#6.2.6.2">6.2.6.2</a>).
--- Two declarations of the same object or function specify types that are not compatible
-  (<a href="#6.2.7">6.2.7</a>).
--- A program requires the formation of a composite type from a variable length array
-  type whose size is specified by an expression that is not evaluated (<a href="#6.2.7">6.2.7</a>).
--- Conversion to or from an integer type produces a value outside the range that can be
-  represented (<a href="#6.3.1.4">6.3.1.4</a>).
--- Demotion of one real floating type to another produces a value outside the range that
-  can be represented (<a href="#6.3.1.5">6.3.1.5</a>).
--- An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
--- A non-array lvalue with an incomplete type is used in a context that requires the value
-  of the designated object (<a href="#6.3.2.1">6.3.2.1</a>).
--- An lvalue designating an object of automatic storage duration that could have been
-  declared with the register storage class is used in a context that requires the value
-  of the designated object, but the object is uninitialized. (<a href="#6.3.2.1">6.3.2.1</a>).
--- An lvalue having array type is converted to a pointer to the initial element of the
-  array, and the array object has register storage class (<a href="#6.3.2.1">6.3.2.1</a>).
--- An attempt is made to use the value of a void expression, or an implicit or explicit
-  conversion (except to void) is applied to a void expression (<a href="#6.3.2.2">6.3.2.2</a>).
--- Conversion of a pointer to an integer type produces a value outside the range that can
-  be represented (<a href="#6.3.2.3">6.3.2.3</a>).
--- Conversion between two pointer types produces a result that is incorrectly aligned
-  (<a href="#6.3.2.3">6.3.2.3</a>).
--- A pointer is used to call a function whose type is not compatible with the referenced
-  type (<a href="#6.3.2.3">6.3.2.3</a>).
-
-[<a name="p554" href="#p554">page 554</a>] (<a href="#Contents">Contents</a>)
-
--- An unmatched ' or " character is encountered on a logical source line during
-  tokenization (<a href="#6.4">6.4</a>).
--- A reserved keyword token is used in translation phase 7 or 8 for some purpose other
-  than as a keyword (<a href="#6.4.1">6.4.1</a>).
--- A universal character name in an identifier does not designate a character whose
-  encoding falls into one of the specified ranges (<a href="#6.4.2.1">6.4.2.1</a>).
--- The initial character of an identifier is a universal character name designating a digit
-  (<a href="#6.4.2.1">6.4.2.1</a>).
--- Two identifiers differ only in nonsignificant characters (<a href="#6.4.2.1">6.4.2.1</a>).
--- The identifier __func__ is explicitly declared (<a href="#6.4.2.2">6.4.2.2</a>).
--- The program attempts to modify a string literal (<a href="#6.4.5">6.4.5</a>).
--- The characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt;
-  delimiters, or the characters ', \, //, or /* occur in the sequence between the "
-  delimiters, in a header name preprocessing token (<a href="#6.4.7">6.4.7</a>).
--- A side effect on a scalar object is unsequenced relative to either a different side effect
-  on the same scalar object or a value computation using the value of the same scalar
-  object (<a href="#6.5">6.5</a>).
--- An exceptional condition occurs during the evaluation of an expression (<a href="#6.5">6.5</a>).
--- An object has its stored value accessed other than by an lvalue of an allowable type
-  (<a href="#6.5">6.5</a>).
--- For a call to a function without a function prototype in scope, the number of *
-  arguments does not equal the number of parameters (<a href="#6.5.2.2">6.5.2.2</a>).
--- For call to a function without a function prototype in scope where the function is
-  defined with a function prototype, either the prototype ends with an ellipsis or the
-  types of the arguments after promotion are not compatible with the types of the
-  parameters (<a href="#6.5.2.2">6.5.2.2</a>).
--- For a call to a function without a function prototype in scope where the function is not
-  defined with a function prototype, the types of the arguments after promotion are not
-  compatible with those of the parameters after promotion (with certain exceptions)
-  (<a href="#6.5.2.2">6.5.2.2</a>).
--- A function is defined with a type that is not compatible with the type (of the
-  expression) pointed to by the expression that denotes the called function (<a href="#6.5.2.2">6.5.2.2</a>).
--- A member of an atomic structure or union is accessed (<a href="#6.5.2.3">6.5.2.3</a>).
--- The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
-
-[<a name="p555" href="#p555">page 555</a>] (<a href="#Contents">Contents</a>)
-
--- A pointer is converted to other than an integer or pointer type (<a href="#6.5.4">6.5.4</a>).
--- The value of the second operand of the / or % operator is zero (<a href="#6.5.5">6.5.5</a>).
--- Addition or subtraction of a pointer into, or just beyond, an array object and an
-  integer type produces a result that does not point into, or just beyond, the same array
-  object (<a href="#6.5.6">6.5.6</a>).
--- Addition or subtraction of a pointer into, or just beyond, an array object and an
-  integer type produces a result that points just beyond the array object and is used as
-  the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
--- Pointers that do not point into, or just beyond, the same array object are subtracted
-  (<a href="#6.5.6">6.5.6</a>).
--- An array subscript is out of range, even if an object is apparently accessible with the
-  given subscript (as in the lvalue expression a[1][7] given the declaration int
-  a[4][5]) (<a href="#6.5.6">6.5.6</a>).
--- The result of subtracting two pointers is not representable in an object of type
-  ptrdiff_t (<a href="#6.5.6">6.5.6</a>).
--- An expression is shifted by a negative number or by an amount greater than or equal
-  to the width of the promoted expression (<a href="#6.5.7">6.5.7</a>).
--- An expression having signed promoted type is left-shifted and either the value of the
-  expression is negative or the result of shifting would be not be representable in the
-  promoted type (<a href="#6.5.7">6.5.7</a>).
--- Pointers that do not point to the same aggregate or union (nor just beyond the same
-  array object) are compared using relational operators (<a href="#6.5.8">6.5.8</a>).
--- An object is assigned to an inexactly overlapping object or to an exactly overlapping
-  object with incompatible type (<a href="#6.5.16.1">6.5.16.1</a>).
--- An expression that is required to be an integer constant expression does not have an
-  integer type; has operands that are not integer constants, enumeration constants,
-  character constants, sizeof expressions whose results are integer constants, or
-  immediately-cast floating constants; or contains casts (outside operands to sizeof
-  operators) other than conversions of arithmetic types to integer types (<a href="#6.6">6.6</a>).
--- A constant expression in an initializer is not, or does not evaluate to, one of the
-  following: an arithmetic constant expression, a null pointer constant, an address
-  constant, or an address constant for a complete object type plus or minus an integer
-  constant expression (<a href="#6.6">6.6</a>).
--- An arithmetic constant expression does not have arithmetic type; has operands that
-  are not integer constants, floating constants, enumeration constants, character
-  constants, or sizeof expressions; or contains casts (outside operands to sizeof
-
-[<a name="p556" href="#p556">page 556</a>] (<a href="#Contents">Contents</a>)
-
-   operators) other than conversions of arithmetic types to arithmetic types (<a href="#6.6">6.6</a>).
--- The value of an object is accessed by an array-subscript [], member-access . or -&gt;,
-  address &amp;, or indirection * operator or a pointer cast in creating an address constant
-  (<a href="#6.6">6.6</a>).
--- An identifier for an object is declared with no linkage and the type of the object is
-  incomplete after its declarator, or after its init-declarator if it has an initializer (<a href="#6.7">6.7</a>).
--- A function is declared at block scope with an explicit storage-class specifier other
-  than extern (<a href="#6.7.1">6.7.1</a>).
--- A structure or union is defined as containing no named members, no anonymous
-  structures, and no anonymous unions (<a href="#6.7.2.1">6.7.2.1</a>).
--- An attempt is made to access, or generate a pointer to just past, a flexible array
-  member of a structure when the referenced object provides no elements for that array
-  (<a href="#6.7.2.1">6.7.2.1</a>).
--- When the complete type is needed, an incomplete structure or union type is not
-  completed in the same scope by another declaration of the tag that defines the content
-  (<a href="#6.7.2.3">6.7.2.3</a>).
--- An attempt is made to modify an object defined with a const-qualified type through
-  use of an lvalue with non-const-qualified type (<a href="#6.7.3">6.7.3</a>).
--- An attempt is made to refer to an object defined with a volatile-qualified type through
-  use of an lvalue with non-volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
--- The specification of a function type includes any type qualifiers (<a href="#6.7.3">6.7.3</a>).                        *
--- Two qualified types that are required to be compatible do not have the identically
-  qualified version of a compatible type (<a href="#6.7.3">6.7.3</a>).
--- An object which has been modified is accessed through a restrict-qualified pointer to
-  a const-qualified type, or through a restrict-qualified pointer and another pointer that
-  are not both based on the same object (<a href="#6.7.3.1">6.7.3.1</a>).
--- A restrict-qualified pointer is assigned a value based on another restricted pointer
-  whose associated block neither began execution before the block associated with this
-  pointer, nor ended before the assignment (<a href="#6.7.3.1">6.7.3.1</a>).
--- A function with external linkage is declared with an inline function specifier, but is
-  not also defined in the same translation unit (<a href="#6.7.4">6.7.4</a>).
--- A function declared with a _Noreturn function specifier returns to its caller (<a href="#6.7.4">6.7.4</a>).
--- The definition of an object has an alignment specifier and another declaration of that
-  object has a different alignment specifier (<a href="#6.7.5">6.7.5</a>).
-
-[<a name="p557" href="#p557">page 557</a>] (<a href="#Contents">Contents</a>)
-
--- Declarations of an object in different translation units have different alignment
-  specifiers (<a href="#6.7.5">6.7.5</a>).
--- Two pointer types that are required to be compatible are not identically qualified, or
-  are not pointers to compatible types (<a href="#6.7.6.1">6.7.6.1</a>).
--- The size expression in an array declaration is not a constant expression and evaluates
-  at program execution time to a nonpositive value (<a href="#6.7.6.2">6.7.6.2</a>).
--- In a context requiring two array types to be compatible, they do not have compatible
-  element types, or their size specifiers evaluate to unequal values (<a href="#6.7.6.2">6.7.6.2</a>).
--- A declaration of an array parameter includes the keyword static within the [ and
-  ] and the corresponding argument does not provide access to the first element of an
-  array with at least the specified number of elements (<a href="#6.7.6.3">6.7.6.3</a>).
--- A storage-class specifier or type qualifier modifies the keyword void as a function
-  parameter type list (<a href="#6.7.6.3">6.7.6.3</a>).
--- In a context requiring two function types to be compatible, they do not have
-  compatible return types, or their parameters disagree in use of the ellipsis terminator
-  or the number and type of parameters (after default argument promotion, when there
-  is no parameter type list or when one type is specified by a function definition with an
-  identifier list) (<a href="#6.7.6.3">6.7.6.3</a>).
--- The value of an unnamed member of a structure or union is used (<a href="#6.7.9">6.7.9</a>).
--- The initializer for a scalar is neither a single expression nor a single expression
-  enclosed in braces (<a href="#6.7.9">6.7.9</a>).
--- The initializer for a structure or union object that has automatic storage duration is
-  neither an initializer list nor a single expression that has compatible structure or union
-  type (<a href="#6.7.9">6.7.9</a>).
--- The initializer for an aggregate or union, other than an array initialized by a string
-  literal, is not a brace-enclosed list of initializers for its elements or members (<a href="#6.7.9">6.7.9</a>).
--- An identifier with external linkage is used, but in the program there does not exist
-  exactly one external definition for the identifier, or the identifier is not used and there
-  exist multiple external definitions for the identifier (<a href="#6.9">6.9</a>).
--- A function definition includes an identifier list, but the types of the parameters are not
-  declared in a following declaration list (<a href="#6.9.1">6.9.1</a>).
--- An adjusted parameter type in a function definition is not a complete object type
-  (<a href="#6.9.1">6.9.1</a>).
--- A function that accepts a variable number of arguments is defined without a
-  parameter type list that ends with the ellipsis notation (<a href="#6.9.1">6.9.1</a>).
-
-[<a name="p558" href="#p558">page 558</a>] (<a href="#Contents">Contents</a>)
-
--- The } that terminates a function is reached, and the value of the function call is used
-  by the caller (<a href="#6.9.1">6.9.1</a>).
--- An identifier for an object with internal linkage and an incomplete type is declared
-  with a tentative definition (<a href="#6.9.2">6.9.2</a>).
--- The token defined is generated during the expansion of a #if or #elif
-  preprocessing directive, or the use of the defined unary operator does not match
-  one of the two specified forms prior to macro replacement (<a href="#6.10.1">6.10.1</a>).
--- The #include preprocessing directive that results after expansion does not match
-  one of the two header name forms (<a href="#6.10.2">6.10.2</a>).
--- The character sequence in an #include preprocessing directive does not start with a
-  letter (<a href="#6.10.2">6.10.2</a>).
--- There are sequences of preprocessing tokens within the list of macro arguments that
-  would otherwise act as preprocessing directives (<a href="#6.10.3">6.10.3</a>).
--- The result of the preprocessing operator # is not a valid character string literal
-  (<a href="#6.10.3.2">6.10.3.2</a>).
--- The result of the preprocessing operator ## is not a valid preprocessing token
-  (<a href="#6.10.3.3">6.10.3.3</a>).
--- The #line preprocessing directive that results after expansion does not match one of
-  the two well-defined forms, or its digit sequence specifies zero or a number greater
-  than 2147483647 (<a href="#6.10.4">6.10.4</a>).
--- A non-STDC #pragma preprocessing directive that is documented as causing
-  translation failure or some other form of undefined behavior is encountered (<a href="#6.10.6">6.10.6</a>).
--- A #pragma STDC preprocessing directive does not match one of the well-defined
-  forms (<a href="#6.10.6">6.10.6</a>).
--- The name of a predefined macro, or the identifier defined, is the subject of a
-  #define or #undef preprocessing directive (<a href="#6.10.8">6.10.8</a>).
--- An attempt is made to copy an object to an overlapping object by use of a library
-  function, other than as explicitly allowed (e.g., memmove) (clause 7).
--- A file with the same name as one of the standard headers, not provided as part of the
-  implementation, is placed in any of the standard places that are searched for included
-  source files (<a href="#7.1.2">7.1.2</a>).
--- A header is included within an external declaration or definition (<a href="#7.1.2">7.1.2</a>).
--- A function, object, type, or macro that is specified as being declared or defined by
-  some standard header is used before any header that declares or defines it is included
-  (<a href="#7.1.2">7.1.2</a>).
-
-[<a name="p559" href="#p559">page 559</a>] (<a href="#Contents">Contents</a>)
-
--- A standard header is included while a macro is defined with the same name as a
-  keyword (<a href="#7.1.2">7.1.2</a>).
--- The program attempts to declare a library function itself, rather than via a standard
-  header, but the declaration does not have external linkage (<a href="#7.1.2">7.1.2</a>).
--- The program declares or defines a reserved identifier, other than as allowed by <a href="#7.1.4">7.1.4</a>
-  (<a href="#7.1.3">7.1.3</a>).
--- The program removes the definition of a macro whose name begins with an
-  underscore and either an uppercase letter or another underscore (<a href="#7.1.3">7.1.3</a>).
--- An argument to a library function has an invalid value or a type not expected by a
-  function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
--- The pointer passed to a library function array parameter does not have a value such
-  that all address computations and object accesses are valid (<a href="#7.1.4">7.1.4</a>).
--- The macro definition of assert is suppressed in order to access an actual function
-  (<a href="#7.2">7.2</a>).
--- The argument to the assert macro does not have a scalar type (<a href="#7.2">7.2</a>).
--- The CX_LIMITED_RANGE, FENV_ACCESS, or FP_CONTRACT pragma is used in
-  any context other than outside all external declarations or preceding all explicit
-  declarations and statements inside a compound statement (<a href="#7.3.4">7.3.4</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.12.2">7.12.2</a>).
--- The value of an argument to a character handling function is neither equal to the value
-  of EOF nor representable as an unsigned char (<a href="#7.4">7.4</a>).
--- A macro definition of errno is suppressed in order to access an actual object, or the
-  program defines an identifier with the name errno (<a href="#7.5">7.5</a>).
--- Part of the program tests floating-point status flags, sets floating-point control modes,
-  or runs under non-default mode settings, but was translated with the state for the
-  FENV_ACCESS pragma ''off'' (<a href="#7.6.1">7.6.1</a>).
--- The exception-mask argument for one of the functions that provide access to the
-  floating-point status flags has a nonzero value not obtained by bitwise OR of the
-  floating-point exception macros (<a href="#7.6.2">7.6.2</a>).
--- The fesetexceptflag function is used to set floating-point status flags that were
-  not specified in the call to the fegetexceptflag function that provided the value
-  of the corresponding fexcept_t object (<a href="#7.6.2.4">7.6.2.4</a>).
--- The argument to fesetenv or feupdateenv is neither an object set by a call to
-  fegetenv or feholdexcept, nor is it an environment macro (<a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>).
--- The value of the result of an integer arithmetic or conversion function cannot be
-  represented (<a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.22.6.1">7.22.6.1</a>, <a href="#7.22.6.2">7.22.6.2</a>, <a href="#7.22.1">7.22.1</a>).
-
-[<a name="p560" href="#p560">page 560</a>] (<a href="#Contents">Contents</a>)
-
--- The program modifies the string pointed to by the value returned by the setlocale
-  function (<a href="#7.11.1.1">7.11.1.1</a>).
--- The program modifies the structure pointed to by the value returned by the
-  localeconv function (<a href="#7.11.2.1">7.11.2.1</a>).
--- A macro definition of math_errhandling is suppressed or the program defines
-  an identifier with the name math_errhandling (<a href="#7.12">7.12</a>).
--- An argument to a floating-point classification or comparison macro is not of real
-  floating type (<a href="#7.12.3">7.12.3</a>, <a href="#7.12.14">7.12.14</a>).
--- A macro definition of setjmp is suppressed in order to access an actual function, or
-  the program defines an external identifier with the name setjmp (<a href="#7.13">7.13</a>).
--- An invocation of the setjmp macro occurs other than in an allowed context
-  (<a href="#7.13.2.1">7.13.2.1</a>).
--- The longjmp function is invoked to restore a nonexistent environment (<a href="#7.13.2.1">7.13.2.1</a>).
--- After a longjmp, there is an attempt to access the value of an object of automatic
-  storage duration that does not have volatile-qualified type, local to the function
-  containing the invocation of the corresponding setjmp macro, that was changed
-  between the setjmp invocation and longjmp call (<a href="#7.13.2.1">7.13.2.1</a>).
--- The program specifies an invalid pointer to a signal handler function (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal handler returns when the signal corresponded to a computational exception
-  (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal occurs as the result of calling the abort or raise function, and the signal
-  handler calls the raise function (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal occurs other than as the result of calling the abort or raise function, and
-  the signal handler refers to an object with static or thread storage duration that is not a
-  lock-free atomic object other than by assigning a value to an object declared as
-  volatile sig_atomic_t, or calls any function in the standard library other
-  than the abort function, the _Exit function, the quick_exit function, or the
-  signal function (for the same signal number) (<a href="#7.14.1.1">7.14.1.1</a>).
--- The value of errno is referred to after a signal occurred other than as the result of
-  calling the abort or raise function and the corresponding signal handler obtained
-  a SIG_ERR return from a call to the signal function (<a href="#7.14.1.1">7.14.1.1</a>).
--- A signal is generated by an asynchronous signal handler (<a href="#7.14.1.1">7.14.1.1</a>).
--- A function with a variable number of arguments attempts to access its varying
-  arguments other than through a properly declared and initialized va_list object, or
-  before the va_start macro is invoked (<a href="#7.16">7.16</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.4">7.16.1.4</a>).
-
-[<a name="p561" href="#p561">page 561</a>] (<a href="#Contents">Contents</a>)
-
--- The macro va_arg is invoked using the parameter ap that was passed to a function
-  that invoked the macro va_arg with the same parameter (<a href="#7.16">7.16</a>).
--- A macro definition of va_start, va_arg, va_copy, or va_end is suppressed in
-  order to access an actual function, or the program defines an external identifier with
-  the name va_copy or va_end (<a href="#7.16.1">7.16.1</a>).
--- The va_start or va_copy macro is invoked without a corresponding invocation
-  of the va_end macro in the same function, or vice versa (<a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>,
-  <a href="#7.16.1.4">7.16.1.4</a>).
--- The type parameter to the va_arg macro is not such that a pointer to an object of
-  that type can be obtained simply by postfixing a * (<a href="#7.16.1.1">7.16.1.1</a>).
--- The va_arg macro is invoked when there is no actual next argument, or with a
-  specified type that is not compatible with the promoted type of the actual next
-  argument, with certain exceptions (<a href="#7.16.1.1">7.16.1.1</a>).
--- The va_copy or va_start macro is called to initialize a va_list that was
-  previously initialized by either macro without an intervening invocation of the
-  va_end macro for the same va_list (<a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.4">7.16.1.4</a>).
--- The parameter parmN of a va_start macro is declared with the register
-  storage class, with a function or array type, or with a type that is not compatible with
-  the type that results after application of the default argument promotions (<a href="#7.16.1.4">7.16.1.4</a>).
--- The member designator parameter of an offsetof macro is an invalid right
-  operand of the . operator for the type parameter, or designates a bit-field (<a href="#7.19">7.19</a>).
--- The argument in an instance of one of the integer-constant macros is not a decimal,
-  octal, or hexadecimal constant, or it has a value that exceeds the limits for the
-  corresponding type (<a href="#7.20.4">7.20.4</a>).
--- A byte input/output function is applied to a wide-oriented stream, or a wide character
-  input/output function is applied to a byte-oriented stream (<a href="#7.21.2">7.21.2</a>).
--- Use is made of any portion of a file beyond the most recent wide character written to
-  a wide-oriented stream (<a href="#7.21.2">7.21.2</a>).
--- The value of a pointer to a FILE object is used after the associated file is closed
-  (<a href="#7.21.3">7.21.3</a>).
--- The stream for the fflush function points to an input stream or to an update stream
-  in which the most recent operation was input (<a href="#7.21.5.2">7.21.5.2</a>).
--- The string pointed to by the mode argument in a call to the fopen function does not
-  exactly match one of the specified character sequences (<a href="#7.21.5.3">7.21.5.3</a>).
--- An output operation on an update stream is followed by an input operation without an
-    intervening call to the fflush function or a file positioning function, or an input
-
-[<a name="p562" href="#p562">page 562</a>] (<a href="#Contents">Contents</a>)
-
-   operation on an update stream is followed by an output operation with an intervening
-   call to a file positioning function (<a href="#7.21.5.3">7.21.5.3</a>).
--- An attempt is made to use the contents of the array that was supplied in a call to the
-  setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
--- There are insufficient arguments for the format in a call to one of the formatted
-  input/output functions, or an argument does not have an appropriate type (<a href="#7.21.6.1">7.21.6.1</a>,
-  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- The format in a call to one of the formatted input/output functions or to the
-  strftime or wcsftime function is not a valid multibyte character sequence that
-  begins and ends in its initial shift state (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>,
-  <a href="#7.28.5.1">7.28.5.1</a>).
--- In a call to one of the formatted output functions, a precision appears with a
-  conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
--- A conversion specification for a formatted output function uses an asterisk to denote
-  an argument-supplied field width or precision, but the corresponding argument is not
-  provided (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
--- A conversion specification for a formatted output function uses a # or 0 flag with a
-  conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
--- A conversion specification for one of the formatted input/output functions uses a
-  length modifier with a conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>,
-  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- An s conversion specifier is encountered by one of the formatted output functions,
-  and the argument is missing the null terminator (unless a precision is specified that
-  does not require null termination) (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
--- An n conversion specification for one of the formatted input/output functions includes
-  any flags, an assignment-suppressing character, a field width, or a precision (<a href="#7.21.6.1">7.21.6.1</a>,
-  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- A % conversion specifier is encountered by one of the formatted input/output
-  functions, but the complete conversion specification is not exactly %% (<a href="#7.21.6.1">7.21.6.1</a>,
-  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- An invalid conversion specification is found in the format for one of the formatted
-  input/output functions, or the strftime or wcsftime function (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
-  <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.5.1">7.28.5.1</a>).
--- The number of characters transmitted by a formatted output function is greater than
-  INT_MAX (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.10">7.21.6.10</a>).
-
-[<a name="p563" href="#p563">page 563</a>] (<a href="#Contents">Contents</a>)
-
--- The result of a conversion by one of the formatted input functions cannot be
-  represented in the corresponding object, or the receiving object does not have an
-  appropriate type (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- A c, s, or [ conversion specifier is encountered by one of the formatted input
-  functions, and the array pointed to by the corresponding argument is not large enough
-  to accept the input sequence (and a null terminator if the conversion specifier is s or
-  [) (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- A c, s, or [ conversion specifier with an l qualifier is encountered by one of the
-  formatted input functions, but the input is not a valid multibyte character sequence
-  that begins in the initial shift state (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- The input item for a %p conversion by one of the formatted input functions is not a
-  value converted earlier during the same program execution (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- The vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf,
-  vsscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, or
-  vwscanf function is called with an improperly initialized va_list argument, or
-  the argument is used (other than in an invocation of va_end) after the function
-  returns (<a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
-  <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>).
--- The contents of the array supplied in a call to the fgets or fgetws function are
-  used after a read error occurred (<a href="#7.21.7.2">7.21.7.2</a>, <a href="#7.28.3.2">7.28.3.2</a>).
--- The file position indicator for a binary stream is used after a call to the ungetc
-  function where its value was zero before the call (<a href="#7.21.7.10">7.21.7.10</a>).
--- The file position indicator for a stream is used after an error occurred during a call to
-  the fread or fwrite function (<a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>).
--- A partial element read by a call to the fread function is used (<a href="#7.21.8.1">7.21.8.1</a>).
--- The fseek function is called for a text stream with a nonzero offset and either the
-  offset was not returned by a previous successful call to the ftell function on a
-  stream associated with the same file or whence is not SEEK_SET (<a href="#7.21.9.2">7.21.9.2</a>).
--- The fsetpos function is called to set a position that was not returned by a previous
-  successful call to the fgetpos function on a stream associated with the same file
-  (<a href="#7.21.9.3">7.21.9.3</a>).
--- A non-null pointer returned by a call to the calloc, malloc, or realloc function
-  with a zero requested size is used to access an object (<a href="#7.22.3">7.22.3</a>).
--- The value of a pointer that refers to space deallocated by a call to the free or
-  realloc function is used (<a href="#7.22.3">7.22.3</a>).
-
-[<a name="p564" href="#p564">page 564</a>] (<a href="#Contents">Contents</a>)
-
--- The alignment requested of the aligned_alloc function is not valid or not
-  supported by the implementation, or the size requested is not an integral multiple of
-  the alignment (<a href="#7.22.3.1">7.22.3.1</a>).
--- The pointer argument to the free or realloc function does not match a pointer
-  earlier returned by a memory management function, or the space has been deallocated
-  by a call to free or realloc (<a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>).
--- The value of the object allocated by the malloc function is used (<a href="#7.22.3.4">7.22.3.4</a>).
--- The value of any bytes in a new object allocated by the realloc function beyond
-  the size of the old object are used (<a href="#7.22.3.5">7.22.3.5</a>).
--- The program calls the exit or quick_exit function more than once, or calls both
-  functions (<a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.7">7.22.4.7</a>).
--- During the call to a function registered with the atexit or at_quick_exit
-  function, a call is made to the longjmp function that would terminate the call to the
-  registered function (<a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.7">7.22.4.7</a>).
--- The string set up by the getenv or strerror function is modified by the program
-  (<a href="#7.22.4.6">7.22.4.6</a>, <a href="#7.23.6.2">7.23.6.2</a>).
--- A command is executed through the system function in a way that is documented as
-  causing termination or some other form of undefined behavior (<a href="#7.22.4.8">7.22.4.8</a>).
--- A searching or sorting utility function is called with an invalid pointer argument, even
-  if the number of elements is zero (<a href="#7.22.5">7.22.5</a>).
--- The comparison function called by a searching or sorting utility function alters the
-  contents of the array being searched or sorted, or returns ordering values
-  inconsistently (<a href="#7.22.5">7.22.5</a>).
--- The array being searched by the bsearch function does not have its elements in
-  proper order (<a href="#7.22.5.1">7.22.5.1</a>).
--- The current conversion state is used by a multibyte/wide character conversion
-  function after changing the LC_CTYPE category (<a href="#7.22.7">7.22.7</a>).
--- A string or wide string utility function is instructed to access an array beyond the end
-  of an object (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
--- A string or wide string utility function is called with an invalid pointer argument, even
-  if the length is zero (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
--- The contents of the destination array are used after a call to the strxfrm,
-  strftime, wcsxfrm, or wcsftime function in which the specified length was
-  too small to hold the entire null-terminated result (<a href="#7.23.4.5">7.23.4.5</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>,
-  <a href="#7.28.5.1">7.28.5.1</a>).
-
-[<a name="p565" href="#p565">page 565</a>] (<a href="#Contents">Contents</a>)
-
-    -- The first argument in the very first call to the strtok or wcstok is a null pointer
-      (<a href="#7.23.5.8">7.23.5.8</a>, <a href="#7.28.4.5.7">7.28.4.5.7</a>).
-    -- The type of an argument to a type-generic macro is not compatible with the type of
-      the corresponding parameter of the selected function (<a href="#7.24">7.24</a>).
-    -- A complex argument is supplied for a generic parameter of a type-generic macro that
-      has no corresponding complex function (<a href="#7.24">7.24</a>).
-    -- At least one field of the broken-down time passed to asctime contains a value
-      outside its normal range, or the calculated year exceeds four digits or is less than the
-      year 1000 (<a href="#7.26.3.1">7.26.3.1</a>).
-    -- The argument corresponding to an s specifier without an l qualifier in a call to the
-      fwprintf function does not point to a valid multibyte character sequence that
-      begins in the initial shift state (<a href="#7.28.2.11">7.28.2.11</a>).
-    -- In a call to the wcstok function, the object pointed to by ptr does not have the
-      value stored by the previous call for the same wide string (<a href="#7.28.4.5.7">7.28.4.5.7</a>).
-    -- An mbstate_t object is used inappropriately (<a href="#7.28.6">7.28.6</a>).
-    -- The value of an argument of type wint_t to a wide character classification or case
-      mapping function is neither equal to the value of WEOF nor representable as a
-      wchar_t (<a href="#7.29.1">7.29.1</a>).
-    -- The iswctype function is called using a different LC_CTYPE category from the
-      one in effect for the call to the wctype function that returned the description
-      (<a href="#7.29.2.2.1">7.29.2.2.1</a>).
-    -- The towctrans function is called using a different LC_CTYPE category from the
-      one in effect for the call to the wctrans function that returned the description
-      (<a href="#7.29.3.2.1">7.29.3.2.1</a>).
-<a name="J.3" href="#J.3"><b>    J.3 Implementation-defined behavior</b></a>
-1   A conforming implementation is required to document its choice of behavior in each of
-    the areas listed in this subclause. The following are implementation-defined:
-
-[<a name="p566" href="#p566">page 566</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3.1" href="#J.3.1"><b>    J.3.1 Translation</b></a>
-1   -- How a diagnostic is identified (<a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>).
-    -- Whether each nonempty sequence of white-space characters other than new-line is
-      retained or replaced by one space character in translation phase 3 (<a href="#5.1.1.2">5.1.1.2</a>).
-<a name="J.3.2" href="#J.3.2"><b>    J.3.2 Environment</b></a>
-1   -- The mapping between physical source file multibyte characters and the source
-      character set in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>).
-    -- The name and type of the function called at program startup in a freestanding
-      environment (<a href="#5.1.2.1">5.1.2.1</a>).
-    -- The effect of program termination in a freestanding environment (<a href="#5.1.2.1">5.1.2.1</a>).
-    -- An alternative manner in which the main function may be defined (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-    -- The values given to the strings pointed to by the argv argument to main (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-    -- What constitutes an interactive device (<a href="#5.1.2.3">5.1.2.3</a>).
-    -- Whether a program can have more than one thread of execution in a freestanding
-      environment (<a href="#5.1.2.4">5.1.2.4</a>).
-    -- The set of signals, their semantics, and their default handling (<a href="#7.14">7.14</a>).
-    -- Signal values other than SIGFPE, SIGILL, and SIGSEGV that correspond to a
-      computational exception (<a href="#7.14.1.1">7.14.1.1</a>).
-    -- Signals for which the equivalent of signal(sig, SIG_IGN); is executed at
-      program startup (<a href="#7.14.1.1">7.14.1.1</a>).
-    -- The set of environment names and the method for altering the environment list used
-      by the getenv function (<a href="#7.22.4.6">7.22.4.6</a>).
-    -- The manner of execution of the string by the system function (<a href="#7.22.4.8">7.22.4.8</a>).
-<a name="J.3.3" href="#J.3.3"><b>    J.3.3 Identifiers</b></a>
-1   -- Which additional multibyte characters may appear in identifiers and their
-      correspondence to universal character names (<a href="#6.4.2">6.4.2</a>).
-    -- The number of significant initial characters in an identifier (<a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2">6.4.2</a>).
-
-[<a name="p567" href="#p567">page 567</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3.4" href="#J.3.4"><b>    J.3.4 Characters</b></a>
-1   -- The number of bits in a byte (<a href="#3.6">3.6</a>).
-    -- The values of the members of the execution character set (<a href="#5.2.1">5.2.1</a>).
-    -- The unique value of the member of the execution character set produced for each of
-      the standard alphabetic escape sequences (<a href="#5.2.2">5.2.2</a>).
-    -- The value of a char object into which has been stored any character other than a
-      member of the basic execution character set (<a href="#6.2.5">6.2.5</a>).
-    -- Which of signed char or unsigned char has the same range, representation,
-      and behavior as ''plain'' char (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>).
-    -- The mapping of members of the source character set (in character constants and string
-      literals) to members of the execution character set (<a href="#6.4.4.4">6.4.4.4</a>, <a href="#5.1.1.2">5.1.1.2</a>).
-    -- The value of an integer character constant containing more than one character or
-      containing a character or escape sequence that does not map to a single-byte
-      execution character (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- The value of a wide character constant containing more than one multibyte character
-      or a single multibyte character that maps to multiple members of the extended
-      execution character set, or containing a multibyte character or escape sequence not
-      represented in the extended execution character set (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- The current locale used to convert a wide character constant consisting of a single
-      multibyte character that maps to a member of the extended execution character set
-      into a corresponding wide character code (<a href="#6.4.4.4">6.4.4.4</a>).
-    -- Whether differently-prefixed wide string literal tokens can be concatenated and, if so,
-      the treatment of the resulting multibyte character sequence (<a href="#6.4.5">6.4.5</a>).
-    -- The current locale used to convert a wide string literal into corresponding wide
-      character codes (<a href="#6.4.5">6.4.5</a>).
-    -- The value of a string literal containing a multibyte character or escape sequence not
-      represented in the execution character set (<a href="#6.4.5">6.4.5</a>).
-    -- The encoding of any of wchar_t, char16_t, and char32_t where the
-      corresponding  standard   encoding macro      (__STDC_ISO_10646__,
-      __STDC_UTF_16__, or __STDC_UTF_32__) is not defined (<a href="#6.10.8.2">6.10.8.2</a>).
-
-[<a name="p568" href="#p568">page 568</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3.5" href="#J.3.5"><b>    J.3.5 Integers</b></a>
-1   -- Any extended integer types that exist in the implementation (<a href="#6.2.5">6.2.5</a>).
-    -- Whether signed integer types are represented using sign and magnitude, two's
-      complement, or ones' complement, and whether the extraordinary value is a trap
-      representation or an ordinary value (<a href="#6.2.6.2">6.2.6.2</a>).
-    -- The rank of any extended integer type relative to another extended integer type with
-      the same precision (<a href="#6.3.1.1">6.3.1.1</a>).
-    -- The result of, or the signal raised by, converting an integer to a signed integer type
-      when the value cannot be represented in an object of that type (<a href="#6.3.1.3">6.3.1.3</a>).
-    -- The results of some bitwise operations on signed integers (<a href="#6.5">6.5</a>).
-<a name="J.3.6" href="#J.3.6"><b>    J.3.6 Floating point</b></a>
-1   -- The accuracy of the floating-point operations and of the library functions in
-      <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The accuracy of the conversions between floating-point internal representations and
-      string representations performed by the library functions in <a href="#7.21">&lt;stdio.h&gt;</a>,
-      <a href="#7.22">&lt;stdlib.h&gt;</a>, and <a href="#7.28">&lt;wchar.h&gt;</a> (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The rounding behaviors characterized by non-standard values of FLT_ROUNDS
-      (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The evaluation methods characterized by non-standard negative values of
-      FLT_EVAL_METHOD (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
-    -- The direction of rounding when an integer is converted to a floating-point number that
-      cannot exactly represent the original value (<a href="#6.3.1.4">6.3.1.4</a>).
-    -- The direction of rounding when a floating-point number is converted to a narrower
-      floating-point number (<a href="#6.3.1.5">6.3.1.5</a>).
-    -- How the nearest representable value or the larger or smaller representable value
-      immediately adjacent to the nearest representable value is chosen for certain floating
-      constants (<a href="#6.4.4.2">6.4.4.2</a>).
-    -- Whether and how floating expressions are contracted when not disallowed by the
-      FP_CONTRACT pragma (<a href="#6.5">6.5</a>).
-    -- The default state for the FENV_ACCESS pragma (<a href="#7.6.1">7.6.1</a>).
-    -- Additional floating-point exceptions, rounding           modes,     environments,   and
-      classifications, and their macro names (<a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>).
-    -- The default state for the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>).
-
-[<a name="p569" href="#p569">page 569</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3.7" href="#J.3.7"><b>    J.3.7 Arrays and pointers</b></a>
-1   -- The result of converting a pointer to an integer or vice versa (<a href="#6.3.2.3">6.3.2.3</a>).
-    -- The size of the result of subtracting two pointers to elements of the same array
-      (<a href="#6.5.6">6.5.6</a>).
-<a name="J.3.8" href="#J.3.8"><b>    J.3.8 Hints</b></a>
-1   -- The extent to which suggestions made by using the register storage-class
-      specifier are effective (<a href="#6.7.1">6.7.1</a>).
-    -- The extent to which suggestions made by using the inline function specifier are
-      effective (<a href="#6.7.4">6.7.4</a>).
-<a name="J.3.9" href="#J.3.9"><b>    J.3.9 Structures, unions, enumerations, and bit-fields</b></a>
-1   -- Whether a ''plain'' int bit-field is treated as a signed int bit-field or as an
-      unsigned int bit-field (<a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.1">6.7.2.1</a>).
-    -- Allowable bit-field types other than _Bool, signed int, and unsigned int
-      (<a href="#6.7.2.1">6.7.2.1</a>).
-    -- Whether atomic types are permitted for bit-fields (<a href="#6.7.2.1">6.7.2.1</a>).
-    -- Whether a bit-field can straddle a storage-unit boundary (<a href="#6.7.2.1">6.7.2.1</a>).
-    -- The order of allocation of bit-fields within a unit (<a href="#6.7.2.1">6.7.2.1</a>).
-    -- The alignment of non-bit-field members of structures (<a href="#6.7.2.1">6.7.2.1</a>). This should present
-      no problem unless binary data written by one implementation is read by another.
-    -- The integer type compatible with each enumerated type (<a href="#6.7.2.2">6.7.2.2</a>).
-<a name="J.3.10" href="#J.3.10"><b>    J.3.10 Qualifiers</b></a>
-1   -- What constitutes an access to an object that has volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
-<a name="J.3.11" href="#J.3.11"><b>    J.3.11 Preprocessing directives</b></a>
-1   -- The locations within #pragma directives where header name preprocessing tokens
-      are recognized (<a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>).
-    -- How sequences in both forms of header names are mapped to headers or external
-      source file names (<a href="#6.4.7">6.4.7</a>).
-    -- Whether the value of a character constant in a constant expression that controls
-      conditional inclusion matches the value of the same character constant in the
-      execution character set (<a href="#6.10.1">6.10.1</a>).
-    -- Whether the value of a single-character character constant in a constant expression
-      that controls conditional inclusion may have a negative value (<a href="#6.10.1">6.10.1</a>).
-
-[<a name="p570" href="#p570">page 570</a>] (<a href="#Contents">Contents</a>)
-
-    -- The places that are searched for an included &lt; &gt; delimited header, and how the places
-      are specified or the header is identified (<a href="#6.10.2">6.10.2</a>).
-    -- How the named source file is searched for in an included " " delimited header
-      (<a href="#6.10.2">6.10.2</a>).
-    -- The method by which preprocessing tokens (possibly resulting from macro
-      expansion) in a #include directive are combined into a header name (<a href="#6.10.2">6.10.2</a>).
-    -- The nesting limit for #include processing (<a href="#6.10.2">6.10.2</a>).
-    -- Whether the # operator inserts a \ character before the \ character that begins a
-      universal character name in a character constant or string literal (<a href="#6.10.3.2">6.10.3.2</a>).
-    -- The behavior on each recognized non-STDC #pragma directive (<a href="#6.10.6">6.10.6</a>).
-    -- The definitions for __DATE__ and __TIME__ when respectively, the date and
-      time of translation are not available (<a href="#6.10.8.1">6.10.8.1</a>).
-<a name="J.3.12" href="#J.3.12"><b>    J.3.12 Library functions</b></a>
-1   -- Any library facilities available to a freestanding program, other than the minimal set
-      required by clause 4 (<a href="#5.1.2.1">5.1.2.1</a>).
-    -- The format of the diagnostic printed by the assert macro (<a href="#7.2.1.1">7.2.1.1</a>).
-    -- The representation of the floating-point               status   flags   stored   by   the
-      fegetexceptflag function (<a href="#7.6.2.2">7.6.2.2</a>).
-    -- Whether the feraiseexcept function raises the ''inexact'' floating-point
-      exception in addition to the ''overflow'' or ''underflow'' floating-point exception
-      (<a href="#7.6.2.3">7.6.2.3</a>).
-    -- Strings other than "C" and "" that may be passed as the second argument to the
-      setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
-    -- The types defined for float_t and double_t when the value of the
-      FLT_EVAL_METHOD macro is less than 0 (<a href="#7.12">7.12</a>).
-    -- Domain errors for the mathematics functions, other than those required by this
-      International Standard (<a href="#7.12.1">7.12.1</a>).
-    -- The values returned by the mathematics functions on domain errors or pole errors
-      (<a href="#7.12.1">7.12.1</a>).
-    -- The values returned by the mathematics functions on underflow range errors, whether
-      errno is set to the value of the macro ERANGE when the integer expression
-      math_errhandling &amp; MATH_ERRNO is nonzero, and whether the ''underflow''
-      floating-point exception is raised when the integer expression math_errhandling
-      &amp; MATH_ERREXCEPT is nonzero. (<a href="#7.12.1">7.12.1</a>).
-
-[<a name="p571" href="#p571">page 571</a>] (<a href="#Contents">Contents</a>)
-
--- Whether a domain error occurs or zero is returned when an fmod function has a
-  second argument of zero (<a href="#7.12.10.1">7.12.10.1</a>).
--- Whether a domain error occurs or zero is returned when a remainder function has
-  a second argument of zero (<a href="#7.12.10.2">7.12.10.2</a>).
--- The base-2 logarithm of the modulus used by the remquo functions in reducing the
-  quotient (<a href="#7.12.10.3">7.12.10.3</a>).
--- Whether a domain error occurs or zero is returned when a remquo function has a
-  second argument of zero (<a href="#7.12.10.3">7.12.10.3</a>).
--- Whether the equivalent of signal(sig, SIG_DFL); is executed prior to the call
-  of a signal handler, and, if not, the blocking of signals that is performed (<a href="#7.14.1.1">7.14.1.1</a>).
--- The null pointer constant to which the macro NULL expands (<a href="#7.19">7.19</a>).
--- Whether the last line of a text stream requires a terminating new-line character
-  (<a href="#7.21.2">7.21.2</a>).
--- Whether space characters that are written out to a text stream immediately before a
-  new-line character appear when read in (<a href="#7.21.2">7.21.2</a>).
--- The number of null characters that may be appended to data written to a binary
-  stream (<a href="#7.21.2">7.21.2</a>).
--- Whether the file position indicator of an append-mode stream is initially positioned at
-  the beginning or end of the file (<a href="#7.21.3">7.21.3</a>).
--- Whether a write on a text stream causes the associated file to be truncated beyond that
-  point (<a href="#7.21.3">7.21.3</a>).
--- The characteristics of file buffering (<a href="#7.21.3">7.21.3</a>).
--- Whether a zero-length file actually exists (<a href="#7.21.3">7.21.3</a>).
--- The rules for composing valid file names (<a href="#7.21.3">7.21.3</a>).
--- Whether the same file can be simultaneously open multiple times (<a href="#7.21.3">7.21.3</a>).
--- The nature and choice of encodings used for multibyte characters in files (<a href="#7.21.3">7.21.3</a>).
--- The effect of the remove function on an open file (<a href="#7.21.4.1">7.21.4.1</a>).
--- The effect if a file with the new name exists prior to a call to the rename function
-  (<a href="#7.21.4.2">7.21.4.2</a>).
--- Whether an open temporary file is removed upon abnormal program termination
-  (<a href="#7.21.4.3">7.21.4.3</a>).
--- Which changes of mode are permitted (if any), and under what circumstances
-  (<a href="#7.21.5.4">7.21.5.4</a>).
-
-[<a name="p572" href="#p572">page 572</a>] (<a href="#Contents">Contents</a>)
-
--- The style used to print an infinity or NaN, and the meaning of any n-char or n-wchar
-  sequence printed for a NaN (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
--- The output for %p conversion in the fprintf or fwprintf function (<a href="#7.21.6.1">7.21.6.1</a>,
-  <a href="#7.28.2.1">7.28.2.1</a>).
--- The interpretation of a - character that is neither the first nor the last character, nor
-  the second where a ^ character is the first, in the scanlist for %[ conversion in the
-  fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>).
--- The set of sequences matched by a %p conversion and the interpretation of the
-  corresponding input item in the fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
--- The value to which the macro errno is set by the fgetpos, fsetpos, or ftell
-  functions on failure (<a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>).
--- The meaning of any n-char or n-wchar sequence in a string representing a NaN that is
-  converted by the strtod, strtof, strtold, wcstod, wcstof, or wcstold
-  function (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
--- Whether or not the strtod, strtof, strtold, wcstod, wcstof, or wcstold
-  function sets errno to ERANGE when underflow occurs (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
--- Whether the calloc, malloc, and realloc functions return a null pointer or a
-  pointer to an allocated object when the size requested is zero (<a href="#7.22.3">7.22.3</a>).
--- Whether open streams with unwritten buffered data are flushed, open streams are
-  closed, or temporary files are removed when the abort or _Exit function is called
-  (<a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.22.4.5">7.22.4.5</a>).
--- The termination status returned to the host environment by the abort, exit,
-  _Exit, or quick_exit function (<a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>).
--- The value returned by the system function when its argument is not a null pointer
-  (<a href="#7.22.4.8">7.22.4.8</a>).
--- The local time zone and Daylight Saving Time (<a href="#7.26.1">7.26.1</a>).
--- The range and precision of times representable in clock_t and time_t (<a href="#7.26">7.26</a>).
--- The era for the clock function (<a href="#7.26.2.1">7.26.2.1</a>).
--- The replacement string for the %Z specifier to the strftime, and wcsftime
-  functions in the "C" locale (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
--- Whether the functions in <a href="#7.12">&lt;math.h&gt;</a> honor the rounding direction mode in an
-  IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.10">F.10</a>).
-
-[<a name="p573" href="#p573">page 573</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.3.13" href="#J.3.13"><b>    J.3.13 Architecture</b></a>
-1   -- The values or expressions assigned to the macros specified in the headers
-      <a href="#7.7">&lt;float.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, and <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#5.2.4.2">5.2.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>).
-    -- The result of attempting to indirectly access an object with automatic or thread
-      storage duration from a thread other than the one with which it is associated (<a href="#6.2.4">6.2.4</a>).
-    -- The number, order, and encoding of bytes in any object (when not explicitly specified
-      in this International Standard) (<a href="#6.2.6.1">6.2.6.1</a>).
-    -- Whether any extended alignments are supported and the contexts in which they are
-      supported (<a href="#6.2.8">6.2.8</a>).
-    -- Valid alignment values other than those returned by an alignof expression for
-      fundamental types, if any (<a href="#6.2.8">6.2.8</a>).
-    -- The value of the result of the sizeof and alignof operators (<a href="#6.5.3.4">6.5.3.4</a>).
-<a name="J.4" href="#J.4"><b>    J.4 Locale-specific behavior</b></a>
-1   The following characteristics of a hosted environment are locale-specific and are required
-    to be documented by the implementation:
-    -- Additional members of the source and execution character sets beyond the basic
-      character set (<a href="#5.2.1">5.2.1</a>).
-    -- The presence, meaning, and representation of additional multibyte characters in the
-      execution character set beyond the basic character set (<a href="#5.2.1.2">5.2.1.2</a>).
-    -- The shift states used for the encoding of multibyte characters (<a href="#5.2.1.2">5.2.1.2</a>).
-    -- The direction of writing of successive printing characters (<a href="#5.2.2">5.2.2</a>).
-    -- The decimal-point character (<a href="#7.1.1">7.1.1</a>).
-    -- The set of printing characters (<a href="#7.4">7.4</a>, <a href="#7.29.2">7.29.2</a>).
-    -- The set of control characters (<a href="#7.4">7.4</a>, <a href="#7.29.2">7.29.2</a>).
-    -- The sets of characters tested for by the isalpha, isblank, islower, ispunct,
-      isspace, isupper, iswalpha, iswblank, iswlower, iswpunct,
-      iswspace, or iswupper functions (<a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>,
-      <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>).
-    -- The native environment (<a href="#7.11.1.1">7.11.1.1</a>).
-    -- Additional subject sequences accepted by the numeric conversion functions (<a href="#7.22.1">7.22.1</a>,
-      <a href="#7.28.4.1">7.28.4.1</a>).
-    -- The collation sequence of the execution character set (<a href="#7.23.4.3">7.23.4.3</a>, <a href="#7.28.4.4.2">7.28.4.4.2</a>).
-
-[<a name="p574" href="#p574">page 574</a>] (<a href="#Contents">Contents</a>)
-
-    -- The contents of the error message strings set up by the strerror function
-      (<a href="#7.23.6.2">7.23.6.2</a>).
-    -- The formats for time and date (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
-    -- Character mappings that are supported by the towctrans function (<a href="#7.29.1">7.29.1</a>).
-    -- Character classifications that are supported by the iswctype function (<a href="#7.29.1">7.29.1</a>).
-<a name="J.5" href="#J.5"><b>    J.5 Common extensions</b></a>
-1   The following extensions are widely used in many systems, but are not portable to all
-    implementations. The inclusion of any extension that may cause a strictly conforming
-    program to become invalid renders an implementation nonconforming. Examples of such
-    extensions are new keywords, extra library functions declared in standard headers, or
-    predefined macros with names that do not begin with an underscore.
-<a name="J.5.1" href="#J.5.1"><b>    J.5.1 Environment arguments</b></a>
-1   In a hosted environment, the main function receives a third argument, char *envp[],
-    that points to a null-terminated array of pointers to char, each of which points to a string
-    that provides information about the environment for this execution of the program
-    (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
-<a name="J.5.2" href="#J.5.2"><b>    J.5.2 Specialized identifiers</b></a>
-1   Characters other than the underscore _, letters, and digits, that are not part of the basic
-    source character set (such as the dollar sign $, or characters in national character sets)
-    may appear in an identifier (<a href="#6.4.2">6.4.2</a>).
-<a name="J.5.3" href="#J.5.3"><b>    J.5.3 Lengths and cases of identifiers</b></a>
-1   All characters in identifiers (with or without external linkage) are significant (<a href="#6.4.2">6.4.2</a>).
-<a name="J.5.4" href="#J.5.4"><b>    J.5.4 Scopes of identifiers</b></a>
-1   A function identifier, or the identifier of an object the declaration of which contains the
-    keyword extern, has file scope (<a href="#6.2.1">6.2.1</a>).
-<a name="J.5.5" href="#J.5.5"><b>    J.5.5 Writable string literals</b></a>
-1   String literals are modifiable (in which case, identical string literals should denote distinct
-    objects) (<a href="#6.4.5">6.4.5</a>).
-
-[<a name="p575" href="#p575">page 575</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.5.6" href="#J.5.6"><b>    J.5.6 Other arithmetic types</b></a>
-1   Additional arithmetic types, such as __int128 or double double, and their
-    appropriate conversions are defined (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1">6.3.1</a>). Additional floating types may have
-    more range or precision than long double, may be used for evaluating expressions of
-    other floating types, and may be used to define float_t or double_t.
-<a name="J.5.7" href="#J.5.7"><b>    J.5.7 Function pointer casts</b></a>
-1   A pointer to an object or to void may be cast to a pointer to a function, allowing data to
-    be invoked as a function (<a href="#6.5.4">6.5.4</a>).
-2   A pointer to a function may be cast to a pointer to an object or to void, allowing a
-    function to be inspected or modified (for example, by a debugger) (<a href="#6.5.4">6.5.4</a>).
-<a name="J.5.8" href="#J.5.8"><b>    J.5.8 Extended bit-field types</b></a>
-1   A bit-field may be declared with a type other than _Bool, unsigned int, or
-    signed int, with an appropriate maximum width (<a href="#6.7.2.1">6.7.2.1</a>).
-<a name="J.5.9" href="#J.5.9"><b>    J.5.9 The fortran keyword</b></a>
-1   The fortran function specifier may be used in a function declaration to indicate that
-    calls suitable for FORTRAN should be generated, or that a different representation for the
-    external name is to be generated (<a href="#6.7.4">6.7.4</a>).
-<a name="J.5.10" href="#J.5.10"><b>    J.5.10 The asm keyword</b></a>
-1   The asm keyword may be used to insert assembly language directly into the translator
-    output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
-           asm ( character-string-literal );
-<a name="J.5.11" href="#J.5.11"><b>    J.5.11 Multiple external definitions</b></a>
-1   There may be more than one external definition for the identifier of an object, with or
-    without the explicit use of the keyword extern; if the definitions disagree, or more than
-    one is initialized, the behavior is undefined (<a href="#6.9.2">6.9.2</a>).
-<a name="J.5.12" href="#J.5.12"><b>    J.5.12 Predefined macro names</b></a>
-1   Macro names that do not begin with an underscore, describing the translation and
-    execution environments, are defined by the implementation before translation begins
-    (<a href="#6.10.8">6.10.8</a>).
-
-[<a name="p576" href="#p576">page 576</a>] (<a href="#Contents">Contents</a>)
-
-<a name="J.5.13" href="#J.5.13"><b>    J.5.13 Floating-point status flags</b></a>
-1   If any floating-point status flags are set on normal termination after all calls to functions
-    registered by the atexit function have been made (see <a href="#7.22.4.4">7.22.4.4</a>), the implementation
-    writes some diagnostics indicating the fact to the stderr stream, if it is still open,
-<a name="J.5.14" href="#J.5.14"><b>    J.5.14 Extra arguments for signal handlers</b></a>
-1   Handlers for specific signals are called with extra arguments in addition to the signal
-    number (<a href="#7.14.1.1">7.14.1.1</a>).
-<a name="J.5.15" href="#J.5.15"><b>    J.5.15 Additional stream types and file-opening modes</b></a>
-1   Additional mappings from files to streams are supported (<a href="#7.21.2">7.21.2</a>).
-2   Additional file-opening modes may be specified by characters appended to the mode
-    argument of the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
-<a name="J.5.16" href="#J.5.16"><b>    J.5.16 Defined file position indicator</b></a>
-1   The file position indicator is decremented by each successful call to the ungetc or
-    ungetwc function for a text stream, except if its value was zero before a call (<a href="#7.21.7.10">7.21.7.10</a>,
-<a name="7.28.3.10)" href="#7.28.3.10)"><b>    7.28.3.10).</b></a>
-<a name="J.5.17" href="#J.5.17"><b>    J.5.17 Math error reporting</b></a>
-1   Functions declared in <a href="#7.3">&lt;complex.h&gt;</a> and <a href="#7.12">&lt;math.h&gt;</a> raise SIGFPE to report errors
-    instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
-<a name="7.12)" href="#7.12)"><b>    7.12).</b></a>
-
-[<a name="p577" href="#p577">page 577</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K" href="#K"><b>                                           Annex K</b></a>
-                                          (normative)
-                              Bounds-checking interfaces
-<a name="K.1" href="#K.1"><b>    K.1 Background</b></a>
-1   Traditionally, the C Library has contained many functions that trust the programmer to
-    provide output character arrays big enough to hold the result being produced. Not only
-    do these functions not check that the arrays are big enough, they frequently lack the
-    information needed to perform such checks. While it is possible to write safe, robust, and
-    error-free code using the existing library, the library tends to promote programming styles
-    that lead to mysterious failures if a result is too big for the provided array.
-2   A common programming style is to declare character arrays large enough to handle most
-    practical cases. However, if these arrays are not large enough to handle the resulting
-    strings, data can be written past the end of the array overwriting other data and program
-    structures. The program never gets any indication that a problem exists, and so never has
-    a chance to recover or to fail gracefully.
-3   Worse, this style of programming has compromised the security of computers and
-    networks. Buffer overflows can often be exploited to run arbitrary code with the
-    permissions of the vulnerable (defective) program.
-4   If the programmer writes runtime checks to verify lengths before calling library
-    functions, then those runtime checks frequently duplicate work done inside the library
-    functions, which discover string lengths as a side effect of doing their job.
-5   This annex provides alternative library functions that promote safer, more secure
-    programming. The alternative functions verify that output buffers are large enough for
-    the intended result and return a failure indicator if they are not. Data is never written past
-    the end of an array. All string results are null terminated.
-6   This annex also addresses another problem that complicates writing robust code:
-    functions that are not reentrant because they return pointers to static objects owned by the
-    function. Such functions can be troublesome since a previously returned result can
-    change if the function is called again, perhaps by another thread.
-
-[<a name="p578" href="#p578">page 578</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.2" href="#K.2"><b>    K.2 Scope</b></a>
-1   This annex specifies a series of optional extensions that can be useful in the mitigation of
-    security vulnerabilities in programs, and comprise new functions, macros, and types
-    declared or defined in existing standard headers.
-2   An implementation that defines __STDC_LIB_EXT1__ shall conform to the
-    specifications in this annex.<sup><a href="#note367"><b>367)</b></a></sup>
-3   Subclause <a href="#K.3">K.3</a> should be read as if it were merged into the parallel structure of named
-    subclauses of clause 7.
-<a name="K.3" href="#K.3"><b>    K.3 Library</b></a>
-<a name="K.3.1" href="#K.3.1"><b>    K.3.1 Introduction</b></a>
-<a name="K.3.1.1" href="#K.3.1.1"><b>    K.3.1.1 Standard headers</b></a>
-1   The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are not
-    declared or defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
-    defined as a macro which expands to the integer constant 0 at the point in the source file
-    where the appropriate header is first included.
-2   The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are
-    declared and defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
-    defined as a macro which expands to the integer constant 1 at the point in the source file
-    where the appropriate header is first included.<sup><a href="#note368"><b>368)</b></a></sup>
-3   It is implementation-defined whether the functions, macros, and types declared or defined
-    in <a href="#K.3">K.3</a> and its subclauses are declared or defined by their respective headers if
-    __STDC_WANT_LIB_EXT1__ is not defined as a macro at the point in the source file
-    where the appropriate header is first included.<sup><a href="#note369"><b>369)</b></a></sup>
-4   Within a preprocessing translation unit, __STDC_WANT_LIB_EXT1__ shall be
-    defined identically for all inclusions of any headers from subclause <a href="#K.3">K.3</a>. If
-    __STDC_WANT_LIB_EXT1__ is defined differently for any such inclusion, the
-    implementation shall issue a diagnostic as if a preprocessor error directive were used.
-
-
-    <sup><a name="note367" href="#note367"><b>367)</b></a></sup> Implementations that do not define __STDC_LIB_EXT1__ are not required to conform to these
-         specifications.
-    <sup><a name="note368" href="#note368"><b>368)</b></a></sup> Future revisions of this International Standard may define meanings for other values of
-         __STDC_WANT_LIB_EXT1__.
-    <sup><a name="note369" href="#note369"><b>369)</b></a></sup> Subclause <a href="#7.1.3">7.1.3</a> reserves certain names and patterns of names that an implementation may use in
-         headers. All other names are not reserved, and a conforming implementation is not permitted to use
-         them. While some of the names defined in <a href="#K.3">K.3</a> and its subclauses are reserved, others are not. If an
-         unreserved name is defined in a header when __STDC_WANT_LIB_EXT1__ is defined as 0, the
-         implementation is not conforming.
-
-[<a name="p579" href="#p579">page 579</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.1.2" href="#K.3.1.2"><b>    K.3.1.2 Reserved identifiers</b></a>
-1   Each macro name in any of the following subclauses is reserved for use as specified if it
-    is defined by any of its associated headers when included; unless explicitly stated
-    otherwise (see <a href="#7.1.4">7.1.4</a>).
-2   All identifiers with external linkage in any of the following subclauses are reserved for
-    use as identifiers with external linkage if any of them are used by the program. None of
-    them are reserved if none of them are used.
-3   Each identifier with file scope listed in any of the following subclauses is reserved for use
-    as a macro name and as an identifier with file scope in the same name space if it is
-    defined by any of its associated headers when included.
-<a name="K.3.1.3" href="#K.3.1.3"><b>    K.3.1.3 Use of errno</b></a>
-1   An implementation may set errno for the functions defined in this annex, but is not
-    required to.
-<a name="K.3.1.4" href="#K.3.1.4"><b>    K.3.1.4 Runtime-constraint violations</b></a>
-1   Most functions in this annex include as part of their specification a list of runtime-
-    constraints. These runtime-constraints are requirements on the program using the
-    library.<sup><a href="#note370"><b>370)</b></a></sup>
-2   Implementations shall verify that the runtime-constraints for a function are not violated
-    by the program. If a runtime-constraint is violated, the implementation shall call the
-    currently registered runtime-constraint handler (see set_constraint_handler_s
-    in <a href="#7.22">&lt;stdlib.h&gt;</a>). Multiple runtime-constraint violations in the same call to a library
-    function result in only one call to the runtime-constraint handler. It is unspecified which
-    one of the multiple runtime-constraint violations cause the handler to be called.
-3   If the runtime-constraints section for a function states an action to be performed when a
-    runtime-constraint violation occurs, the function shall perform the action before calling
-    the runtime-constraint handler. If the runtime-constraints section lists actions that are
-    prohibited when a runtime-constraint violation occurs, then such actions are prohibited to
-    the function both before calling the handler and after the handler returns.
-4   The runtime-constraint handler might not return. If the handler does return, the library
-    function whose runtime-constraint was violated shall return some indication of failure as
-    given by the returns section in the function's specification.
-
-
-
-    <sup><a name="note370" href="#note370"><b>370)</b></a></sup> Although runtime-constraints replace many cases of undefined behavior, undefined behavior still
-         exists in this annex. Implementations are free to detect any case of undefined behavior and treat it as a
-         runtime-constraint violation by calling the runtime-constraint handler. This license comes directly
-         from the definition of undefined behavior.
-
-[<a name="p580" href="#p580">page 580</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.2" href="#K.3.2"><b>    K.3.2 Errors &lt;errno.h&gt;</b></a>
-1   The header <a href="#7.5">&lt;errno.h&gt;</a> defines a type.
-2   The type is
-             errno_t
-    which is type int.<sup><a href="#note371"><b>371)</b></a></sup>
-<a name="K.3.3" href="#K.3.3"><b>    K.3.3 Common definitions &lt;stddef.h&gt;</b></a>
-1   The header <a href="#7.19">&lt;stddef.h&gt;</a> defines a type.
-2   The type is
-             rsize_t
-    which is the type size_t.<sup><a href="#note372"><b>372)</b></a></sup>
-<a name="K.3.4" href="#K.3.4"><b>    K.3.4 Integer types &lt;stdint.h&gt;</b></a>
-1   The header <a href="#7.20">&lt;stdint.h&gt;</a> defines a macro.
-2   The macro is
-             RSIZE_MAX
-    which expands to a value<sup><a href="#note373"><b>373)</b></a></sup> of type size_t. Functions that have parameters of type
-    rsize_t consider it a runtime-constraint violation if the values of those parameters are
-    greater than RSIZE_MAX.
-    Recommended practice
-3   Extremely large object sizes are frequently a sign that an object's size was calculated
-    incorrectly. For example, negative numbers appear as very large positive numbers when
-    converted to an unsigned type like size_t. Also, some implementations do not support
-    objects as large as the maximum value that can be represented by type size_t.
-4   For those reasons, it is sometimes beneficial to restrict the range of object sizes to detect
-    programming errors. For implementations targeting machines with large address spaces,
-    it is recommended that RSIZE_MAX be defined as the smaller of the size of the largest
-    object supported or (SIZE_MAX &gt;&gt; 1), even if this limit is smaller than the size of
-    some legitimate, but very large, objects. Implementations targeting machines with small
-    address spaces may wish to define RSIZE_MAX as SIZE_MAX, which means that there
-
-    <sup><a name="note371" href="#note371"><b>371)</b></a></sup> As a matter of programming style, errno_t may be used as the type of something that deals only
-         with the values that might be found in errno. For example, a function which returns the value of
-         errno might be declared as having the return type errno_t.
-    <sup><a name="note372" href="#note372"><b>372)</b></a></sup> See the description of the RSIZE_MAX macro in <a href="#7.20">&lt;stdint.h&gt;</a>.
-    <sup><a name="note373" href="#note373"><b>373)</b></a></sup> The macro RSIZE_MAX need not expand to a constant expression.
-
-[<a name="p581" href="#p581">page 581</a>] (<a href="#Contents">Contents</a>)
-
-    is no object size that is considered a runtime-constraint violation.
-<a name="K.3.5" href="#K.3.5"><b>    K.3.5 Input/output &lt;stdio.h&gt;</b></a>
-1   The header <a href="#7.21">&lt;stdio.h&gt;</a> defines several macros and two types.
-2   The macros are
-           L_tmpnam_s
-    which expands to an integer constant expression that is the size needed for an array of
-    char large enough to hold a temporary file name string generated by the tmpnam_s
-    function;
-           TMP_MAX_S
-    which expands to an integer constant expression that is the maximum number of unique
-    file names that can be generated by the tmpnam_s function.
-3   The types are
-           errno_t
-    which is type int; and
-           rsize_t
-    which is the type size_t.
-<a name="K.3.5.1" href="#K.3.5.1"><b>    K.3.5.1 Operations on files</b></a>
-<a name="K.3.5.1.1" href="#K.3.5.1.1"><b>    K.3.5.1.1 The tmpfile_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           errno_t tmpfile_s(FILE * restrict * restrict streamptr);
-    Runtime-constraints
-2   streamptr shall not be a null pointer.
-3   If there is a runtime-constraint violation, tmpfile_s does not attempt to create a file.
-<b>    Description</b>
-4   The tmpfile_s function creates a temporary binary file that is different from any other
-    existing file and that will automatically be removed when it is closed or at program
-    termination. If the program terminates abnormally, whether an open temporary file is
-    removed is implementation-defined. The file is opened for update with "wb+" mode
-    with the meaning that mode has in the fopen_s function (including the mode's effect
-    on exclusive access and file permissions).
-
-[<a name="p582" href="#p582">page 582</a>] (<a href="#Contents">Contents</a>)
-
-5   If the file was created successfully, then the pointer to FILE pointed to by streamptr
-    will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
-    to FILE pointed to by streamptr will be set to a null pointer.
-    Recommended practice
-    It should be possible to open at least TMP_MAX_S temporary files during the lifetime of
-    the program (this limit may be shared with tmpnam_s) and there should be no limit on
-    the number simultaneously open other than this limit and any limit on the number of open
-    files (FOPEN_MAX).
-<b>    Returns</b>
-6   The tmpfile_s function returns zero if it created the file. If it did not create the file or
-    there was a runtime-constraint violation, tmpfile_s returns a nonzero value.
-<a name="K.3.5.1.2" href="#K.3.5.1.2"><b>    K.3.5.1.2 The tmpnam_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            errno_t tmpnam_s(char *s, rsize_t maxsize);
-    Runtime-constraints
-2   s shall not be a null pointer. maxsize shall be less than or equal to RSIZE_MAX.
-    maxsize shall be greater than the length of the generated file name string.
-<b>    Description</b>
-3   The tmpnam_s function generates a string that is a valid file name and that is not the
-    same as the name of an existing file.<sup><a href="#note374"><b>374)</b></a></sup> The function is potentially capable of generating
-    TMP_MAX_S different strings, but any or all of them may already be in use by existing
-    files and thus not be suitable return values. The lengths of these strings shall be less than
-    the value of the L_tmpnam_s macro.
-4   The tmpnam_s function generates a different string each time it is called.
-5   It is assumed that s points to an array of at least maxsize characters. This array will be
-    set to generated string, as specified below.
-
-
-
-    <sup><a name="note374" href="#note374"><b>374)</b></a></sup> Files created using strings generated by the tmpnam_s function are temporary only in the sense that
-         their names should not collide with those generated by conventional naming rules for the
-         implementation. It is still necessary to use the remove function to remove such files when their use
-         is ended, and before program termination. Implementations should take care in choosing the patterns
-         used for names returned by tmpnam_s. For example, making a thread id part of the names avoids the
-         race condition and possible conflict when multiple programs run simultaneously by the same user
-         generate the same temporary file names.
-
-[<a name="p583" href="#p583">page 583</a>] (<a href="#Contents">Contents</a>)
-
-6    The implementation shall behave as if no library function except tmpnam calls the
-     tmpnam_s function.<sup><a href="#note375"><b>375)</b></a></sup>
-     Recommended practice
-7    After a program obtains a file name using the tmpnam_s function and before the
-     program creates a file with that name, the possibility exists that someone else may create
-     a file with that same name. To avoid this race condition, the tmpfile_s function
-     should be used instead of tmpnam_s when possible. One situation that requires the use
-     of the tmpnam_s function is when the program needs to create a temporary directory
-     rather than a temporary file.
-<b>     Returns</b>
-8    If no suitable string can be generated, or if there is a runtime-constraint violation, the
-     tmpnam_s function writes a null character to s[0] (only if s is not null and maxsize
-     is greater than zero) and returns a nonzero value.
-9    Otherwise, the tmpnam_s function writes the string in the array pointed to by s and
-     returns zero.
-     Environmental limits
-10   The value of the macro TMP_MAX_S shall be at least 25.
-<a name="K.3.5.2" href="#K.3.5.2"><b>     K.3.5.2 File access functions</b></a>
-<a name="K.3.5.2.1" href="#K.3.5.2.1"><b>     K.3.5.2.1 The fopen_s function</b></a>
-<b>     Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            errno_t fopen_s(FILE * restrict * restrict streamptr,
-                 const char * restrict filename,
-                 const char * restrict mode);
-     Runtime-constraints
-2    None of streamptr, filename, or mode shall be a null pointer.
-3    If there is a runtime-constraint violation, fopen_s does not attempt to open a file.
-     Furthermore, if streamptr is not a null pointer, fopen_s sets *streamptr to the
-     null pointer.
-
-
-
-
-     <sup><a name="note375" href="#note375"><b>375)</b></a></sup> An implementation may have tmpnam call tmpnam_s (perhaps so there is only one naming
-          convention for temporary files), but this is not required.
-
-[<a name="p584" href="#p584">page 584</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-4   The fopen_s function opens the file whose name is the string pointed to by
-    filename, and associates a stream with it.
-5   The mode string shall be as described for fopen, with the addition that modes starting
-    with the character 'w' or 'a' may be preceded by the character 'u', see below:
-    uw             truncate to zero length or create text file for writing, default
-                   permissions
-    uwx            create text file for writing, default permissions
-    ua             append; open or create text file for writing at end-of-file, default
-                   permissions
-    uwb            truncate to zero length or create binary file for writing, default
-                   permissions
-    uwbx           create binary file for writing, default permissions
-    uab            append; open or create binary file for writing at end-of-file, default
-                   permissions
-    uw+            truncate to zero length or create text file for update, default
-                   permissions
-    uw+x           create text file for update, default permissions
-    ua+            append; open or create text file for update, writing at end-of-file,
-                   default permissions
-    uw+b or uwb+   truncate to zero length or create binary file for update, default
-                   permissions
-    uw+bx or uwb+x create binary file for update, default permissions
-    ua+b or uab+   append; open or create binary file for update, writing at end-of-file,
-                   default permissions
-6   Opening a file with exclusive mode ('x' as the last character in the mode argument)
-    fails if the file already exists or cannot be created.
-7   To the extent that the underlying system supports the concepts, files opened for writing
-    shall be opened with exclusive (also known as non-shared) access. If the file is being
-    created, and the first character of the mode string is not 'u', to the extent that the
-    underlying system supports it, the file shall have a file permission that prevents other
-    users on the system from accessing the file. If the file is being created and first character
-    of the mode string is 'u', then by the time the file has been closed, it shall have the
-    system default file access permissions.<sup><a href="#note376"><b>376)</b></a></sup>
-8   If the file was opened successfully, then the pointer to FILE pointed to by streamptr
-    will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
-
-
-    <sup><a name="note376" href="#note376"><b>376)</b></a></sup> These are the same permissions that the file would have been created with by fopen.
-
-[<a name="p585" href="#p585">page 585</a>] (<a href="#Contents">Contents</a>)
-
-    to FILE pointed to by streamptr will be set to a null pointer.
-<b>    Returns</b>
-9   The fopen_s function returns zero if it opened the file. If it did not open the file or if
-    there was a runtime-constraint violation, fopen_s returns a nonzero value.
-<a name="K.3.5.2.2" href="#K.3.5.2.2"><b>    K.3.5.2.2 The freopen_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           errno_t freopen_s(FILE * restrict * restrict newstreamptr,
-                const char * restrict filename,
-                const char * restrict mode,
-                FILE * restrict stream);
-    Runtime-constraints
-2   None of newstreamptr, mode, and stream shall be a null pointer.
-3   If there is a runtime-constraint violation, freopen_s neither attempts to close any file
-    associated with stream nor attempts to open a file. Furthermore, if newstreamptr is
-    not a null pointer, fopen_s sets *newstreamptr to the null pointer.
-<b>    Description</b>
-4   The freopen_s function opens the file whose name is the string pointed to by
-    filename and associates the stream pointed to by stream with it. The mode
-    argument has the same meaning as in the fopen_s function (including the mode's effect
-    on exclusive access and file permissions).
-5   If filename is a null pointer, the freopen_s function attempts to change the mode of
-    the stream to that specified by mode, as if the name of the file currently associated with
-    the stream had been used. It is implementation-defined which changes of mode are
-    permitted (if any), and under what circumstances.
-6   The freopen_s function first attempts to close any file that is associated with stream.
-    Failure to close the file is ignored. The error and end-of-file indicators for the stream are
-    cleared.
-7   If the file was opened successfully, then the pointer to FILE pointed to by
-    newstreamptr will be set to the value of stream. Otherwise, the pointer to FILE
-    pointed to by newstreamptr will be set to a null pointer.
-<b>    Returns</b>
-8   The freopen_s function returns zero if it opened the file. If it did not open the file or
-    there was a runtime-constraint violation, freopen_s returns a nonzero value.
-
-[<a name="p586" href="#p586">page 586</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.5.3" href="#K.3.5.3"><b>    K.3.5.3 Formatted input/output functions</b></a>
-1   Unless explicitly stated otherwise, if the execution of a function described in this
-    subclause causes copying to take place between objects that overlap, the objects take on
-    unspecified values.
-<a name="K.3.5.3.1" href="#K.3.5.3.1"><b>    K.3.5.3.1 The fprintf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int fprintf_s(FILE * restrict stream,
-                  const char * restrict format, ...);
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note377"><b>377)</b></a></sup> (modified or
-    not by flags, field width, or precision) shall not appear in the string pointed to by
-    format. Any argument to fprintf_s corresponding to a %s specifier shall not be a
-    null pointer.
-3   If there is a runtime-constraint violation,<sup><a href="#note378"><b>378)</b></a></sup> the fprintf_s function does not attempt
-    to produce further output, and it is unspecified to what extent fprintf_s produced
-    output before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The fprintf_s function is equivalent to the fprintf function except for the explicit
-    runtime-constraints listed above.
-<b>    Returns</b>
-5   The fprintf_s function returns the number of characters transmitted, or a negative
-    value if an output error, encoding error, or runtime-constraint violation occurred.
-
-
-
-
-    <sup><a name="note377" href="#note377"><b>377)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-    <sup><a name="note378" href="#note378"><b>378)</b></a></sup> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
-         implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
-         constraint violation.
-
-[<a name="p587" href="#p587">page 587</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.5.3.2" href="#K.3.5.3.2"><b>    K.3.5.3.2 The fscanf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int fscanf_s(FILE * restrict stream,
-                 const char * restrict format, ...);
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. Any argument indirected though in
-    order to store converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation,<sup><a href="#note379"><b>379)</b></a></sup> the fscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent fscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The fscanf_s function is equivalent to fscanf except that the c, s, and [ conversion
-    specifiers apply to a pair of arguments (unless assignment suppression is indicated by a
-    *). The first of these arguments is the same as for fscanf. That argument is
-    immediately followed in the argument list by the second argument, which has type
-    rsize_t and gives the number of elements in the array pointed to by the first argument
-    of the pair. If the first argument points to a scalar object, it is considered to be an array of
-    one element.<sup><a href="#note380"><b>380)</b></a></sup>
-5   A matching failure occurs if the number of elements in a receiving object is insufficient to
-    hold the converted input (including any trailing null character).
-<b>    Returns</b>
-6   The fscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-
-    <sup><a name="note379" href="#note379"><b>379)</b></a></sup> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
-         implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
-         constraint violation.
-    <sup><a name="note380" href="#note380"><b>380)</b></a></sup> If the format is known at translation time, an implementation may issue a diagnostic for any argument
-         used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
-         argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
-         the format is not known at translation time. For example, an implementation may issue a diagnostic
-         for each argument after format that has of type pointer to one of char, signed char,
-         unsigned char, or void that is not followed by an argument of a type compatible with
-         rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
-         using the hh length modifier, a length argument must follow the pointer argument. Another useful
-         diagnostic could flag any non-pointer argument following format that did not have a type
-         compatible with rsize_t.
-
-[<a name="p588" href="#p588">page 588</a>] (<a href="#Contents">Contents</a>)
-
-    fscanf_s function returns the number of input items assigned, which can be fewer than
-    provided for, or even zero, in the event of an early matching failure.
-7   EXAMPLE 1        The call:
-             #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             /* ... */
-             int n, i; float x; char name[50];
-             n = fscanf_s(stdin, "%d%f%s", &amp;i, &amp;x, name, (rsize_t) 50);
-    with the input line:
-             25 54.32E-1 thompson
-    will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
-    thompson\0.
-
-8   EXAMPLE 2        The call:
-             #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             /* ... */
-             int n; char s[5];
-             n = fscanf_s(stdin, "%s", s, sizeof s);
-    with the input line:
-             hello
-    will assign to n the value 0 since a matching failure occurred because the sequence hello\0 requires an
-    array of six characters to store it.
-
-<a name="K.3.5.3.3" href="#K.3.5.3.3"><b>    K.3.5.3.3 The printf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int printf_s(const char * restrict format, ...);
-    Runtime-constraints
-2   format shall not be a null pointer. The %n specifier<sup><a href="#note381"><b>381)</b></a></sup> (modified or not by flags, field
-    width, or precision) shall not appear in the string pointed to by format. Any argument
-    to printf_s corresponding to a %s specifier shall not be a null pointer.
-3   If there is a runtime-constraint violation, the printf_s function does not attempt to
-    produce further output, and it is unspecified to what extent printf_s produced output
-    before discovering the runtime-constraint violation.
-
-
-    <sup><a name="note381" href="#note381"><b>381)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-
-[<a name="p589" href="#p589">page 589</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-4   The printf_s function is equivalent to the printf function except for the explicit
-    runtime-constraints listed above.
-<b>    Returns</b>
-5   The printf_s function returns the number of characters transmitted, or a negative
-    value if an output error, encoding error, or runtime-constraint violation occurred.
-<a name="K.3.5.3.4" href="#K.3.5.3.4"><b>    K.3.5.3.4 The scanf_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int scanf_s(const char * restrict format, ...);
-    Runtime-constraints
-2   format shall not be a null pointer. Any argument indirected though in order to store
-    converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the scanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent scanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The scanf_s function is equivalent to fscanf_s with the argument stdin
-    interposed before the arguments to scanf_s.
-<b>    Returns</b>
-5   The scanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    scanf_s function returns the number of input items assigned, which can be fewer than
-    provided for, or even zero, in the event of an early matching failure.
-<a name="K.3.5.3.5" href="#K.3.5.3.5"><b>    K.3.5.3.5 The snprintf_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int snprintf_s(char * restrict s, rsize_t n,
-                const char * restrict format, ...);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The %n specifier<sup><a href="#note382"><b>382)</b></a></sup> (modified or not by flags, field width, or
-    precision) shall not appear in the string pointed to by format. Any argument to
-
-[<a name="p590" href="#p590">page 590</a>] (<a href="#Contents">Contents</a>)
-
-    snprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
-    error shall occur.
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the snprintf_s function sets s[0] to the
-    null character.
-<b>    Description</b>
-4   The snprintf_s function is equivalent to the snprintf function except for the
-    explicit runtime-constraints listed above.
-5   The snprintf_s function, unlike sprintf_s, will truncate the result to fit within the
-    array pointed to by s.
-<b>    Returns</b>
-6   The snprintf_s function returns the number of characters that would have been
-    written had n been sufficiently large, not counting the terminating null character, or a
-    negative value if a runtime-constraint violation occurred. Thus, the null-terminated
-    output has been completely written if and only if the returned value is nonnegative and
-    less than n.
-<a name="K.3.5.3.6" href="#K.3.5.3.6"><b>    K.3.5.3.6 The sprintf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int sprintf_s(char * restrict s, rsize_t n,
-                  const char * restrict format, ...);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The number of characters (including the trailing null) required for the
-    result to be written to the array pointed to by s shall not be greater than n. The %n
-    specifier<sup><a href="#note383"><b>383)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
-    string pointed to by format. Any argument to sprintf_s corresponding to a %s
-    specifier shall not be a null pointer. No encoding error shall occur.
-
-
-
-    <sup><a name="note382" href="#note382"><b>382)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-    <sup><a name="note383" href="#note383"><b>383)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-
-[<a name="p591" href="#p591">page 591</a>] (<a href="#Contents">Contents</a>)
-
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the sprintf_s function sets s[0] to the
-    null character.
-<b>    Description</b>
-4   The sprintf_s function is equivalent to the sprintf function except for the
-    parameter n and the explicit runtime-constraints listed above.
-5   The sprintf_s function, unlike snprintf_s, treats a result too big for the array
-    pointed to by s as a runtime-constraint violation.
-<b>    Returns</b>
-6   If no runtime-constraint violation occurred, the sprintf_s function returns the number
-    of characters written in the array, not counting the terminating null character. If an
-    encoding error occurred, sprintf_s returns a negative value. If any other runtime-
-    constraint violation occurred, sprintf_s returns zero.
-<a name="K.3.5.3.7" href="#K.3.5.3.7"><b>    K.3.5.3.7 The sscanf_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int sscanf_s(const char * restrict s,
-                const char * restrict format, ...);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. Any argument indirected though in order
-    to store converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the sscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent sscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The sscanf_s function is equivalent to fscanf_s, except that input is obtained from
-    a string (specified by the argument s) rather than from a stream. Reaching the end of the
-    string is equivalent to encountering end-of-file for the fscanf_s function. If copying
-    takes place between objects that overlap, the objects take on unspecified values.
-<b>    Returns</b>
-5   The sscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    sscanf_s function returns the number of input items assigned, which can be fewer than
-    provided for, or even zero, in the event of an early matching failure.
-
-[<a name="p592" href="#p592">page 592</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.5.3.8" href="#K.3.5.3.8"><b>    K.3.5.3.8 The vfprintf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int vfprintf_s(FILE * restrict stream,
-                  const char * restrict format,
-                  va_list arg);
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note384"><b>384)</b></a></sup> (modified or
-    not by flags, field width, or precision) shall not appear in the string pointed to by
-    format. Any argument to vfprintf_s corresponding to a %s specifier shall not be a
-    null pointer.
-3   If there is a runtime-constraint violation, the vfprintf_s function does not attempt to
-    produce further output, and it is unspecified to what extent vfprintf_s produced
-    output before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vfprintf_s function is equivalent to the vfprintf function except for the
-    explicit runtime-constraints listed above.
-<b>    Returns</b>
-5   The vfprintf_s function returns the number of characters transmitted, or a negative
-    value if an output error, encoding error, or runtime-constraint violation occurred.
-<a name="K.3.5.3.9" href="#K.3.5.3.9"><b>    K.3.5.3.9 The vfscanf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int vfscanf_s(FILE * restrict stream,
-                  const char * restrict format,
-                  va_list arg);
-
-
-
-
-    <sup><a name="note384" href="#note384"><b>384)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-
-[<a name="p593" href="#p593">page 593</a>] (<a href="#Contents">Contents</a>)
-
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. Any argument indirected though in
-    order to store converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vfscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent vfscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vfscanf_s function is equivalent to fscanf_s, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfscanf_s function does not invoke the
-    va_end macro.<sup><a href="#note385"><b>385)</b></a></sup>
-<b>    Returns</b>
-5   The vfscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    vfscanf_s function returns the number of input items assigned, which can be fewer
-    than provided for, or even zero, in the event of an early matching failure.
-<a name="K.3.5.3.10" href="#K.3.5.3.10"><b>    K.3.5.3.10 The vprintf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int vprintf_s(const char * restrict format,
-                  va_list arg);
-    Runtime-constraints
-2   format shall not be a null pointer. The %n specifier<sup><a href="#note386"><b>386)</b></a></sup> (modified or not by flags, field
-    width, or precision) shall not appear in the string pointed to by format. Any argument
-    to vprintf_s corresponding to a %s specifier shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vprintf_s function does not attempt to
-    produce further output, and it is unspecified to what extent vprintf_s produced output
-    before discovering the runtime-constraint violation.
-
-    <sup><a name="note385" href="#note385"><b>385)</b></a></sup> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
-         vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
-         indeterminate.
-    <sup><a name="note386" href="#note386"><b>386)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-
-[<a name="p594" href="#p594">page 594</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-4   The vprintf_s function is equivalent to the vprintf function except for the explicit
-    runtime-constraints listed above.
-<b>    Returns</b>
-5   The vprintf_s function returns the number of characters transmitted, or a negative
-    value if an output error, encoding error, or runtime-constraint violation occurred.
-<a name="K.3.5.3.11" href="#K.3.5.3.11"><b>    K.3.5.3.11 The vscanf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            int vscanf_s(const char * restrict format,
-                 va_list arg);
-    Runtime-constraints
-2   format shall not be a null pointer. Any argument indirected though in order to store
-    converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent vscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vscanf_s function is equivalent to scanf_s, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vscanf_s function does not invoke the
-    va_end macro.<sup><a href="#note387"><b>387)</b></a></sup>
-<b>    Returns</b>
-5   The vscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    vscanf_s function returns the number of input items assigned, which can be fewer than
-    provided for, or even zero, in the event of an early matching failure.
-
-
-
-
-    <sup><a name="note387" href="#note387"><b>387)</b></a></sup> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
-         vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
-         indeterminate.
-
-[<a name="p595" href="#p595">page 595</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.5.3.12" href="#K.3.5.3.12"><b>    K.3.5.3.12 The vsnprintf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int vsnprintf_s(char * restrict s, rsize_t n,
-                  const char * restrict format,
-                  va_list arg);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The %n specifier<sup><a href="#note388"><b>388)</b></a></sup> (modified or not by flags, field width, or
-    precision) shall not appear in the string pointed to by format. Any argument to
-    vsnprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
-    error shall occur.
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the vsnprintf_s function sets s[0] to the
-    null character.
-<b>    Description</b>
-4   The vsnprintf_s function is equivalent to the vsnprintf function except for the
-    explicit runtime-constraints listed above.
-5   The vsnprintf_s function, unlike vsprintf_s, will truncate the result to fit within
-    the array pointed to by s.
-<b>    Returns</b>
-6   The vsnprintf_s function returns the number of characters that would have been
-    written had n been sufficiently large, not counting the terminating null character, or a
-    negative value if a runtime-constraint violation occurred. Thus, the null-terminated
-    output has been completely written if and only if the returned value is nonnegative and
-    less than n.
-
-
-
-
-    <sup><a name="note388" href="#note388"><b>388)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-
-[<a name="p596" href="#p596">page 596</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.5.3.13" href="#K.3.5.3.13"><b>    K.3.5.3.13 The vsprintf_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-             #include <a href="#7.21">&lt;stdio.h&gt;</a>
-             int vsprintf_s(char * restrict s, rsize_t n,
-                  const char * restrict format,
-                  va_list arg);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The number of characters (including the trailing null) required for the
-    result to be written to the array pointed to by s shall not be greater than n. The %n
-    specifier<sup><a href="#note389"><b>389)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
-    string pointed to by format. Any argument to vsprintf_s corresponding to a %s
-    specifier shall not be a null pointer. No encoding error shall occur.
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the vsprintf_s function sets s[0] to the
-    null character.
-<b>    Description</b>
-4   The vsprintf_s function is equivalent to the vsprintf function except for the
-    parameter n and the explicit runtime-constraints listed above.
-5   The vsprintf_s function, unlike vsnprintf_s, treats a result too big for the array
-    pointed to by s as a runtime-constraint violation.
-<b>    Returns</b>
-6   If no runtime-constraint violation occurred, the vsprintf_s function returns the
-    number of characters written in the array, not counting the terminating null character. If
-    an encoding error occurred, vsprintf_s returns a negative value. If any other
-    runtime-constraint violation occurred, vsprintf_s returns zero.
-
-
-
-
-    <sup><a name="note389" href="#note389"><b>389)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
-         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
-         format string was %%n.
-
-[<a name="p597" href="#p597">page 597</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.5.3.14" href="#K.3.5.3.14"><b>    K.3.5.3.14 The vsscanf_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           int vsscanf_s(const char * restrict s,
-                const char * restrict format,
-                va_list arg);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. Any argument indirected though in order
-    to store converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vsscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent vsscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vsscanf_s function is equivalent to sscanf_s, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vsscanf_s function does not invoke the
-    va_end macro.<sup><a href="#note390"><b>390)</b></a></sup>
-<b>    Returns</b>
-5   The vsscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    vscanf_s function returns the number of input items assigned, which can be fewer than
-    provided for, or even zero, in the event of an early matching failure.
-<a name="K.3.5.4" href="#K.3.5.4"><b>    K.3.5.4 Character input/output functions</b></a>
-<a name="K.3.5.4.1" href="#K.3.5.4.1"><b>    K.3.5.4.1 The gets_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.21">&lt;stdio.h&gt;</a>
-           char *gets_s(char *s, rsize_t n);
-
-
-
-
-    <sup><a name="note390" href="#note390"><b>390)</b></a></sup> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
-         vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
-         indeterminate.
-
-[<a name="p598" href="#p598">page 598</a>] (<a href="#Contents">Contents</a>)
-
-    Runtime-constraints
-2   s shall not be a null pointer. n shall neither be equal to zero nor be greater than
-    RSIZE_MAX. A new-line character, end-of-file, or read error shall occur within reading
-    n-1 characters from stdin.<sup><a href="#note391"><b>391)</b></a></sup>
-3   If there is a runtime-constraint violation, s[0] is set to the null character, and characters
-    are read and discarded from stdin until a new-line character is read, or end-of-file or a
-    read error occurs.
-<b>    Description</b>
-4   The gets_s function reads at most one less than the number of characters specified by n
-    from the stream pointed to by stdin, into the array pointed to by s. No additional
-    characters are read after a new-line character (which is discarded) or after end-of-file.
-    The discarded new-line character does not count towards number of characters read. A
-    null character is written immediately after the last character read into the array.
-5   If end-of-file is encountered and no characters have been read into the array, or if a read
-    error occurs during the operation, then s[0] is set to the null character, and the other
-    elements of s take unspecified values.
-    Recommended practice
-6   The fgets function allows properly-written programs to safely process input lines too
-    long to store in the result array. In general this requires that callers of fgets pay
-    attention to the presence or absence of a new-line character in the result array. Consider
-    using fgets (along with any needed processing based on new-line characters) instead of
-    gets_s.
-<b>    Returns</b>
-7   The gets_s function returns s if successful. If there was a runtime-constraint violation,
-    or if end-of-file is encountered and no characters have been read into the array, or if a
-    read error occurs during the operation, then a null pointer is returned.
-
-
-
-
-    <sup><a name="note391" href="#note391"><b>391)</b></a></sup> The gets_s function, unlike the historical gets function, makes it a runtime-constraint violation for
-         a line of input to overflow the buffer to store it. Unlike the fgets function, gets_s maintains a
-         one-to-one relationship between input lines and successful calls to gets_s. Programs that use gets
-         expect such a relationship.
-
-[<a name="p599" href="#p599">page 599</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.6" href="#K.3.6"><b>    K.3.6 General utilities &lt;stdlib.h&gt;</b></a>
-1   The header <a href="#7.22">&lt;stdlib.h&gt;</a> defines three types.
-2   The types are
-            errno_t
-    which is type int; and
-            rsize_t
-    which is the type size_t; and
-            constraint_handler_t
-    which has the following definition
-            typedef void (*constraint_handler_t)(
-                 const char * restrict msg,
-                 void * restrict ptr,
-                 errno_t error);
-<a name="K.3.6.1" href="#K.3.6.1"><b>    K.3.6.1 Runtime-constraint handling</b></a>
-<a name="K.3.6.1.1" href="#K.3.6.1.1"><b>    K.3.6.1.1 The set_constraint_handler_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            constraint_handler_t set_constraint_handler_s(
-                 constraint_handler_t handler);
-<b>    Description</b>
-2   The set_constraint_handler_s function sets the runtime-constraint handler to
-    be handler. The runtime-constraint handler is the function to be called when a library
-    function detects a runtime-constraint violation. Only the most recent handler registered
-    with set_constraint_handler_s is called when a runtime-constraint violation
-    occurs.
-3   When the handler is called, it is passed the following arguments in the following order:
-       1.   A pointer to a character string describing the runtime-constraint violation.
-       2.   A null pointer or a pointer to an implementation defined object.
-       3.   If the function calling the handler has a return type declared as errno_t, the
-            return value of the function is passed. Otherwise, a positive value of type
-            errno_t is passed.
-
-[<a name="p600" href="#p600">page 600</a>] (<a href="#Contents">Contents</a>)
-
-4   The implementation has a default constraint handler that is used if no calls to the
-    set_constraint_handler_s function have been made. The behavior of the
-    default handler is implementation-defined, and it may cause the program to exit or abort.
-5   If the handler argument to set_constraint_handler_s is a null pointer, the
-    implementation default handler becomes the current constraint handler.
-<b>    Returns</b>
-6   The set_constraint_handler_s function returns a pointer to the previously
-    registered handler.<sup><a href="#note392"><b>392)</b></a></sup>
-<a name="K.3.6.1.2" href="#K.3.6.1.2"><b>    K.3.6.1.2 The abort_handler_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void abort_handler_s(
-                 const char * restrict msg,
-                 void * restrict ptr,
-                 errno_t error);
-<b>    Description</b>
-2   A pointer to the abort_handler_s function shall be a suitable argument to the
-    set_constraint_handler_s function.
-3   The abort_handler_s function writes a message on the standard error stream in an
-    implementation-defined format. The message shall include the string pointed to by msg.
-    The abort_handler_s function then calls the abort function.<sup><a href="#note393"><b>393)</b></a></sup>
-<b>    Returns</b>
-4   The abort_handler_s function does not return to its caller.
-
-
-
-
-    <sup><a name="note392" href="#note392"><b>392)</b></a></sup> If the previous handler was registered by calling set_constraint_handler_s with a null
-         pointer argument, a pointer to the implementation default handler is returned (not NULL).
-    <sup><a name="note393" href="#note393"><b>393)</b></a></sup> Many implementations invoke a debugger when the abort function is called.
-
-[<a name="p601" href="#p601">page 601</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.6.1.3" href="#K.3.6.1.3"><b>    K.3.6.1.3 The ignore_handler_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            void ignore_handler_s(
-                 const char * restrict msg,
-                 void * restrict ptr,
-                 errno_t error);
-<b>    Description</b>
-2   A pointer to the ignore_handler_s function shall be a suitable argument to the
-    set_constraint_handler_s function.
-3   The ignore_handler_s function simply returns to its caller.<sup><a href="#note394"><b>394)</b></a></sup>
-<b>    Returns</b>
-4   The ignore_handler_s function returns no value.
-<a name="K.3.6.2" href="#K.3.6.2"><b>    K.3.6.2 Communication with the environment</b></a>
-<a name="K.3.6.2.1" href="#K.3.6.2.1"><b>    K.3.6.2.1 The getenv_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            errno_t getenv_s(size_t * restrict len,
-                       char * restrict value, rsize_t maxsize,
-                       const char * restrict name);
-    Runtime-constraints
-2   name shall not be a null pointer. maxsize shall neither equal zero nor be greater than
-    RSIZE_MAX. If maxsize is not equal to zero, then value shall not be a null pointer.
-3   If there is a runtime-constraint violation, the integer pointed to by len is set to 0 (if len
-    is not null), and the environment list is not searched.
-<b>    Description</b>
-4   The getenv_s function searches an environment list, provided by the host environment,
-    for a string that matches the string pointed to by name.
-
-
-    <sup><a name="note394" href="#note394"><b>394)</b></a></sup> If the runtime-constraint handler is set to the ignore_handler_s function, any library function in
-         which a runtime-constraint violation occurs will return to its caller. The caller can determine whether
-         a runtime-constraint violation occurred based on the library function's specification (usually, the
-         library function returns a nonzero errno_t).
-
-[<a name="p602" href="#p602">page 602</a>] (<a href="#Contents">Contents</a>)
-
-5   If that name is found then getenv_s performs the following actions. If len is not a
-    null pointer, the length of the string associated with the matched list member is stored in
-    the integer pointed to by len. If the length of the associated string is less than maxsize,
-    then the associated string is copied to the array pointed to by value.
-6   If that name is not found then getenv_s performs the following actions. If len is not
-    a null pointer, zero is stored in the integer pointed to by len. If maxsize is greater than
-    zero, then value[0] is set to the null character.
-7   The set of environment names and the method for altering the environment list are
-    implementation-defined.
-<b>    Returns</b>
-8   The getenv_s function returns zero if the specified name is found and the associated
-    string was successfully stored in value. Otherwise, a nonzero value is returned.
-<a name="K.3.6.3" href="#K.3.6.3"><b>    K.3.6.3 Searching and sorting utilities</b></a>
-1   These utilities make use of a comparison function to search or sort arrays of unspecified
-    type. Where an argument declared as size_t nmemb specifies the length of the array
-    for a function, if nmemb has the value zero on a call to that function, then the comparison
-    function is not called, a search finds no matching element, sorting performs no
-    rearrangement, and the pointer to the array may be null.
-2   The implementation shall ensure that the second argument of the comparison function
-    (when called from bsearch_s), or both arguments (when called from qsort_s), are
-    pointers to elements of the array.<sup><a href="#note395"><b>395)</b></a></sup> The first argument when called from bsearch_s
-    shall equal key.
-3   The comparison function shall not alter the contents of either the array or search key. The
-    implementation may reorder elements of the array between calls to the comparison
-    function, but shall not otherwise alter the contents of any individual element.
-4   When the same objects (consisting of size bytes, irrespective of their current positions
-    in the array) are passed more than once to the comparison function, the results shall be
-    consistent with one another. That is, for qsort_s they shall define a total ordering on
-    the array, and for bsearch_s the same object shall always compare the same way with
-    the key.
-
-
-
-
-    <sup><a name="note395" href="#note395"><b>395)</b></a></sup> That is, if the value passed is p, then the following expressions are always valid and nonzero:
-                  ((char *)p - (char *)base) % size == 0
-                  (char *)p &gt;= (char *)base
-                  (char *)p &lt; (char *)base + nmemb * size
-
-[<a name="p603" href="#p603">page 603</a>] (<a href="#Contents">Contents</a>)
-
-5   A sequence point occurs immediately before and immediately after each call to the
-    comparison function, and also between any call to the comparison function and any
-    movement of the objects passed as arguments to that call.
-<a name="K.3.6.3.1" href="#K.3.6.3.1"><b>    K.3.6.3.1 The bsearch_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             void *bsearch_s(const void *key, const void *base,
-                  rsize_t nmemb, rsize_t size,
-                  int (*compar)(const void *k, const void *y,
-                                  void *context),
-                  void *context);
-    Runtime-constraints
-2   Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
-    zero, then none of key, base, or compar shall be a null pointer.
-3   If there is a runtime-constraint violation, the bsearch_s function does not search the
-    array.
-<b>    Description</b>
-4   The bsearch_s function searches an array of nmemb objects, the initial element of
-    which is pointed to by base, for an element that matches the object pointed to by key.
-    The size of each element of the array is specified by size.
-5   The comparison function pointed to by compar is called with three arguments. The first
-    two point to the key object and to an array element, in that order. The function shall
-    return an integer less than, equal to, or greater than zero if the key object is considered,
-    respectively, to be less than, to match, or to be greater than the array element. The array
-    shall consist of: all the elements that compare less than, all the elements that compare
-    equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note396"><b>396)</b></a></sup>
-    The third argument to the comparison function is the context argument passed to
-    bsearch_s. The sole use of context by bsearch_s is to pass it to the comparison
-    function.<sup><a href="#note397"><b>397)</b></a></sup>
-
-
-
-
-    <sup><a name="note396" href="#note396"><b>396)</b></a></sup> In practice, this means that the entire array has been sorted according to the comparison function.
-    <sup><a name="note397" href="#note397"><b>397)</b></a></sup> The context argument is for the use of the comparison function in performing its duties. For
-         example, it might specify a collating sequence used by the comparison function.
-
-[<a name="p604" href="#p604">page 604</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-6   The bsearch_s function returns a pointer to a matching element of the array, or a null
-    pointer if no match is found or there is a runtime-constraint violation. If two elements
-    compare as equal, which element is matched is unspecified.
-<a name="K.3.6.3.2" href="#K.3.6.3.2"><b>    K.3.6.3.2 The qsort_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
-                 int (*compar)(const void *x, const void *y,
-                                 void *context),
-                 void *context);
-    Runtime-constraints
-2   Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
-    zero, then neither base nor compar shall be a null pointer.
-3   If there is a runtime-constraint violation, the qsort_s function does not sort the array.
-<b>    Description</b>
-4   The qsort_s function sorts an array of nmemb objects, the initial element of which is
-    pointed to by base. The size of each object is specified by size.
-5   The contents of the array are sorted into ascending order according to a comparison
-    function pointed to by compar, which is called with three arguments. The first two
-    point to the objects being compared. The function shall return an integer less than, equal
-    to, or greater than zero if the first argument is considered to be respectively less than,
-    equal to, or greater than the second. The third argument to the comparison function is the
-    context argument passed to qsort_s. The sole use of context by qsort_s is to
-    pass it to the comparison function.<sup><a href="#note398"><b>398)</b></a></sup>
-6   If two elements compare as equal, their relative order in the resulting sorted array is
-    unspecified.
-<b>    Returns</b>
-7   The qsort_s function returns zero if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-
-
-
-
-    <sup><a name="note398" href="#note398"><b>398)</b></a></sup> The context argument is for the use of the comparison function in performing its duties. For
-         example, it might specify a collating sequence used by the comparison function.
-
-[<a name="p605" href="#p605">page 605</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.6.4" href="#K.3.6.4"><b>    K.3.6.4 Multibyte/wide character conversion functions</b></a>
-1   The behavior of the multibyte character functions is affected by the LC_CTYPE category
-    of the current locale. For a state-dependent encoding, each function is placed into its
-    initial conversion state by a call for which its character pointer argument, s, is a null
-    pointer. Subsequent calls with s as other than a null pointer cause the internal conversion
-    state of the function to be altered as necessary. A call with s as a null pointer causes
-    these functions to set the int pointed to by their status argument to a nonzero value if
-    encodings have state dependency, and zero otherwise.<sup><a href="#note399"><b>399)</b></a></sup> Changing the LC_CTYPE
-    category causes the conversion state of these functions to be indeterminate.
-<a name="K.3.6.4.1" href="#K.3.6.4.1"><b>    K.3.6.4.1 The wctomb_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-            errno_t wctomb_s(int * restrict status,
-                 char * restrict s,
-                 rsize_t smax,
-                 wchar_t wc);
-    Runtime-constraints
-2   Let n denote the number of bytes needed to represent the multibyte character
-    corresponding to the wide character given by wc (including any shift sequences).
-3   If s is not a null pointer, then smax shall not be less than n, and smax shall not be
-    greater than RSIZE_MAX. If s is a null pointer, then smax shall equal zero.
-4   If there is a runtime-constraint violation, wctomb_s does not modify the int pointed to
-    by status, and if s is not a null pointer, no more than smax elements in the array
-    pointed to by s will be accessed.
-<b>    Description</b>
-5   The wctomb_s function determines n and stores the multibyte character representation
-    of wc in the array whose first element is pointed to by s (if s is not a null pointer). The
-    number of characters stored never exceeds MB_CUR_MAX or smax. If wc is a null wide
-    character, a null byte is stored, preceded by any shift sequence needed to restore the
-    initial shift state, and the function is left in the initial conversion state.
-6   The implementation shall behave as if no library function calls the wctomb_s function.
-
-
-
-
-    <sup><a name="note399" href="#note399"><b>399)</b></a></sup> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
-         character codes, but are grouped with an adjacent multibyte character.
-
-[<a name="p606" href="#p606">page 606</a>] (<a href="#Contents">Contents</a>)
-
-7    If s is a null pointer, the wctomb_s function stores into the int pointed to by status a
-     nonzero or zero value, if multibyte character encodings, respectively, do or do not have
-     state-dependent encodings.
-8    If s is not a null pointer, the wctomb_s function stores into the int pointed to by
-     status either n or -1 if wc, respectively, does or does not correspond to a valid
-     multibyte character.
-9    In no case will the int pointed to by status be set to a value greater than the
-     MB_CUR_MAX macro.
-<b>     Returns</b>
-10   The wctomb_s function returns zero if successful, and a nonzero value if there was a
-     runtime-constraint violation or wc did not correspond to a valid multibyte character.
-<a name="K.3.6.5" href="#K.3.6.5"><b>     K.3.6.5 Multibyte/wide string conversion functions</b></a>
-1    The behavior of the multibyte string functions is affected by the LC_CTYPE category of
-     the current locale.
-<a name="K.3.6.5.1" href="#K.3.6.5.1"><b>     K.3.6.5.1 The mbstowcs_s function</b></a>
-<b>     Synopsis</b>
-1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             errno_t mbstowcs_s(size_t * restrict retval,
-                  wchar_t * restrict dst, rsize_t dstmax,
-                  const char * restrict src, rsize_t len);
-     Runtime-constraints
-2    Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
-     neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
-     then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
-     zero. If dst is not a null pointer and len is not less than dstmax, then a null character
-     shall occur within the first dstmax multibyte characters of the array pointed to by src.
-3    If there is a runtime-constraint violation, then mbstowcs_s does the following. If
-     retval is not a null pointer, then mbstowcs_s sets *retval to (size_t)(-1). If
-     dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
-     then mbstowcs_s sets dst[0] to the null wide character.
-<b>     Description</b>
-4    The mbstowcs_s function converts a sequence of multibyte characters that begins in
-     the initial shift state from the array pointed to by src into a sequence of corresponding
-     wide characters. If dst is not a null pointer, the converted characters are stored into the
-     array pointed to by dst. Conversion continues up to and including a terminating null
-     character, which is also stored. Conversion stops earlier in two cases: when a sequence of
-
-[<a name="p607" href="#p607">page 607</a>] (<a href="#Contents">Contents</a>)
-
-    bytes is encountered that does not form a valid multibyte character, or (if dst is not a
-    null pointer) when len wide characters have been stored into the array pointed to by
-    dst.<sup><a href="#note400"><b>400)</b></a></sup> If dst is not a null pointer and no null wide character was stored into the array
-    pointed to by dst, then dst[len] is set to the null wide character. Each conversion
-    takes place as if by a call to the mbrtowc function.
-5   Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
-    sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
-    the mbstowcs_s function stores the value (size_t)(-1) into *retval.
-    Otherwise, the mbstowcs_s function stores into *retval the number of multibyte
-    characters successfully converted, not including the terminating null character (if any).
-6   All elements following the terminating null wide character (if any) written by
-    mbstowcs_s in the array of dstmax wide characters pointed to by dst take
-    unspecified values when mbstowcs_s returns.<sup><a href="#note401"><b>401)</b></a></sup>
-7   If copying takes place between objects that overlap, the objects take on unspecified
-    values.
-<b>    Returns</b>
-8   The mbstowcs_s function returns zero if no runtime-constraint violation and no
-    encoding error occurred. Otherwise, a nonzero value is returned.
-<a name="K.3.6.5.2" href="#K.3.6.5.2"><b>    K.3.6.5.2 The wcstombs_s function</b></a>
-<b>    Synopsis</b>
-1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
-             errno_t wcstombs_s(size_t * restrict retval,
-                  char * restrict dst, rsize_t dstmax,
-                  const wchar_t * restrict src, rsize_t len);
-    Runtime-constraints
-2   Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
-    neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
-    then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
-    zero. If dst is not a null pointer and len is not less than dstmax, then the conversion
-    shall have been stopped (see below) because a terminating null wide character was
-    reached or because an encoding error occurred.
-
-
-
-
-    <sup><a name="note400" href="#note400"><b>400)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
-    <sup><a name="note401" href="#note401"><b>401)</b></a></sup> This allows an implementation to attempt converting the multibyte string before discovering a
-         terminating null character did not occur where required.
-
-[<a name="p608" href="#p608">page 608</a>] (<a href="#Contents">Contents</a>)
-
-3   If there is a runtime-constraint violation, then wcstombs_s does the following. If
-    retval is not a null pointer, then wcstombs_s sets *retval to (size_t)(-1). If
-    dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
-    then wcstombs_s sets dst[0] to the null character.
-<b>    Description</b>
-4   The wcstombs_s function converts a sequence of wide characters from the array
-    pointed to by src into a sequence of corresponding multibyte characters that begins in
-    the initial shift state. If dst is not a null pointer, the converted characters are then stored
-    into the array pointed to by dst. Conversion continues up to and including a terminating
-    null wide character, which is also stored. Conversion stops earlier in two cases:
-    -- when a wide character is reached that does not correspond to a valid multibyte
-      character;
-    -- (if dst is not a null pointer) when the next multibyte character would exceed the
-        limit of n total bytes to be stored into the array pointed to by dst. If the wide
-        character being converted is the null wide character, then n is the lesser of len or
-        dstmax. Otherwise, n is the lesser of len or dstmax-1.
-    If the conversion stops without converting a null wide character and dst is not a null
-    pointer, then a null character is stored into the array pointed to by dst immediately
-    following any multibyte characters already stored. Each conversion takes place as if by a
-    call to the wcrtomb function.<sup><a href="#note402"><b>402)</b></a></sup>
-5   Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
-    wide character that does not correspond to a valid multibyte character, an encoding error
-    occurs: the wcstombs_s function stores the value (size_t)(-1) into *retval.
-    Otherwise, the wcstombs_s function stores into *retval the number of bytes in the
-    resulting multibyte character sequence, not including the terminating null character (if
-    any).
-6   All elements following the terminating null character (if any) written by wcstombs_s
-    in the array of dstmax elements pointed to by dst take unspecified values when
-    wcstombs_s returns.<sup><a href="#note403"><b>403)</b></a></sup>
-7   If copying takes place between objects that overlap, the objects take on unspecified
-    values.
-
-
-    <sup><a name="note402" href="#note402"><b>402)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
-         include those necessary to reach the initial shift state immediately before the null byte. However, if
-         the conversion stops before a terminating null wide character has been reached, the result will be null
-         terminated, but might not end in the initial shift state.
-    <sup><a name="note403" href="#note403"><b>403)</b></a></sup> When len is not less than dstmax, the implementation might fill the array before discovering a
-         runtime-constraint violation.
-
-[<a name="p609" href="#p609">page 609</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-8   The wcstombs_s function returns zero if no runtime-constraint violation and no
-    encoding error occurred. Otherwise, a nonzero value is returned.
-<a name="K.3.7" href="#K.3.7"><b>    K.3.7 String handling &lt;string.h&gt;</b></a>
-1   The header <a href="#7.23">&lt;string.h&gt;</a> defines two types.
-2   The types are
-           errno_t
-    which is type int; and
-           rsize_t
-    which is the type size_t.
-<a name="K.3.7.1" href="#K.3.7.1"><b>    K.3.7.1 Copying functions</b></a>
-<a name="K.3.7.1.1" href="#K.3.7.1.1"><b>    K.3.7.1.1 The memcpy_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.23">&lt;string.h&gt;</a>
-           errno_t memcpy_s(void * restrict s1, rsize_t s1max,
-                const void * restrict s2, rsize_t n);
-    Runtime-constraints
-2   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-    RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
-    objects that overlap.
-3   If there is a runtime-constraint violation, the memcpy_s function stores zeros in the first
-    s1max characters of the object pointed to by s1 if s1 is not a null pointer and s1max is
-    not greater than RSIZE_MAX.
-<b>    Description</b>
-4   The memcpy_s function copies n characters from the object pointed to by s2 into the
-    object pointed to by s1.
-<b>    Returns</b>
-5   The memcpy_s function returns zero if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-
-[<a name="p610" href="#p610">page 610</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.7.1.2" href="#K.3.7.1.2"><b>    K.3.7.1.2 The memmove_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            errno_t memmove_s(void *s1, rsize_t s1max,
-                 const void *s2, rsize_t n);
-    Runtime-constraints
-2   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-    RSIZE_MAX. n shall not be greater than s1max.
-3   If there is a runtime-constraint violation, the memmove_s function stores zeros in the
-    first s1max characters of the object pointed to by s1 if s1 is not a null pointer and
-    s1max is not greater than RSIZE_MAX.
-<b>    Description</b>
-4   The memmove_s function copies n characters from the object pointed to by s2 into the
-    object pointed to by s1. This copying takes place as if the n characters from the object
-    pointed to by s2 are first copied into a temporary array of n characters that does not
-    overlap the objects pointed to by s1 or s2, and then the n characters from the temporary
-    array are copied into the object pointed to by s1.
-<b>    Returns</b>
-5   The memmove_s function returns zero if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-<a name="K.3.7.1.3" href="#K.3.7.1.3"><b>    K.3.7.1.3 The strcpy_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            errno_t strcpy_s(char * restrict s1,
-                 rsize_t s1max,
-                 const char * restrict s2);
-    Runtime-constraints
-2   Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
-    s1max shall not equal zero. s1max shall be greater than strnlen_s(s2, s1max).
-    Copying shall not take place between objects that overlap.
-3   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-    greater than zero and not greater than RSIZE_MAX, then strcpy_s sets s1[0] to the
-    null character.
-
-[<a name="p611" href="#p611">page 611</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-4   The strcpy_s function copies the string pointed to by s2 (including the terminating
-    null character) into the array pointed to by s1.
-5   All elements following the terminating null character (if any) written by strcpy_s in
-    the array of s1max characters pointed to by s1 take unspecified values when
-    strcpy_s returns.<sup><a href="#note404"><b>404)</b></a></sup>
-<b>    Returns</b>
-6   The strcpy_s function returns zero<sup><a href="#note405"><b>405)</b></a></sup> if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-<a name="K.3.7.1.4" href="#K.3.7.1.4"><b>    K.3.7.1.4 The strncpy_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            errno_t strncpy_s(char * restrict s1,
-                 rsize_t s1max,
-                 const char * restrict s2,
-                 rsize_t n);
-    Runtime-constraints
-2   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-    RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
-    shall be greater than strnlen_s(s2, s1max). Copying shall not take place between
-    objects that overlap.
-3   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-    greater than zero and not greater than RSIZE_MAX, then strncpy_s sets s1[0] to the
-    null character.
-<b>    Description</b>
-4   The strncpy_s function copies not more than n successive characters (characters that
-    follow a null character are not copied) from the array pointed to by s2 to the array
-    pointed to by s1. If no null character was copied from s2, then s1[n] is set to a null
-    character.
-
-
-    <sup><a name="note404" href="#note404"><b>404)</b></a></sup> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
-         any of those characters are null. Such an approach might write a character to every element of s1
-         before discovering that the first element should be set to the null character.
-    <sup><a name="note405" href="#note405"><b>405)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
-         within the array pointed to by s1 and that the result in s1 is null terminated.
-
-[<a name="p612" href="#p612">page 612</a>] (<a href="#Contents">Contents</a>)
-
-5   All elements following the terminating null character (if any) written by strncpy_s in
-    the array of s1max characters pointed to by s1 take unspecified values when
-    strncpy_s returns.<sup><a href="#note406"><b>406)</b></a></sup>
-<b>    Returns</b>
-6   The strncpy_s function returns zero<sup><a href="#note407"><b>407)</b></a></sup> if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-7   EXAMPLE 1 The strncpy_s function can be used to copy a string without the danger that the result
-    will not be null terminated or that characters will be written past the end of the destination array.
-            #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            /* ... */
-            char src1[100] = "hello";
-            char src2[7] = {'g', 'o', 'o', 'd', 'b', 'y', 'e'};
-            char dst1[6], dst2[5], dst3[5];
-            int r1, r2, r3;
-            r1 = strncpy_s(dst1, 6, src1, 100);
-            r2 = strncpy_s(dst2, 5, src2, 7);
-            r3 = strncpy_s(dst3, 5, src2, 4);
-    The first call will assign to r1 the value zero and to dst1 the sequence hello\0.
-    The second call will assign to r2 a nonzero value and to dst2 the sequence \0.
-    The third call will assign to r3 the value zero and to dst3 the sequence good\0.
-
-<a name="K.3.7.2" href="#K.3.7.2"><b>    K.3.7.2 Concatenation functions</b></a>
-<a name="K.3.7.2.1" href="#K.3.7.2.1"><b>    K.3.7.2.1 The strcat_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            errno_t strcat_s(char * restrict s1,
-                 rsize_t s1max,
-                 const char * restrict s2);
-    Runtime-constraints
-2   Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
-    strcat_s.
-
-
-
-
-    <sup><a name="note406" href="#note406"><b>406)</b></a></sup> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
-         any of those characters are null. Such an approach might write a character to every element of s1
-         before discovering that the first element should be set to the null character.
-    <sup><a name="note407" href="#note407"><b>407)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
-         within the array pointed to by s1 and that the result in s1 is null terminated.
-
-[<a name="p613" href="#p613">page 613</a>] (<a href="#Contents">Contents</a>)
-
-3   Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
-    s1max shall not equal zero. m shall not equal zero.<sup><a href="#note408"><b>408)</b></a></sup> m shall be greater than
-    strnlen_s(s2, m). Copying shall not take place between objects that overlap.
-4   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-    greater than zero and not greater than RSIZE_MAX, then strcat_s sets s1[0] to the
-    null character.
-<b>    Description</b>
-5   The strcat_s function appends a copy of the string pointed to by s2 (including the
-    terminating null character) to the end of the string pointed to by s1. The initial character
-    from s2 overwrites the null character at the end of s1.
-6   All elements following the terminating null character (if any) written by strcat_s in
-    the array of s1max characters pointed to by s1 take unspecified values when
-    strcat_s returns.<sup><a href="#note409"><b>409)</b></a></sup>
-<b>    Returns</b>
-7   The strcat_s function returns zero<sup><a href="#note410"><b>410)</b></a></sup> if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-<a name="K.3.7.2.2" href="#K.3.7.2.2"><b>    K.3.7.2.2 The strncat_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            errno_t strncat_s(char * restrict s1,
-                 rsize_t s1max,
-                 const char * restrict s2,
-                 rsize_t n);
-    Runtime-constraints
-2   Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
-    strncat_s.
-3   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-    RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note411"><b>411)</b></a></sup> If n is not less
-
-
-    <sup><a name="note408" href="#note408"><b>408)</b></a></sup> Zero means that s1 was not null terminated upon entry to strcat_s.
-    <sup><a name="note409" href="#note409"><b>409)</b></a></sup> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
-         any of those characters are null. Such an approach might write a character to every element of s1
-         before discovering that the first element should be set to the null character.
-    <sup><a name="note410" href="#note410"><b>410)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 were
-         appended to the string pointed to by s1 and that the result in s1 is null terminated.
-
-[<a name="p614" href="#p614">page 614</a>] (<a href="#Contents">Contents</a>)
-
-    than m, then m shall be greater than strnlen_s(s2, m). Copying shall not take
-    place between objects that overlap.
-4   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-    greater than zero and not greater than RSIZE_MAX, then strncat_s sets s1[0] to the
-    null character.
-<b>    Description</b>
-5   The strncat_s function appends not more than n successive characters (characters
-    that follow a null character are not copied) from the array pointed to by s2 to the end of
-    the string pointed to by s1. The initial character from s2 overwrites the null character at
-    the end of s1. If no null character was copied from s2, then s1[s1max-m+n] is set to
-    a null character.
-6   All elements following the terminating null character (if any) written by strncat_s in
-    the array of s1max characters pointed to by s1 take unspecified values when
-    strncat_s returns.<sup><a href="#note412"><b>412)</b></a></sup>
-<b>    Returns</b>
-7   The strncat_s function returns zero<sup><a href="#note413"><b>413)</b></a></sup> if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-8   EXAMPLE 1 The strncat_s function can be used to copy a string without the danger that the result
-    will not be null terminated or that characters will be written past the end of the destination array.
-            #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            /* ... */
-            char s1[100] = "good";
-            char s2[6] = "hello";
-            char s3[6] = "hello";
-            char s4[7] = "abc";
-            char s5[1000] = "bye";
-            int r1, r2, r3, r4;
-            r1 = strncat_s(s1, 100, s5, 1000);
-            r2 = strncat_s(s2, 6, "", 1);
-            r3 = strncat_s(s3, 6, "X", 2);
-            r4 = strncat_s(s4, 7, "defghijklmn", 3);
-    After the first call r1 will have the value zero and s1 will contain the sequence goodbye\0.
-
-
-
-    <sup><a name="note411" href="#note411"><b>411)</b></a></sup> Zero means that s1 was not null terminated upon entry to strncat_s.
-    <sup><a name="note412" href="#note412"><b>412)</b></a></sup> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
-         any of those characters are null. Such an approach might write a character to every element of s1
-         before discovering that the first element should be set to the null character.
-    <sup><a name="note413" href="#note413"><b>413)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 were
-         appended to the string pointed to by s1 and that the result in s1 is null terminated.
-
-[<a name="p615" href="#p615">page 615</a>] (<a href="#Contents">Contents</a>)
-
-    After the second call r2 will have the value zero and s2 will contain the sequence hello\0.
-    After the third call r3 will have a nonzero value and s3 will contain the sequence \0.
-    After the fourth call r4 will have the value zero and s4 will contain the sequence abcdef\0.
-
-<a name="K.3.7.3" href="#K.3.7.3"><b>    K.3.7.3 Search functions</b></a>
-<a name="K.3.7.3.1" href="#K.3.7.3.1"><b>    K.3.7.3.1 The strtok_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            char *strtok_s(char * restrict s1,
-                 rsize_t * restrict s1max,
-                 const char * restrict s2,
-                 char ** restrict ptr);
-    Runtime-constraints
-2   None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
-    shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
-    The end of the token found shall occur within the first *s1max characters of s1 for the
-    first call, and shall occur within the first *s1max characters of where searching resumes
-    on subsequent calls.
-3   If there is a runtime-constraint violation, the strtok_s function does not indirect
-    through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
-<b>    Description</b>
-4   A sequence of calls to the strtok_s function breaks the string pointed to by s1 into a
-    sequence of tokens, each of which is delimited by a character from the string pointed to
-    by s2. The fourth argument points to a caller-provided char pointer into which the
-    strtok_s function stores information necessary for it to continue scanning the same
-    string.
-5   The first call in a sequence has a non-null first argument and s1max points to an object
-    whose value is the number of elements in the character array pointed to by the first
-    argument. The first call stores an initial value in the object pointed to by ptr and
-    updates the value pointed to by s1max to reflect the number of elements that remain in
-    relation to ptr. Subsequent calls in the sequence have a null first argument and the
-    objects pointed to by s1max and ptr are required to have the values stored by the
-    previous call in the sequence, which are then updated. The separator string pointed to by
-    s2 may be different from call to call.
-6   The first call in the sequence searches the string pointed to by s1 for the first character
-    that is not contained in the current separator string pointed to by s2. If no such character
-    is found, then there are no tokens in the string pointed to by s1 and the strtok_s
-    function returns a null pointer. If such a character is found, it is the start of the first token.
-
-[<a name="p616" href="#p616">page 616</a>] (<a href="#Contents">Contents</a>)
-
-7    The strtok_s function then searches from there for the first character in s1 that is
-     contained in the current separator string. If no such character is found, the current token
-     extends to the end of the string pointed to by s1, and subsequent searches in the same
-     string for a token return a null pointer. If such a character is found, it is overwritten by a
-     null character, which terminates the current token.
-8    In all cases, the strtok_s function stores sufficient information in the pointer pointed
-     to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
-     value for ptr, shall start searching just past the element overwritten by a null character
-     (if any).
-<b>     Returns</b>
-9    The strtok_s function returns a pointer to the first character of a token, or a null
-     pointer if there is no token or there is a runtime-constraint violation.
-10   EXAMPLE
-             #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.23">&lt;string.h&gt;</a>
-             static char str1[] = "?a???b,,,#c";
-             static char str2[] = "\t \t";
-             char *t, *ptr1, *ptr2;
-             rsize_t max1 = sizeof(str1);
-             rsize_t max2 = sizeof(str2);
-             t   =   strtok_s(str1,   &amp;max1,   "?", &amp;ptr1);        //   t   points to the token "a"
-             t   =   strtok_s(NULL,   &amp;max1,   ",", &amp;ptr1);        //   t   points to the token "??b"
-             t   =   strtok_s(str2,   &amp;max2,   " \t", &amp;ptr2);      //   t   is a null pointer
-             t   =   strtok_s(NULL,   &amp;max1,   "#,", &amp;ptr1);       //   t   points to the token "c"
-             t   =   strtok_s(NULL,   &amp;max1,   "?", &amp;ptr1);        //   t   is a null pointer
-
-<a name="K.3.7.4" href="#K.3.7.4"><b>     K.3.7.4 Miscellaneous functions</b></a>
-<a name="K.3.7.4.1" href="#K.3.7.4.1"><b>     K.3.7.4.1 The memset_s function</b></a>
-<b>     Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.23">&lt;string.h&gt;</a>
-             errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)
-     Runtime-constraints
-2    s shall not be a null pointer. Neither smax nor n shall be greater than RSIZE_MAX. n
-     shall not be greater than smax.
-3    If there is a runtime-constraint violation, then if s is not a null pointer and smax is not
-     greater than RSIZE_MAX, the memset_s function stores the value of c (converted to an
-     unsigned char) into each of the first smax characters of the object pointed to by s.
-
-[<a name="p617" href="#p617">page 617</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-4   The memset_s function copies the value of c (converted to an unsigned char) into
-    each of the first n characters of the object pointed to by s. Unlike memset, any call to
-    the memset_s function shall be evaluated strictly according to the rules of the abstract
-    machine as described in (<a href="#5.1.2.3">5.1.2.3</a>). That is, any call to the memset_s function shall
-    assume that the memory indicated by s and n may be accessible in the future and thus
-    must contain the values indicated by c.
-<b>    Returns</b>
-5   The memset_s function returns zero if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-<a name="K.3.7.4.2" href="#K.3.7.4.2"><b>    K.3.7.4.2 The strerror_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.23">&lt;string.h&gt;</a>
-           errno_t strerror_s(char *s, rsize_t maxsize,
-                errno_t errnum);
-    Runtime-constraints
-2   s shall not be a null pointer. maxsize shall not be greater than RSIZE_MAX.
-    maxsize shall not equal zero.
-3   If there is a runtime-constraint violation, then the array (if any) pointed to by s is not
-    modified.
-<b>    Description</b>
-4   The strerror_s function maps the number in errnum to a locale-specific message
-    string. Typically, the values for errnum come from errno, but strerror_s shall
-    map any value of type int to a message.
-5   If the length of the desired string is less than maxsize, then the string is copied to the
-    array pointed to by s.
-6   Otherwise, if maxsize is greater than zero, then maxsize-1 characters are copied
-    from the string to the array pointed to by s and then s[maxsize-1] is set to the null
-    character. Then, if maxsize is greater than 3, then s[maxsize-2],
-    s[maxsize-3], and s[maxsize-4] are set to the character period (.).
-<b>    Returns</b>
-7   The strerror_s function returns zero if the length of the desired string was less than
-    maxsize and there was no runtime-constraint violation. Otherwise, the strerror_s
-    function returns a nonzero value.
-
-[<a name="p618" href="#p618">page 618</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.7.4.3" href="#K.3.7.4.3"><b>    K.3.7.4.3 The strerrorlen_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            size_t strerrorlen_s(errno_t errnum);
-<b>    Description</b>
-2   The strerrorlen_s function calculates the length of the (untruncated) locale-specific
-    message string that the strerror_s function maps to errnum.
-<b>    Returns</b>
-3   The strerrorlen_s function returns the number of characters (not including the null
-    character) in the full message string.
-<a name="K.3.7.4.4" href="#K.3.7.4.4"><b>    K.3.7.4.4 The strnlen_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.23">&lt;string.h&gt;</a>
-            size_t strnlen_s(const char *s, size_t maxsize);
-<b>    Description</b>
-2   The strnlen_s function computes the length of the string pointed to by s.
-<b>    Returns</b>
-3   If s is a null pointer,<sup><a href="#note414"><b>414)</b></a></sup> then the strnlen_s function returns zero.
-4   Otherwise, the strnlen_s function returns the number of characters that precede the
-    terminating null character. If there is no null character in the first maxsize characters of
-    s then strnlen_s returns maxsize. At most the first maxsize characters of s shall
-    be accessed by strnlen_s.
-
-
-
-
-    <sup><a name="note414" href="#note414"><b>414)</b></a></sup> Note that the strnlen_s function has no runtime-constraints. This lack of runtime-constraints
-         along with the values returned for a null pointer or an unterminated string argument make
-         strnlen_s useful in algorithms that gracefully handle such exceptional data.
-
-[<a name="p619" href="#p619">page 619</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.8" href="#K.3.8"><b>    K.3.8 Date and time &lt;time.h&gt;</b></a>
-1   The header <a href="#7.26">&lt;time.h&gt;</a> defines two types.
-2   The types are
-            errno_t
-    which is type int; and
-            rsize_t
-    which is the type size_t.
-<a name="K.3.8.1" href="#K.3.8.1"><b>    K.3.8.1 Components of time</b></a>
-1   A broken-down time is normalized if the values of the members of the tm structure are in
-    their normal rages.<sup><a href="#note415"><b>415)</b></a></sup>
-<a name="K.3.8.2" href="#K.3.8.2"><b>    K.3.8.2 Time conversion functions</b></a>
-1   Like the strftime function, the asctime_s and ctime_s functions do not return a
-    pointer to a static object, and other library functions are permitted to call them.
-<a name="K.3.8.2.1" href="#K.3.8.2.1"><b>    K.3.8.2.1 The asctime_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.26">&lt;time.h&gt;</a>
-            errno_t asctime_s(char *s, rsize_t maxsize,
-                 const struct tm *timeptr);
-    Runtime-constraints
-2   Neither s nor timeptr shall be a null pointer. maxsize shall not be less than 26 and
-    shall not be greater than RSIZE_MAX. The broken-down time pointed to by timeptr
-    shall be normalized. The calendar year represented by the broken-down time pointed to
-    by timeptr shall not be less than calendar year 0 and shall not be greater than calendar
-    year 9999.
-3   If there is a runtime-constraint violation, there is no attempt to convert the time, and
-    s[0] is set to a null character if s is not a null pointer and maxsize is not zero and is
-    not greater than RSIZE_MAX.
-<b>    Description</b>
-4   The asctime_s function converts the normalized broken-down time in the structure
-    pointed to by timeptr into a 26 character (including the null character) string in the
-
-
-    <sup><a name="note415" href="#note415"><b>415)</b></a></sup> The normal ranges are defined in <a href="#7.26.1">7.26.1</a>.
-
-[<a name="p620" href="#p620">page 620</a>] (<a href="#Contents">Contents</a>)
-
-    form
-            Sun Sep 16 01:03:52 1973\n\0
-    The fields making up this string are (in order):
-       1.   The name of the day of the week represented by timeptr-&gt;tm_wday using the
-            following three character weekday names: Sun, Mon, Tue, Wed, Thu, Fri, and Sat.
-       2.   The character space.
-       3. The name of the month represented by timeptr-&gt;tm_mon using the following
-          three character month names: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct,
-          Nov, and Dec.
-       4.   The character space.
-       5.   The value of timeptr-&gt;tm_mday as if printed using the fprintf format
-            "%2d".
-       6.   The character space.
-       7.   The value of timeptr-&gt;tm_hour as if printed using the fprintf format
-            "%.2d".
-       8.   The character colon.
-       9.   The value of timeptr-&gt;tm_min as if printed using the fprintf format
-            "%.2d".
-     10.    The character colon.
-     11.    The value of timeptr-&gt;tm_sec as if printed using the fprintf format
-            "%.2d".
-     12.    The character space.
-     13.    The value of timeptr-&gt;tm_year + 1900 as if printed using the fprintf
-            format "%4d".
-     14.    The character new line.
-     15.    The null character.
-    Recommended practice
-    The strftime function allows more flexible formatting and supports locale-specific
-    behavior. If you do not require the exact form of the result string produced by the
-    asctime_s function, consider using the strftime function instead.
-<b>    Returns</b>
-5   The asctime_s function returns zero if the time was successfully converted and stored
-    into the array pointed to by s. Otherwise, it returns a nonzero value.
-
-[<a name="p621" href="#p621">page 621</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.8.2.2" href="#K.3.8.2.2"><b>    K.3.8.2.2 The ctime_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.26">&lt;time.h&gt;</a>
-           errno_t ctime_s(char *s, rsize_t maxsize,
-                const time_t *timer);
-    Runtime-constraints
-2   Neither s nor timer shall be a null pointer. maxsize shall not be less than 26 and
-    shall not be greater than RSIZE_MAX.
-3   If there is a runtime-constraint violation, s[0] is set to a null character if s is not a null
-    pointer and maxsize is not equal zero and is not greater than RSIZE_MAX.
-<b>    Description</b>
-4   The ctime_s function converts the calendar time pointed to by timer to local time in
-    the form of a string. It is equivalent to
-           asctime_s(s, maxsize, localtime_s(timer))
-    Recommended practice
-    The strftime function allows more flexible formatting and supports locale-specific
-    behavior. If you do not require the exact form of the result string produced by the
-    ctime_s function, consider using the strftime function instead.
-<b>    Returns</b>
-5   The ctime_s function returns zero if the time was successfully converted and stored
-    into the array pointed to by s. Otherwise, it returns a nonzero value.
-<a name="K.3.8.2.3" href="#K.3.8.2.3"><b>    K.3.8.2.3 The gmtime_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.26">&lt;time.h&gt;</a>
-           struct tm *gmtime_s(const time_t * restrict timer,
-                struct tm * restrict result);
-    Runtime-constraints
-2   Neither timer nor result shall be a null pointer.
-3   If there is a runtime-constraint violation, there is no attempt to convert the time.
-<b>    Description</b>
-4   The gmtime_s function converts the calendar time pointed to by timer into a broken-
-    down time, expressed as UTC. The broken-down time is stored in the structure pointed
-
-[<a name="p622" href="#p622">page 622</a>] (<a href="#Contents">Contents</a>)
-
-    to by result.
-<b>    Returns</b>
-5   The gmtime_s function returns result, or a null pointer if the specified time cannot
-    be converted to UTC or there is a runtime-constraint violation.
-<a name="K.3.8.2.4" href="#K.3.8.2.4"><b>    K.3.8.2.4 The localtime_s function</b></a>
-<b>    Synopsis</b>
-1            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.26">&lt;time.h&gt;</a>
-             struct tm *localtime_s(const time_t * restrict timer,
-                  struct tm * restrict result);
-    Runtime-constraints
-2   Neither timer nor result shall be a null pointer.
-3   If there is a runtime-constraint violation, there is no attempt to convert the time.
-<b>    Description</b>
-4   The localtime_s function converts the calendar time pointed to by timer into a
-    broken-down time, expressed as local time. The broken-down time is stored in the
-    structure pointed to by result.
-<b>    Returns</b>
-5   The localtime_s function returns result, or a null pointer if the specified time
-    cannot be converted to local time or there is a runtime-constraint violation.
-<a name="K.3.9" href="#K.3.9"><b>    K.3.9 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
-1   The header <a href="#7.28">&lt;wchar.h&gt;</a> defines two types.
-2   The types are
-             errno_t
-    which is type int; and
-             rsize_t
-    which is the type size_t.
-3   Unless explicitly stated otherwise, if the execution of a function described in this
-    subclause causes copying to take place between objects that overlap, the objects take on
-    unspecified values.
-
-[<a name="p623" href="#p623">page 623</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.9.1" href="#K.3.9.1"><b>    K.3.9.1 Formatted wide character input/output functions</b></a>
-<a name="K.3.9.1.1" href="#K.3.9.1.1"><b>    K.3.9.1.1 The fwprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int fwprintf_s(FILE * restrict stream,
-                 const wchar_t * restrict format, ...);
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note416"><b>416)</b></a></sup> (modified or
-    not by flags, field width, or precision) shall not appear in the wide string pointed to by
-    format. Any argument to fwprintf_s corresponding to a %s specifier shall not be a
-    null pointer.
-3   If there is a runtime-constraint violation, the fwprintf_s function does not attempt to
-    produce further output, and it is unspecified to what extent fwprintf_s produced
-    output before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The fwprintf_s function is equivalent to the fwprintf function except for the
-    explicit runtime-constraints listed above.
-<b>    Returns</b>
-5   The fwprintf_s function returns the number of wide characters transmitted, or a
-    negative value if an output error, encoding error, or runtime-constraint violation occurred.
-<a name="K.3.9.1.2" href="#K.3.9.1.2"><b>    K.3.9.1.2 The fwscanf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int fwscanf_s(FILE * restrict stream,
-                 const wchar_t * restrict format, ...);
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. Any argument indirected though in
-    order to store converted input shall not be a null pointer.
-
-
-    <sup><a name="note416" href="#note416"><b>416)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-
-[<a name="p624" href="#p624">page 624</a>] (<a href="#Contents">Contents</a>)
-
-3   If there is a runtime-constraint violation, the fwscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent fwscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The fwscanf_s function is equivalent to fwscanf except that the c, s, and [
-    conversion specifiers apply to a pair of arguments (unless assignment suppression is
-    indicated by a *). The first of these arguments is the same as for fwscanf. That
-    argument is immediately followed in the argument list by the second argument, which has
-    type size_t and gives the number of elements in the array pointed to by the first
-    argument of the pair. If the first argument points to a scalar object, it is considered to be
-    an array of one element.<sup><a href="#note417"><b>417)</b></a></sup>
-5   A matching failure occurs if the number of elements in a receiving object is insufficient to
-    hold the converted input (including any trailing null character).
-<b>    Returns</b>
-6   The fwscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    fwscanf_s function returns the number of input items assigned, which can be fewer
-    than provided for, or even zero, in the event of an early matching failure.
-<a name="K.3.9.1.3" href="#K.3.9.1.3"><b>    K.3.9.1.3 The snwprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int snwprintf_s(wchar_t * restrict s,
-                 rsize_t n,
-                 const wchar_t * restrict format, ...);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The %n specifier<sup><a href="#note418"><b>418)</b></a></sup> (modified or not by flags, field width, or
-
-    <sup><a name="note417" href="#note417"><b>417)</b></a></sup> If the format is known at translation time, an implementation may issue a diagnostic for any argument
-         used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
-         argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
-         the format is not known at translation time. For example, an implementation may issue a diagnostic
-         for each argument after format that has of type pointer to one of char, signed char,
-         unsigned char, or void that is not followed by an argument of a type compatible with
-         rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
-         using the hh length modifier, a length argument must follow the pointer argument. Another useful
-         diagnostic could flag any non-pointer argument following format that did not have a type
-         compatible with rsize_t.
-
-[<a name="p625" href="#p625">page 625</a>] (<a href="#Contents">Contents</a>)
-
-    precision) shall not appear in the wide string pointed to by format. Any argument to
-    snwprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
-    error shall occur.
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the snwprintf_s function sets s[0] to the
-    null wide character.
-<b>    Description</b>
-4   The snwprintf_s function is equivalent to the swprintf function except for the
-    explicit runtime-constraints listed above.
-5   The snwprintf_s function, unlike swprintf_s, will truncate the result to fit within
-    the array pointed to by s.
-<b>    Returns</b>
-6   The snwprintf_s function returns the number of wide characters that would have
-    been written had n been sufficiently large, not counting the terminating wide null
-    character, or a negative value if a runtime-constraint violation occurred. Thus, the null-
-    terminated output has been completely written if and only if the returned value is
-    nonnegative and less than n.
-<a name="K.3.9.1.4" href="#K.3.9.1.4"><b>    K.3.9.1.4 The swprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int swprintf_s(wchar_t * restrict s, rsize_t n,
-                 const wchar_t * restrict format, ...);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The number of wide characters (including the trailing null) required
-    for the result to be written to the array pointed to by s shall not be greater than n. The %n
-    specifier<sup><a href="#note419"><b>419)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
-    wide string pointed to by format. Any argument to swprintf_s corresponding to a
-    %s specifier shall not be a null pointer. No encoding error shall occur.
-
-
-    <sup><a name="note418" href="#note418"><b>418)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-    <sup><a name="note419" href="#note419"><b>419)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-
-[<a name="p626" href="#p626">page 626</a>] (<a href="#Contents">Contents</a>)
-
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the swprintf_s function sets s[0] to the
-    null wide character.
-<b>    Description</b>
-4   The swprintf_s function is equivalent to the swprintf function except for the
-    explicit runtime-constraints listed above.
-5   The swprintf_s function, unlike snwprintf_s, treats a result too big for the array
-    pointed to by s as a runtime-constraint violation.
-<b>    Returns</b>
-6   If no runtime-constraint violation occurred, the swprintf_s function returns the
-    number of wide characters written in the array, not counting the terminating null wide
-    character. If an encoding error occurred or if n or more wide characters are requested to
-    be written, swprintf_s returns a negative value. If any other runtime-constraint
-    violation occurred, swprintf_s returns zero.
-<a name="K.3.9.1.5" href="#K.3.9.1.5"><b>    K.3.9.1.5 The swscanf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int swscanf_s(const wchar_t * restrict s,
-                 const wchar_t * restrict format, ...);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. Any argument indirected though in order
-    to store converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the swscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent swscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The swscanf_s function is equivalent to fwscanf_s, except that the argument s
-    specifies a wide string from which the input is to be obtained, rather than from a stream.
-    Reaching the end of the wide string is equivalent to encountering end-of-file for the
-    fwscanf_s function.
-<b>    Returns</b>
-5   The swscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    swscanf_s function returns the number of input items assigned, which can be fewer
-    than provided for, or even zero, in the event of an early matching failure.
-
-[<a name="p627" href="#p627">page 627</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.9.1.6" href="#K.3.9.1.6"><b>    K.3.9.1.6 The vfwprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vfwprintf_s(FILE * restrict stream,
-                 const wchar_t * restrict format,
-                 va_list arg);
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note420"><b>420)</b></a></sup> (modified or
-    not by flags, field width, or precision) shall not appear in the wide string pointed to by
-    format. Any argument to vfwprintf_s corresponding to a %s specifier shall not be
-    a null pointer.
-3   If there is a runtime-constraint violation, the vfwprintf_s function does not attempt
-    to produce further output, and it is unspecified to what extent vfwprintf_s produced
-    output before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vfwprintf_s function is equivalent to the vfwprintf function except for the
-    explicit runtime-constraints listed above.
-<b>    Returns</b>
-5   The vfwprintf_s function returns the number of wide characters transmitted, or a
-    negative value if an output error, encoding error, or runtime-constraint violation occurred.
-<a name="K.3.9.1.7" href="#K.3.9.1.7"><b>    K.3.9.1.7 The vfwscanf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.21">&lt;stdio.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vfwscanf_s(FILE * restrict stream,
-                 const wchar_t * restrict format, va_list arg);
-
-
-
-    <sup><a name="note420" href="#note420"><b>420)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-
-[<a name="p628" href="#p628">page 628</a>] (<a href="#Contents">Contents</a>)
-
-    Runtime-constraints
-2   Neither stream nor format shall be a null pointer. Any argument indirected though in
-    order to store converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vfwscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent vfwscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vfwscanf_s function is equivalent to fwscanf_s, with the variable argument
-    list replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vfwscanf_s function does not invoke the
-    va_end macro.<sup><a href="#note421"><b>421)</b></a></sup>
-<b>    Returns</b>
-5   The vfwscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    vfwscanf_s function returns the number of input items assigned, which can be fewer
-    than provided for, or even zero, in the event of an early matching failure.
-<a name="K.3.9.1.8" href="#K.3.9.1.8"><b>    K.3.9.1.8 The vsnwprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vsnwprintf_s(wchar_t * restrict s,
-                 rsize_t n,
-                 const wchar_t * restrict format,
-                 va_list arg);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The %n specifier<sup><a href="#note422"><b>422)</b></a></sup> (modified or not by flags, field width, or
-    precision) shall not appear in the wide string pointed to by format. Any argument to
-    vsnwprintf_s corresponding to a %s specifier shall not be a null pointer. No
-    encoding error shall occur.
-
-    <sup><a name="note421" href="#note421"><b>421)</b></a></sup> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
-         value of arg after the return is indeterminate.
-    <sup><a name="note422" href="#note422"><b>422)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-
-[<a name="p629" href="#p629">page 629</a>] (<a href="#Contents">Contents</a>)
-
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the vsnwprintf_s function sets s[0] to
-    the null wide character.
-<b>    Description</b>
-4   The vsnwprintf_s function is equivalent to the vswprintf function except for the
-    explicit runtime-constraints listed above.
-5   The vsnwprintf_s function, unlike vswprintf_s, will truncate the result to fit
-    within the array pointed to by s.
-<b>    Returns</b>
-6   The vsnwprintf_s function returns the number of wide characters that would have
-    been written had n been sufficiently large, not counting the terminating null character, or
-    a negative value if a runtime-constraint violation occurred. Thus, the null-terminated
-    output has been completely written if and only if the returned value is nonnegative and
-    less than n.
-<a name="K.3.9.1.9" href="#K.3.9.1.9"><b>    K.3.9.1.9 The vswprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vswprintf_s(wchar_t * restrict s,
-                 rsize_t n,
-                 const wchar_t * restrict format,
-                 va_list arg);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
-    than RSIZE_MAX. The number of wide characters (including the trailing null) required
-    for the result to be written to the array pointed to by s shall not be greater than n. The %n
-    specifier<sup><a href="#note423"><b>423)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
-    wide string pointed to by format. Any argument to vswprintf_s corresponding to a
-    %s specifier shall not be a null pointer. No encoding error shall occur.
-3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
-    than zero and less than RSIZE_MAX, then the vswprintf_s function sets s[0] to the
-    null wide character.
-
-    <sup><a name="note423" href="#note423"><b>423)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-
-[<a name="p630" href="#p630">page 630</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Description</b>
-4   The vswprintf_s function is equivalent to the vswprintf function except for the
-    explicit runtime-constraints listed above.
-5   The vswprintf_s function, unlike vsnwprintf_s, treats a result too big for the
-    array pointed to by s as a runtime-constraint violation.
-<b>    Returns</b>
-6   If no runtime-constraint violation occurred, the vswprintf_s function returns the
-    number of wide characters written in the array, not counting the terminating null wide
-    character. If an encoding error occurred or if n or more wide characters are requested to
-    be written, vswprintf_s returns a negative value. If any other runtime-constraint
-    violation occurred, vswprintf_s returns zero.
-<a name="K.3.9.1.10" href="#K.3.9.1.10"><b>    K.3.9.1.10 The vswscanf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vswscanf_s(const wchar_t * restrict s,
-                 const wchar_t * restrict format,
-                 va_list arg);
-    Runtime-constraints
-2   Neither s nor format shall be a null pointer. Any argument indirected though in order
-    to store converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vswscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent vswscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vswscanf_s function is equivalent to swscanf_s, with the variable argument
-    list replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vswscanf_s function does not invoke the
-    va_end macro.<sup><a href="#note424"><b>424)</b></a></sup>
-
-
-
-
-    <sup><a name="note424" href="#note424"><b>424)</b></a></sup> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
-         value of arg after the return is indeterminate.
-
-[<a name="p631" href="#p631">page 631</a>] (<a href="#Contents">Contents</a>)
-
-<b>    Returns</b>
-5   The vswscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    vswscanf_s function returns the number of input items assigned, which can be fewer
-    than provided for, or even zero, in the event of an early matching failure.
-<a name="K.3.9.1.11" href="#K.3.9.1.11"><b>    K.3.9.1.11 The vwprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vwprintf_s(const wchar_t * restrict format,
-                 va_list arg);
-    Runtime-constraints
-2   format shall not be a null pointer. The %n specifier<sup><a href="#note425"><b>425)</b></a></sup> (modified or not by flags, field
-    width, or precision) shall not appear in the wide string pointed to by format. Any
-    argument to vwprintf_s corresponding to a %s specifier shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vwprintf_s function does not attempt to
-    produce further output, and it is unspecified to what extent vwprintf_s produced
-    output before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vwprintf_s function is equivalent to the vwprintf function except for the
-    explicit runtime-constraints listed above.
-<b>    Returns</b>
-5   The vwprintf_s function returns the number of wide characters transmitted, or a
-    negative value if an output error, encoding error, or runtime-constraint violation occurred.
-
-
-
-
-    <sup><a name="note425" href="#note425"><b>425)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-
-[<a name="p632" href="#p632">page 632</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.9.1.12" href="#K.3.9.1.12"><b>    K.3.9.1.12 The vwscanf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int vwscanf_s(const wchar_t * restrict format,
-                 va_list arg);
-    Runtime-constraints
-2   format shall not be a null pointer. Any argument indirected though in order to store
-    converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the vwscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent vwscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The vwscanf_s function is equivalent to wscanf_s, with the variable argument list
-    replaced by arg, which shall have been initialized by the va_start macro (and
-    possibly subsequent va_arg calls). The vwscanf_s function does not invoke the
-    va_end macro.<sup><a href="#note426"><b>426)</b></a></sup>
-<b>    Returns</b>
-5   The vwscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    vwscanf_s function returns the number of input items assigned, which can be fewer
-    than provided for, or even zero, in the event of an early matching failure.
-<a name="K.3.9.1.13" href="#K.3.9.1.13"><b>    K.3.9.1.13 The wprintf_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            int wprintf_s(const wchar_t * restrict format, ...);
-    Runtime-constraints
-2   format shall not be a null pointer. The %n specifier<sup><a href="#note427"><b>427)</b></a></sup> (modified or not by flags, field
-
-    <sup><a name="note426" href="#note426"><b>426)</b></a></sup> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
-         value of arg after the return is indeterminate.
-    <sup><a name="note427" href="#note427"><b>427)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
-         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
-         example, if the entire format string was L"%%n".
-
-[<a name="p633" href="#p633">page 633</a>] (<a href="#Contents">Contents</a>)
-
-    width, or precision) shall not appear in the wide string pointed to by format. Any
-    argument to wprintf_s corresponding to a %s specifier shall not be a null pointer.
-3   If there is a runtime-constraint violation, the wprintf_s function does not attempt to
-    produce further output, and it is unspecified to what extent wprintf_s produced output
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The wprintf_s function is equivalent to the wprintf function except for the explicit
-    runtime-constraints listed above.
-<b>    Returns</b>
-5   The wprintf_s function returns the number of wide characters transmitted, or a
-    negative value if an output error, encoding error, or runtime-constraint violation occurred.
-<a name="K.3.9.1.14" href="#K.3.9.1.14"><b>    K.3.9.1.14 The wscanf_s function</b></a>
-<b>    Synopsis</b>
-1          #define __STDC_WANT_LIB_EXT1__ 1
-           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           int wscanf_s(const wchar_t * restrict format, ...);
-    Runtime-constraints
-2   format shall not be a null pointer. Any argument indirected though in order to store
-    converted input shall not be a null pointer.
-3   If there is a runtime-constraint violation, the wscanf_s function does not attempt to
-    perform further input, and it is unspecified to what extent wscanf_s performed input
-    before discovering the runtime-constraint violation.
-<b>    Description</b>
-4   The wscanf_s function is equivalent to fwscanf_s with the argument stdin
-    interposed before the arguments to wscanf_s.
-<b>    Returns</b>
-5   The wscanf_s function returns the value of the macro EOF if an input failure occurs
-    before any conversion or if there is a runtime-constraint violation. Otherwise, the
-    wscanf_s function returns the number of input items assigned, which can be fewer than
-    provided for, or even zero, in the event of an early matching failure.
-
-[<a name="p634" href="#p634">page 634</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.9.2" href="#K.3.9.2"><b>    K.3.9.2 General wide string utilities</b></a>
-<a name="K.3.9.2.1" href="#K.3.9.2.1"><b>    K.3.9.2.1 Wide string copying functions</b></a>
-<a name="K.3.9.2.1.1" href="#K.3.9.2.1.1"><b>    K.3.9.2.1.1 The wcscpy_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            errno_t wcscpy_s(wchar_t * restrict s1,
-                 rsize_t s1max,
-                 const wchar_t * restrict s2);
-    Runtime-constraints
-2   Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
-    s1max shall not equal zero. s1max shall be greater than wcsnlen_s(s2, s1max).
-    Copying shall not take place between objects that overlap.
-3   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-    greater than zero and not greater than RSIZE_MAX, then wcscpy_s sets s1[0] to the
-    null wide character.
-<b>    Description</b>
-4   The wcscpy_s function copies the wide string pointed to by s2 (including the
-    terminating null wide character) into the array pointed to by s1.
-5   All elements following the terminating null wide character (if any) written by
-    wcscpy_s in the array of s1max wide characters pointed to by s1 take unspecified
-    values when wcscpy_s returns.<sup><a href="#note428"><b>428)</b></a></sup>
-<b>    Returns</b>
-6   The wcscpy_s function returns zero<sup><a href="#note429"><b>429)</b></a></sup> if there was no runtime-constraint violation.
-    Otherwise, a nonzero value is returned.
-
-
-
-
-    <sup><a name="note428" href="#note428"><b>428)</b></a></sup> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
-         if any of those wide characters are null. Such an approach might write a wide character to every
-         element of s1 before discovering that the first element should be set to the null wide character.
-    <sup><a name="note429" href="#note429"><b>429)</b></a></sup> A zero return value implies that all of the requested wide characters from the string pointed to by s2
-         fit within the array pointed to by s1 and that the result in s1 is null terminated.
-
-[<a name="p635" href="#p635">page 635</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.9.2.1.2" href="#K.3.9.2.1.2"><b>     K.3.9.2.1.2 The wcsncpy_s function</b></a>
-<b>     Synopsis</b>
-7            #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             errno_t wcsncpy_s(wchar_t * restrict s1,
-                  rsize_t s1max,
-                  const wchar_t * restrict s2,
-                  rsize_t n);
-     Runtime-constraints
-8    Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-     RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
-     shall be greater than wcsnlen_s(s2, s1max). Copying shall not take place between
-     objects that overlap.
-9    If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-     greater than zero and not greater than RSIZE_MAX, then wcsncpy_s sets s1[0] to the
-     null wide character.
-<b>     Description</b>
-10   The wcsncpy_s function copies not more than n successive wide characters (wide
-     characters that follow a null wide character are not copied) from the array pointed to by
-     s2 to the array pointed to by s1. If no null wide character was copied from s2, then
-     s1[n] is set to a null wide character.
-11   All elements following the terminating null wide character (if any) written by
-     wcsncpy_s in the array of s1max wide characters pointed to by s1 take unspecified
-     values when wcsncpy_s returns.<sup><a href="#note430"><b>430)</b></a></sup>
-<b>     Returns</b>
-12   The wcsncpy_s function returns zero<sup><a href="#note431"><b>431)</b></a></sup> if there was no runtime-constraint violation.
-     Otherwise, a nonzero value is returned.
-13   EXAMPLE 1 The wcsncpy_s function can be used to copy a wide string without the danger that the
-     result will not be null terminated or that wide characters will be written past the end of the destination
-     array.
-
-
-
-
-     <sup><a name="note430" href="#note430"><b>430)</b></a></sup> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
-          if any of those wide characters are null. Such an approach might write a wide character to every
-          element of s1 before discovering that the first element should be set to the null wide character.
-     <sup><a name="note431" href="#note431"><b>431)</b></a></sup> A zero return value implies that all of the requested wide characters from the string pointed to by s2
-          fit within the array pointed to by s1 and that the result in s1 is null terminated.
-
-[<a name="p636" href="#p636">page 636</a>] (<a href="#Contents">Contents</a>)
-
-             #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             /* ... */
-             wchar_t src1[100] = L"hello";
-             wchar_t src2[7] = {L'g', L'o', L'o', L'd', L'b', L'y', L'e'};
-             wchar_t dst1[6], dst2[5], dst3[5];
-             int r1, r2, r3;
-             r1 = wcsncpy_s(dst1, 6, src1, 100);
-             r2 = wcsncpy_s(dst2, 5, src2, 7);
-             r3 = wcsncpy_s(dst3, 5, src2, 4);
-     The first call will assign to r1 the value zero and to dst1 the sequence of wide characters hello\0.
-     The second call will assign to r2 a nonzero value and to dst2 the sequence of wide characters \0.
-     The third call will assign to r3 the value zero and to dst3 the sequence of wide characters good\0.
-
-<a name="K.3.9.2.1.3" href="#K.3.9.2.1.3"><b>     K.3.9.2.1.3 The wmemcpy_s function</b></a>
-<b>     Synopsis</b>
-14           #define __STDC_WANT_LIB_EXT1__ 1
-             #include <a href="#7.28">&lt;wchar.h&gt;</a>
-             errno_t wmemcpy_s(wchar_t * restrict s1,
-                  rsize_t s1max,
-                  const wchar_t * restrict s2,
-                  rsize_t n);
-     Runtime-constraints
-15   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-     RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
-     objects that overlap.
-16   If there is a runtime-constraint violation, the wmemcpy_s function stores zeros in the
-     first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
-     s1max is not greater than RSIZE_MAX.
-<b>     Description</b>
-17   The wmemcpy_s function copies n successive wide characters from the object pointed
-     to by s2 into the object pointed to by s1.
-<b>     Returns</b>
-18   The wmemcpy_s function returns zero if there was no runtime-constraint violation.
-     Otherwise, a nonzero value is returned.
-
-[<a name="p637" href="#p637">page 637</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.9.2.1.4" href="#K.3.9.2.1.4"><b>     K.3.9.2.1.4 The wmemmove_s function</b></a>
-<b>     Synopsis</b>
-19          #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
-                 const wchar_t *s2, rsize_t n);
-     Runtime-constraints
-20   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-     RSIZE_MAX. n shall not be greater than s1max.
-21   If there is a runtime-constraint violation, the wmemmove_s function stores zeros in the
-     first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
-     s1max is not greater than RSIZE_MAX.
-<b>     Description</b>
-22   The wmemmove_s function copies n successive wide characters from the object pointed
-     to by s2 into the object pointed to by s1. This copying takes place as if the n wide
-     characters from the object pointed to by s2 are first copied into a temporary array of n
-     wide characters that does not overlap the objects pointed to by s1 or s2, and then the n
-     wide characters from the temporary array are copied into the object pointed to by s1.
-<b>     Returns</b>
-23   The wmemmove_s function returns zero if there was no runtime-constraint violation.
-     Otherwise, a nonzero value is returned.
-<a name="K.3.9.2.2" href="#K.3.9.2.2"><b>     K.3.9.2.2 Wide string concatenation functions</b></a>
-<a name="K.3.9.2.2.1" href="#K.3.9.2.2.1"><b>     K.3.9.2.2.1 The wcscat_s function</b></a>
-<b>     Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            errno_t wcscat_s(wchar_t * restrict s1,
-                 rsize_t s1max,
-                 const wchar_t * restrict s2);
-     Runtime-constraints
-2    Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
-     wcscat_s.
-3    Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
-     s1max shall not equal zero. m shall not equal zero.<sup><a href="#note432"><b>432)</b></a></sup> m shall be greater than
-     wcsnlen_s(s2, m). Copying shall not take place between objects that overlap.
-
-[<a name="p638" href="#p638">page 638</a>] (<a href="#Contents">Contents</a>)
-
-4    If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-     greater than zero and not greater than RSIZE_MAX, then wcscat_s sets s1[0] to the
-     null wide character.
-<b>     Description</b>
-5    The wcscat_s function appends a copy of the wide string pointed to by s2 (including
-     the terminating null wide character) to the end of the wide string pointed to by s1. The
-     initial wide character from s2 overwrites the null wide character at the end of s1.
-6    All elements following the terminating null wide character (if any) written by
-     wcscat_s in the array of s1max wide characters pointed to by s1 take unspecified
-     values when wcscat_s returns.<sup><a href="#note433"><b>433)</b></a></sup>
-<b>     Returns</b>
-7    The wcscat_s function returns zero<sup><a href="#note434"><b>434)</b></a></sup> if there was no runtime-constraint violation.
-     Otherwise, a nonzero value is returned.
-<a name="K.3.9.2.2.2" href="#K.3.9.2.2.2"><b>     K.3.9.2.2.2 The wcsncat_s function</b></a>
-<b>     Synopsis</b>
-8             #define __STDC_WANT_LIB_EXT1__ 1
-              #include <a href="#7.28">&lt;wchar.h&gt;</a>
-              errno_t wcsncat_s(wchar_t * restrict s1,
-                   rsize_t s1max,
-                   const wchar_t * restrict s2,
-                   rsize_t n);
-     Runtime-constraints
-9    Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
-     wcsncat_s.
-10   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
-     RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note435"><b>435)</b></a></sup> If n is not less
-     than m, then m shall be greater than wcsnlen_s(s2, m). Copying shall not take
-     place between objects that overlap.
-
-
-     <sup><a name="note432" href="#note432"><b>432)</b></a></sup> Zero means that s1 was not null terminated upon entry to wcscat_s.
-     <sup><a name="note433" href="#note433"><b>433)</b></a></sup> This allows an implementation to append wide characters from s2 to s1 while simultaneously
-          checking if any of those wide characters are null. Such an approach might write a wide character to
-          every element of s1 before discovering that the first element should be set to the null wide character.
-     <sup><a name="note434" href="#note434"><b>434)</b></a></sup> A zero return value implies that all of the requested wide characters from the wide string pointed to by
-          s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
-     <sup><a name="note435" href="#note435"><b>435)</b></a></sup> Zero means that s1 was not null terminated upon entry to wcsncat_s.
-
-[<a name="p639" href="#p639">page 639</a>] (<a href="#Contents">Contents</a>)
-
-11   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
-     greater than zero and not greater than RSIZE_MAX, then wcsncat_s sets s1[0] to the
-     null wide character.
-<b>     Description</b>
-12   The wcsncat_s function appends not more than n successive wide characters (wide
-     characters that follow a null wide character are not copied) from the array pointed to by
-     s2 to the end of the wide string pointed to by s1. The initial wide character from s2
-     overwrites the null wide character at the end of s1. If no null wide character was copied
-     from s2, then s1[s1max-m+n] is set to a null wide character.
-13   All elements following the terminating null wide character (if any) written by
-     wcsncat_s in the array of s1max wide characters pointed to by s1 take unspecified
-     values when wcsncat_s returns.<sup><a href="#note436"><b>436)</b></a></sup>
-<b>     Returns</b>
-14   The wcsncat_s function returns zero<sup><a href="#note437"><b>437)</b></a></sup> if there was no runtime-constraint violation.
-     Otherwise, a nonzero value is returned.
-15   EXAMPLE 1 The wcsncat_s function can be used to copy a wide string without the danger that the
-     result will not be null terminated or that wide characters will be written past the end of the destination
-     array.
-              #define __STDC_WANT_LIB_EXT1__ 1
-              #include <a href="#7.28">&lt;wchar.h&gt;</a>
-              /* ... */
-              wchar_t s1[100] = L"good";
-              wchar_t s2[6] = L"hello";
-              wchar_t s3[6] = L"hello";
-              wchar_t s4[7] = L"abc";
-              wchar_t s5[1000] = L"bye";
-              int r1, r2, r3, r4;
-              r1 = wcsncat_s(s1, 100, s5, 1000);
-              r2 = wcsncat_s(s2, 6, L"", 1);
-              r3 = wcsncat_s(s3, 6, L"X", 2);
-              r4 = wcsncat_s(s4, 7, L"defghijklmn", 3);
-     After the first call r1 will have the value zero and s1 will be the wide character sequence goodbye\0.
-     After the second call r2 will have the value zero and s2 will be the wide character sequence hello\0.
-     After the third call r3 will have a nonzero value and s3 will be the wide character sequence \0.
-     After the fourth call r4 will have the value zero and s4 will be the wide character sequence abcdef\0.
-
-
-
-
-     <sup><a name="note436" href="#note436"><b>436)</b></a></sup> This allows an implementation to append wide characters from s2 to s1 while simultaneously
-          checking if any of those wide characters are null. Such an approach might write a wide character to
-          every element of s1 before discovering that the first element should be set to the null wide character.
-     <sup><a name="note437" href="#note437"><b>437)</b></a></sup> A zero return value implies that all of the requested wide characters from the wide string pointed to by
-          s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
-
-[<a name="p640" href="#p640">page 640</a>] (<a href="#Contents">Contents</a>)
-
-<a name="K.3.9.2.3" href="#K.3.9.2.3"><b>    K.3.9.2.3 Wide string search functions</b></a>
-<a name="K.3.9.2.3.1" href="#K.3.9.2.3.1"><b>    K.3.9.2.3.1 The wcstok_s function</b></a>
-<b>    Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            wchar_t *wcstok_s(wchar_t * restrict s1,
-                 rsize_t * restrict s1max,
-                 const wchar_t * restrict s2,
-                 wchar_t ** restrict ptr);
-    Runtime-constraints
-2   None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
-    shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
-    The end of the token found shall occur within the first *s1max wide characters of s1 for
-    the first call, and shall occur within the first *s1max wide characters of where searching
-    resumes on subsequent calls.
-3   If there is a runtime-constraint violation, the wcstok_s function does not indirect
-    through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
-<b>    Description</b>
-4   A sequence of calls to the wcstok_s function breaks the wide string pointed to by s1
-    into a sequence of tokens, each of which is delimited by a wide character from the wide
-    string pointed to by s2. The fourth argument points to a caller-provided wchar_t
-    pointer into which the wcstok_s function stores information necessary for it to
-    continue scanning the same wide string.
-5   The first call in a sequence has a non-null first argument and s1max points to an object
-    whose value is the number of elements in the wide character array pointed to by the first
-    argument. The first call stores an initial value in the object pointed to by ptr and
-    updates the value pointed to by s1max to reflect the number of elements that remain in
-    relation to ptr. Subsequent calls in the sequence have a null first argument and the
-    objects pointed to by s1max and ptr are required to have the values stored by the
-    previous call in the sequence, which are then updated. The separator wide string pointed
-    to by s2 may be different from call to call.
-6   The first call in the sequence searches the wide string pointed to by s1 for the first wide
-    character that is not contained in the current separator wide string pointed to by s2. If no
-    such wide character is found, then there are no tokens in the wide string pointed to by s1
-    and the wcstok_s function returns a null pointer. If such a wide character is found, it is
-    the start of the first token.
-
-[<a name="p641" href="#p641">page 641</a>] (<a href="#Contents">Contents</a>)
-
-7    The wcstok_s function then searches from there for the first wide character in s1 that
-     is contained in the current separator wide string. If no such wide character is found, the
-     current token extends to the end of the wide string pointed to by s1, and subsequent
-     searches in the same wide string for a token return a null pointer. If such a wide character
-     is found, it is overwritten by a null wide character, which terminates the current token.
-8    In all cases, the wcstok_s function stores sufficient information in the pointer pointed
-     to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
-     value for ptr, shall start searching just past the element overwritten by a null wide
-     character (if any).
-<b>     Returns</b>
-9    The wcstok_s function returns a pointer to the first wide character of a token, or a null
-     pointer if there is no token or there is a runtime-constraint violation.
-10   EXAMPLE
-            #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            static wchar_t str1[] = L"?a???b,,,#c";
-            static wchar_t str2[] = L"\t \t";
-            wchar_t *t, *ptr1, *ptr2;
-            rsize_t max1 = wcslen(str1)+1;
-            rsize_t max2 = wcslen(str2)+1;
-            t   =   wcstok_s(str1,   &amp;max1,   "?", &amp;ptr1);        //   t   points to the token "a"
-            t   =   wcstok_s(NULL,   &amp;max1,   ",", &amp;ptr1);        //   t   points to the token "??b"
-            t   =   wcstok_s(str2,   &amp;max2,   " \t", &amp;ptr2);      //   t   is a null pointer
-            t   =   wcstok_s(NULL,   &amp;max1,   "#,", &amp;ptr1);       //   t   points to the token "c"
-            t   =   wcstok_s(NULL,   &amp;max1,   "?", &amp;ptr1);        //   t   is a null pointer
-
-<a name="K.3.9.2.4" href="#K.3.9.2.4"><b>     K.3.9.2.4 Miscellaneous functions</b></a>
-<a name="K.3.9.2.4.1" href="#K.3.9.2.4.1"><b>     K.3.9.2.4.1 The wcsnlen_s function</b></a>
-<b>     Synopsis</b>
-1           #define __STDC_WANT_LIB_EXT1__ 1
-            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
-<b>     Description</b>
-2    The wcsnlen_s function computes the length of the wide string pointed to by s.
-<b>     Returns</b>
-3    If s is a null pointer,<sup><a href="#note438"><b>438)</b></a></sup> then the wcsnlen_s function returns zero.
-4    Otherwise, the wcsnlen_s function returns the number of wide characters that precede
-     the terminating null wide character. If there is no null wide character in the first
-     maxsize wide characters of s then wcsnlen_s returns maxsize. At most the first
-
-[<a name="p642" href="#p642">page 642</a>] (<a href="#Contents">Contents</a>)
-
-    maxsize wide characters of s shall be accessed by wcsnlen_s.
-<a name="K.3.9.3" href="#K.3.9.3"><b>    K.3.9.3 Extended multibyte/wide character conversion utilities</b></a>
-<a name="K.3.9.3.1" href="#K.3.9.3.1"><b>    K.3.9.3.1 Restartable multibyte/wide character conversion functions</b></a>
-1   Unlike wcrtomb, wcrtomb_s does not permit the ps parameter (the pointer to the
-    conversion state) to be a null pointer.
-<a name="K.3.9.3.1.1" href="#K.3.9.3.1.1"><b>    K.3.9.3.1.1 The wcrtomb_s function</b></a>
-<b>    Synopsis</b>
-2           #include <a href="#7.28">&lt;wchar.h&gt;</a>
-            errno_t wcrtomb_s(size_t * restrict retval,
-                 char * restrict s, rsize_t smax,
-                 wchar_t wc, mbstate_t * restrict ps);
-    Runtime-constraints
-3   Neither retval nor ps shall be a null pointer. If s is not a null pointer, then smax
-    shall not equal zero and shall not be greater than RSIZE_MAX. If s is not a null pointer,
-    then smax shall be not be less than the number of bytes to be stored in the array pointed
-    to by s. If s is a null pointer, then smax shall equal zero.
-4   If there is a runtime-constraint violation, then wcrtomb_s does the following. If s is
-    not a null pointer and smax is greater than zero and not greater than RSIZE_MAX, then
-    wcrtomb_s sets s[0] to the null character. If retval is not a null pointer, then
-    wcrtomb_s sets *retval to (size_t)(-1).
-<b>    Description</b>
-5   If s is a null pointer, the wcrtomb_s function is equivalent to the call
-                    wcrtomb_s(&amp;retval, buf, sizeof buf, L'\0', ps)
-    where retval and buf are internal variables of the appropriate types, and the size of
-    buf is greater than MB_CUR_MAX.
-6   If s is not a null pointer, the wcrtomb_s function determines the number of bytes
-    needed to represent the multibyte character that corresponds to the wide character given
-    by wc (including any shift sequences), and stores the multibyte character representation
-    in the array whose first element is pointed to by s. At most MB_CUR_MAX bytes are
-    stored. If wc is a null wide character, a null byte is stored, preceded by any shift
-    sequence needed to restore the initial shift state; the resulting state described is the initial
-    conversion state.
-
-    <sup><a name="note438" href="#note438"><b>438)</b></a></sup> Note that the wcsnlen_s function has no runtime-constraints. This lack of runtime-constraints
-         along with the values returned for a null pointer or an unterminated wide string argument make
-         wcsnlen_s useful in algorithms that gracefully handle such exceptional data.
-
-[<a name="p643" href="#p643">page 643</a>] (<a href="#Contents">Contents</a>)
-
-7   If wc does not correspond to a valid multibyte character, an encoding error occurs: the
-    wcrtomb_s function stores the value (size_t)(-1) into *retval and the
-    conversion state is unspecified. Otherwise, the wcrtomb_s function stores into
-    *retval the number of bytes (including any shift sequences) stored in the array pointed
-    to by s.
-<b>    Returns</b>
-8   The wcrtomb_s function returns zero if no runtime-constraint violation and no
-    encoding error occurred. Otherwise, a nonzero value is returned.
-<a name="K.3.9.3.2" href="#K.3.9.3.2"><b>    K.3.9.3.2 Restartable multibyte/wide string conversion functions</b></a>
-1   Unlike mbsrtowcs and wcsrtombs, mbsrtowcs_s and wcsrtombs_s do not
-    permit the ps parameter (the pointer to the conversion state) to be a null pointer.
-<a name="K.3.9.3.2.1" href="#K.3.9.3.2.1"><b>    K.3.9.3.2.1 The mbsrtowcs_s function</b></a>
-<b>    Synopsis</b>
-2          #include <a href="#7.28">&lt;wchar.h&gt;</a>
-           errno_t mbsrtowcs_s(size_t * restrict retval,
-                wchar_t * restrict dst, rsize_t dstmax,
-                const char ** restrict src, rsize_t len,
-                mbstate_t * restrict ps);
-    Runtime-constraints
-3   None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
-    then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
-    pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
-    not equal zero. If dst is not a null pointer and len is not less than dstmax, then a null
-    character shall occur within the first dstmax multibyte characters of the array pointed to
-    by *src.
-4   If there is a runtime-constraint violation, then mbsrtowcs_s does the following. If
-    retval is not a null pointer, then mbsrtowcs_s sets *retval to (size_t)(-1).
-    If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
-    then mbsrtowcs_s sets dst[0] to the null wide character.
-<b>    Description</b>
-5   The mbsrtowcs_s function converts a sequence of multibyte characters that begins in
-    the conversion state described by the object pointed to by ps, from the array indirectly
-    pointed to by src into a sequence of corresponding wide characters. If dst is not a null
-    pointer, the converted characters are stored into the array pointed to by dst. Conversion
-    continues up to and including a terminating null character, which is also stored.
-    Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
-    not form a valid multibyte character, or (if dst is not a null pointer) when len wide
-
-[<a name="p644" href="#p644">page 644</a>] (<a href="#Contents">Contents</a>)
-
-     characters have been stored into the array pointed to by dst.<sup><a href="#note439"><b>439)</b></a></sup> If dst is not a null
-     pointer and no null wide character was stored into the array pointed to by dst, then
-     dst[len] is set to the null wide character. Each conversion takes place as if by a call
-     to the mbrtowc function.
-6    If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
-     pointer (if conversion stopped due to reaching a terminating null character) or the address
-     just past the last multibyte character converted (if any). If conversion stopped due to
-     reaching a terminating null character and if dst is not a null pointer, the resulting state
-     described is the initial conversion state.
-7    Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
-     sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
-     the mbsrtowcs_s function stores the value (size_t)(-1) into *retval and the
-     conversion state is unspecified. Otherwise, the mbsrtowcs_s function stores into
-     *retval the number of multibyte characters successfully converted, not including the
-     terminating null character (if any).
-8    All elements following the terminating null wide character (if any) written by
-     mbsrtowcs_s in the array of dstmax wide characters pointed to by dst take
-     unspecified values when mbsrtowcs_s returns.<sup><a href="#note440"><b>440)</b></a></sup>
-9    If copying takes place between objects that overlap, the objects take on unspecified
-     values.
-<b>     Returns</b>
-10   The mbsrtowcs_s function returns zero if no runtime-constraint violation and no
-     encoding error occurred. Otherwise, a nonzero value is returned.
-<a name="K.3.9.3.2.2" href="#K.3.9.3.2.2"><b>     K.3.9.3.2.2 The wcsrtombs_s function</b></a>
-<b>     Synopsis</b>
-11            #include <a href="#7.28">&lt;wchar.h&gt;</a>
-              errno_t wcsrtombs_s(size_t * restrict retval,
-                   char * restrict dst, rsize_t dstmax,
-                   const wchar_t ** restrict src, rsize_t len,
-                   mbstate_t * restrict ps);
-
-
-
-
-     <sup><a name="note439" href="#note439"><b>439)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
-     <sup><a name="note440" href="#note440"><b>440)</b></a></sup> This allows an implementation to attempt converting the multibyte string before discovering a
-          terminating null character did not occur where required.
-
-[<a name="p645" href="#p645">page 645</a>] (<a href="#Contents">Contents</a>)
-
-     Runtime-constraints
-12   None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
-     then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
-     pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
-     not equal zero. If dst is not a null pointer and len is not less than dstmax, then the
-     conversion shall have been stopped (see below) because a terminating null wide character
-     was reached or because an encoding error occurred.
-13   If there is a runtime-constraint violation, then wcsrtombs_s does the following. If
-     retval is not a null pointer, then wcsrtombs_s sets *retval to (size_t)(-1).
-     If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
-     then wcsrtombs_s sets dst[0] to the null character.
-<b>     Description</b>
-14   The wcsrtombs_s function converts a sequence of wide characters from the array
-     indirectly pointed to by src into a sequence of corresponding multibyte characters that
-     begins in the conversion state described by the object pointed to by ps. If dst is not a
-     null pointer, the converted characters are then stored into the array pointed to by dst.
-     Conversion continues up to and including a terminating null wide character, which is also
-     stored. Conversion stops earlier in two cases:
-     -- when a wide character is reached that does not correspond to a valid multibyte
-       character;
-     -- (if dst is not a null pointer) when the next multibyte character would exceed the
-         limit of n total bytes to be stored into the array pointed to by dst. If the wide
-         character being converted is the null wide character, then n is the lesser of len or
-         dstmax. Otherwise, n is the lesser of len or dstmax-1.
-     If the conversion stops without converting a null wide character and dst is not a null
-     pointer, then a null character is stored into the array pointed to by dst immediately
-     following any multibyte characters already stored. Each conversion takes place as if by a
-     call to the wcrtomb function.<sup><a href="#note441"><b>441)</b></a></sup>
-15   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
-     pointer (if conversion stopped due to reaching a terminating null wide character) or the
-     address just past the last wide character converted (if any). If conversion stopped due to
-     reaching a terminating null wide character, the resulting state described is the initial
-     conversion state.
-
-
-     <sup><a name="note441" href="#note441"><b>441)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
-          include those necessary to reach the initial shift state immediately before the null byte. However, if
-          the conversion stops before a terminating null wide character has been reached, the result will be null
-          terminated, but might not end in the initial shift state.
-
-[<a name="p646" href="#p646">page 646</a>] (<a href="#Contents">Contents</a>)
-
-16   Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
-     wide character that does not correspond to a valid multibyte character, an encoding error
-     occurs: the wcsrtombs_s function stores the value (size_t)(-1) into *retval
-     and the conversion state is unspecified. Otherwise, the wcsrtombs_s function stores
-     into *retval the number of bytes in the resulting multibyte character sequence, not
-     including the terminating null character (if any).
-17   All elements following the terminating null character (if any) written by wcsrtombs_s
-     in the array of dstmax elements pointed to by dst take unspecified values when
-     wcsrtombs_s returns.<sup><a href="#note442"><b>442)</b></a></sup>
-18   If copying takes place between objects that overlap, the objects take on unspecified
-     values.
-<b>     Returns</b>
-19   The wcsrtombs_s function returns zero if no runtime-constraint violation and no
-     encoding error occurred. Otherwise, a nonzero value is returned.
-
-
-
-
-     <sup><a name="note442" href="#note442"><b>442)</b></a></sup> When len is not less than dstmax, the implementation might fill the array before discovering a
-          runtime-constraint violation.
-
-[<a name="p647" href="#p647">page 647</a>] (<a href="#Contents">Contents</a>)
-
-<a name="L" href="#L"><b>                                                Annex L</b></a>
-                                               (normative)
-                                            Analyzability
-<a name="L.1" href="#L.1"><b>    L.1 Scope</b></a>
-1   This annex specifies optional behavior that can aid in the analyzability of C programs.
-2   An implementation that defines __STDC_ANALYZABLE__ shall conform to the
-    specifications in this annex.<sup><a href="#note443"><b>443)</b></a></sup>
-<a name="L.2" href="#L.2"><b>    L.2 Definitions</b></a>
-<a name="L.2.1" href="#L.2.1"><b>    L.2.1</b></a>
-1   out-of-bounds store
-    an (attempted) access (<a href="#3.1">3.1</a>) that, at run time, for a given computational state, would
-    modify (or, for an object declared volatile, fetch) one or more bytes that lie outside
-    the bounds permitted by this Standard.
-<a name="L.2.2" href="#L.2.2"><b>    L.2.2</b></a>
-1   bounded undefined behavior
-    undefined behavior (<a href="#3.4.3">3.4.3</a>) that does not perform an out-of-bounds store.
-2   NOTE 1    The behavior might perform a trap.
-
-3   NOTE 2    Any values produced or stored might be indeterminate values.
-
-<a name="L.2.3" href="#L.2.3"><b>    L.2.3</b></a>
-1   critical undefined behavior
-    undefined behavior that is not bounded undefined behavior.
-2   NOTE     The behavior might perform an out-of-bounds store or perform a trap.
-
-
-
-
-    <sup><a name="note443" href="#note443"><b>443)</b></a></sup> Implementations that do not define __STDC_ANALYZABLE__ are not required to conform to these
-         specifications.
-
-[<a name="p648" href="#p648">page 648</a>] (<a href="#Contents">Contents</a>)
-
-<a name="L.3" href="#L.3"><b>    L.3 Requirements</b></a>
-1   If the program performs a trap (<a href="#3.19.5">3.19.5</a>), the implementation is permitted to invoke a
-    runtime-constraint handler. Any such semantics are implementation-defined.
-2   All undefined behavior shall be limited to bounded undefined behavior, except for the
-    following which are permitted to result in critical undefined behavior:
-    -- An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
-    -- An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
-    -- A pointer is used to call a function whose type is not compatible with the referenced
-      type (<a href="#6.3.2.3">6.3.2.3</a>).
-    -- The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
-    -- Addition or subtraction of a pointer into, or just beyond, an array object and an
-      integer type produces a result that points just beyond the array object and is used as
-      the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
-    -- An argument to a library function has an invalid value or a type not expected by a
-      function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
-    -- The value of a pointer that refers to space deallocated by a call to the free or realloc
-      function is used (<a href="#7.22.3">7.22.3</a>).
-    -- A string or wide string utility function is instructed to access an array beyond the end
-      of an object (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
-
-[<a name="p649" href="#p649">page 649</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="Bibliography" href="#Bibliography"><b>                                  Bibliography</b></a>
-  1.   ''The C Reference Manual'' by Dennis M. Ritchie, a version of which was
-       published in The C Programming Language by Brian W. Kernighan and Dennis
-       M. Ritchie, Prentice-Hall, Inc., (1978). Copyright owned by AT&amp;T.
-  2.   1984 /usr/group Standard by the /usr/group Standards Committee, Santa Clara,
-       California, USA, November 1984.
-  3.   ANSI X3/TR-1-82 (1982), American National Dictionary for Information
-       Processing Systems, Information Processing Systems Technical Report.
-  4.   ANSI/IEEE 754-1985, American National Standard for Binary Floating-Point
-       Arithmetic.
-  5.   ANSI/IEEE 854-1988, American National Standard for Radix-Independent
-       Floating-Point Arithmetic.
-  6.   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems,
-       second edition (previously designated IEC 559:1989).
-  7.   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and
-       symbols for use in the physical sciences and technology.
-  8.   ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character set for
-       information interchange.
-  9.   ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1:
-       Fundamental terms.
- 10.   ISO 4217:1995, Codes for the representation of currencies and funds.
- 11.   ISO 8601:1988, Data elements and interchange formats -- Information
-       interchange -- Representation of dates and times.
- 12.   ISO/IEC 9899:1990, Programming languages -- C.
- 13.   ISO/IEC 9899/COR1:1994, Technical Corrigendum 1.
- 14.   ISO/IEC 9899/COR2:1996, Technical Corrigendum 2.
- 15.   ISO/IEC 9899/AMD1:1995, Amendment 1 to ISO/IEC 9899:1990 C Integrity.
- 16.   ISO/IEC 9899:1999, Programming languages -- C.
- 17.   ISO/IEC 9899:1999/Cor.1:2001, Technical Corrigendum 1.
- 18.   ISO/IEC 9899:1999/Cor.2:2004, Technical Corrigendum 2.
- 19.   ISO/IEC 9899:1999/Cor.3:2007, Technical Corrigendum 3.
-
-[<a name="p650" href="#p650">page 650</a>] (<a href="#Contents">Contents</a>)
-
- 20.    ISO/IEC 9945-2:1993, Information technology -- Portable Operating System
-        Interface (POSIX) -- Part 2: Shell and Utilities.
- 21.    ISO/IEC TR 10176:1998, Information technology -- Guidelines for the
-        preparation of programming language standards.
- 22.    ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet
-        Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.
- 23.    ISO/IEC 10646-1/COR1:1996,         Technical       Corrigendum       1      to
-        ISO/IEC 10646-1:1993.
- 24.    ISO/IEC 10646-1/COR2:1998,         Technical       Corrigendum       2      to
-        ISO/IEC 10646-1:1993.
- 25.    ISO/IEC 10646-1/AMD1:1996, Amendment 1 to ISO/IEC 10646-1:1993
-        Transformation Format for 16 planes of group 00 (UTF-16).
- 26.    ISO/IEC 10646-1/AMD2:1996, Amendment 2 to ISO/IEC 10646-1:1993 UCS
-        Transformation Format 8 (UTF-8).
- 27.    ISO/IEC 10646-1/AMD3:1996, Amendment 3 to ISO/IEC 10646-1:1993.
- 28.    ISO/IEC 10646-1/AMD4:1996, Amendment 4 to ISO/IEC 10646-1:1993.
- 29.    ISO/IEC 10646-1/AMD5:1998, Amendment 5 to ISO/IEC 10646-1:1993 Hangul
-        syllables.
- 30.    ISO/IEC 10646-1/AMD6:1997,       Amendment     6   to   ISO/IEC 10646-1:1993
-        Tibetan.
- 31.    ISO/IEC 10646-1/AMD7:1997, Amendment 7 to ISO/IEC 10646-1:1993 33
-        additional characters.
- 32.    ISO/IEC 10646-1/AMD8:1997, Amendment 8 to ISO/IEC 10646-1:1993.
- 33.    ISO/IEC 10646-1/AMD9:1997,       Amendment     9   to   ISO/IEC 10646-1:1993
-        Identifiers for characters.
- 34.    ISO/IEC 10646-1/AMD10:1998, Amendment 10 to ISO/IEC 10646-1:1993
-        Ethiopic.
- 35.    ISO/IEC 10646-1/AMD11:1998, Amendment 11 to ISO/IEC 10646-1:1993
-        Unified Canadian Aboriginal Syllabics.
- 36.    ISO/IEC 10646-1/AMD12:1998, Amendment 12 to ISO/IEC 10646-1:1993
-        Cherokee.
- 37.    ISO/IEC 10967-1:1994, Information technology -- Language independent
-        arithmetic -- Part 1: Integer and floating point arithmetic.
-
-[<a name="p651" href="#p651">page 651</a>] (<a href="#Contents">Contents</a>)
-
- 38.   ISO/IEC TR 19769:2004, Information technology -- Programming languages,
-       their environments and system software interfaces -- Extensions for the
-       programming language C to support new character data types.
- 39.   ISO/IEC TR 24731-1:2007, Information technology -- Programming languages,
-       their environments and system software interfaces -- Extensions to the C library
-       -- Part 1: Bounds-checking interfaces.
-
-[<a name="p652" href="#p652">page 652</a>] (<a href="#Contents">Contents</a>)
-
-
-<a name="Index" href="#Index"><b>Index</b></a>
-[^ x ^], <a href="#3.20">3.20</a>                                                    , (comma operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a>
-                                                               , (comma punctuator), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,
-[_ x _], <a href="#3.21">3.21</a>                                                         <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>
-! (logical negation operator), <a href="#6.5.3.3">6.5.3.3</a>                         - (subtraction operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
-!= (inequality operator), <a href="#6.5.9">6.5.9</a>                                - (unary minus operator), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
-# operator, <a href="#6.10.3.2">6.10.3.2</a>                                           -- (postfix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
-# preprocessing directive, <a href="#6.10.7">6.10.7</a>                              -- (prefix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
-# punctuator, <a href="#6.10">6.10</a>                                             -= (subtraction assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
-## operator, <a href="#6.10.3.3">6.10.3.3</a>                                          -&gt; (structure/union pointer operator), <a href="#6.5.2.3">6.5.2.3</a>
-#define preprocessing directive, <a href="#6.10.3">6.10.3</a>                        . (structure/union member operator), <a href="#6.3.2.1">6.3.2.1</a>,
-#elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                               <a href="#6.5.2.3">6.5.2.3</a>
-#else preprocessing directive, <a href="#6.10.1">6.10.1</a>                          . punctuator, <a href="#6.7.9">6.7.9</a>
-#endif preprocessing directive, <a href="#6.10.1">6.10.1</a>                         ... (ellipsis punctuator), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
-#error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                      / (division operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
-#if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,             /* */ (comment delimiters), <a href="#6.4.9">6.4.9</a>
-     <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             // (comment delimiter), <a href="#6.4.9">6.4.9</a>
-#ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                         /= (division assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
-#ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                        : (colon punctuator), <a href="#6.7.2.1">6.7.2.1</a>
-#include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>,                     :&gt; (alternative spelling of ]), <a href="#6.4.6">6.4.6</a>
-     <a href="#6.10.2">6.10.2</a>                                                    ; (semicolon punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
-#line preprocessing directive, <a href="#6.10.4">6.10.4</a>                               <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
-#pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>                        &lt; (less-than operator), <a href="#6.5.8">6.5.8</a>
-#undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,               &lt;% (alternative spelling of {), <a href="#6.4.6">6.4.6</a>
-     <a href="#7.1.4">7.1.4</a>                                                     &lt;: (alternative spelling of [), <a href="#6.4.6">6.4.6</a>
-% (remainder operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>                         &lt;&lt; (left-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
-%: (alternative spelling of #), <a href="#6.4.6">6.4.6</a>                          &lt;&lt;= (left-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
-%:%: (alternative spelling of ##), <a href="#6.4.6">6.4.6</a>                       &lt;= (less-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>
-%= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                   <a href="#7.2">&lt;assert.h&gt;</a> header, <a href="#7.2">7.2</a>
-%&gt; (alternative spelling of }), <a href="#6.4.6">6.4.6</a>                          <a href="#7.3">&lt;complex.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,
-&amp; (address operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                              <a href="#7.3">7.3</a>, <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
-&amp; (bitwise AND operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>                      <a href="#7.4">&lt;ctype.h&gt;</a> header, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>
-&amp;&amp; (logical AND operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>                     <a href="#7.5">&lt;errno.h&gt;</a> header, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>
-&amp;= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                 <a href="#7.6">&lt;fenv.h&gt;</a> header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>,
-' ' (space character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,                <a href="#H">H</a>
-     <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>                                      <a href="#7.7">&lt;float.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
-( ) (cast operator), <a href="#6.5.4">6.5.4</a>                                          <a href="#7.28.4.1.1">7.28.4.1.1</a>
-( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a>                          <a href="#7.8">&lt;inttypes.h&gt;</a> header, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>
-( ) (parentheses punctuator), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>            <a href="#7.9">&lt;iso646.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
-( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                    <a href="#7.10">&lt;limits.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
-* (asterisk punctuator), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a>                      <a href="#7.11">&lt;locale.h&gt;</a> header, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>
-* (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                     <a href="#7.12">&lt;math.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>,
-* (multiplication operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>,                   <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a>
-     <a href="#G.5.1">G.5.1</a>                                                     <a href="#7.13">&lt;setjmp.h&gt;</a> header, <a href="#7.13">7.13</a>
-*= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              <a href="#7.14">&lt;signal.h&gt;</a> header, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>
-+ (addition operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>,              <a href="#7.15">&lt;stdalign.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
-     <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                                         <a href="#7.16">&lt;stdarg.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
-+ (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a>                               <a href="#7.17">&lt;stdatomic.h&gt;</a> header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>
-++ (postfix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>               <a href="#7.18">&lt;stdbool.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>
-++ (prefix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>                <a href="#7.19">&lt;stddef.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
-+= (addition assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
-
-[<a name="p653" href="#p653">page 653</a>] (<a href="#Contents">Contents</a>)
-
-     <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>                      \x hexadecimal digits (hexadecimal-character
-<a href="#7.20">&lt;stdint.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>,                       escape sequence), <a href="#6.4.4.4">6.4.4.4</a>
-     <a href="#7.20">7.20</a>, <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>                              ^ (bitwise exclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
-<a href="#7.21">&lt;stdio.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>,                ^= (bitwise exclusive OR assignment operator),
-     <a href="#K.3.5">K.3.5</a>                                                        <a href="#6.5.16.2">6.5.16.2</a>
-<a href="#7.22">&lt;stdlib.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,              __alignas_is_defined macro, <a href="#7.15">7.15</a>
-     <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>                                          __bool_true_false_are_defined
-<a href="#7.23">&lt;string.h&gt;</a> header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                           macro, <a href="#7.18">7.18</a>
-<a href="#7.24">&lt;tgmath.h&gt;</a> header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                 __cplusplus macro, <a href="#6.10.8">6.10.8</a>
-<a href="#7.25">&lt;threads.h&gt;</a> header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                    __DATE__ macro, <a href="#6.10.8.1">6.10.8.1</a>
-<a href="#7.26">&lt;time.h&gt;</a> header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                 __FILE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
-<a href="#7.27">&lt;uchar.h&gt;</a> header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                       __func__ identifier, <a href="#6.4.2.2">6.4.2.2</a>, <a href="#7.2.1.1">7.2.1.1</a>
-<a href="#7.28">&lt;wchar.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>,                   __LINE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
-     <a href="#7.30.12">7.30.12</a>, <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>                                       __STDC_, <a href="#6.11.9">6.11.9</a>
-<a href="#7.29">&lt;wctype.h&gt;</a> header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                             __STDC__ macro, <a href="#6.10.8.1">6.10.8.1</a>
-= (equal-sign punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a>               __STDC_ANALYZABLE__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#L.1">L.1</a>
-= (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a>                     __STDC_HOSTED__ macro, <a href="#6.10.8.1">6.10.8.1</a>
-== (equality operator), <a href="#6.5.9">6.5.9</a>                                __STDC_IEC_559__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#F.1">F.1</a>
-&gt; (greater-than operator), <a href="#6.5.8">6.5.8</a>                             __STDC_IEC_559_COMPLEX__ macro,
-&gt;= (greater-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>                     <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G.1">G.1</a>
-&gt;&gt; (right-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>                    __STDC_ISO_10646__ macro, <a href="#6.10.8.2">6.10.8.2</a>
-&gt;&gt;= (right-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              __STDC_LIB_EXT1__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#K.2">K.2</a>
-? : (conditional operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a>                  __STDC_MB_MIGHT_NEQ_WC__ macro,
-?? (trigraph sequences), <a href="#5.2.1.1">5.2.1.1</a>                                  <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>
-[ ] (array subscript operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>             __STDC_NO_COMPLEX__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
-[ ] (brackets punctuator), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>                         <a href="#7.3.1">7.3.1</a>
-\ (backslash character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>             __STDC_NO_THREADS__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
-\ (escape character), <a href="#6.4.4.4">6.4.4.4</a>                                     <a href="#7.17.1">7.17.1</a>, <a href="#7.25.1">7.25.1</a>
-\" (double-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>,                  __STDC_NO_VLA__ macro, <a href="#6.10.8.3">6.10.8.3</a>
-     <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                           __STDC_UTF_16__ macro, <a href="#6.10.8.2">6.10.8.2</a>
-\\ (backslash escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>              __STDC_UTF_32__ macro, <a href="#6.10.8.2">6.10.8.2</a>
-\' (single-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>            __STDC_VERSION__ macro, <a href="#6.10.8.1">6.10.8.1</a>
-\0 (null character), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                   __STDC_WANT_LIB_EXT1__ macro, <a href="#K.3.1.1">K.3.1.1</a>
-  padding of binary stream, <a href="#7.21.2">7.21.2</a>                           __TIME__ macro, <a href="#6.10.8.1">6.10.8.1</a>
-\? (question-mark escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                  __VA_ARGS__ identifier, <a href="#6.10.3">6.10.3</a>, <a href="#6.10.3.1">6.10.3.1</a>
-\a (alert escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                   _Alignas, <a href="#6.7.5">6.7.5</a>
-\b (backspace escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>               _Atomic type qualifier, <a href="#6.7.3">6.7.3</a>
-\f (form-feed escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,              _Bool type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.17.1">7.17.1</a>,
-     <a href="#7.4.1.10">7.4.1.10</a>                                                     <a href="#F.4">F.4</a>
-\n (new-line escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               _Bool type conversions, <a href="#6.3.1.2">6.3.1.2</a>
-     <a href="#7.4.1.10">7.4.1.10</a>                                                _Complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
-\octal digits (octal-character escape sequence),             _Complex_I macro, <a href="#7.3.1">7.3.1</a>
-     <a href="#6.4.4.4">6.4.4.4</a>                                                 _Exit function, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
-\r (carriage-return escape sequence), <a href="#5.2.2">5.2.2</a>,                 _Imaginary keyword, <a href="#G.2">G.2</a>
-     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                       _Imaginary types, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
-\t (horizontal-tab escape sequence), <a href="#5.2.2">5.2.2</a>,                  _Imaginary_I macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
-     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>                  _IOFBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>
-\U (universal character names), <a href="#6.4.3">6.4.3</a>                        _IOLBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.6">7.21.5.6</a>
-\u (universal character names), <a href="#6.4.3">6.4.3</a>                        _IONBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>
-\v (vertical-tab escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           _Noreturn, <a href="#6.7.4">6.7.4</a>
-     <a href="#7.4.1.10">7.4.1.10</a>                                                _Pragma operator, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>
-
-[<a name="p654" href="#p654">page 654</a>] (<a href="#Contents">Contents</a>)
-
-_Static_assert, <a href="#6.7.10">6.7.10</a>, <a href="#7.2">7.2</a>                                  allocated storage, order and contiguity, <a href="#7.22.3">7.22.3</a>
-_Thread_local storage-class specifier, <a href="#6.2.4">6.2.4</a>,                 and macro, <a href="#7.9">7.9</a>
-     <a href="#6.7.1">6.7.1</a>                                                   AND operators
-{ } (braces punctuator), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>,               bitwise (&amp;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
-     <a href="#6.8.2">6.8.2</a>                                                      bitwise assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>
-{ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                        logical (&amp;&amp;), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>
-| (bitwise inclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>           and_eq macro, <a href="#7.9">7.9</a>
-|= (bitwise inclusive OR assignment operator),               anonymous structure, <a href="#6.7.2.1">6.7.2.1</a>
-     <a href="#6.5.16.2">6.5.16.2</a>                                                anonymous union, <a href="#6.7.2.1">6.7.2.1</a>
-|| (logical OR operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>                    ANSI/IEEE 754, <a href="#F.1">F.1</a>
-~ (bitwise complement operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>            ANSI/IEEE 854, <a href="#F.1">F.1</a>
-                                                             argc (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
-abort function, <a href="#7.2.1.1">7.2.1.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>,                   argument, <a href="#3.3">3.3</a>
-      <a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.25.3.6">7.25.3.6</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a>                             array, <a href="#6.9.1">6.9.1</a>
-abort_handler_s function, <a href="#K.3.6.1.2">K.3.6.1.2</a>                             default promotions, <a href="#6.5.2.2">6.5.2.2</a>
-abs function, <a href="#7.22.6.1">7.22.6.1</a>                                          function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
-absolute-value functions                                        macro, substitution, <a href="#6.10.3.1">6.10.3.1</a>
-   complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                     argument, complex, <a href="#7.3.9.1">7.3.9.1</a>
-   integer, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.22.6.1">7.22.6.1</a>                                argv (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
-   real, <a href="#7.12.7">7.12.7</a>, <a href="#F.10.4">F.10.4</a>                                      arithmetic constant expression, <a href="#6.6">6.6</a>
-abstract declarator, <a href="#6.7.7">6.7.7</a>                                   arithmetic conversions, usual, see usual arithmetic
-abstract machine, <a href="#5.1.2.3">5.1.2.3</a>                                          conversions
-access, <a href="#3.1">3.1</a>, <a href="#6.7.3">6.7.3</a>, <a href="#L.2.1">L.2.1</a>                                    arithmetic operators
-accuracy, see floating-point accuracy                            additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>
-acos functions, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#F.10.1.1">F.10.1.1</a>                              bitwise, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>
-acos type-generic macro, <a href="#7.24">7.24</a>                                   increment and decrement, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>
-acosh functions, <a href="#7.12.5.1">7.12.5.1</a>, <a href="#F.10.2.1">F.10.2.1</a>                             multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
-acosh type-generic macro, <a href="#7.24">7.24</a>                                  shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
-acquire fence, <a href="#7.17.4">7.17.4</a>                                           unary, <a href="#6.5.3.3">6.5.3.3</a>
-acquire operation, <a href="#5.1.2.4">5.1.2.4</a>                                   arithmetic types, <a href="#6.2.5">6.2.5</a>
-active position, <a href="#5.2.2">5.2.2</a>                                       arithmetic, pointer, <a href="#6.5.6">6.5.6</a>
-actual argument, <a href="#3.3">3.3</a>                                         array
-actual parameter (deprecated), <a href="#3.3">3.3</a>                              argument, <a href="#6.9.1">6.9.1</a>
-addition assignment operator (+=), <a href="#6.5.16.2">6.5.16.2</a>                     declarator, <a href="#6.7.6.2">6.7.6.2</a>
-addition operator (+), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>,               initialization, <a href="#6.7.9">6.7.9</a>
-      <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                                         multidimensional, <a href="#6.5.2.1">6.5.2.1</a>
-additive expressions, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                              parameter, <a href="#6.9.1">6.9.1</a>
-address constant, <a href="#6.6">6.6</a>                                           storage order, <a href="#6.5.2.1">6.5.2.1</a>
-address operator (&amp;), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                          subscript operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
-address-free, <a href="#7.17.5">7.17.5</a>                                            subscripting, <a href="#6.5.2.1">6.5.2.1</a>
-aggregate initialization, <a href="#6.7.9">6.7.9</a>                                 type, <a href="#6.2.5">6.2.5</a>
-aggregate types, <a href="#6.2.5">6.2.5</a>                                          type conversion, <a href="#6.3.2.1">6.3.2.1</a>
-alert escape sequence (\a), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                      variable length, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>
-aliasing, <a href="#6.5">6.5</a>                                                arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
-alignas macro, <a href="#7.15">7.15</a>                                          as-if rule, <a href="#5.1.2.3">5.1.2.3</a>
-aligned_alloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.1">7.22.3.1</a>                     ASCII code set, <a href="#5.2.1.1">5.2.1.1</a>
-alignment, <a href="#3.2">3.2</a>, <a href="#6.2.8">6.2.8</a>, <a href="#7.22.3.1">7.22.3.1</a>                              asctime function, <a href="#7.26.3.1">7.26.3.1</a>
-   pointer, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.3">6.3.2.3</a>                                   asctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>
-   structure/union member, <a href="#6.7.2.1">6.7.2.1</a>                           asin functions, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#F.10.1.2">F.10.1.2</a>
-alignment specifier, <a href="#6.7.5">6.7.5</a>                                    asin type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
-alignof operator, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>                             asinh functions, <a href="#7.12.5.2">7.12.5.2</a>, <a href="#F.10.2.2">F.10.2.2</a>
-
-[<a name="p655" href="#p655">page 655</a>] (<a href="#Contents">Contents</a>)
-
-asinh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                           atomic_is_lock_free generic function,
-asm keyword, <a href="#J.5.10">J.5.10</a>                                               <a href="#7.17.5.1">7.17.5.1</a>
-assert macro, <a href="#7.2.1.1">7.2.1.1</a>                                         ATOMIC_LLONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
-assert.h header, <a href="#7.2">7.2</a>                                          atomic_load generic functions, <a href="#7.17.7.2">7.17.7.2</a>
-assignment                                                    ATOMIC_LONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
-   compound, <a href="#6.5.16.2">6.5.16.2</a>                                         ATOMIC_SHORT_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
-   conversion, <a href="#6.5.16.1">6.5.16.1</a>                                       atomic_signal_fence function, <a href="#7.17.4.2">7.17.4.2</a>
-   expression, <a href="#6.5.16">6.5.16</a>                                         atomic_store generic functions, <a href="#7.17.7.1">7.17.7.1</a>
-   operators, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>                                 atomic_thread_fence function, <a href="#7.17.4.1">7.17.4.1</a>
-   simple, <a href="#6.5.16.1">6.5.16.1</a>                                           ATOMIC_VAR_INIT macro, <a href="#7.17.2.1">7.17.2.1</a>
-associativity of operators, <a href="#6.5">6.5</a>                               ATOMIC_WCHAR_T_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
-asterisk punctuator (*), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a>                     atomics header, <a href="#7.17">7.17</a>
-at_quick_exit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>,                   auto storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
-     <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>                             automatic storage duration, <a href="#5.2.3">5.2.3</a>, <a href="#6.2.4">6.2.4</a>
-atan functions, <a href="#7.12.4.3">7.12.4.3</a>, <a href="#F.10.1.3">F.10.1.3</a>
-atan type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                            backslash character (\), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
-atan2 functions, <a href="#7.12.4.4">7.12.4.4</a>, <a href="#F.10.1.4">F.10.1.4</a>                           backslash escape sequence (\\), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>
-atan2 type-generic macro, <a href="#7.24">7.24</a>                                backspace escape sequence (\b), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
-atanh functions, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#F.10.2.3">F.10.2.3</a>                           basic character set, <a href="#3.6">3.6</a>, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>
-atanh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                           basic types, <a href="#6.2.5">6.2.5</a>
-atexit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>,                behavior, <a href="#3.4">3.4</a>
-     <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>, <a href="#J.5.13">J.5.13</a>                               binary streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
-atof function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.1">7.22.1.1</a>                                     <a href="#7.21.9.4">7.21.9.4</a>
-atoi function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                               bit, <a href="#3.5">3.5</a>
-atol function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                                  high order, <a href="#3.6">3.6</a>
-atoll function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                                 low order, <a href="#3.6">3.6</a>
-atomic lock-free macros, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.5">7.17.5</a>                       bit-field, <a href="#6.7.2.1">6.7.2.1</a>
-atomic operations, <a href="#5.1.2.4">5.1.2.4</a>                                    bitand macro, <a href="#7.9">7.9</a>
-atomic types, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>,               bitor macro, <a href="#7.9">7.9</a>
-     <a href="#6.5.2.3">6.5.2.3</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>,           bitwise operators, <a href="#6.5">6.5</a>
-     <a href="#7.17.6">7.17.6</a>                                                      AND, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
-atomic_address type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.6">7.17.6</a>                              AND assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>
-ATOMIC_ADDRESS_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                           complement (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>
-atomic_bool type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.6">7.17.6</a>                                 exclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
-ATOMIC_CHAR16_T_LOCK_FREE macro,                                 exclusive OR assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
-     <a href="#7.17.1">7.17.1</a>                                                      inclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
-ATOMIC_CHAR32_T_LOCK_FREE macro,                                 inclusive OR assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
-     <a href="#7.17.1">7.17.1</a>                                                      shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
-ATOMIC_CHAR_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                           blank character, <a href="#7.4.1.3">7.4.1.3</a>
-atomic_compare_exchange generic                               block, <a href="#6.8">6.8</a>, <a href="#6.8.2">6.8.2</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
-     functions, <a href="#7.17.7.4">7.17.7.4</a>                                      block scope, <a href="#6.2.1">6.2.1</a>
-atomic_exchange generic functions, <a href="#7.17.7.3">7.17.7.3</a>                   block structure, <a href="#6.2.1">6.2.1</a>
-atomic_fetch and modify generic functions,                    bold type convention, <a href="#6.1">6.1</a>
-     <a href="#7.17.7.5">7.17.7.5</a>                                                 bool macro, <a href="#7.18">7.18</a>
-atomic_flag type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>                              boolean type, <a href="#6.3.1.2">6.3.1.2</a>
-atomic_flag_clear functions, <a href="#7.17.8.2">7.17.8.2</a>                         boolean type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>
-ATOMIC_FLAG_INIT macro, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>                        bounded undefined behavior, <a href="#L.2.2">L.2.2</a>
-atomic_flag_test_and_set functions,                           braces punctuator ({ }), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>,
-     <a href="#7.17.8.1">7.17.8.1</a>                                                       <a href="#6.8.2">6.8.2</a>
-atomic_init generic function, <a href="#7.17.2.2">7.17.2.2</a>                        brackets operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
-ATOMIC_INT_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                            brackets punctuator ([ ]), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>
-
-[<a name="p656" href="#p656">page 656</a>] (<a href="#Contents">Contents</a>)
-
-branch cuts, <a href="#7.3.3">7.3.3</a>                                                type-generic macro for, <a href="#7.24">7.24</a>
-break statement, <a href="#6.8.6.3">6.8.6.3</a>                                       ccosh functions, <a href="#7.3.6.4">7.3.6.4</a>, <a href="#G.6.2.4">G.6.2.4</a>
-broken-down time, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.3">7.26.3</a>,                       type-generic macro for, <a href="#7.24">7.24</a>
-     <a href="#7.26.3.1">7.26.3.1</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#7.26.3.5">7.26.3.5</a>,                   ceil functions, <a href="#7.12.9.1">7.12.9.1</a>, <a href="#F.10.6.1">F.10.6.1</a>
-     <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                           ceil type-generic macro, <a href="#7.24">7.24</a>
-bsearch function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a>                             cerf function, <a href="#7.30.1">7.30.1</a>
-bsearch_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>                         cerfc function, <a href="#7.30.1">7.30.1</a>
-btowc function, <a href="#7.28.6.1.1">7.28.6.1.1</a>                                     cexp functions, <a href="#7.3.7.1">7.3.7.1</a>, <a href="#G.6.3.1">G.6.3.1</a>
-BUFSIZ macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.5">7.21.5.5</a>                            type-generic macro for, <a href="#7.24">7.24</a>
-byte, <a href="#3.6">3.6</a>, <a href="#6.5.3.4">6.5.3.4</a>                                             cexp2 function, <a href="#7.30.1">7.30.1</a>
-byte input/output functions, <a href="#7.21.1">7.21.1</a>                            cexpm1 function, <a href="#7.30.1">7.30.1</a>
-byte-oriented stream, <a href="#7.21.2">7.21.2</a>                                   char type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
-                                                                     <a href="#K.3.9.1.2">K.3.9.1.2</a>
-C program, <a href="#5.1.1.1">5.1.1.1</a>                                             char type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
-c16rtomb function, <a href="#7.27.1.2">7.27.1.2</a>                                          <a href="#6.3.1.8">6.3.1.8</a>
-c32rtomb function, <a href="#7.27.1.4">7.27.1.4</a>                                    char16_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.27">7.27</a>
-cabs functions, <a href="#7.3.8.1">7.3.8.1</a>, <a href="#G.6">G.6</a>                                   char32_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.27">7.27</a>
-  type-generic macro for, <a href="#7.24">7.24</a>                                 CHAR_BIT macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
-cacos functions, <a href="#7.3.5.1">7.3.5.1</a>, <a href="#G.6.1.1">G.6.1.1</a>                              CHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-  type-generic macro for, <a href="#7.24">7.24</a>                                 CHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-cacosh functions, <a href="#7.3.6.1">7.3.6.1</a>, <a href="#G.6.2.1">G.6.2.1</a>                             character, <a href="#3.7">3.7</a>, <a href="#3.7.1">3.7.1</a>
-  type-generic macro for, <a href="#7.24">7.24</a>                                 character array initialization, <a href="#6.7.9">6.7.9</a>
-calendar time, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.2">7.26.2.2</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.2.4">7.26.2.4</a>,           character case mapping functions, <a href="#7.4.2">7.4.2</a>
-      <a href="#7.26.3.2">7.26.3.2</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>,                    wide character, <a href="#7.29.3.1">7.29.3.1</a>
-      <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                           extensible, <a href="#7.29.3.2">7.29.3.2</a>
-call by value, <a href="#6.5.2.2">6.5.2.2</a>                                         character classification functions, <a href="#7.4.1">7.4.1</a>
-call_once function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.1">7.25.2.1</a>                              wide character, <a href="#7.29.2.1">7.29.2.1</a>
-calloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.2">7.22.3.2</a>                                    extensible, <a href="#7.29.2.2">7.29.2.2</a>
-carg functions, <a href="#7.3.9.1">7.3.9.1</a>, <a href="#G.6">G.6</a>                                   character constant, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
-carg type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                             character display semantics, <a href="#5.2.2">5.2.2</a>
-carriage-return escape sequence (\r), <a href="#5.2.2">5.2.2</a>,                   character handling header, <a href="#7.4">7.4</a>, <a href="#7.11.1.1">7.11.1.1</a>
-      <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                        character input/output functions, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a>
-carries a dependency, <a href="#5.1.2.4">5.1.2.4</a>                                     wide character, <a href="#7.28.3">7.28.3</a>
-case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                                     character sets, <a href="#5.2.1">5.2.1</a>
-case mapping functions                                         character string literal, see string literal
-  character, <a href="#7.4.2">7.4.2</a>                                             character type conversion, <a href="#6.3.1.1">6.3.1.1</a>
-  wide character, <a href="#7.29.3.1">7.29.3.1</a>                                     character types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.9">6.7.9</a>
-      extensible, <a href="#7.29.3.2">7.29.3.2</a>                                     cimag functions, <a href="#7.3.9.2">7.3.9.2</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>
-casin functions, <a href="#7.3.5.2">7.3.5.2</a>, <a href="#G.6">G.6</a>                                  cimag type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
-  type-generic macro for, <a href="#7.24">7.24</a>                                 cis function, <a href="#G.6">G.6</a>
-casinh functions, <a href="#7.3.6.2">7.3.6.2</a>, <a href="#G.6.2.2">G.6.2.2</a>                             classification functions
-  type-generic macro for, <a href="#7.24">7.24</a>                                    character, <a href="#7.4.1">7.4.1</a>
-cast expression, <a href="#6.5.4">6.5.4</a>                                            floating-point, <a href="#7.12.3">7.12.3</a>
-cast operator (( )), <a href="#6.5.4">6.5.4</a>                                        wide character, <a href="#7.29.2.1">7.29.2.1</a>
-catan functions, <a href="#7.3.5.3">7.3.5.3</a>, <a href="#G.6">G.6</a>                                        extensible, <a href="#7.29.2.2">7.29.2.2</a>
-  type-generic macro for, <a href="#7.24">7.24</a>                                 clearerr function, <a href="#7.21.10.1">7.21.10.1</a>
-catanh functions, <a href="#7.3.6.3">7.3.6.3</a>, <a href="#G.6.2.3">G.6.2.3</a>                             clgamma function, <a href="#7.30.1">7.30.1</a>
-  type-generic macro for, <a href="#7.24">7.24</a>                                 clock function, <a href="#7.26.2.1">7.26.2.1</a>
-cbrt functions, <a href="#7.12.7.1">7.12.7.1</a>, <a href="#F.10.4.1">F.10.4.1</a>                             clock_t type, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.1">7.26.2.1</a>
-cbrt type-generic macro, <a href="#7.24">7.24</a>                                  CLOCKS_PER_SEC macro, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.1">7.26.2.1</a>
-ccos functions, <a href="#7.3.5.4">7.3.5.4</a>, <a href="#G.6">G.6</a>                                   clog functions, <a href="#7.3.7.2">7.3.7.2</a>, <a href="#G.6.3.2">G.6.3.2</a>
-
-[<a name="p657" href="#p657">page 657</a>] (<a href="#Contents">Contents</a>)
-
-  type-generic macro for, <a href="#7.24">7.24</a>                                  string, <a href="#7.23.3">7.23.3</a>, <a href="#K.3.7.2">K.3.7.2</a>
-clog10 function, <a href="#7.30.1">7.30.1</a>                                         wide string, <a href="#7.28.4.3">7.28.4.3</a>, <a href="#K.3.9.2.2">K.3.9.2.2</a>
-clog1p function, <a href="#7.30.1">7.30.1</a>                                       concatenation, preprocessing, see preprocessing
-clog2 function, <a href="#7.30.1">7.30.1</a>                                             concatenation
-CMPLX macros, <a href="#7.3.9.3">7.3.9.3</a>                                         conceptual models, <a href="#5.1">5.1</a>
-cnd_broadcast function, <a href="#7.25.3.1">7.25.3.1</a>, <a href="#7.25.3.5">7.25.3.5</a>,                   conditional features, <a href="#4">4</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>,
-     <a href="#7.25.3.6">7.25.3.6</a>                                                      <a href="#7.1.2">7.1.2</a>, <a href="#F.1">F.1</a>, <a href="#G.1">G.1</a>, <a href="#K.2">K.2</a>, <a href="#L.1">L.1</a>
-cnd_destroy function, <a href="#7.25.3.2">7.25.3.2</a>                                conditional inclusion, <a href="#6.10.1">6.10.1</a>
-cnd_init function, <a href="#7.25.3.3">7.25.3.3</a>                                   conditional operator (? :), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a>
-cnd_signal function, <a href="#7.25.3.4">7.25.3.4</a>, <a href="#7.25.3.5">7.25.3.5</a>,                      conflict, <a href="#5.1.2.4">5.1.2.4</a>
-     <a href="#7.25.3.6">7.25.3.6</a>                                                 conformance, <a href="#4">4</a>
-cnd_t type, <a href="#7.25.1">7.25.1</a>                                            conj functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>
-cnd_timedwait function, <a href="#7.25.3.5">7.25.3.5</a>                              conj type-generic macro, <a href="#7.24">7.24</a>
-cnd_wait function, <a href="#7.25.3.3">7.25.3.3</a>, <a href="#7.25.3.6">7.25.3.6</a>                         const type qualifier, <a href="#6.7.3">6.7.3</a>
-collating sequences, <a href="#5.2.1">5.2.1</a>                                    const-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.7.3">6.7.3</a>
-colon punctuator (:), <a href="#6.7.2.1">6.7.2.1</a>                                 constant expression, <a href="#6.6">6.6</a>, <a href="#F.8.4">F.8.4</a>
-comma operator (,), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a>                           constants, <a href="#6.4.4">6.4.4</a>
-comma punctuator (,), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,             as primary expression, <a href="#6.5.1">6.5.1</a>
-     <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>                                             character, <a href="#6.4.4.4">6.4.4.4</a>
-command processor, <a href="#7.22.4.8">7.22.4.8</a>                                     enumeration, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
-comment delimiters (/* */ and //), <a href="#6.4.9">6.4.9</a>                        floating, <a href="#6.4.4.2">6.4.4.2</a>
-comments, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.4.9">6.4.9</a>                                   hexadecimal, <a href="#6.4.4.1">6.4.4.1</a>
-common extensions, <a href="#J.5">J.5</a>                                          integer, <a href="#6.4.4.1">6.4.4.1</a>
-common initial sequence, <a href="#6.5.2.3">6.5.2.3</a>                                octal, <a href="#6.4.4.1">6.4.4.1</a>
-common real type, <a href="#6.3.1.8">6.3.1.8</a>                                     constraint, <a href="#3.8">3.8</a>, <a href="#4">4</a>
-common warnings, <a href="#I">I</a>                                            constraint_handler_t type, <a href="#K.3.6">K.3.6</a>
-comparison functions, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a>, <a href="#7.22.5.2">7.22.5.2</a>,             consume operation, <a href="#5.1.2.4">5.1.2.4</a>
-     <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>                            content of structure/union/enumeration, <a href="#6.7.2.3">6.7.2.3</a>
-  string, <a href="#7.23.4">7.23.4</a>                                              contiguity of allocated storage, <a href="#7.22.3">7.22.3</a>
-  wide string, <a href="#7.28.4.4">7.28.4.4</a>                                       continue statement, <a href="#6.8.6.2">6.8.6.2</a>
-comparison macros, <a href="#7.12.14">7.12.14</a>                                    contracted expression, <a href="#6.5">6.5</a>, <a href="#7.12.2">7.12.2</a>, <a href="#F.7">F.7</a>
-comparison, pointer, <a href="#6.5.8">6.5.8</a>                                    control character, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
-compatible type, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a>                   control wide character, <a href="#7.29.2">7.29.2</a>
-compl macro, <a href="#7.9">7.9</a>                                              conversion, <a href="#6.3">6.3</a>
-complement operator (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>                       arithmetic operands, <a href="#6.3.1">6.3.1</a>
-complete type, <a href="#6.2.5">6.2.5</a>                                            array argument, <a href="#6.9.1">6.9.1</a>
-complex macro, <a href="#7.3.1">7.3.1</a>                                            array parameter, <a href="#6.9.1">6.9.1</a>
-complex numbers, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>                                       arrays, <a href="#6.3.2.1">6.3.2.1</a>
-complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>                       boolean, <a href="#6.3.1.2">6.3.1.2</a>
-complex type domain, <a href="#6.2.5">6.2.5</a>                                      boolean, characters, and integers, <a href="#6.3.1.1">6.3.1.1</a>
-complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G">G</a>                        by assignment, <a href="#6.5.16.1">6.5.16.1</a>
-complex.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,                   by return statement, <a href="#6.8.6.4">6.8.6.4</a>
-     <a href="#7.3">7.3</a>, <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>                             complex types, <a href="#6.3.1.6">6.3.1.6</a>
-compliance, see conformance                                     explicit, <a href="#6.3">6.3</a>
-components of time, <a href="#7.26.1">7.26.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                             function, <a href="#6.3.2.1">6.3.2.1</a>
-composite type, <a href="#6.2.7">6.2.7</a>                                           function argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
-compound assignment, <a href="#6.5.16.2">6.5.16.2</a>                                   function designators, <a href="#6.3.2.1">6.3.2.1</a>
-compound literals, <a href="#6.5.2.5">6.5.2.5</a>                                      function parameter, <a href="#6.9.1">6.9.1</a>
-compound statement, <a href="#6.8.2">6.8.2</a>                                       imaginary, <a href="#G.4.1">G.4.1</a>
-compound-literal operator (( ){ }), <a href="#6.5.2.5">6.5.2.5</a>                     imaginary and complex, <a href="#G.4.3">G.4.3</a>
-concatenation functions                                         implicit, <a href="#6.3">6.3</a>
-
-[<a name="p658" href="#p658">page 658</a>] (<a href="#Contents">Contents</a>)
-
-   lvalues, <a href="#6.3.2.1">6.3.2.1</a>                                             csinh functions, <a href="#7.3.6.5">7.3.6.5</a>, <a href="#G.6.2.5">G.6.2.5</a>
-   pointer, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                                      type-generic macro for, <a href="#7.24">7.24</a>
-   real and complex, <a href="#6.3.1.7">6.3.1.7</a>                                    csqrt functions, <a href="#7.3.8.3">7.3.8.3</a>, <a href="#G.6.4.2">G.6.4.2</a>
-   real and imaginary, <a href="#G.4.2">G.4.2</a>                                      type-generic macro for, <a href="#7.24">7.24</a>
-   real floating and integer, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                  ctan functions, <a href="#7.3.5.6">7.3.5.6</a>, <a href="#G.6">G.6</a>
-   real floating types, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#F.3">F.3</a>                               type-generic macro for, <a href="#7.24">7.24</a>
-   signed and unsigned integers, <a href="#6.3.1.3">6.3.1.3</a>                        ctanh functions, <a href="#7.3.6.6">7.3.6.6</a>, <a href="#G.6.2.6">G.6.2.6</a>
-   usual arithmetic, see usual arithmetic                         type-generic macro for, <a href="#7.24">7.24</a>
-         conversions                                            ctgamma function, <a href="#7.30.1">7.30.1</a>
-   void type, <a href="#6.3.2.2">6.3.2.2</a>                                           ctime function, <a href="#7.26.3.2">7.26.3.2</a>
-conversion functions                                            ctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>
-   multibyte/wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>                    ctype.h header, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>
-      extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>                                 current object, <a href="#6.7.9">6.7.9</a>
-      restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>                  CX_LIMITED_RANGE pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.3.4">7.3.4</a>
-   multibyte/wide string, <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
-      restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                          data race, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.4.6">7.22.4.6</a>,
-   numeric, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                                          <a href="#7.23.5.8">7.23.5.8</a>, <a href="#7.23.6.2">7.23.6.2</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>,
-      wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1">7.28.4.1</a>                                 <a href="#7.28.6.4">7.28.6.4</a>
-   single byte/wide character, <a href="#7.28.6.1">7.28.6.1</a>                         data stream, see streams
-   time, <a href="#7.26.3">7.26.3</a>, <a href="#K.3.8.2">K.3.8.2</a>                                        date and time header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>
-      wide character, <a href="#7.28.5">7.28.5</a>                                    Daylight Saving Time, <a href="#7.26.1">7.26.1</a>
-conversion specifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>,              DBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.28.2.2">7.28.2.2</a>                                                  DBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-conversion state, <a href="#7.22.7">7.22.7</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.1.1">7.27.1.1</a>,                     DBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.6">7.28.6</a>,                     DBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.28.6.2.1">7.28.6.2.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>,             DBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.28.6.4">7.28.6.4</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.6.4">K.3.6.4</a>,                DBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>,           DBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>                                               DBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-conversion state functions, <a href="#7.28.6.2">7.28.6.2</a>                            DBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-copying functions                                               DBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-   string, <a href="#7.23.2">7.23.2</a>, <a href="#K.3.7.1">K.3.7.1</a>                                      DBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-   wide string, <a href="#7.28.4.2">7.28.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a>                             DBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-copysign functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12.11.1">7.12.11.1</a>, <a href="#F.3">F.3</a>,                    decimal constant, <a href="#6.4.4.1">6.4.4.1</a>
-      <a href="#F.10.8.1">F.10.8.1</a>                                                  decimal digit, <a href="#5.2.1">5.2.1</a>
-copysign type-generic macro, <a href="#7.24">7.24</a>                               decimal-point character, <a href="#7.1.1">7.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-correctly rounded result, <a href="#3.9">3.9</a>                                   DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
-corresponding real type, <a href="#6.2.5">6.2.5</a>                                       <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.5">F.5</a>
-cos functions, <a href="#7.12.4.5">7.12.4.5</a>, <a href="#F.10.1.5">F.10.1.5</a>                               declaration specifiers, <a href="#6.7">6.7</a>
-cos type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                               declarations, <a href="#6.7">6.7</a>
-cosh functions, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#F.10.2.4">F.10.2.4</a>                                function, <a href="#6.7.6.3">6.7.6.3</a>
-cosh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                pointer, <a href="#6.7.6.1">6.7.6.1</a>
-cpow functions, <a href="#7.3.8.2">7.3.8.2</a>, <a href="#G.6.4.1">G.6.4.1</a>                                  structure/union, <a href="#6.7.2.1">6.7.2.1</a>
-   type-generic macro for, <a href="#7.24">7.24</a>                                   typedef, <a href="#6.7.8">6.7.8</a>
-cproj functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                   declarator, <a href="#6.7.6">6.7.6</a>
-cproj type-generic macro, <a href="#7.24">7.24</a>                                    abstract, <a href="#6.7.7">6.7.7</a>
-creal functions, <a href="#7.3.9.6">7.3.9.6</a>, <a href="#G.6">G.6</a>                                   declarator type derivation, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6">6.7.6</a>
-creal type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                             decrement operators, see arithmetic operators,
-critical undefined behavior, <a href="#L.2.3">L.2.3</a>                                    increment and decrement
-csin functions, <a href="#7.3.5.5">7.3.5.5</a>, <a href="#G.6">G.6</a>                                    default argument promotions, <a href="#6.5.2.2">6.5.2.2</a>
-   type-generic macro for, <a href="#7.24">7.24</a>                                 default initialization, <a href="#6.7.9">6.7.9</a>
-
-[<a name="p659" href="#p659">page 659</a>] (<a href="#Contents">Contents</a>)
-
-default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                                  elif preprocessing directive, <a href="#6.10.1">6.10.1</a>
-define preprocessing directive, <a href="#6.10.3">6.10.3</a>                         ellipsis punctuator (...), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
-defined operator, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.8">6.10.8</a>                               else preprocessing directive, <a href="#6.10.1">6.10.1</a>
-definition, <a href="#6.7">6.7</a>                                                 else statement, <a href="#6.8.4.1">6.8.4.1</a>
-   function, <a href="#6.9.1">6.9.1</a>                                             empty statement, <a href="#6.8.3">6.8.3</a>
-dependency-ordered before, <a href="#5.1.2.4">5.1.2.4</a>                             encoding error, <a href="#7.21.3">7.21.3</a>, <a href="#7.27.1.1">7.27.1.1</a>, <a href="#7.27.1.2">7.27.1.2</a>,
-derived declarator types, <a href="#6.2.5">6.2.5</a>                                      <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>,
-derived types, <a href="#6.2.5">6.2.5</a>                                                 <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>,
-designated initializer, <a href="#6.7.9">6.7.9</a>                                        <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>,
-destringizing, <a href="#6.10.9">6.10.9</a>                                                <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
-device input/output, <a href="#5.1.2.3">5.1.2.3</a>                                   end-of-file, <a href="#7.28.1">7.28.1</a>
-diagnostic message, <a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>                              end-of-file indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,
-diagnostics, <a href="#5.1.1.3">5.1.1.3</a>                                                 <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
-diagnostics header, <a href="#7.2">7.2</a>                                              <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.2">7.21.10.2</a>, <a href="#7.28.3.1">7.28.3.1</a>,
-difftime function, <a href="#7.26.2.2">7.26.2.2</a>                                          <a href="#7.28.3.10">7.28.3.10</a>
-digit, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                              end-of-file macro, see EOF macro
-digraphs, <a href="#6.4.6">6.4.6</a>                                                end-of-line indicator, <a href="#5.2.1">5.2.1</a>
-direct input/output functions, <a href="#7.21.8">7.21.8</a>                          endif preprocessing directive, <a href="#6.10.1">6.10.1</a>
-display device, <a href="#5.2.2">5.2.2</a>                                          enum type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.2">6.7.2.2</a>
-div function, <a href="#7.22.6.2">7.22.6.2</a>                                         enumerated type, <a href="#6.2.5">6.2.5</a>
-div_t type, <a href="#7.22">7.22</a>                                               enumeration, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.2">6.7.2.2</a>
-division assignment operator (/=), <a href="#6.5.16.2">6.5.16.2</a>                    enumeration constant, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
-division operator (/), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>              enumeration content, <a href="#6.7.2.3">6.7.2.3</a>
-do statement, <a href="#6.8.5.2">6.8.5.2</a>                                          enumeration members, <a href="#6.7.2.2">6.7.2.2</a>
-documentation of implementation, <a href="#4">4</a>                             enumeration specifiers, <a href="#6.7.2.2">6.7.2.2</a>
-domain error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#7.12.4.4">7.12.4.4</a>,            enumeration tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
-      <a href="#7.12.5.1">7.12.5.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.7">7.12.6.7</a>,                  enumerator, <a href="#6.7.2.2">6.7.2.2</a>
-      <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>,                environment, <a href="#5">5</a>
-      <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>,                  environment functions, <a href="#7.22.4">7.22.4</a>, <a href="#K.3.6.2">K.3.6.2</a>
-      <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>                environment list, <a href="#7.22.4.6">7.22.4.6</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>
-dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                      environmental considerations, <a href="#5.2">5.2</a>
-double _Complex type, <a href="#6.2.5">6.2.5</a>                                    environmental limits, <a href="#5.2.4">5.2.4</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.21.2">7.21.2</a>,
-double _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                            <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.4.2">7.22.4.2</a>,
-      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                               <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
-double _Imaginary type, <a href="#G.2">G.2</a>                                    EOF macro, <a href="#7.4">7.4</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.2">7.21.5.2</a>,
-double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.2">7.21.6.2</a>,                        <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.11">7.21.6.11</a>,
-      <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.2">F.2</a>                                                  <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.4">7.21.7.4</a>,
-double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,                   <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>,
-      <a href="#6.3.1.8">6.3.1.8</a>                                                        <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.2.4">7.28.2.4</a>,
-double-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                                 <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.2.12">7.28.2.12</a>,
-double-quote escape sequence (\"), <a href="#6.4.4.4">6.4.4.4</a>,                          <a href="#7.28.3.4">7.28.3.4</a>, <a href="#7.28.6.1.1">7.28.6.1.1</a>, <a href="#7.28.6.1.2">7.28.6.1.2</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>,
-      <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                                  <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>,
-double_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                           <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>,
-                                                                     <a href="#K.3.9.1.14">K.3.9.1.14</a>
-EDOM macro, <a href="#7.5">7.5</a>, <a href="#7.12.1">7.12.1</a>, see also domain error                 equal-sign punctuator (=), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a>
-effective type, <a href="#6.5">6.5</a>                                            equal-to operator, see equality operator
-EILSEQ macro, <a href="#7.5">7.5</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.27.1.1">7.27.1.1</a>, <a href="#7.27.1.2">7.27.1.2</a>,                 equality expressions, <a href="#6.5.9">6.5.9</a>
-     <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>,                   equality operator (==), <a href="#6.5.9">6.5.9</a>
-     <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>,           ERANGE macro, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.12.1">7.12.1</a>,
-     see also encoding error                                         <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, see
-element type, <a href="#6.2.5">6.2.5</a>                                                  also range error, pole error
-
-[<a name="p660" href="#p660">page 660</a>] (<a href="#Contents">Contents</a>)
-
-erf functions, <a href="#7.12.8.1">7.12.8.1</a>, <a href="#F.10.5.1">F.10.5.1</a>                               exp2 functions, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#F.10.3.2">F.10.3.2</a>
-erf type-generic macro, <a href="#7.24">7.24</a>                                    exp2 type-generic macro, <a href="#7.24">7.24</a>
-erfc functions, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#F.10.5.2">F.10.5.2</a>                              explicit conversion, <a href="#6.3">6.3</a>
-erfc type-generic macro, <a href="#7.24">7.24</a>                                   expm1 functions, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#F.10.3.3">F.10.3.3</a>
-errno macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.3.2">7.3.2</a>, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>,               expm1 type-generic macro, <a href="#7.24">7.24</a>
-      <a href="#7.12.1">7.12.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.4">7.21.10.4</a>,            exponent part, <a href="#6.4.4.2">6.4.4.2</a>
-      <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.23.6.2">7.23.6.2</a>, <a href="#7.27.1.1">7.27.1.1</a>,           exponential functions
-      <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>,                     complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
-      <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>,               real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>
-      <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#J.5.17">J.5.17</a>,               expression, <a href="#6.5">6.5</a>
-      <a href="#K.3.1.3">K.3.1.3</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a>                                          assignment, <a href="#6.5.16">6.5.16</a>
-errno.h header, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>                                cast, <a href="#6.5.4">6.5.4</a>
-errno_t type, <a href="#K.3.2">K.3.2</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>,                     constant, <a href="#6.6">6.6</a>
-      <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>                                         evaluation, <a href="#5.1.2.3">5.1.2.3</a>
-error                                                             full, <a href="#6.8">6.8</a>
-   domain, see domain error                                       order of evaluation, see order of evaluation
-   encoding, see encoding error                                   parenthesized, <a href="#6.5.1">6.5.1</a>
-   pole, see pole error                                           primary, <a href="#6.5.1">6.5.1</a>
-   range, see range error                                         unary, <a href="#6.5.3">6.5.3</a>
-error conditions, <a href="#7.12.1">7.12.1</a>                                        expression statement, <a href="#6.8.3">6.8.3</a>
-error functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a>                                 extended alignment, <a href="#6.2.8">6.2.8</a>
-error indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,                    extended character set, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.1.2">5.2.1.2</a>
-      <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.7">7.21.7.7</a>,                   extended characters, <a href="#5.2.1">5.2.1</a>
-      <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.3">7.21.10.3</a>,                 extended integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>,
-      <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>                                             <a href="#7.20">7.20</a>
-error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                        extended multibyte/wide character conversion
-error-handling functions, <a href="#7.21.10">7.21.10</a>, <a href="#7.23.6.2">7.23.6.2</a>,                         utilities, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
-      <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a>                                      extensible wide character case mapping functions,
-escape character (\), <a href="#6.4.4.4">6.4.4.4</a>                                        <a href="#7.29.3.2">7.29.3.2</a>
-escape sequences, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.11.4">6.11.4</a>                 extensible wide character classification functions,
-evaluation format, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#7.12">7.12</a>                          <a href="#7.29.2.2">7.29.2.2</a>
-evaluation method, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#F.8.5">F.8.5</a>                        extern storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.7.1">6.7.1</a>
-evaluation of expression, <a href="#5.1.2.3">5.1.2.3</a>                               external definition, <a href="#6.9">6.9</a>
-evaluation order, see order of evaluation                       external identifiers, underscore, <a href="#7.1.3">7.1.3</a>
-exceptional condition, <a href="#6.5">6.5</a>                                      external linkage, <a href="#6.2.2">6.2.2</a>
-excess precision, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                   external name, <a href="#6.4.2.1">6.4.2.1</a>
-excess range, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                       external object definitions, <a href="#6.9.2">6.9.2</a>
-exclusive OR operators
-   bitwise (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>                                 fabs functions, <a href="#7.12.7.2">7.12.7.2</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.2">F.10.4.2</a>
-   bitwise assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                            fabs type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
-executable program, <a href="#5.1.1.1">5.1.1.1</a>                                     false macro, <a href="#7.18">7.18</a>
-execution character set, <a href="#5.2.1">5.2.1</a>                                  fclose function, <a href="#7.21.5.1">7.21.5.1</a>
-execution environment, <a href="#5">5</a>, <a href="#5.1.2">5.1.2</a>, see also                       fdim functions, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#F.10.9.1">F.10.9.1</a>
-      environmental limits                                      fdim type-generic macro, <a href="#7.24">7.24</a>
-execution sequence, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.8">6.8</a>                                FE_ALL_EXCEPT macro, <a href="#7.6">7.6</a>
-exit function, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>,               FE_DFL_ENV macro, <a href="#7.6">7.6</a>
-      <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>                                        FE_DIVBYZERO macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-EXIT_FAILURE macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>                              FE_DOWNWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-EXIT_SUCCESS macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>                              FE_INEXACT macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-exp functions, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#F.10.3.1">F.10.3.1</a>                               FE_INVALID macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-exp type-generic macro, <a href="#7.24">7.24</a>                                    FE_OVERFLOW macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
-
-[<a name="p661" href="#p661">page 661</a>] (<a href="#Contents">Contents</a>)
-
-FE_TONEAREST macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                 float _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,
-FE_TOWARDZERO macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                     <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
-FE_UNDERFLOW macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                 float _Imaginary type, <a href="#G.2">G.2</a>
-FE_UPWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                    float type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.2">F.2</a>
-feclearexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.1">7.6.2.1</a>, <a href="#F.3">F.3</a>                  float type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
-fegetenv function, <a href="#7.6.4.1">7.6.4.1</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                 <a href="#6.3.1.8">6.3.1.8</a>
-fegetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.2">7.6.2.2</a>, <a href="#F.3">F.3</a>                float.h header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
-fegetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.1">7.6.3.1</a>, <a href="#F.3">F.3</a>                            <a href="#7.28.4.1.1">7.28.4.1.1</a>
-feholdexcept function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.3">7.6.4.3</a>,                     float_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>
-     <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                                            floating constant, <a href="#6.4.4.2">6.4.4.2</a>
-fence, <a href="#5.1.2.4">5.1.2.4</a>                                               floating suffix, f or <a href="#F">F</a>, <a href="#6.4.4.2">6.4.4.2</a>
-fences, <a href="#7.17.4">7.17.4</a>                                               floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
-fenv.h header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>                <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
-FENV_ACCESS pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#F.8">F.8</a>, <a href="#F.9">F.9</a>,                 floating types, <a href="#6.2.5">6.2.5</a>, <a href="#6.11.1">6.11.1</a>
-     <a href="#F.10">F.10</a>                                                    floating-point accuracy, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.5">6.5</a>,
-fenv_t type, <a href="#7.6">7.6</a>                                                  <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.5">F.5</a>, see also contracted expression
-feof function, <a href="#7.21.10.2">7.21.10.2</a>                                     floating-point arithmetic functions, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>
-feraiseexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.3">7.6.2.3</a>, <a href="#F.3">F.3</a>                  floating-point classification functions, <a href="#7.12.3">7.12.3</a>
-ferror function, <a href="#7.21.10.3">7.21.10.3</a>                                   floating-point control mode, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
-fesetenv function, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#F.3">F.3</a>                              floating-point environment, <a href="#7.6">7.6</a>, <a href="#F.8">F.8</a>, <a href="#F.8.6">F.8.6</a>
-fesetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.4">7.6.2.4</a>, <a href="#F.3">F.3</a>                floating-point exception, <a href="#7.6">7.6</a>, <a href="#7.6.2">7.6.2</a>, <a href="#F.10">F.10</a>
-fesetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.2">7.6.3.2</a>, <a href="#F.3">F.3</a>                       floating-point number, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.2.5">6.2.5</a>
-fetestexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.5">7.6.2.5</a>, <a href="#F.3">F.3</a>                   floating-point rounding mode, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-feupdateenv function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                  floating-point status flag, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
-fexcept_t type, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                     floor functions, <a href="#7.12.9.2">7.12.9.2</a>, <a href="#F.10.6.2">F.10.6.2</a>
-fflush function, <a href="#7.21.5.2">7.21.5.2</a>, <a href="#7.21.5.3">7.21.5.3</a>                          floor type-generic macro, <a href="#7.24">7.24</a>
-fgetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,                    FLT_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-     <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.8.1">7.21.8.1</a>                                      FLT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-fgetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>                 FLT_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-fgets function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.2">7.21.7.2</a>, <a href="#K.3.5.4.1">K.3.5.4.1</a>                  FLT_EVAL_METHOD macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.6">6.6</a>, <a href="#7.12">7.12</a>,
-fgetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.28.3.1">7.28.3.1</a>,                        <a href="#F.10.11">F.10.11</a>
-     <a href="#7.28.3.6">7.28.3.6</a>                                                FLT_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-fgetws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.2">7.28.3.2</a>                            FLT_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-field width, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>                               FLT_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-file, <a href="#7.21.3">7.21.3</a>                                                  FLT_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  access functions, <a href="#7.21.5">7.21.5</a>, <a href="#K.3.5.2">K.3.5.2</a>                          FLT_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  name, <a href="#7.21.3">7.21.3</a>                                               FLT_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  operations, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>                                FLT_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  position indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>,                FLT_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-        <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,             FLT_RADIX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,
-        <a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.2">7.21.9.2</a>,                   <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>
-        <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.28.3.1">7.28.3.1</a>,              FLT_ROUNDS macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
-        <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.3.10">7.28.3.10</a>                                  FLT_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  positioning functions, <a href="#7.21.9">7.21.9</a>                              fma functions, <a href="#7.12">7.12</a>, <a href="#7.12.13.1">7.12.13.1</a>, <a href="#F.10.10.1">F.10.10.1</a>
-file scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.9">6.9</a>                                        fma type-generic macro, <a href="#7.24">7.24</a>
-FILE type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                    fmax functions, <a href="#7.12.12.2">7.12.12.2</a>, <a href="#F.10.9.2">F.10.9.2</a>
-FILENAME_MAX macro, <a href="#7.21.1">7.21.1</a>                                   fmax type-generic macro, <a href="#7.24">7.24</a>
-flags, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>, see also floating-point             fmin functions, <a href="#7.12.12.3">7.12.12.3</a>, <a href="#F.10.9.3">F.10.9.3</a>
-     status flag                                              fmin type-generic macro, <a href="#7.24">7.24</a>
-flexible array member, <a href="#6.7.2.1">6.7.2.1</a>                                fmod functions, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#F.10.7.1">F.10.7.1</a>
-float _Complex type, <a href="#6.2.5">6.2.5</a>                                   fmod type-generic macro, <a href="#7.24">7.24</a>
-
-[<a name="p662" href="#p662">page 662</a>] (<a href="#Contents">Contents</a>)
-
-fopen function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.5.4">7.21.5.4</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a>                       <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>
-FOPEN_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.3">7.21.4.3</a>,                    fseek function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
-     <a href="#K.3.5.1.1">K.3.5.1.1</a>                                                      <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.28.3.10">7.28.3.10</a>
-fopen_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a>,                       fsetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
-     <a href="#K.3.5.2.2">K.3.5.2.2</a>                                                      <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.28.3.10">7.28.3.10</a>
-for statement, <a href="#6.8.5">6.8.5</a>, <a href="#6.8.5.3">6.8.5.3</a>                                 ftell function, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>
-form-feed character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                               full declarator, <a href="#6.7.6">6.7.6</a>
-form-feed escape sequence (\f), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               full expression, <a href="#6.8">6.8</a>
-     <a href="#7.4.1.10">7.4.1.10</a>                                                 fully buffered stream, <a href="#7.21.3">7.21.3</a>
-formal argument (deprecated), <a href="#3.16">3.16</a>                            function
-formal parameter, <a href="#3.16">3.16</a>                                           argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
-formatted input/output functions, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.6">7.21.6</a>,              body, <a href="#6.9.1">6.9.1</a>
-     <a href="#K.3.5.3">K.3.5.3</a>                                                     call, <a href="#6.5.2.2">6.5.2.2</a>
-   wide character, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                                  library, <a href="#7.1.4">7.1.4</a>
-fortran keyword, <a href="#J.5.9">J.5.9</a>                                           declarator, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.11.6">6.11.6</a>
-forward reference, <a href="#3.11">3.11</a>                                          definition, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.7">6.11.7</a>
-FP_CONTRACT pragma, <a href="#6.5">6.5</a>, <a href="#6.10.6">6.10.6</a>, <a href="#7.12.2">7.12.2</a>, see                     designator, <a href="#6.3.2.1">6.3.2.1</a>
-     also contracted expression                                  image, <a href="#5.2.3">5.2.3</a>
-FP_FAST_FMA macro, <a href="#7.12">7.12</a>                                          inline, <a href="#6.7.4">6.7.4</a>
-FP_FAST_FMAF macro, <a href="#7.12">7.12</a>                                         library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.4">7.1.4</a>
-FP_FAST_FMAL macro, <a href="#7.12">7.12</a>                                         name length, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
-FP_ILOGB0 macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                                  no-return, <a href="#6.7.4">6.7.4</a>
-FP_ILOGBNAN macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                                parameter, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
-FP_INFINITE macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                     prototype, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.7">6.2.7</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>,
-FP_NAN macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                                <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.6">6.11.6</a>, <a href="#6.11.7">6.11.7</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.12">7.12</a>
-FP_NORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                       prototype scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.7.6.2">6.7.6.2</a>
-FP_SUBNORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                    recursive call, <a href="#6.5.2.2">6.5.2.2</a>
-FP_ZERO macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                         return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
-fpclassify macro, <a href="#7.12.3.1">7.12.3.1</a>, <a href="#F.3">F.3</a>                                  scope, <a href="#6.2.1">6.2.1</a>
-fpos_t type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>                                      type, <a href="#6.2.5">6.2.5</a>
-fprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.1">7.21.6.1</a>,                       type conversion, <a href="#6.3.2.1">6.3.2.1</a>
-     <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.6">7.21.6.6</a>,                  function specifiers, <a href="#6.7.4">6.7.4</a>
-     <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.1">K.3.5.3.1</a>                       function type, <a href="#6.2.5">6.2.5</a>
-fprintf_s function, <a href="#K.3.5.3.1">K.3.5.3.1</a>                                 function-call operator (( )), <a href="#6.5.2.2">6.5.2.2</a>
-fputc function, <a href="#5.2.2">5.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.3">7.21.7.3</a>,              function-like macro, <a href="#6.10.3">6.10.3</a>
-     <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.8.2">7.21.8.2</a>                                       fundamental alignment, <a href="#6.2.8">6.2.8</a>
-fputs function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.4">7.21.7.4</a>                              future directions
-fputwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.28.3.3">7.28.3.3</a>,                       language, <a href="#6.11">6.11</a>
-     <a href="#7.28.3.8">7.28.3.8</a>                                                    library, <a href="#7.30">7.30</a>
-fputws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.4">7.28.3.4</a>                             fwide function, <a href="#7.21.2">7.21.2</a>, <a href="#7.28.3.5">7.28.3.5</a>
-fread function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.1">7.21.8.1</a>                              fwprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
-free function, <a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>                                   <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.2.3">7.28.2.3</a>, <a href="#7.28.2.5">7.28.2.5</a>,
-freestanding execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>,                       <a href="#7.28.2.11">7.28.2.11</a>, <a href="#K.3.9.1.1">K.3.9.1.1</a>
-     <a href="#5.1.2.1">5.1.2.1</a>                                                  fwprintf_s function, <a href="#K.3.9.1.1">K.3.9.1.1</a>
-freopen function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.4">7.21.5.4</a>                            fwrite function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.2">7.21.8.2</a>
-freopen_s function, <a href="#K.3.5.2.2">K.3.5.2.2</a>                                 fwscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.2">7.28.2.2</a>,
-frexp functions, <a href="#7.12.6.4">7.12.6.4</a>, <a href="#F.10.3.4">F.10.3.4</a>                                 <a href="#7.28.2.4">7.28.2.4</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.12">7.28.2.12</a>, <a href="#7.28.3.10">7.28.3.10</a>,
-frexp type-generic macro, <a href="#7.24">7.24</a>                                      <a href="#K.3.9.1.2">K.3.9.1.2</a>
-fscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                     fwscanf_s function, <a href="#K.3.9.1.2">K.3.9.1.2</a>, <a href="#K.3.9.1.5">K.3.9.1.5</a>,
-     <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>                   <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
-fscanf_s function, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
-
-[<a name="p663" href="#p663">page 663</a>] (<a href="#Contents">Contents</a>)
-
-gamma functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a>                               name spaces, <a href="#6.2.3">6.2.3</a>
-general utilities, <a href="#7.22">7.22</a>, <a href="#K.3.6">K.3.6</a>                                reserved, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>
-  wide string, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>                                 scope, <a href="#6.2.1">6.2.1</a>
-general wide string utilities, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>                 type, <a href="#6.2.5">6.2.5</a>
-generic parameters, <a href="#7.24">7.24</a>                                    identifier list, <a href="#6.7.6">6.7.6</a>
-generic selection, <a href="#6.5.1.1">6.5.1.1</a>                                  identifier nondigit, <a href="#6.4.2.1">6.4.2.1</a>
-getc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>                   IEC 559, <a href="#F.1">F.1</a>
-getchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.6">7.21.7.6</a>                          IEC 60559, <a href="#2">2</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.3.3">7.3.3</a>,
-getenv function, <a href="#7.22.4.6">7.22.4.6</a>                                         <a href="#7.6">7.6</a>, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.14">7.12.14</a>, <a href="#F">F</a>, <a href="#G">G</a>,
-getenv_s function, <a href="#K.3.6.2.1">K.3.6.2.1</a>                                      <a href="#H.1">H.1</a>
-gets function, <a href="#K.3.5.4.1">K.3.5.4.1</a>                                    IEEE 754, <a href="#F.1">F.1</a>
-gets_s function, <a href="#K.3.5.4.1">K.3.5.4.1</a>                                  IEEE 854, <a href="#F.1">F.1</a>
-getwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.6">7.28.3.6</a>, <a href="#7.28.3.7">7.28.3.7</a>                  IEEE floating-point arithmetic standard, see
-getwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.7">7.28.3.7</a>                               IEC 60559, ANSI/IEEE 754,
-gmtime function, <a href="#7.26.3.3">7.26.3.3</a>                                         ANSI/IEEE 854
-gmtime_s function, <a href="#K.3.8.2.3">K.3.8.2.3</a>                                if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,
-goto statement, <a href="#6.2.1">6.2.1</a>, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.6.1">6.8.6.1</a>                             <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>
-graphic characters, <a href="#5.2.1">5.2.1</a>                                   if statement, <a href="#6.8.4.1">6.8.4.1</a>
-greater-than operator (&gt;), <a href="#6.5.8">6.5.8</a>                            ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>
-greater-than-or-equal-to operator (&gt;=), <a href="#6.5.8">6.5.8</a>               ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>
-                                                            ignore_handler_s function, <a href="#K.3.6.1.3">K.3.6.1.3</a>
-happens before, <a href="#5.1.2.4">5.1.2.4</a>                                     ilogb functions, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>
-header, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.2">7.1.2</a>, see also standard headers           ilogb type-generic macro, <a href="#7.24">7.24</a>
-header names, <a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>, <a href="#6.10.2">6.10.2</a>                            imaginary macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
-hexadecimal constant, <a href="#6.4.4.1">6.4.4.1</a>                               imaginary numbers, <a href="#G">G</a>
-hexadecimal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                imaginary type domain, <a href="#G.2">G.2</a>
-hexadecimal prefix, <a href="#6.4.4.1">6.4.4.1</a>                                  imaginary types, <a href="#G">G</a>
-hexadecimal-character escape sequence                       imaxabs function, <a href="#7.8.2.1">7.8.2.1</a>
-     (\x hexadecimal digits), <a href="#6.4.4.4">6.4.4.4</a>                       imaxdiv function, <a href="#7.8">7.8</a>, <a href="#7.8.2.2">7.8.2.2</a>
-high-order bit, <a href="#3.6">3.6</a>                                         imaxdiv_t type, <a href="#7.8">7.8</a>
-horizontal-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                        implementation, <a href="#3.12">3.12</a>
-horizontal-tab escape sequence (\r), <a href="#7.29.2.1.3">7.29.2.1.3</a>             implementation limit, <a href="#3.13">3.13</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.4.2.1">6.4.2.1</a>,
-horizontal-tab escape sequence (\t), <a href="#5.2.2">5.2.2</a>,                       <a href="#6.7.6">6.7.6</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#E">E</a>, see also environmental
-     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>                                   limits
-hosted execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.2">5.1.2.2</a>             implementation-defined behavior, <a href="#3.4.1">3.4.1</a>, <a href="#4">4</a>, <a href="#J.3">J.3</a>
-HUGE_VAL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                     implementation-defined value, <a href="#3.19.1">3.19.1</a>
-     <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                       implicit conversion, <a href="#6.3">6.3</a>
-HUGE_VALF macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    implicit initialization, <a href="#6.7.9">6.7.9</a>
-     <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                       include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.2">6.10.2</a>
-HUGE_VALL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    inclusive OR operators
-     <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                         bitwise (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
-hyperbolic functions                                           bitwise assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
-  complex, <a href="#7.3.6">7.3.6</a>, <a href="#G.6.2">G.6.2</a>                                     incomplete type, <a href="#6.2.5">6.2.5</a>
-  real, <a href="#7.12.5">7.12.5</a>, <a href="#F.10.2">F.10.2</a>                                      increment operators, see arithmetic operators,
-hypot functions, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#F.10.4.3">F.10.4.3</a>                               increment and decrement
-hypot type-generic macro, <a href="#7.24">7.24</a>                              indeterminate value, <a href="#3.19.2">3.19.2</a>
-                                                            indeterminately sequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>,
-I macro, <a href="#7.3.1">7.3.1</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                      <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, see also sequenced before,
-identifier, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.5.1">6.5.1</a>                                         unsequenced
-   linkage, see linkage                                     indirection operator (*), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
-   maximum length, <a href="#6.4.2.1">6.4.2.1</a>                                  inequality operator (!=), <a href="#6.5.9">6.5.9</a>
-
-[<a name="p664" href="#p664">page 664</a>] (<a href="#Contents">Contents</a>)
-
-infinitary, <a href="#7.12.1">7.12.1</a>                                                    extended, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#7.20">7.20</a>
-INFINITY macro, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                              inter-thread happens before, <a href="#5.1.2.4">5.1.2.4</a>
-initial position, <a href="#5.2.2">5.2.2</a>                                           interactive device, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a>
-initial shift state, <a href="#5.2.1.2">5.2.1.2</a>                                      internal linkage, <a href="#6.2.2">6.2.2</a>
-initialization, <a href="#5.1.2">5.1.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.5">6.5.2.5</a>, <a href="#6.7.9">6.7.9</a>,            internal name, <a href="#6.4.2.1">6.4.2.1</a>
-      <a href="#F.8.5">F.8.5</a>                                                       interrupt, <a href="#5.2.3">5.2.3</a>
-   in blocks, <a href="#6.8">6.8</a>                                                 INTMAX_C macro, <a href="#7.20.4.2">7.20.4.2</a>
-initializer, <a href="#6.7.9">6.7.9</a>                                                INTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
-   permitted form, <a href="#6.6">6.6</a>                                            INTMAX_MIN macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
-   string literal, <a href="#6.3.2.1">6.3.2.1</a>                                        intmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
-inline, <a href="#6.7.4">6.7.4</a>                                                           <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
-inner scope, <a href="#6.2.1">6.2.1</a>                                                INTN_C macros, <a href="#7.20.4.1">7.20.4.1</a>
-input failure, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>,                     INTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>
-      <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>,                 INTN_MIN macros, <a href="#7.20.2.1">7.20.2.1</a>
-      <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>, <a href="#K.3.9.1.5">K.3.9.1.5</a>,               intN_t types, <a href="#7.20.1.1">7.20.1.1</a>
-      <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>               INTPTR_MAX macro, <a href="#7.20.2.4">7.20.2.4</a>
-input/output functions                                            INTPTR_MIN macro, <a href="#7.20.2.4">7.20.2.4</a>
-   character, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a>                                     intptr_t type, <a href="#7.20.1.4">7.20.1.4</a>
-   direct, <a href="#7.21.8">7.21.8</a>                                                 inttypes.h header, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>
-   formatted, <a href="#7.21.6">7.21.6</a>, <a href="#K.3.5.3">K.3.5.3</a>                                     isalnum function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>
-      wide character, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                             isalpha function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>
-   wide character, <a href="#7.28.3">7.28.3</a>                                         isblank function, <a href="#7.4.1.3">7.4.1.3</a>
-      formatted, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                                  iscntrl function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.4">7.4.1.4</a>, <a href="#7.4.1.7">7.4.1.7</a>,
-input/output header, <a href="#7.21">7.21</a>, <a href="#K.3.5">K.3.5</a>                                        <a href="#7.4.1.11">7.4.1.11</a>
-input/output, device, <a href="#5.1.2.3">5.1.2.3</a>                                     isdigit function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.5">7.4.1.5</a>,
-int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.7.2">6.7.2</a>                       <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.11.1.1">7.11.1.1</a>
-int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,                   isfinite macro, <a href="#7.12.3.2">7.12.3.2</a>, <a href="#F.3">F.3</a>
-      <a href="#6.3.1.8">6.3.1.8</a>                                                     isgraph function, <a href="#7.4.1.6">7.4.1.6</a>
-INT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>                                    isgreater macro, <a href="#7.12.14.1">7.12.14.1</a>, <a href="#F.3">F.3</a>
-INT_FASTN_MIN macros, <a href="#7.20.2.3">7.20.2.3</a>                                    isgreaterequal macro, <a href="#7.12.14.2">7.12.14.2</a>, <a href="#F.3">F.3</a>
-int_fastN_t types, <a href="#7.20.1.3">7.20.1.3</a>                                       isinf macro, <a href="#7.12.3.3">7.12.3.3</a>
-INT_LEASTN_MAX macros, <a href="#7.20.2.2">7.20.2.2</a>                                   isless macro, <a href="#7.12.14.3">7.12.14.3</a>, <a href="#F.3">F.3</a>
-INT_LEASTN_MIN macros, <a href="#7.20.2.2">7.20.2.2</a>                                   islessequal macro, <a href="#7.12.14.4">7.12.14.4</a>, <a href="#F.3">F.3</a>
-int_leastN_t types, <a href="#7.20.1.2">7.20.1.2</a>                                      islessgreater macro, <a href="#7.12.14.5">7.12.14.5</a>, <a href="#F.3">F.3</a>
-INT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                          islower function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.2.1">7.4.2.1</a>,
-INT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>                                          <a href="#7.4.2.2">7.4.2.2</a>
-integer arithmetic functions, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>,                   isnan macro, <a href="#7.12.3.4">7.12.3.4</a>, <a href="#F.3">F.3</a>
-      <a href="#7.22.6">7.22.6</a>                                                      isnormal macro, <a href="#7.12.3.5">7.12.3.5</a>
-integer character constant, <a href="#6.4.4.4">6.4.4.4</a>                               ISO 31-11, <a href="#2">2</a>, <a href="#3">3</a>
-integer constant, <a href="#6.4.4.1">6.4.4.1</a>                                         ISO 4217, <a href="#2">2</a>, <a href="#7.11.2.1">7.11.2.1</a>
-integer constant expression, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.6">6.6</a>, <a href="#6.7.2.1">6.7.2.1</a>,               ISO 8601, <a href="#2">2</a>, <a href="#7.26.3.5">7.26.3.5</a>
-      <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.7.10">6.7.10</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#6.10.1">6.10.1</a>,           ISO/IEC 10646, <a href="#2">2</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.4.3">6.4.3</a>, <a href="#6.10.8.2">6.10.8.2</a>
-      <a href="#7.1.4">7.1.4</a>                                                       ISO/IEC 10976-1, <a href="#H.1">H.1</a>
-integer conversion rank, <a href="#6.3.1.1">6.3.1.1</a>                                  ISO/IEC 2382-1, <a href="#2">2</a>, <a href="#3">3</a>
-integer promotions, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.3.1.1">6.3.1.1</a>,                  ISO/IEC 646, <a href="#2">2</a>, <a href="#5.2.1.1">5.2.1.1</a>
-      <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.7">6.5.7</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>,           ISO/IEC 9945-2, <a href="#7.11">7.11</a>
-      <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>                                          iso646.h header, <a href="#4">4</a>, <a href="#7.9">7.9</a>                          *
-integer suffix, <a href="#6.4.4.1">6.4.4.1</a>                                            isprint function, <a href="#5.2.2">5.2.2</a>, <a href="#7.4.1.8">7.4.1.8</a>
-integer type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,               ispunct function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,
-      <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                                          <a href="#7.4.1.11">7.4.1.11</a>
-integer types, <a href="#6.2.5">6.2.5</a>, <a href="#7.20">7.20</a>                                        isspace function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,
-
-[<a name="p665" href="#p665">page 665</a>] (<a href="#Contents">Contents</a>)
-
-      <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>,                   LC_ALL macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-      <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>                                        LC_COLLATE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.3">7.23.4.3</a>,
-isunordered macro, <a href="#7.12.14.6">7.12.14.6</a>, <a href="#F.3">F.3</a>                                     <a href="#7.28.4.4.2">7.28.4.4.2</a>
-isupper function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.4.2.1">7.4.2.1</a>,                   LC_CTYPE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7">7.22.7</a>,
-      <a href="#7.4.2.2">7.4.2.2</a>                                                         <a href="#7.22.8">7.22.8</a>, <a href="#7.28.6">7.28.6</a>, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>,
-iswalnum function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>,                            <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>, <a href="#K.3.6.4">K.3.6.4</a>, <a href="#K.3.6.5">K.3.6.5</a>
-      <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   LC_MONETARY macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-iswalpha function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                      LC_NUMERIC macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
-      <a href="#7.29.2.2.1">7.29.2.2.1</a>                                                LC_TIME macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.26.3.5">7.26.3.5</a>
-iswblank function, <a href="#7.29.2.1.3">7.29.2.1.3</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                       lconv structure type, <a href="#7.11">7.11</a>
-iswcntrl function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.4">7.29.2.1.4</a>,                      LDBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                       LDBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-iswctype function, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>                       LDBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-iswdigit function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                      LDBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.29.2.1.5">7.29.2.1.5</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>           LDBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-iswgraph function, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.1.6">7.29.2.1.6</a>,                        LDBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   LDBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-iswlower function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>,                      LDBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.1.2">7.29.3.1.2</a>                        LDBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-iswprint function, <a href="#7.29.2.1.6">7.29.2.1.6</a>, <a href="#7.29.2.1.8">7.29.2.1.8</a>,                      LDBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.29.2.2.1">7.29.2.2.1</a>                                                LDBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-iswpunct function, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                        LDBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>,                      ldexp functions, <a href="#7.12.6.6">7.12.6.6</a>, <a href="#F.10.3.6">F.10.3.6</a>
-      <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   ldexp type-generic macro, <a href="#7.24">7.24</a>
-iswspace function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,                          ldiv function, <a href="#7.22.6.2">7.22.6.2</a>
-      <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.6">7.29.2.1.6</a>,           ldiv_t type, <a href="#7.22">7.22</a>
-      <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>,                      leading underscore in identifiers, <a href="#7.1.3">7.1.3</a>
-      <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   left-shift assignment operator (&lt;&lt;=), <a href="#6.5.16.2">6.5.16.2</a>
-iswupper function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>,                     left-shift operator (&lt;&lt;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
-      <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.1.2">7.29.3.1.2</a>                        length
-iswxdigit function, <a href="#7.29.2.1.12">7.29.2.1.12</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                        external name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
-isxdigit function, <a href="#7.4.1.12">7.4.1.12</a>, <a href="#7.11.1.1">7.11.1.1</a>                              function name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
-italic type convention, <a href="#3">3</a>, <a href="#6.1">6.1</a>                                     identifier, <a href="#6.4.2.1">6.4.2.1</a>
-iteration statements, <a href="#6.8.5">6.8.5</a>                                        internal name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
-                                                                length function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.23.6.3">7.23.6.3</a>, <a href="#7.28.4.6.1">7.28.4.6.1</a>,
-jmp_buf type, <a href="#7.13">7.13</a>                                                    <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#K.3.7.4.4">K.3.7.4.4</a>, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a>
-jump statements, <a href="#6.8.6">6.8.6</a>                                          length modifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>,
-                                                                      <a href="#7.28.2.2">7.28.2.2</a>
-keywords, <a href="#6.4.1">6.4.1</a>, <a href="#G.2">G.2</a>, <a href="#J.5.9">J.5.9</a>, <a href="#J.5.10">J.5.10</a>                             less-than operator (&lt;), <a href="#6.5.8">6.5.8</a>
-kill_dependency macro, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.17.3.1">7.17.3.1</a>                        less-than-or-equal-to operator (&lt;=), <a href="#6.5.8">6.5.8</a>
-known constant size, <a href="#6.2.5">6.2.5</a>                                      letter, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
-                                                                lexical elements, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>
-L_tmpnam macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.4">7.21.4.4</a>                                lgamma functions, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#F.10.5.3">F.10.5.3</a>
-L_tmpnam_s macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                              lgamma type-generic macro, <a href="#7.24">7.24</a>
-label name, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.3">6.2.3</a>                                        library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7">7</a>, <a href="#K.3">K.3</a>
-labeled statement, <a href="#6.8.1">6.8.1</a>                                           future directions, <a href="#7.30">7.30</a>
-labs function, <a href="#7.22.6.1">7.22.6.1</a>                                            summary, <a href="#B">B</a>
-language, <a href="#6">6</a>                                                        terms, <a href="#7.1.1">7.1.1</a>
-   future directions, <a href="#6.11">6.11</a>                                         use of functions, <a href="#7.1.4">7.1.4</a>
-   syntax summary, <a href="#A">A</a>                                            lifetime, <a href="#6.2.4">6.2.4</a>
-Latin alphabet, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.2.1">6.4.2.1</a>                                  limits
-
-[<a name="p666" href="#p666">page 666</a>] (<a href="#Contents">Contents</a>)
-
-   environmental, see environmental limits                      <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
-   implementation, see implementation limits               long double _Imaginary type, <a href="#G.2">G.2</a>
-   numerical, see numerical limits                         long double suffix, l or <a href="#L">L</a>, <a href="#6.4.4.2">6.4.4.2</a>
-   translation, see translation limits                     long double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>,
-limits.h header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                      <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.2">F.2</a>
-line buffered stream, <a href="#7.21.3">7.21.3</a>                               long double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,
-line number, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a>                                   <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
-line preprocessing directive, <a href="#6.10.4">6.10.4</a>                       long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
-lines, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#7.21.2">7.21.2</a>                                          <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
-   preprocessing directive, <a href="#6.10">6.10</a>                           long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
-linkage, <a href="#6.2.2">6.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.4">6.7.4</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.9">6.9</a>, <a href="#6.9.2">6.9.2</a>,                <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
-      <a href="#6.11.2">6.11.2</a>                                               long integer suffix, l or <a href="#L">L</a>, <a href="#6.4.4.1">6.4.4.1</a>
-llabs function, <a href="#7.22.6.1">7.22.6.1</a>                                   long long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>,
-lldiv function, <a href="#7.22.6.2">7.22.6.2</a>                                        <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
-lldiv_t type, <a href="#7.22">7.22</a>                                         long long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>,
-LLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                           <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
-      <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           long long integer suffix, ll or LL, <a href="#6.4.4.1">6.4.4.1</a>
-LLONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                      LONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
-      <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           LONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
-llrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a>                  longjmp function, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>, <a href="#7.22.4.4">7.22.4.4</a>,
-llrint type-generic macro, <a href="#7.24">7.24</a>                                 <a href="#7.22.4.7">7.22.4.7</a>
-llround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a>                      loop body, <a href="#6.8.5">6.8.5</a>
-llround type-generic macro, <a href="#7.24">7.24</a>                           low-order bit, <a href="#3.6">3.6</a>
-local time, <a href="#7.26.1">7.26.1</a>                                         lowercase letter, <a href="#5.2.1">5.2.1</a>
-locale, <a href="#3.4.2">3.4.2</a>                                              lrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a>
-locale-specific behavior, <a href="#3.4.2">3.4.2</a>, <a href="#J.4">J.4</a>                        lrint type-generic macro, <a href="#7.24">7.24</a>
-locale.h header, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>                              lround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a>
-localeconv function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>                    lround type-generic macro, <a href="#7.24">7.24</a>
-localization, <a href="#7.11">7.11</a>                                         lvalue, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>, <a href="#6.5.16">6.5.16</a>,
-localtime function, <a href="#7.26.3.4">7.26.3.4</a>                                    <a href="#6.7.2.4">6.7.2.4</a>
-localtime_s function, <a href="#K.3.8.2.4">K.3.8.2.4</a>                            lvalue conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.5.16.1">6.5.16.1</a>,
-log functions, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#F.10.3.7">F.10.3.7</a>                               <a href="#6.5.16.2">6.5.16.2</a>
-log type-generic macro, <a href="#7.24">7.24</a>
-log10 functions, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#F.10.3.8">F.10.3.8</a>                        macro argument substitution, <a href="#6.10.3.1">6.10.3.1</a>
-log10 type-generic macro, <a href="#7.24">7.24</a>                             macro definition
-log1p functions, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#F.10.3.9">F.10.3.9</a>                          library function, <a href="#7.1.4">7.1.4</a>
-log1p type-generic macro, <a href="#7.24">7.24</a>                             macro invocation, <a href="#6.10.3">6.10.3</a>
-log2 functions, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#F.10.3.10">F.10.3.10</a>                       macro name, <a href="#6.10.3">6.10.3</a>
-log2 type-generic macro, <a href="#7.24">7.24</a>                                length, <a href="#5.2.4.1">5.2.4.1</a>
-logarithmic functions                                        predefined, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>
-   complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>                                     redefinition, <a href="#6.10.3">6.10.3</a>
-   real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>                                      scope, <a href="#6.10.3.5">6.10.3.5</a>
-logb functions, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.11">F.10.3.11</a>                  macro parameter, <a href="#6.10.3">6.10.3</a>
-logb type-generic macro, <a href="#7.24">7.24</a>                              macro preprocessor, <a href="#6.10">6.10</a>
-logical operators                                          macro replacement, <a href="#6.10.3">6.10.3</a>
-   AND (&amp;&amp;), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>                               magnitude, complex, <a href="#7.3.8.1">7.3.8.1</a>
-   negation (!), <a href="#6.5.3.3">6.5.3.3</a>                                   main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.4">6.7.4</a>,
-   OR (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>                                     <a href="#7.21.3">7.21.3</a>
-logical source lines, <a href="#5.1.1.2">5.1.1.2</a>                              malloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.4">7.22.3.4</a>, <a href="#7.22.3.5">7.22.3.5</a>
-long double _Complex type, <a href="#6.2.5">6.2.5</a>                           manipulation functions
-long double _Complex type conversion,                        complex, <a href="#7.3.9">7.3.9</a>
-
-[<a name="p667" href="#p667">page 667</a>] (<a href="#Contents">Contents</a>)
-
-  real, <a href="#7.12.11">7.12.11</a>, <a href="#F.10.8">F.10.8</a>                                    modf functions, <a href="#7.12.6.12">7.12.6.12</a>, <a href="#F.10.3.12">F.10.3.12</a>
-matching failure, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>,           modifiable lvalue, <a href="#6.3.2.1">6.3.2.1</a>
-     <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>                     modification order, <a href="#5.1.2.4">5.1.2.4</a>
-math.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>,              modulus functions, <a href="#7.12.6.12">7.12.6.12</a>
-     <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a>                                          modulus, complex, <a href="#7.3.8.1">7.3.8.1</a>
-MATH_ERREXCEPT macro, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>                           mtx_destroy function, <a href="#7.25.4.1">7.25.4.1</a>
-math_errhandling macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>                  mtx_init function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.4.2">7.25.4.2</a>
-MATH_ERRNO macro, <a href="#7.12">7.12</a>                                     mtx_lock function, <a href="#7.25.4.3">7.25.4.3</a>
-max_align_t type, <a href="#7.19">7.19</a>                                     mtx_t type, <a href="#7.25.1">7.25.1</a>
-maximum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                         mtx_timedlock function, <a href="#7.25.4.4">7.25.4.4</a>
-MB_CUR_MAX macro, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7.2">7.22.7.2</a>,                   mtx_trylock function, <a href="#7.25.4.5">7.25.4.5</a>
-     <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>,             mtx_unlock function, <a href="#7.25.4.3">7.25.4.3</a>, <a href="#7.25.4.4">7.25.4.4</a>,
-     <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>                                     <a href="#7.25.4.5">7.25.4.5</a>, <a href="#7.25.4.6">7.25.4.6</a>
-MB_LEN_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a>                   multibyte character, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
-mblen function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.28.6.3">7.28.6.3</a>                         multibyte conversion functions
-mbrlen function, <a href="#7.28.6.3.1">7.28.6.3.1</a>                                  wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
-mbrtoc16 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27.1.1">7.27.1.1</a>                     extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
-mbrtoc32 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27.1.3">7.27.1.3</a>                     restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
-mbrtowc function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                wide string, <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
-     <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>,                restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
-     <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>                    multibyte string, <a href="#7.1.1">7.1.1</a>
-mbsinit function, <a href="#7.28.6.2.1">7.28.6.2.1</a>                               multibyte/wide character conversion functions,
-mbsrtowcs function, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                       <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
-mbsrtowcs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>                 extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
-mbstate_t type, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>,                    restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
-     <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.27">7.27</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>,             multibyte/wide string conversion functions,
-     <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.6">7.28.6</a>, <a href="#7.28.6.2.1">7.28.6.2.1</a>, <a href="#7.28.6.3">7.28.6.3</a>,                    <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
-     <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#7.28.6.4">7.28.6.4</a>                                    restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
-mbstowcs function, <a href="#6.4.5">6.4.5</a>, <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.28.6.4">7.28.6.4</a>               multidimensional array, <a href="#6.5.2.1">6.5.2.1</a>
-mbstowcs_s function, <a href="#K.3.6.5.1">K.3.6.5.1</a>                             multiplication assignment operator (*=), <a href="#6.5.16.2">6.5.16.2</a>
-mbtowc function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.22.7.2">7.22.7.2</a>,              multiplication operator (*), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>,
-     <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.28.6.3">7.28.6.3</a>                                         <a href="#G.5.1">G.5.1</a>
-member access operators (. and -&gt;), <a href="#6.5.2.3">6.5.2.3</a>                multiplicative expressions, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
-member alignment, <a href="#6.7.2.1">6.7.2.1</a>
-memchr function, <a href="#7.23.5.1">7.23.5.1</a>                                  n-char sequence, <a href="#7.22.1.3">7.22.1.3</a>
-memcmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.1">7.23.4.1</a>                          n-wchar sequence, <a href="#7.28.4.1.1">7.28.4.1.1</a>
-memcpy function, <a href="#7.23.2.1">7.23.2.1</a>                                  name
-memcpy_s function, <a href="#K.3.7.1.1">K.3.7.1.1</a>                                 external, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
-memmove function, <a href="#7.23.2.2">7.23.2.2</a>                                   file, <a href="#7.21.3">7.21.3</a>
-memmove_s function, <a href="#K.3.7.1.2">K.3.7.1.2</a>                                internal, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
-memory location, <a href="#3.14">3.14</a>                                        label, <a href="#6.2.3">6.2.3</a>
-memory management functions, <a href="#7.22.3">7.22.3</a>                          structure/union member, <a href="#6.2.3">6.2.3</a>
-memory_order type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.3">7.17.3</a>                          name spaces, <a href="#6.2.3">6.2.3</a>
-memset function, <a href="#7.23.6.1">7.23.6.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>                       named label, <a href="#6.8.1">6.8.1</a>
-memset_s function, <a href="#K.3.7.4.1">K.3.7.4.1</a>                               NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-minimum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                         nan functions, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#F.2.1">F.2.1</a>, <a href="#F.10.8.2">F.10.8.2</a>
-minus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                             NAN macro, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>
-miscellaneous functions                                    NDEBUG macro, <a href="#7.2">7.2</a>
-  string, <a href="#7.23.6">7.23.6</a>, <a href="#K.3.7.4">K.3.7.4</a>                                  nearbyint functions, <a href="#7.12.9.3">7.12.9.3</a>, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>,
-  wide string, <a href="#7.28.4.6">7.28.4.6</a>, <a href="#K.3.9.2.4">K.3.9.2.4</a>                              <a href="#F.10.6.3">F.10.6.3</a>
-mktime function, <a href="#7.26.2.3">7.26.2.3</a>                                  nearbyint type-generic macro, <a href="#7.24">7.24</a>
-
-[<a name="p668" href="#p668">page 668</a>] (<a href="#Contents">Contents</a>)
-
-nearest integer functions, <a href="#7.12.9">7.12.9</a>, <a href="#F.10.6">F.10.6</a>                       operating system, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#7.22.4.8">7.22.4.8</a>
-negation operator (!), <a href="#6.5.3.3">6.5.3.3</a>                                  operations on files, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>
-negative zero, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.12.11.1">7.12.11.1</a>                               operator, <a href="#6.4.6">6.4.6</a>
-new-line character, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#6.10.4">6.10.4</a>           operators, <a href="#6.5">6.5</a>
-new-line escape sequence (\n), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,                     additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>
-     <a href="#7.4.1.10">7.4.1.10</a>                                                      alignof, <a href="#6.5.3.4">6.5.3.4</a>
-nextafter functions, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>,                    assignment, <a href="#6.5.16">6.5.16</a>
-     <a href="#F.10.8.3">F.10.8.3</a>                                                      associativity, <a href="#6.5">6.5</a>
-nextafter type-generic macro, <a href="#7.24">7.24</a>                                 equality, <a href="#6.5.9">6.5.9</a>
-nexttoward functions, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.8.4">F.10.8.4</a>                     multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
-nexttoward type-generic macro, <a href="#7.24">7.24</a>                                postfix, <a href="#6.5.2">6.5.2</a>
-no linkage, <a href="#6.2.2">6.2.2</a>                                                  precedence, <a href="#6.5">6.5</a>
-no-return function, <a href="#6.7.4">6.7.4</a>                                          preprocessing, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, <a href="#6.10.9">6.10.9</a>
-non-stop floating-point control mode, <a href="#7.6.4.2">7.6.4.2</a>                       relational, <a href="#6.5.8">6.5.8</a>
-nongraphic characters, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                              shift, <a href="#6.5.7">6.5.7</a>
-nonlocal jumps header, <a href="#7.13">7.13</a>                                        sizeof, <a href="#6.5.3.4">6.5.3.4</a>
-norm, complex, <a href="#7.3.8.1">7.3.8.1</a>                                             unary, <a href="#6.5.3">6.5.3</a>
-normalized broken-down time, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>                    unary arithmetic, <a href="#6.5.3.3">6.5.3.3</a>
-not macro, <a href="#7.9">7.9</a>                                                  optional features, see conditional features
-not-equal-to operator, see inequality operator                  or macro, <a href="#7.9">7.9</a>
-not_eq macro, <a href="#7.9">7.9</a>                                               OR operators
-null character (\0), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                         bitwise exclusive (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
-  padding of binary stream, <a href="#7.21.2">7.21.2</a>                                 bitwise exclusive assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
-NULL macro, <a href="#7.11">7.11</a>, <a href="#7.19">7.19</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.22">7.22</a>, <a href="#7.23.1">7.23.1</a>,                      bitwise inclusive (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
-     <a href="#7.26.1">7.26.1</a>, <a href="#7.28.1">7.28.1</a>                                                bitwise inclusive assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
-null pointer, <a href="#6.3.2.3">6.3.2.3</a>                                              logical (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>
-null pointer constant, <a href="#6.3.2.3">6.3.2.3</a>                                  or_eq macro, <a href="#7.9">7.9</a>
-null preprocessing directive, <a href="#6.10.7">6.10.7</a>                            order of allocated storage, <a href="#7.22.3">7.22.3</a>
-null statement, <a href="#6.8.3">6.8.3</a>                                           order of evaluation, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>,
-null wide character, <a href="#7.1.1">7.1.1</a>                                            see also sequence points
-number classification macros, <a href="#7.12">7.12</a>, <a href="#7.12.3.1">7.12.3.1</a>                     ordinary identifier name space, <a href="#6.2.3">6.2.3</a>
-numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                   orientation of stream, <a href="#7.21.2">7.21.2</a>, <a href="#7.28.3.5">7.28.3.5</a>
-  wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1">7.28.4.1</a>                                out-of-bounds store, <a href="#L.2.1">L.2.1</a>
-numerical limits, <a href="#5.2.4.2">5.2.4.2</a>                                       outer scope, <a href="#6.2.1">6.2.1</a>
-                                                                over-aligned, <a href="#6.2.8">6.2.8</a>
-object, <a href="#3.15">3.15</a>
-object representation, <a href="#6.2.6.1">6.2.6.1</a>                                  padding
-object type, <a href="#6.2.5">6.2.5</a>                                                binary stream, <a href="#7.21.2">7.21.2</a>
-object-like macro, <a href="#6.10.3">6.10.3</a>                                         bits, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a>
-observable behavior, <a href="#5.1.2.3">5.1.2.3</a>                                      structure/union, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
-obsolescence, <a href="#6.11">6.11</a>, <a href="#7.30">7.30</a>                                        parameter, <a href="#3.16">3.16</a>
-octal constant, <a href="#6.4.4.1">6.4.4.1</a>                                           array, <a href="#6.9.1">6.9.1</a>
-octal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.4">6.4.4.4</a>                                     ellipsis, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
-octal-character escape sequence (\octal digits),                  function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
-     <a href="#6.4.4.4">6.4.4.4</a>                                                      macro, <a href="#6.10.3">6.10.3</a>
-offsetof macro, <a href="#7.19">7.19</a>                                              main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-on-off switch, <a href="#6.10.6">6.10.6</a>                                             program, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-once_flag type, <a href="#7.25.1">7.25.1</a>                                          parameter type list, <a href="#6.7.6.3">6.7.6.3</a>
-ONCE_FLAG_INIT macro, <a href="#7.25.1">7.25.1</a>                                    parentheses punctuator (( )), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
-ones' complement, <a href="#6.2.6.2">6.2.6.2</a>                                       parenthesized expression, <a href="#6.5.1">6.5.1</a>
-operand, <a href="#6.4.6">6.4.6</a>, <a href="#6.5">6.5</a>                                             parse state, <a href="#7.21.2">7.21.2</a>
-
-[<a name="p669" href="#p669">page 669</a>] (<a href="#Contents">Contents</a>)
-
-perform a trap, <a href="#3.19.5">3.19.5</a>                                        preprocessor, <a href="#6.10">6.10</a>
-permitted form of initializer, <a href="#6.6">6.6</a>                            PRIcFASTN macros, <a href="#7.8.1">7.8.1</a>
-perror function, <a href="#7.21.10.4">7.21.10.4</a>                                    PRIcLEASTN macros, <a href="#7.8.1">7.8.1</a>
-phase angle, complex, <a href="#7.3.9.1">7.3.9.1</a>                                 PRIcMAX macros, <a href="#7.8.1">7.8.1</a>
-physical source lines, <a href="#5.1.1.2">5.1.1.2</a>                                PRIcN macros, <a href="#7.8.1">7.8.1</a>
-placemarker, <a href="#6.10.3.3">6.10.3.3</a>                                         PRIcPTR macros, <a href="#7.8.1">7.8.1</a>
-plus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                                 primary expression, <a href="#6.5.1">6.5.1</a>
-pointer arithmetic, <a href="#6.5.6">6.5.6</a>                                     printf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.10">7.21.6.10</a>,
-pointer comparison, <a href="#6.5.8">6.5.8</a>                                           <a href="#K.3.5.3.3">K.3.5.3.3</a>
-pointer declarator, <a href="#6.7.6.1">6.7.6.1</a>                                   printf_s function, <a href="#K.3.5.3.3">K.3.5.3.3</a>
-pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                printing character, <a href="#5.2.2">5.2.2</a>, <a href="#7.4">7.4</a>, <a href="#7.4.1.8">7.4.1.8</a>
-pointer to function, <a href="#6.5.2.2">6.5.2.2</a>                                  printing wide character, <a href="#7.29.2">7.29.2</a>
-pointer type, <a href="#6.2.5">6.2.5</a>                                           program diagnostics, <a href="#7.2.1">7.2.1</a>
-pointer type conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                     program execution, <a href="#5.1.2.2.2">5.1.2.2.2</a>, <a href="#5.1.2.3">5.1.2.3</a>
-pointer, null, <a href="#6.3.2.3">6.3.2.3</a>                                        program file, <a href="#5.1.1.1">5.1.1.1</a>
-pole error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#7.12.6.8">7.12.6.8</a>,             program image, <a href="#5.1.1.2">5.1.1.2</a>
-     <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#7.12.7.4">7.12.7.4</a>,                program name (argv[0]), <a href="#5.1.2.2.1">5.1.2.2.1</a>
-     <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>                                       program parameters, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-portability, <a href="#4">4</a>, <a href="#J">J</a>                                             program startup, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.1">5.1.2.2.1</a>
-position indicator, file, see file position indicator           program structure, <a href="#5.1.1.1">5.1.1.1</a>
-positive difference, <a href="#7.12.12.1">7.12.12.1</a>                                program termination, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>,
-positive difference functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                      <a href="#5.1.2.3">5.1.2.3</a>
-postfix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              program, conforming, <a href="#4">4</a>
-postfix expressions, <a href="#6.5.2">6.5.2</a>                                     program, strictly conforming, <a href="#4">4</a>
-postfix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              promotions
-pow functions, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#F.10.4.4">F.10.4.4</a>                                default argument, <a href="#6.5.2.2">6.5.2.2</a>
-pow type-generic macro, <a href="#7.24">7.24</a>                                     integer, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.3.1.1">6.3.1.1</a>
-power functions                                               prototype, see function prototype
-  complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                       pseudo-random sequence functions, <a href="#7.22.2">7.22.2</a>
-  real, <a href="#7.12.7">7.12.7</a>, <a href="#F.10.4">F.10.4</a>                                        PTRDIFF_MAX macro, <a href="#7.20.3">7.20.3</a>
-pp-number, <a href="#6.4.8">6.4.8</a>                                              PTRDIFF_MIN macro, <a href="#7.20.3">7.20.3</a>
-pragma operator, <a href="#6.10.9">6.10.9</a>                                       ptrdiff_t type, <a href="#7.17.1">7.17.1</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>,
-pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                      <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
-precedence of operators, <a href="#6.5">6.5</a>                                  punctuators, <a href="#6.4.6">6.4.6</a>
-precedence of syntax rules, <a href="#5.1.1.2">5.1.1.2</a>                           putc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.7.8">7.21.7.8</a>
-precision, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>               putchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.8">7.21.7.8</a>
-  excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                         puts function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.9">7.21.7.9</a>
-predefined macro names, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>                         putwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#7.28.3.9">7.28.3.9</a>
-prefix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               putwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.9">7.28.3.9</a>
-prefix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
-preprocessing concatenation, <a href="#6.10.3.3">6.10.3.3</a>                         qsort function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.2">7.22.5.2</a>
-preprocessing directives, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10">6.10</a>                       qsort_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>
-preprocessing file, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.10">6.10</a>                              qualified types, <a href="#6.2.5">6.2.5</a>
-preprocessing numbers, <a href="#6.4">6.4</a>, <a href="#6.4.8">6.4.8</a>                             qualified version of type, <a href="#6.2.5">6.2.5</a>
-preprocessing operators                                       question-mark escape sequence (\?), <a href="#6.4.4.4">6.4.4.4</a>
-  #, <a href="#6.10.3.2">6.10.3.2</a>                                                 quick_exit function, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>,
-  ##, <a href="#6.10.3.3">6.10.3.3</a>                                                     <a href="#7.22.4.7">7.22.4.7</a>
-  _Pragma, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>                                    quiet NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-  defined, <a href="#6.10.1">6.10.1</a>
-preprocessing tokens, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>                      raise function, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>, <a href="#7.22.4.1">7.22.4.1</a>
-preprocessing translation unit, <a href="#5.1.1.1">5.1.1.1</a>                       rand function, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.2.2">7.22.2.2</a>
-
-[<a name="p670" href="#p670">page 670</a>] (<a href="#Contents">Contents</a>)
-
-RAND_MAX macro, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a>                               restrict-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
-range                                                        return statement, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
-   excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                       rewind function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.5">7.21.9.5</a>,
-range error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#7.12.6.1">7.12.6.1</a>,                 <a href="#7.28.3.10">7.28.3.10</a>
-      <a href="#7.12.6.2">7.12.6.2</a>, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.6">7.12.6.6</a>,                right-shift assignment operator (&gt;&gt;=), <a href="#6.5.16.2">6.5.16.2</a>
-      <a href="#7.12.6.13">7.12.6.13</a>, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.8.2">7.12.8.2</a>,               right-shift operator (&gt;&gt;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
-      <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>,                rint functions, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.4">F.10.6.4</a>
-      <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#7.12.13.1">7.12.13.1</a>                        rint type-generic macro, <a href="#7.24">7.24</a>
-rank, see integer conversion rank                            round functions, <a href="#7.12.9.6">7.12.9.6</a>, <a href="#F.10.6.6">F.10.6.6</a>
-read-modify-write operations, <a href="#5.1.2.4">5.1.2.4</a>                        round type-generic macro, <a href="#7.24">7.24</a>
-real floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,              rounding mode, floating point, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                      RSIZE_MAX macro, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>,
-real floating types, <a href="#6.2.5">6.2.5</a>                                          <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>, <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>,
-real type domain, <a href="#6.2.5">6.2.5</a>                                            <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>,
-real types, <a href="#6.2.5">6.2.5</a>                                                  <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.7.1.1">K.3.7.1.1</a>,
-real-floating, <a href="#7.12.3">7.12.3</a>                                               <a href="#K.3.7.1.2">K.3.7.1.2</a>, <a href="#K.3.7.1.3">K.3.7.1.3</a>, <a href="#K.3.7.1.4">K.3.7.1.4</a>, <a href="#K.3.7.2.1">K.3.7.2.1</a>,
-realloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.5">7.22.3.5</a>                                 <a href="#K.3.7.2.2">K.3.7.2.2</a>, <a href="#K.3.7.3.1">K.3.7.3.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a>,
-recommended practice, <a href="#3.17">3.17</a>                                         <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>,
-recursion, <a href="#6.5.2.2">6.5.2.2</a>                                                 <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a>, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a>,
-recursive function call, <a href="#6.5.2.2">6.5.2.2</a>                                   <a href="#K.3.9.2.1.3">K.3.9.2.1.3</a>, <a href="#K.3.9.2.1.4">K.3.9.2.1.4</a>, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a>,
-redefinition of macro, <a href="#6.10.3">6.10.3</a>                                       <a href="#K.3.9.2.2.2">K.3.9.2.2.2</a>, <a href="#K.3.9.2.3.1">K.3.9.2.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>,
-reentrancy, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>                                         <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
-   library functions, <a href="#7.1.4">7.1.4</a>                                  rsize_t type, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
-referenced type, <a href="#6.2.5">6.2.5</a>                                             <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
-register storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>                  runtime-constraint, <a href="#3.18">3.18</a>
-relational expressions, <a href="#6.5.8">6.5.8</a>                                Runtime-constraint handling functions, <a href="#K.3.6.1">K.3.6.1</a>
-relaxed atomic operations, <a href="#5.1.2.4">5.1.2.4</a>                           rvalue, <a href="#6.3.2.1">6.3.2.1</a>
-release fence, <a href="#7.17.4">7.17.4</a>
-release operation, <a href="#5.1.2.4">5.1.2.4</a>                                   same scope, <a href="#6.2.1">6.2.1</a>
-release sequence, <a href="#5.1.2.4">5.1.2.4</a>                                    save calling environment function, <a href="#7.13.1">7.13.1</a>
-reliability of data, interrupted, <a href="#5.1.2.3">5.1.2.3</a>                    scalar types, <a href="#6.2.5">6.2.5</a>
-remainder assignment operator (%=), <a href="#6.5.16.2">6.5.16.2</a>                 scalbln function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a>
-remainder functions, <a href="#7.12.10">7.12.10</a>, <a href="#F.10.7">F.10.7</a>                         scalbln type-generic macro, <a href="#7.24">7.24</a>
-remainder functions, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>,              scalbn function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a>
-      <a href="#F.10.7.2">F.10.7.2</a>                                               scalbn type-generic macro, <a href="#7.24">7.24</a>
-remainder operator (%), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>                       scanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.11">7.21.6.11</a>
-remainder type-generic macro, <a href="#7.24">7.24</a>                           scanf_s function, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>
-remove function, <a href="#7.21.4.1">7.21.4.1</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>               scanlist, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
-remquo functions, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>, <a href="#F.10.7.3">F.10.7.3</a>                   scanset, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
-remquo type-generic macro, <a href="#7.24">7.24</a>                              SCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-rename function, <a href="#7.21.4.2">7.21.4.2</a>                                    SCHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-representations of types, <a href="#6.2.6">6.2.6</a>                              SCNcFASTN macros, <a href="#7.8.1">7.8.1</a>
-   pointer, <a href="#6.2.5">6.2.5</a>                                            SCNcLEASTN macros, <a href="#7.8.1">7.8.1</a>
-rescanning and replacement, <a href="#6.10.3.4">6.10.3.4</a>                         SCNcMAX macros, <a href="#7.8.1">7.8.1</a>
-reserved identifiers, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>                   SCNcN macros, <a href="#7.8.1">7.8.1</a>
-restartable multibyte/wide character conversion              SCNcPTR macros, <a href="#7.8.1">7.8.1</a>
-      functions, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>                 scope of identifier, <a href="#6.2.1">6.2.1</a>, <a href="#6.9.2">6.9.2</a>
-restartable multibyte/wide string conversion                 search functions
-      functions, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                           string, <a href="#7.23.5">7.23.5</a>, <a href="#K.3.7.3">K.3.7.3</a>
-restore calling environment function, <a href="#7.13.2">7.13.2</a>                   utility, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a>
-restrict type qualifier, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>                         wide string, <a href="#7.28.4.5">7.28.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a>
-
-[<a name="p671" href="#p671">page 671</a>] (<a href="#Contents">Contents</a>)
-
-SEEK_CUR macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 sign and magnitude, <a href="#6.2.6.2">6.2.6.2</a>
-SEEK_END macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 sign bit, <a href="#6.2.6.2">6.2.6.2</a>
-SEEK_SET macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 signal function, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
-selection statements, <a href="#6.8.4">6.8.4</a>                                      signal handler, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>
-self-referential structure, <a href="#6.7.2.3">6.7.2.3</a>                              signal handling functions, <a href="#7.14.1">7.14.1</a>
-semicolon punctuator (;), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,                   signal.h header, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>
-      <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>                                               signaling NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#F.2.1">F.2.1</a>
-separate compilation, <a href="#5.1.1.1">5.1.1.1</a>                                    signals, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1">7.14.1</a>
-separate translation, <a href="#5.1.1.1">5.1.1.1</a>                                    signbit macro, <a href="#7.12.3.6">7.12.3.6</a>, <a href="#F.3">F.3</a>
-sequence points, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.13">6.5.13</a>, <a href="#6.5.14">6.5.14</a>,               signed char type, <a href="#6.2.5">6.2.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
-      <a href="#6.5.15">6.5.15</a>, <a href="#6.5.17">6.5.17</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.6">6.7.6</a>, <a href="#6.8">6.8</a>,                     <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
-      <a href="#7.1.4">7.1.4</a>, <a href="#7.21.6">7.21.6</a>, <a href="#7.22.5">7.22.5</a>, <a href="#7.28.2">7.28.2</a>, <a href="#C">C</a>, <a href="#K.3.6.3">K.3.6.3</a>                  signed character, <a href="#6.3.1.1">6.3.1.1</a>
-sequenced after, see sequenced before                            signed integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>
-sequenced before, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.2.4">6.5.2.4</a>,                signed type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
-      <a href="#6.5.16">6.5.16</a>, see also indeterminately sequenced,                     <a href="#6.3.1.8">6.3.1.8</a>
-      unsequenced                                                signed types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>
-sequencing of statements, <a href="#6.8">6.8</a>                                    significand part, <a href="#6.4.4.2">6.4.4.2</a>
-set_constraint_handler_s function,                               SIGSEGV macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>
-      <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a>, <a href="#K.3.6.1.3">K.3.6.1.3</a>                   SIGTERM macro, <a href="#7.14">7.14</a>
-setbuf function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.5">7.21.5.5</a>                      simple assignment operator (=), <a href="#6.5.16.1">6.5.16.1</a>
-setjmp macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>                          sin functions, <a href="#7.12.4.6">7.12.4.6</a>, <a href="#F.10.1.6">F.10.1.6</a>
-setjmp.h header, <a href="#7.13">7.13</a>                                            sin type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
-setlocale function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>                           single-byte character, <a href="#3.7.1">3.7.1</a>, <a href="#5.2.1.2">5.2.1.2</a>
-setvbuf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>,                      single-byte/wide character conversion functions,
-      <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>                                              <a href="#7.28.6.1">7.28.6.1</a>
-shall, <a href="#4">4</a>                                                         single-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>
-shift expressions, <a href="#6.5.7">6.5.7</a>                                         single-quote escape sequence (\'), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>
-shift sequence, <a href="#7.1.1">7.1.1</a>                                            singularity, <a href="#7.12.1">7.12.1</a>
-shift states, <a href="#5.2.1.2">5.2.1.2</a>                                            sinh functions, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#F.10.2.5">F.10.2.5</a>
-short identifier, character, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.3">6.4.3</a>                       sinh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
-short int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,                 SIZE_MAX macro, <a href="#7.20.3">7.20.3</a>
-      <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>                               size_t type, <a href="#6.2.8">6.2.8</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.1">7.21.1</a>,
-short int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,                          <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.23.1">7.23.1</a>, <a href="#7.26.1">7.26.1</a>, <a href="#7.27">7.27</a>,
-      <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                                <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>,
-SHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                             <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
-SHRT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                        sizeof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>
-side effects, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.4">6.5.2.4</a>,           snprintf function, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.12">7.21.6.12</a>,
-      <a href="#6.5.16">6.5.16</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8.3">6.8.3</a>, <a href="#7.6">7.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.21.7.5">7.21.7.5</a>,                     <a href="#K.3.5.3.5">K.3.5.3.5</a>
-      <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.28.3.6">7.28.3.6</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#F.8.1">F.8.1</a>, <a href="#F.9.1">F.9.1</a>,                snprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
-      <a href="#F.9.3">F.9.3</a>                                                      snwprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
-SIG_ATOMIC_MAX macro, <a href="#7.20.3">7.20.3</a>                                     sorting utility functions, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a>
-SIG_ATOMIC_MIN macro, <a href="#7.20.3">7.20.3</a>                                     source character set, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>
-sig_atomic_t type, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>,                      source file, <a href="#5.1.1.1">5.1.1.1</a>
-      <a href="#7.20.3">7.20.3</a>                                                        name, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a>
-SIG_DFL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source file inclusion, <a href="#6.10.2">6.10.2</a>
-SIG_ERR macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source lines, <a href="#5.1.1.2">5.1.1.2</a>
-SIG_IGN macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source text, <a href="#5.1.1.2">5.1.1.2</a>
-SIGABRT macro, <a href="#7.14">7.14</a>, <a href="#7.22.4.1">7.22.4.1</a>                                    space character (' '), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,
-SIGFPE macro, <a href="#7.12.1">7.12.1</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.5.17">J.5.17</a>                          <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>
-SIGILL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                     sprintf function, <a href="#7.21.6.6">7.21.6.6</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
-SIGINT macro, <a href="#7.14">7.14</a>                                               sprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
-
-[<a name="p672" href="#p672">page 672</a>] (<a href="#Contents">Contents</a>)
-
-sqrt functions, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.5">F.10.4.5</a>                         do, <a href="#6.8.5.2">6.8.5.2</a>
-sqrt type-generic macro, <a href="#7.24">7.24</a>                                   else, <a href="#6.8.4.1">6.8.4.1</a>
-srand function, <a href="#7.22.2.2">7.22.2.2</a>                                        expression, <a href="#6.8.3">6.8.3</a>
-sscanf function, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.14">7.21.6.14</a>                            for, <a href="#6.8.5.3">6.8.5.3</a>
-sscanf_s function, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                        goto, <a href="#6.8.6.1">6.8.6.1</a>
-standard error stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.10.4">7.21.10.4</a>                if, <a href="#6.8.4.1">6.8.4.1</a>
-standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a>                                      iteration, <a href="#6.8.5">6.8.5</a>
-   <a href="#7.2">&lt;assert.h&gt;</a>, <a href="#7.2">7.2</a>                                              jump, <a href="#6.8.6">6.8.6</a>
-   <a href="#7.3">&lt;complex.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.3">7.3</a>,                labeled, <a href="#6.8.1">6.8.1</a>
-        <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>                               null, <a href="#6.8.3">6.8.3</a>
-   <a href="#7.4">&lt;ctype.h&gt;</a>, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>                                       return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
-   <a href="#7.5">&lt;errno.h&gt;</a>, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>                                selection, <a href="#6.8.4">6.8.4</a>
-   <a href="#7.6">&lt;fenv.h&gt;</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>                sequencing, <a href="#6.8">6.8</a>
-   <a href="#7.7">&lt;float.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,                      switch, <a href="#6.8.4.2">6.8.4.2</a>
-        <a href="#7.28.4.1.1">7.28.4.1.1</a>                                              while, <a href="#6.8.5.1">6.8.5.1</a>
-   <a href="#7.8">&lt;inttypes.h&gt;</a>, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>                                 static assertions, <a href="#6.7.10">6.7.10</a>
-   <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#4">4</a>, <a href="#7.9">7.9</a>                                        static storage duration, <a href="#6.2.4">6.2.4</a>
-   <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                     static storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.7.1">6.7.1</a>
-   <a href="#7.11">&lt;locale.h&gt;</a>, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>                                  static, in array declarators, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.6.3">6.7.6.3</a>
-   <a href="#7.12">&lt;math.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>, <a href="#F.10">F.10</a>,            static_assert declaration, <a href="#6.7.10">6.7.10</a>
-        <a href="#J.5.17">J.5.17</a>                                               static_assert macro, <a href="#7.2">7.2</a>
-   <a href="#7.13">&lt;setjmp.h&gt;</a>, <a href="#7.13">7.13</a>                                          stdalign.h header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
-   <a href="#7.14">&lt;signal.h&gt;</a>, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>                                  stdarg.h header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
-   <a href="#7.15">&lt;stdalign.h&gt;</a>, <a href="#4">4</a>, <a href="#7.15">7.15</a>                                     stdatomic.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>
-   <a href="#7.16">&lt;stdarg.h&gt;</a>, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>                              stdbool.h header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>
-   <a href="#7.17">&lt;stdatomic.h&gt;</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>                      STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>
-   <a href="#7.18">&lt;stdbool.h&gt;</a>, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>                           stddef.h header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
-   <a href="#7.19">&lt;stddef.h&gt;</a>, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,                       <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>
-        <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>                   stderr macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>
-   <a href="#7.20">&lt;stdint.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>,                stdin macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.4">7.21.6.4</a>,
-        <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>                                       <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.28.2.12">7.28.2.12</a>, <a href="#7.28.3.7">7.28.3.7</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
-   <a href="#7.21">&lt;stdio.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>                    <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
-   <a href="#7.22">&lt;stdlib.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,                  stdint.h header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>,
-        <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>                                             <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>
-   <a href="#7.23">&lt;string.h&gt;</a>, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                          stdio.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>
-   <a href="#7.24">&lt;tgmath.h&gt;</a>, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                     stdlib.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,
-   <a href="#7.25">&lt;threads.h&gt;</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                              <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>
-   <a href="#7.26">&lt;time.h&gt;</a>, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                     stdout macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.3">7.21.6.3</a>,
-   <a href="#7.27">&lt;uchar.h&gt;</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                                 <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>, <a href="#7.28.2.11">7.28.2.11</a>, <a href="#7.28.3.9">7.28.3.9</a>
-   <a href="#7.28">&lt;wchar.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>, <a href="#7.30.12">7.30.12</a>,              storage duration, <a href="#6.2.4">6.2.4</a>
-        <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>                                             storage order of array, <a href="#6.5.2.1">6.5.2.1</a>
-   <a href="#7.29">&lt;wctype.h&gt;</a>, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                                 storage unit (bit-field), <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
-standard input stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                        storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a>
-standard integer types, <a href="#6.2.5">6.2.5</a>                                strcat function, <a href="#7.23.3.1">7.23.3.1</a>
-standard output stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                       strcat_s function, <a href="#K.3.7.2.1">K.3.7.2.1</a>
-standard signed integer types, <a href="#6.2.5">6.2.5</a>                         strchr function, <a href="#7.23.5.2">7.23.5.2</a>
-state-dependent encoding, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>           strcmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.2">7.23.4.2</a>
-statements, <a href="#6.8">6.8</a>                                              strcoll function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.3">7.23.4.3</a>, <a href="#7.23.4.5">7.23.4.5</a>
-   break, <a href="#6.8.6.3">6.8.6.3</a>                                            strcpy function, <a href="#7.23.2.3">7.23.2.3</a>
-   compound, <a href="#6.8.2">6.8.2</a>                                           strcpy_s function, <a href="#K.3.7.1.3">K.3.7.1.3</a>
-   continue, <a href="#6.8.6.2">6.8.6.2</a>                                         strcspn function, <a href="#7.23.5.3">7.23.5.3</a>
-
-[<a name="p673" href="#p673">page 673</a>] (<a href="#Contents">Contents</a>)
-
-streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.22.4.4">7.22.4.4</a>                                                <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>
-   fully buffered, <a href="#7.21.3">7.21.3</a>                                          strtoull function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>
-   line buffered, <a href="#7.21.3">7.21.3</a>                                           strtoumax function, <a href="#7.8.2.3">7.8.2.3</a>
-   orientation, <a href="#7.21.2">7.21.2</a>                                             struct hack, see flexible array member
-   standard error, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                  struct lconv, <a href="#7.11">7.11</a>
-   standard input, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                  struct tm, <a href="#7.26.1">7.26.1</a>
-   standard output, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                 structure
-   unbuffered, <a href="#7.21.3">7.21.3</a>                                                 arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
-strerror function, <a href="#7.21.10.4">7.21.10.4</a>, <a href="#7.23.6.2">7.23.6.2</a>                                content, <a href="#6.7.2.3">6.7.2.3</a>
-strerror_s function, <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a>                             dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>
-strerrorlen_s function, <a href="#K.3.7.4.3">K.3.7.4.3</a>                                     initialization, <a href="#6.7.9">6.7.9</a>
-strftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.26.3.5">7.26.3.5</a>,                        member alignment, <a href="#6.7.2.1">6.7.2.1</a>
-      <a href="#7.28.5.1">7.28.5.1</a>, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>                         member name space, <a href="#6.2.3">6.2.3</a>
-stricter, <a href="#6.2.8">6.2.8</a>                                                       member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>
-strictly conforming program, <a href="#4">4</a>                                        pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
-string, <a href="#7.1.1">7.1.1</a>                                                         specifier, <a href="#6.7.2.1">6.7.2.1</a>
-   comparison functions, <a href="#7.23.4">7.23.4</a>                                       tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
-   concatenation functions, <a href="#7.23.3">7.23.3</a>, <a href="#K.3.7.2">K.3.7.2</a>                           type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>
-   conversion functions, <a href="#7.11.1.1">7.11.1.1</a>                                  strxfrm function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.5">7.23.4.5</a>
-   copying functions, <a href="#7.23.2">7.23.2</a>, <a href="#K.3.7.1">K.3.7.1</a>                              subnormal floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-   library function conventions, <a href="#7.23.1">7.23.1</a>                            subscripting, <a href="#6.5.2.1">6.5.2.1</a>
-   literal, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.7.9">6.7.9</a>           subtraction assignment operator (-=), <a href="#6.5.16.2">6.5.16.2</a>
-   miscellaneous functions, <a href="#7.23.6">7.23.6</a>, <a href="#K.3.7.4">K.3.7.4</a>                        subtraction operator (-), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
-   numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                   suffix
-   search functions, <a href="#7.23.5">7.23.5</a>, <a href="#K.3.7.3">K.3.7.3</a>                                  floating constant, <a href="#6.4.4.2">6.4.4.2</a>
-string handling header, <a href="#7.23">7.23</a>, <a href="#K.3.7">K.3.7</a>                                   integer constant, <a href="#6.4.4.1">6.4.4.1</a>
-string.h header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                              switch body, <a href="#6.8.4.2">6.8.4.2</a>
-stringizing, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.9">6.10.9</a>                                      switch case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
-strlen function, <a href="#7.23.6.3">7.23.6.3</a>                                          switch default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
-strncat function, <a href="#7.23.3.2">7.23.3.2</a>                                         switch statement, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
-strncat_s function, <a href="#K.3.7.2.2">K.3.7.2.2</a>                                      swprintf function, <a href="#7.28.2.3">7.28.2.3</a>, <a href="#7.28.2.7">7.28.2.7</a>,
-strncmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.4">7.23.4.4</a>                                       <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
-strncpy function, <a href="#7.23.2.4">7.23.2.4</a>                                         swprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
-strncpy_s function, <a href="#K.3.7.1.4">K.3.7.1.4</a>                                      swscanf function, <a href="#7.28.2.4">7.28.2.4</a>, <a href="#7.28.2.8">7.28.2.8</a>
-strnlen_s function, <a href="#K.3.7.4.4">K.3.7.4.4</a>                                      swscanf_s function, <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>
-stronger, <a href="#6.2.8">6.2.8</a>                                                    symbols, <a href="#3">3</a>
-strpbrk function, <a href="#7.23.5.4">7.23.5.4</a>                                         synchronization operation, <a href="#5.1.2.4">5.1.2.4</a>
-strrchr function, <a href="#7.23.5.5">7.23.5.5</a>                                         synchronize with, <a href="#5.1.2.4">5.1.2.4</a>
-strspn function, <a href="#7.23.5.6">7.23.5.6</a>                                          syntactic categories, <a href="#6.1">6.1</a>
-strstr function, <a href="#7.23.5.7">7.23.5.7</a>                                          syntax notation, <a href="#6.1">6.1</a>
-strtod function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    syntax rule precedence, <a href="#5.1.1.2">5.1.1.2</a>
-      <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.3">F.3</a>                                                syntax summary, language, <a href="#A">A</a>
-strtof function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>                          system function, <a href="#7.22.4.8">7.22.4.8</a>
-strtoimax function, <a href="#7.8.2.3">7.8.2.3</a>
-strtok function, <a href="#7.23.5.8">7.23.5.8</a>                                          tab characters, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
-strtok_s function, <a href="#K.3.7.3.1">K.3.7.3.1</a>                                       tag compatibility, <a href="#6.2.7">6.2.7</a>
-strtol function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,                      tag name space, <a href="#6.2.3">6.2.3</a>
-      <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>                                           tags, <a href="#6.7.2.3">6.7.2.3</a>
-strtold function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>                         tan functions, <a href="#7.12.4.7">7.12.4.7</a>, <a href="#F.10.1.7">F.10.1.7</a>
-strtoll function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>                      tan type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
-strtoul function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,                     tanh functions, <a href="#7.12.5.6">7.12.5.6</a>, <a href="#F.10.2.6">F.10.2.6</a>
-
-[<a name="p674" href="#p674">page 674</a>] (<a href="#Contents">Contents</a>)
-
-tanh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                            toupper function, <a href="#7.4.2.2">7.4.2.2</a>
-temporary lifetime, <a href="#6.2.4">6.2.4</a>                                     towctrans function, <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>
-tentative definition, <a href="#6.9.2">6.9.2</a>                                    towlower function, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.2.1">7.29.3.2.1</a>
-terms, <a href="#3">3</a>                                                      towupper function, <a href="#7.29.3.1.2">7.29.3.1.2</a>, <a href="#7.29.3.2.1">7.29.3.2.1</a>
-text streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>           translation environment, <a href="#5">5</a>, <a href="#5.1.1">5.1.1</a>
-tgamma functions, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#F.10.5.4">F.10.5.4</a>                          translation limits, <a href="#5.2.4.1">5.2.4.1</a>
-tgamma type-generic macro, <a href="#7.24">7.24</a>                               translation phases, <a href="#5.1.1.2">5.1.1.2</a>
-tgmath.h header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                    translation unit, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.9">6.9</a>
-thrd_create function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.5.1">7.25.5.1</a>                        trap, see perform a trap
-thrd_current function, <a href="#7.25.5.2">7.25.5.2</a>                               trap representation, <a href="#3.19.4">3.19.4</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.2.6.2">6.2.6.2</a>,
-thrd_detach function, <a href="#7.25.5.3">7.25.5.3</a>                                      <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.5.2.3">6.5.2.3</a>
-thrd_equal function, <a href="#7.25.5.4">7.25.5.4</a>                                 trigonometric functions
-thrd_exit function, <a href="#7.25.5.5">7.25.5.5</a>                                     complex, <a href="#7.3.5">7.3.5</a>, <a href="#G.6.1">G.6.1</a>
-thrd_join function, <a href="#7.25.5.6">7.25.5.6</a>                                     real, <a href="#7.12.4">7.12.4</a>, <a href="#F.10.1">F.10.1</a>
-thrd_sleep function, <a href="#7.25.5.7">7.25.5.7</a>                                 trigraph sequences, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1.1">5.2.1.1</a>
-thrd_start_t type, <a href="#7.25.1">7.25.1</a>                                     true macro, <a href="#7.18">7.18</a>
-thrd_t type, <a href="#7.25.1">7.25.1</a>                                           trunc functions, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#F.10.6.8">F.10.6.8</a>
-thrd_yield function, <a href="#7.25.5.8">7.25.5.8</a>                                 trunc type-generic macro, <a href="#7.24">7.24</a>
-thread of execution, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.6">7.6</a>, <a href="#7.22.4.6">7.22.4.6</a>            truncation, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a>
-thread storage duration, <a href="#6.2.4">6.2.4</a>, <a href="#7.6">7.6</a>                           truncation toward zero, <a href="#6.5.5">6.5.5</a>
-threads header, <a href="#7.25">7.25</a>                                          tss_create function, <a href="#7.25.6.1">7.25.6.1</a>
-threads.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                       tss_delete function, <a href="#7.25.6.2">7.25.6.2</a>
-time                                                          TSS_DTOR_ITERATIONS macro, <a href="#7.25.1">7.25.1</a>
-   broken down, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.26.3.1">7.26.3.1</a>,           tss_dtor_t type, <a href="#7.25.1">7.25.1</a>
-         <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>,             tss_get function, <a href="#7.25.6.3">7.25.6.3</a>
-         <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                 tss_set function, <a href="#7.25.6.4">7.25.6.4</a>
-   calendar, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.2">7.26.2.2</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.2.4">7.26.2.4</a>,            tss_t type, <a href="#7.25.1">7.25.1</a>
-         <a href="#7.26.3.2">7.26.3.2</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>,             two's complement, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a>
-         <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                 type category, <a href="#6.2.5">6.2.5</a>
-   components, <a href="#7.26.1">7.26.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                                type conversion, <a href="#6.3">6.3</a>
-   conversion functions, <a href="#7.26.3">7.26.3</a>, <a href="#K.3.8.2">K.3.8.2</a>                      type definitions, <a href="#6.7.8">6.7.8</a>
-      wide character, <a href="#7.28.5">7.28.5</a>                                  type domain, <a href="#6.2.5">6.2.5</a>, <a href="#G.2">G.2</a>
-   local, <a href="#7.26.1">7.26.1</a>                                              type names, <a href="#6.7.7">6.7.7</a>
-   manipulation functions, <a href="#7.26.2">7.26.2</a>                             type punning, <a href="#6.5.2.3">6.5.2.3</a>
-   normalized broken down, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>                 type qualifiers, <a href="#6.7.3">6.7.3</a>
-time function, <a href="#7.26.2.4">7.26.2.4</a>                                       type specifiers, <a href="#6.7.2">6.7.2</a>
-time.h header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                    type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
-time_t type, <a href="#7.26.1">7.26.1</a>                                           typedef declaration, <a href="#6.7.8">6.7.8</a>
-TIME_UTC macro, <a href="#7.25.7.1">7.25.7.1</a>                                      typedef storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.7.8">6.7.8</a>
-tm structure type, <a href="#7.26.1">7.26.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                    types, <a href="#6.2.5">6.2.5</a>
-TMP_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>                        atomic, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>,
-TMP_MAX_S macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                           <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.17.6">7.17.6</a>
-tmpfile function, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>                             character, <a href="#6.7.9">6.7.9</a>
-tmpfile_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                         compatible, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a>
-tmpnam function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>,                     complex, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>
-      <a href="#K.3.5.1.2">K.3.5.1.2</a>                                                  composite, <a href="#6.2.7">6.2.7</a>
-tmpnam_s function, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                   const qualified, <a href="#6.7.3">6.7.3</a>
-token, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, see also preprocessing tokens               conversions, <a href="#6.3">6.3</a>
-token concatenation, <a href="#6.10.3.3">6.10.3.3</a>                                    imaginary, <a href="#G">G</a>
-token pasting, <a href="#6.10.3.3">6.10.3.3</a>                                          restrict qualified, <a href="#6.7.3">6.7.3</a>
-tolower function, <a href="#7.4.2.1">7.4.2.1</a>                                        volatile qualified, <a href="#6.7.3">6.7.3</a>
-
-[<a name="p675" href="#p675">page 675</a>] (<a href="#Contents">Contents</a>)
-
-uchar.h header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                      universal character name, <a href="#6.4.3">6.4.3</a>
-UCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                unnormalized floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a>
-UINT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>                           unqualified type, <a href="#6.2.5">6.2.5</a>
-uint_fastN_t types, <a href="#7.20.1.3">7.20.1.3</a>                              unqualified version of type, <a href="#6.2.5">6.2.5</a>
-uint_least16_t type, <a href="#7.27">7.27</a>                                 unsequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, see also
-uint_least32_t type, <a href="#7.27">7.27</a>                                       indeterminately sequenced, sequenced
-UINT_LEASTN_MAX macros, <a href="#7.20.2.2">7.20.2.2</a>                                before
-uint_leastN_t types, <a href="#7.20.1.2">7.20.1.2</a>                             unsigned char type, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
-UINT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                 unsigned integer suffix, u or <a href="#U">U</a>, <a href="#6.4.4.1">6.4.4.1</a>
-UINTMAX_C macro, <a href="#7.20.4.2">7.20.4.2</a>                                 unsigned integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>
-UINTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>             unsigned type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
-uintmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                   <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
-     <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>                                   unsigned types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
-UINTN_C macros, <a href="#7.20.4.1">7.20.4.1</a>                                        <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
-UINTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>                                unspecified behavior, <a href="#3.4.4">3.4.4</a>, <a href="#4">4</a>, <a href="#J.1">J.1</a>
-uintN_t types, <a href="#7.20.1.1">7.20.1.1</a>                                   unspecified value, <a href="#3.19.3">3.19.3</a>
-UINTPTR_MAX macro, <a href="#7.20.2.4">7.20.2.4</a>                               uppercase letter, <a href="#5.2.1">5.2.1</a>
-uintptr_t type, <a href="#7.20.1.4">7.20.1.4</a>                                  use of library functions, <a href="#7.1.4">7.1.4</a>
-ULLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                    USHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
-     <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           usual arithmetic conversions, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.5.5">6.5.5</a>, <a href="#6.5.6">6.5.6</a>,
-ULONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                           <a href="#6.5.8">6.5.8</a>, <a href="#6.5.9">6.5.9</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>, <a href="#6.5.15">6.5.15</a>
-     <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           UTF-16, <a href="#6.10.8.2">6.10.8.2</a>
-unary arithmetic operators, <a href="#6.5.3.3">6.5.3.3</a>                       UTF-32, <a href="#6.10.8.2">6.10.8.2</a>
-unary expression, <a href="#6.5.3">6.5.3</a>                                   UTF-8 string literal, see string literal
-unary minus operator (-), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>                    utilities, general, <a href="#7.22">7.22</a>, <a href="#K.3.6">K.3.6</a>
-unary operators, <a href="#6.5.3">6.5.3</a>                                       wide string, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>
-unary plus operator (+), <a href="#6.5.3.3">6.5.3.3</a>
-unbuffered stream, <a href="#7.21.3">7.21.3</a>                                 va_arg macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.2">7.16.1.2</a>,
-undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,                <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>,
-     <a href="#7.1.4">7.1.4</a>                                                     <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
-undefined behavior, <a href="#3.4.3">3.4.3</a>, <a href="#4">4</a>, <a href="#J.2">J.2</a>                               <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>,
-underscore character, <a href="#6.4.2.1">6.4.2.1</a>                                  <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
-underscore, leading, in identifier, <a href="#7.1.3">7.1.3</a>                       <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
-ungetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,             va_copy macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>,
-     <a href="#7.21.9.3">7.21.9.3</a>                                                  <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>
-ungetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.10">7.28.3.10</a>                       va_end macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.3">7.16.1.3</a>,
-Unicode, <a href="#7.27">7.27</a>, see also char16_t type,                         <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>,
-     char32_t type, wchar_t type                               <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
-Unicode required set, <a href="#6.10.8.2">6.10.8.2</a>                                 <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>,
-union                                                          <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
-  arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                 <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
-  content, <a href="#6.7.2.3">6.7.2.3</a>                                        va_list type, <a href="#7.16">7.16</a>, <a href="#7.16.1.3">7.16.1.3</a>
-  dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                               va_start macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>,
-  initialization, <a href="#6.7.9">6.7.9</a>                                        <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>, <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>,
-  member alignment, <a href="#6.7.2.1">6.7.2.1</a>                                    <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>,
-  member name space, <a href="#6.2.3">6.2.3</a>                                     <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>,
-  member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>                        <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>,
-  pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                               <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>,
-  specifier, <a href="#6.7.2.1">6.7.2.1</a>                                            <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
-  tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>                                     value, <a href="#3.19">3.19</a>
-  type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>                                    value bits, <a href="#6.2.6.2">6.2.6.2</a>
-
-[<a name="p676" href="#p676">page 676</a>] (<a href="#Contents">Contents</a>)
-
-variable arguments, <a href="#6.10.3">6.10.3</a>, <a href="#7.16">7.16</a>                             vswscanf function, <a href="#7.28.2.8">7.28.2.8</a>
-variable arguments header, <a href="#7.16">7.16</a>                              vswscanf_s function, <a href="#K.3.9.1.10">K.3.9.1.10</a>
-variable length array, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>              vwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#K.3.9.1.11">K.3.9.1.11</a>
-variably modified type, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>              vwprintf_s function, <a href="#K.3.9.1.11">K.3.9.1.11</a>
-vertical-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                           vwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.3.10">7.28.3.10</a>
-vertical-tab escape sequence (\v), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           vwscanf_s function, <a href="#K.3.9.1.12">K.3.9.1.12</a>
-     <a href="#7.4.1.10">7.4.1.10</a>
-vfprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#K.3.5.3.8">K.3.5.3.8</a>               warnings, <a href="#I">I</a>
-vfprintf_s function, <a href="#K.3.5.3.8">K.3.5.3.8</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>,                   wchar.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>, <a href="#7.30.12">7.30.12</a>,
-     <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                                      <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>
-vfscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>                 WCHAR_MAX macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.28.1">7.28.1</a>
-vfscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                   WCHAR_MIN macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.28.1">7.28.1</a>
-     <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wchar_t type, <a href="#3.7.3">3.7.3</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>,
-vfwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.5">7.28.2.5</a>, <a href="#K.3.9.1.6">K.3.9.1.6</a>                  <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.28.1">7.28.1</a>,
-vfwprintf_s function, <a href="#K.3.9.1.6">K.3.9.1.6</a>                                  <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
-vfwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.3.10">7.28.3.10</a>               wcrtomb function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,
-vfwscanf_s function, <a href="#K.3.9.1.7">K.3.9.1.7</a>                                   <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>,
-visibility of identifier, <a href="#6.2.1">6.2.1</a>                                   <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
-visible sequence of side effects, <a href="#5.1.2.4">5.1.2.4</a>                    wcrtomb_s function, <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>
-visible side effect, <a href="#5.1.2.4">5.1.2.4</a>                                 wcscat function, <a href="#7.28.4.3.1">7.28.4.3.1</a>
-VLA, see variable length array                               wcscat_s function, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a>
-void expression, <a href="#6.3.2.2">6.3.2.2</a>                                     wcschr function, <a href="#7.28.4.5.1">7.28.4.5.1</a>
-void function parameter, <a href="#6.7.6.3">6.7.6.3</a>                             wcscmp function, <a href="#7.28.4.4.1">7.28.4.4.1</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>
-void type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,                 wcscoll function, <a href="#7.28.4.4.2">7.28.4.4.2</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>
-     <a href="#K.3.9.1.2">K.3.9.1.2</a>                                               wcscpy function, <a href="#7.28.4.2.1">7.28.4.2.1</a>
-void type conversion, <a href="#6.3.2.2">6.3.2.2</a>                                wcscpy_s function, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a>
-volatile storage, <a href="#5.1.2.3">5.1.2.3</a>                                    wcscspn function, <a href="#7.28.4.5.2">7.28.4.5.2</a>
-volatile type qualifier, <a href="#6.7.3">6.7.3</a>                                wcsftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.28.5.1">7.28.5.1</a>
-volatile-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>                         wcslen function, <a href="#7.28.4.6.1">7.28.4.6.1</a>
-vprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.10">7.21.6.10</a>,               wcsncat function, <a href="#7.28.4.3.2">7.28.4.3.2</a>
-     <a href="#K.3.5.3.10">K.3.5.3.10</a>                                              wcsncat_s function, <a href="#K.3.9.2.2.2">K.3.9.2.2.2</a>
-vprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.10">K.3.5.3.10</a>,                   wcsncmp function, <a href="#7.28.4.4.3">7.28.4.4.3</a>
-     <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                                  wcsncpy function, <a href="#7.28.4.2.2">7.28.4.2.2</a>
-vscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.11">7.21.6.11</a>                 wcsncpy_s function, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a>
-vscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                    wcsnlen_s function, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a>
-     <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wcspbrk function, <a href="#7.28.4.5.3">7.28.4.5.3</a>
-vsnprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.12">7.21.6.12</a>,                     wcsrchr function, <a href="#7.28.4.5.4">7.28.4.5.4</a>
-     <a href="#K.3.5.3.12">K.3.5.3.12</a>                                              wcsrtombs function, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
-vsnprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                 wcsrtombs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
-     <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                      wcsspn function, <a href="#7.28.4.5.5">7.28.4.5.5</a>
-vsnwprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>                  wcsstr function, <a href="#7.28.4.5.6">7.28.4.5.6</a>
-vsprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.13">7.21.6.13</a>,                      wcstod function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
-     <a href="#K.3.5.3.13">K.3.5.3.13</a>                                              wcstod function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
-vsprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                  wcstof function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
-     <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                      wcstoimax function, <a href="#7.8.2.4">7.8.2.4</a>
-vsscanf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.14">7.21.6.14</a>                        wcstok function, <a href="#7.28.4.5.7">7.28.4.5.7</a>
-vsscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                   wcstok_s function, <a href="#K.3.9.2.3.1">K.3.9.2.3.1</a>
-     <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wcstol function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,
-vswprintf function, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#K.3.9.1.8">K.3.9.1.8</a>,                         <a href="#7.28.4.1.2">7.28.4.1.2</a>
-     <a href="#K.3.9.1.9">K.3.9.1.9</a>                                               wcstold function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
-vswprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>                   wcstoll function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
-
-[<a name="p677" href="#p677">page 677</a>] (<a href="#Contents">Contents</a>)
-
-wcstombs function, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.28.6.4">7.28.6.4</a>                           <a href="#7.29.1">7.29.1</a>
-wcstombs_s function, <a href="#K.3.6.5.2">K.3.6.5.2</a>                               wmemchr function, <a href="#7.28.4.5.8">7.28.4.5.8</a>
-wcstoul function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,               wmemcmp function, <a href="#7.28.4.4.5">7.28.4.4.5</a>
-     <a href="#7.28.4.1.2">7.28.4.1.2</a>                                              wmemcpy function, <a href="#7.28.4.2.3">7.28.4.2.3</a>
-wcstoull function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>                       wmemcpy_s function, <a href="#K.3.9.2.1.3">K.3.9.2.1.3</a>
-wcstoumax function, <a href="#7.8.2.4">7.8.2.4</a>                                  wmemmove function, <a href="#7.28.4.2.4">7.28.4.2.4</a>
-wcsxfrm function, <a href="#7.28.4.4.4">7.28.4.4.4</a>                                 wmemmove_s function, <a href="#K.3.9.2.1.4">K.3.9.2.1.4</a>
-wctob function, <a href="#7.28.6.1.2">7.28.6.1.2</a>, <a href="#7.29.2.1">7.29.2.1</a>                         wmemset function, <a href="#7.28.4.6.2">7.28.4.6.2</a>
-wctomb function, <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.28.6.3">7.28.6.3</a>                wprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.11">7.28.2.11</a>,
-wctomb_s function, <a href="#K.3.6.4.1">K.3.6.4.1</a>                                    <a href="#K.3.9.1.13">K.3.9.1.13</a>
-wctrans function, <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>                     wprintf_s function, <a href="#K.3.9.1.13">K.3.9.1.13</a>
-wctrans_t type, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>                           wscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.2.12">7.28.2.12</a>,
-wctype function, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>                         <a href="#7.28.3.10">7.28.3.10</a>
-wctype.h header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                               wscanf_s function, <a href="#K.3.9.1.12">K.3.9.1.12</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
-wctype_t type, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>
-weaker, <a href="#6.2.8">6.2.8</a>                                                xor macro, <a href="#7.9">7.9</a>
-WEOF macro, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.3.6">7.28.3.6</a>,            xor_eq macro, <a href="#7.9">7.9</a>
-     <a href="#7.28.3.7">7.28.3.7</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#7.28.3.9">7.28.3.9</a>, <a href="#7.28.3.10">7.28.3.10</a>,                xtime type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.3.5">7.25.3.5</a>, <a href="#7.25.4.4">7.25.4.4</a>, <a href="#7.25.5.7">7.25.5.7</a>,
-     <a href="#7.28.6.1.1">7.28.6.1.1</a>, <a href="#7.29.1">7.29.1</a>                                          <a href="#7.25.7.1">7.25.7.1</a>
-while statement, <a href="#6.8.5.1">6.8.5.1</a>                                     xtime_get function, <a href="#7.25.7.1">7.25.7.1</a>
-white space, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#7.4.1.10">7.4.1.10</a>,
-     <a href="#7.29.2.1.10">7.29.2.1.10</a>
-white-space characters, <a href="#6.4">6.4</a>
-wide character, <a href="#3.7.3">3.7.3</a>
-  case mapping functions, <a href="#7.29.3.1">7.29.3.1</a>
-     extensible, <a href="#7.29.3.2">7.29.3.2</a>
-  classification functions, <a href="#7.29.2.1">7.29.2.1</a>
-     extensible, <a href="#7.29.2.2">7.29.2.2</a>
-  constant, <a href="#6.4.4.4">6.4.4.4</a>
-  formatted input/output functions, <a href="#7.28.2">7.28.2</a>,
-        <a href="#K.3.9.1">K.3.9.1</a>
-  input functions, <a href="#7.21.1">7.21.1</a>
-  input/output functions, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3">7.28.3</a>
-  output functions, <a href="#7.21.1">7.21.1</a>
-  single-byte conversion functions, <a href="#7.28.6.1">7.28.6.1</a>
-wide string, <a href="#7.1.1">7.1.1</a>
-wide string comparison functions, <a href="#7.28.4.4">7.28.4.4</a>
-wide string concatenation functions, <a href="#7.28.4.3">7.28.4.3</a>,
-     <a href="#K.3.9.2.2">K.3.9.2.2</a>
-wide string copying functions, <a href="#7.28.4.2">7.28.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a>
-wide string literal, see string literal
-wide string miscellaneous functions, <a href="#7.28.4.6">7.28.4.6</a>,
-     <a href="#K.3.9.2.4">K.3.9.2.4</a>
-wide string numeric conversion functions, <a href="#7.8.2.4">7.8.2.4</a>,
-     <a href="#7.28.4.1">7.28.4.1</a>
-wide string search functions, <a href="#7.28.4.5">7.28.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a>
-wide-oriented stream, <a href="#7.21.2">7.21.2</a>
-width, <a href="#6.2.6.2">6.2.6.2</a>
-WINT_MAX macro, <a href="#7.20.3">7.20.3</a>
-WINT_MIN macro, <a href="#7.20.3">7.20.3</a>
-wint_t type, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>,
-
-[<a name="p678" href="#p678">page 678</a>] (<a href="#Contents">Contents</a>)
-</pre></body></html>
+             mbstate_t * restrict ps);</pre>
+ Runtime-constraints
+<p><!--para 3-->
+ None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
+ then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
+ pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
+ not equal zero. If dst is not a null pointer and len is not less than dstmax, then a null
+ character shall occur within the first dstmax multibyte characters of the array pointed to
+ by *src.
+<p><!--para 4-->
+ If there is a runtime-constraint violation, then mbsrtowcs_s does the following. If
+ retval is not a null pointer, then mbsrtowcs_s sets *retval to (size_t)(-1).
+ If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+ then mbsrtowcs_s sets dst[0] to the null wide character.
+<h6>Description</h6>
+<p><!--para 5-->
+ The mbsrtowcs_s function converts a sequence of multibyte characters that begins in
+ the conversion state described by the object pointed to by ps, from the array indirectly
+ pointed to by src into a sequence of corresponding wide characters. If dst is not a null
+ pointer, the converted characters are stored into the array pointed to by dst. Conversion
+ continues up to and including a terminating null character, which is also stored.
+ Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
+ not form a valid multibyte character, or (if dst is not a null pointer) when len wide
+<!--page 663 indent 5-->
+ characters have been stored into the array pointed to by dst.<sup><a href="#note439"><b>439)</b></a></sup> If dst is not a null
+ pointer and no null wide character was stored into the array pointed to by dst, then
+ dst[len] is set to the null wide character. Each conversion takes place as if by a call
+ to the mbrtowc function.
+<p><!--para 6-->
+ If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+ pointer (if conversion stopped due to reaching a terminating null character) or the address
+ just past the last multibyte character converted (if any). If conversion stopped due to
+ reaching a terminating null character and if dst is not a null pointer, the resulting state
+ described is the initial conversion state.
+<p><!--para 7-->
+ Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+ sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
+ the mbsrtowcs_s function stores the value (size_t)(-1) into *retval and the
+ conversion state is unspecified. Otherwise, the mbsrtowcs_s function stores into
+ *retval the number of multibyte characters successfully converted, not including the
+ terminating null character (if any).
+<p><!--para 8-->
+ All elements following the terminating null wide character (if any) written by
+ mbsrtowcs_s in the array of dstmax wide characters pointed to by dst take
+ unspecified values when mbsrtowcs_s returns.<sup><a href="#note440"><b>440)</b></a></sup>
+<p><!--para 9-->
+ If copying takes place between objects that overlap, the objects take on unspecified
+ values.
+<h6>Returns</h6>
+<p><!--para 10-->
+ The mbsrtowcs_s function returns zero if no runtime-constraint violation and no
+ encoding error occurred. Otherwise, a nonzero value is returned.
+
+<h6>footnotes</h6>
+<p><a name="note439">439)</a> Thus, the value of len is ignored if dst is a null pointer.
+
+<p><a name="note440">440)</a> This allows an implementation to attempt converting the multibyte string before discovering a
+ terminating null character did not occur where required.
+
+
+<a name="K.3.9.3.2.2" href="#K.3.9.3.2.2"><h5>K.3.9.3.2.2 The wcsrtombs_s function</h5></a>
+<h6>Synopsis</h6>
+<p><!--para 11-->
+<pre>
+          #include &lt;wchar.h&gt;
+          errno_t wcsrtombs_s(size_t * restrict retval,
+               char * restrict dst, rsize_t dstmax,
+               const wchar_t ** restrict src, rsize_t len,
+               mbstate_t * restrict ps);</pre>
+ 
+ 
+ 
+ 
+<!--page 664 indent 5-->
+ Runtime-constraints
+<p><!--para 12-->
+ None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
+ then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
+ pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
+ not equal zero. If dst is not a null pointer and len is not less than dstmax, then the
+ conversion shall have been stopped (see below) because a terminating null wide character
+ was reached or because an encoding error occurred.
+<p><!--para 13-->
+ If there is a runtime-constraint violation, then wcsrtombs_s does the following. If
+ retval is not a null pointer, then wcsrtombs_s sets *retval to (size_t)(-1).
+ If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+ then wcsrtombs_s sets dst[0] to the null character.
+<h6>Description</h6>
+<p><!--para 14-->
+ The wcsrtombs_s function converts a sequence of wide characters from the array
+ indirectly pointed to by src into a sequence of corresponding multibyte characters that
+ begins in the conversion state described by the object pointed to by ps. If dst is not a
+ null pointer, the converted characters are then stored into the array pointed to by dst.
+ Conversion continues up to and including a terminating null wide character, which is also
+ stored. Conversion stops earlier in two cases:
+<ul>
+<li>  when a wide character is reached that does not correspond to a valid multibyte
+ character;
+<li>  (if dst is not a null pointer) when the next multibyte character would exceed the
+   limit of n total bytes to be stored into the array pointed to by dst. If the wide
+   character being converted is the null wide character, then n is the lesser of len or
+   dstmax. Otherwise, n is the lesser of len or dstmax-1.
+</ul>
+ If the conversion stops without converting a null wide character and dst is not a null
+ pointer, then a null character is stored into the array pointed to by dst immediately
+ following any multibyte characters already stored. Each conversion takes place as if by a
+ call to the wcrtomb function.<sup><a href="#note441"><b>441)</b></a></sup>
+<p><!--para 15-->
+ If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+ pointer (if conversion stopped due to reaching a terminating null wide character) or the
+ address just past the last wide character converted (if any). If conversion stopped due to
+ reaching a terminating null wide character, the resulting state described is the initial
+ conversion state.
+ 
+ 
+<!--page 665 indent 5-->
+<p><!--para 16-->
+ Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+ wide character that does not correspond to a valid multibyte character, an encoding error
+ occurs: the wcsrtombs_s function stores the value (size_t)(-1) into *retval
+ and the conversion state is unspecified. Otherwise, the wcsrtombs_s function stores
+ into *retval the number of bytes in the resulting multibyte character sequence, not
+ including the terminating null character (if any).
+<p><!--para 17-->
+ All elements following the terminating null character (if any) written by wcsrtombs_s
+ in the array of dstmax elements pointed to by dst take unspecified values when
+ wcsrtombs_s returns.<sup><a href="#note442"><b>442)</b></a></sup>
+<p><!--para 18-->
+ If copying takes place between objects that overlap, the objects take on unspecified
+ values.
+<h6>Returns</h6>
+<p><!--para 19-->
+ The wcsrtombs_s function returns zero if no runtime-constraint violation and no
+ encoding error occurred. Otherwise, a nonzero value is returned.
+ 
+ 
+ 
+ 
+<!--page 666 indent 4-->
+
+<h6>footnotes</h6>
+<p><a name="note441">441)</a> If conversion stops because a terminating null wide character has been reached, the bytes stored
+ include those necessary to reach the initial shift state immediately before the null byte. However, if
+ the conversion stops before a terminating null wide character has been reached, the result will be null
+ terminated, but might not end in the initial shift state.
+
+<p><a name="note442">442)</a> When len is not less than dstmax, the implementation might fill the array before discovering a
+ runtime-constraint violation.
+
+
+<a name="L" href="#L"><h2>Annex L</h2></a>
+<pre>
+                                            (normative)
+                                         Analyzability</pre>
+
+<a name="L.1" href="#L.1"><h3>L.1 Scope</h3></a>
+<p><!--para 1-->
+ This annex specifies optional behavior that can aid in the analyzability of C programs.
+<p><!--para 2-->
+ An implementation that defines __STDC_ANALYZABLE__ shall conform to the
+ specifications in this annex.<sup><a href="#note443"><b>443)</b></a></sup>
+
+<h6>footnotes</h6>
+<p><a name="note443">443)</a> Implementations that do not define __STDC_ANALYZABLE__ are not required to conform to these
+ specifications.
+
+
+<a name="L.2" href="#L.2"><h3>L.2 Definitions</h3></a>
+
+<a name="L.2.1" href="#L.2.1"><h4>L.2.1</h4></a>
+<p><!--para 1-->
+ out-of-bounds store
+ an (attempted) access (<a href="#3.1">3.1</a>) that, at run time, for a given computational state, would
+ modify (or, for an object declared volatile, fetch) one or more bytes that lie outside
+ the bounds permitted by this Standard.
+
+<a name="L.2.2" href="#L.2.2"><h4>L.2.2</h4></a>
+<p><!--para 1-->
+ bounded undefined behavior
+ undefined behavior (<a href="#3.4.3">3.4.3</a>) that does not perform an out-of-bounds store.
+<p><!--para 2-->
+ NOTE 1    The behavior might perform a trap.
+ 
+<p><!--para 3-->
+ NOTE 2    Any values produced or stored might be indeterminate values.
+ 
+
+<a name="L.2.3" href="#L.2.3"><h4>L.2.3</h4></a>
+<p><!--para 1-->
+ critical undefined behavior
+ undefined behavior that is not bounded undefined behavior.
+<p><!--para 2-->
+ NOTE     The behavior might perform an out-of-bounds store or perform a trap.
+ 
+ 
+ 
+ 
+<!--page 667 indent 4-->
+
+<a name="L.3" href="#L.3"><h3>L.3 Requirements</h3></a>
+<p><!--para 1-->
+ If the program performs a trap (<a href="#3.19.5">3.19.5</a>), the implementation is permitted to invoke a
+ runtime-constraint handler. Any such semantics are implementation-defined.
+<p><!--para 2-->
+ All undefined behavior shall be limited to bounded undefined behavior, except for the
+ following which are permitted to result in critical undefined behavior:
+<ul>
+<li>  An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
+<li>  An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
+<li>  A pointer is used to call a function whose type is not compatible with the referenced
+ type (<a href="#6.3.2.3">6.3.2.3</a>).
+<li>  The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
+<li>  Addition or subtraction of a pointer into, or just beyond, an array object and an
+ integer type produces a result that points just beyond the array object and is used as
+ the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
+<li>  An argument to a library function has an invalid value or a type not expected by a
+ function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
+<li>  The value of a pointer that refers to space deallocated by a call to the free or realloc
+ function is used (<a href="#7.22.3">7.22.3</a>).
+<li>  A string or wide string utility function is instructed to access an array beyond the end
+ of an object (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
+<!--page 668 indent -1-->
+</ul>
+
+<a name="Bibliography" href="#Bibliography"><h2>Bibliography</h2></a>
+<ol>
+<li>  ''The C Reference Manual'' by Dennis M. Ritchie, a version of which was
+ published in The C Programming Language by Brian W. Kernighan and Dennis
+ M. Ritchie, Prentice-Hall, Inc., (1978). Copyright owned by AT&amp;T.
+<li>  1984 /usr/group Standard by the /usr/group Standards Committee, Santa Clara,
+ California, USA, November 1984.
+<li>  ANSI X3/TR-1-82 (1982), American National Dictionary for Information
+ Processing Systems, Information Processing Systems Technical Report.
+<li>  ANSI/IEEE 754-1985, American National Standard for Binary Floating-Point
+ Arithmetic.
+<li>  ANSI/IEEE 854-1988, American National Standard for Radix-Independent
+ Floating-Point Arithmetic.
+<li>  IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems,
+ second edition (previously designated IEC 559:1989).
+<li>  ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and
+ symbols for use in the physical sciences and technology.
+<li>  ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character set for
+ information interchange.
+<li>  ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1:
+ Fundamental terms.
+<li>  ISO 4217:1995, Codes for the representation of currencies and funds.
+<li>  ISO 8601:1988, Data elements and interchange formats -- Information
+ interchange -- Representation of dates and times.
+<li>  ISO/IEC 9899:1990, Programming languages -- C.
+<li>  ISO/IEC 9899/COR1:1994, Technical Corrigendum 1.
+<li>  ISO/IEC 9899/COR2:1996, Technical Corrigendum 2.
+<li>  ISO/IEC 9899/AMD1:1995, Amendment 1 to ISO/IEC 9899:1990 C Integrity.
+<li>  ISO/IEC 9899:1999, Programming languages -- C.
+<li>  ISO/IEC 9899:1999/Cor.1:2001, Technical Corrigendum 1.
+<li>  ISO/IEC 9899:1999/Cor.2:2004, Technical Corrigendum 2.
+<li>  ISO/IEC 9899:1999/Cor.3:2007, Technical Corrigendum 3.
+<!--page 669 indent -1-->
+<li>  ISO/IEC 9945-2:1993, Information technology -- Portable Operating System
+ Interface (POSIX) -- Part 2: Shell and Utilities.
+<li>  ISO/IEC TR 10176:1998, Information technology -- Guidelines for the
+ preparation of programming language standards.
+<li>  ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet
+ Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.
+<li>  ISO/IEC 10646-1/COR1:1996,         Technical       Corrigendum       1      to
+ ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/COR2:1998,         Technical       Corrigendum       2      to
+ ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD1:1996, Amendment 1 to ISO/IEC 10646-1:1993
+ Transformation Format for 16 planes of group 00 (UTF-16).
+<li>  ISO/IEC 10646-1/AMD2:1996, Amendment 2 to ISO/IEC 10646-1:1993 UCS
+ Transformation Format 8 (UTF-8).
+<li>  ISO/IEC 10646-1/AMD3:1996, Amendment 3 to ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD4:1996, Amendment 4 to ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD5:1998, Amendment 5 to ISO/IEC 10646-1:1993 Hangul
+ syllables.
+<li>  ISO/IEC 10646-1/AMD6:1997,       Amendment     6   to   ISO/IEC 10646-1:1993
+ Tibetan.
+<li>  ISO/IEC 10646-1/AMD7:1997, Amendment 7 to ISO/IEC 10646-1:1993 33
+ additional characters.
+<li>  ISO/IEC 10646-1/AMD8:1997, Amendment 8 to ISO/IEC 10646-1:1993.
+<li>  ISO/IEC 10646-1/AMD9:1997,       Amendment     9   to   ISO/IEC 10646-1:1993
+ Identifiers for characters.
+<li>  ISO/IEC 10646-1/AMD10:1998, Amendment 10 to ISO/IEC 10646-1:1993
+ Ethiopic.
+<li>  ISO/IEC 10646-1/AMD11:1998, Amendment 11 to ISO/IEC 10646-1:1993
+ Unified Canadian Aboriginal Syllabics.
+<li>  ISO/IEC 10646-1/AMD12:1998, Amendment 12 to ISO/IEC 10646-1:1993
+ Cherokee.
+<li>  ISO/IEC 10967-1:1994, Information technology -- Language independent
+ arithmetic -- Part 1: Integer and floating point arithmetic.
+<!--page 670 indent -1-->
+<li>  ISO/IEC TR 19769:2004, Information technology -- Programming languages,
+ their environments and system software interfaces -- Extensions for the
+ programming language C to support new character data types.
+<li>  ISO/IEC TR 24731-1:2007, Information technology -- Programming languages,
+ their environments and system software interfaces -- Extensions to the C library
+ -- Part 1: Bounds-checking interfaces.
+<!--page 671 indent 0-->
+</ol>
+
+<a name="Index" href="#Index"><h2>Index</h2></a>
+<pre>
+ [^ x ^], <a href="#3.20">3.20</a>                                                    , (comma operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a>
+                                                                , (comma punctuator), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,
+ [_ x _], <a href="#3.21">3.21</a>                                                         <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>
+ ! (logical negation operator), <a href="#6.5.3.3">6.5.3.3</a>                         - (subtraction operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
+ != (inequality operator), <a href="#6.5.9">6.5.9</a>                                - (unary minus operator), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
+ # operator, <a href="#6.10.3.2">6.10.3.2</a>                                           -- (postfix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
+ # preprocessing directive, <a href="#6.10.7">6.10.7</a>                              -- (prefix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
+ # punctuator, <a href="#6.10">6.10</a>                                             -= (subtraction assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+ ## operator, <a href="#6.10.3.3">6.10.3.3</a>                                          -&gt; (structure/union pointer operator), <a href="#6.5.2.3">6.5.2.3</a>
+ #define preprocessing directive, <a href="#6.10.3">6.10.3</a>                        . (structure/union member operator), <a href="#6.3.2.1">6.3.2.1</a>,
+ #elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                               <a href="#6.5.2.3">6.5.2.3</a>
+ #else preprocessing directive, <a href="#6.10.1">6.10.1</a>                          . punctuator, <a href="#6.7.9">6.7.9</a>
+ #endif preprocessing directive, <a href="#6.10.1">6.10.1</a>                         ... (ellipsis punctuator), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
+ #error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                      / (division operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
+ #if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,             /* */ (comment delimiters), <a href="#6.4.9">6.4.9</a>
+      <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             // (comment delimiter), <a href="#6.4.9">6.4.9</a>
+ #ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                         /= (division assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+ #ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                        : (colon punctuator), <a href="#6.7.2.1">6.7.2.1</a>
+ #include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>,                     :&gt; (alternative spelling of ]), <a href="#6.4.6">6.4.6</a>
+      <a href="#6.10.2">6.10.2</a>                                                    ; (semicolon punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
+ #line preprocessing directive, <a href="#6.10.4">6.10.4</a>                               <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
+ #pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>                        &lt; (less-than operator), <a href="#6.5.8">6.5.8</a>
+ #undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,               &lt;% (alternative spelling of {), <a href="#6.4.6">6.4.6</a>
+      <a href="#7.1.4">7.1.4</a>                                                     &lt;: (alternative spelling of [), <a href="#6.4.6">6.4.6</a>
+ % (remainder operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>                         &lt;&lt; (left-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+ %: (alternative spelling of #), <a href="#6.4.6">6.4.6</a>                          &lt;&lt;= (left-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+ %:%: (alternative spelling of ##), <a href="#6.4.6">6.4.6</a>                       &lt;= (less-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>
+ %= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                   &lt;assert.h&gt; header, <a href="#7.2">7.2</a>
+ %&gt; (alternative spelling of }), <a href="#6.4.6">6.4.6</a>                          &lt;complex.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,
+ &amp; (address operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                              <a href="#7.3">7.3</a>, <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+ &amp; (bitwise AND operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>                      &lt;ctype.h&gt; header, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>
+ &amp;&amp; (logical AND operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>                     &lt;errno.h&gt; header, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>
+ &amp;= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                 &lt;fenv.h&gt; header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>,
+ ' ' (space character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,                <a href="#H">H</a>
+      <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>                                      &lt;float.h&gt; header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
+ ( ) (cast operator), <a href="#6.5.4">6.5.4</a>                                          <a href="#7.28.4.1.1">7.28.4.1.1</a>
+ ( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a>                          &lt;inttypes.h&gt; header, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>
+ ( ) (parentheses punctuator), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>            &lt;iso646.h&gt; header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
+ ( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                    &lt;limits.h&gt; header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
+ * (asterisk punctuator), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a>                      &lt;locale.h&gt; header, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>
+ * (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                     &lt;math.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>,
+ * (multiplication operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>,                   <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a>
+      <a href="#G.5.1">G.5.1</a>                                                     &lt;setjmp.h&gt; header, <a href="#7.13">7.13</a>
+ *= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              &lt;signal.h&gt; header, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>
+ + (addition operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>,              &lt;stdalign.h&gt; header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
+      <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                                         &lt;stdarg.h&gt; header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
+ + (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a>                               &lt;stdatomic.h&gt; header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>
+ ++ (postfix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>               &lt;stdbool.h&gt; header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>
+ ++ (prefix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>                &lt;stddef.h&gt; header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+ += (addition assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+<!--page 672 indent 0-->
+      <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>                      \x hexadecimal digits (hexadecimal-character
+ &lt;stdint.h&gt; header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>,                       escape sequence), <a href="#6.4.4.4">6.4.4.4</a>
+      <a href="#7.20">7.20</a>, <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>                              ^ (bitwise exclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
+ &lt;stdio.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>,                ^= (bitwise exclusive OR assignment operator),
+      <a href="#K.3.5">K.3.5</a>                                                        <a href="#6.5.16.2">6.5.16.2</a>
+ &lt;stdlib.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,              __alignas_is_defined macro, <a href="#7.15">7.15</a>
+      <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>                                          __bool_true_false_are_defined
+ &lt;string.h&gt; header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                           macro, <a href="#7.18">7.18</a>
+ &lt;tgmath.h&gt; header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                 __cplusplus macro, <a href="#6.10.8">6.10.8</a>
+ &lt;threads.h&gt; header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                    __DATE__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+ &lt;time.h&gt; header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                 __FILE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
+ &lt;uchar.h&gt; header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                       __func__ identifier, <a href="#6.4.2.2">6.4.2.2</a>, <a href="#7.2.1.1">7.2.1.1</a>
+ &lt;wchar.h&gt; header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>,                   __LINE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
+      <a href="#7.30.12">7.30.12</a>, <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>                                       __STDC_, <a href="#6.11.9">6.11.9</a>
+ &lt;wctype.h&gt; header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                             __STDC__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+ = (equal-sign punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a>               __STDC_ANALYZABLE__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#L.1">L.1</a>
+ = (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a>                     __STDC_HOSTED__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+ == (equality operator), <a href="#6.5.9">6.5.9</a>                                __STDC_IEC_559__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#F.1">F.1</a>
+ &gt; (greater-than operator), <a href="#6.5.8">6.5.8</a>                             __STDC_IEC_559_COMPLEX__ macro,
+ &gt;= (greater-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>                     <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G.1">G.1</a>
+ &gt;&gt; (right-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>                    __STDC_ISO_10646__ macro, <a href="#6.10.8.2">6.10.8.2</a>
+ &gt;&gt;= (right-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              __STDC_LIB_EXT1__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#K.2">K.2</a>
+ ? : (conditional operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a>                  __STDC_MB_MIGHT_NEQ_WC__ macro,
+ ?? (trigraph sequences), <a href="#5.2.1.1">5.2.1.1</a>                                  <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>
+ [ ] (array subscript operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>             __STDC_NO_COMPLEX__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
+ [ ] (brackets punctuator), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>                         <a href="#7.3.1">7.3.1</a>
+ \ (backslash character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>             __STDC_NO_THREADS__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
+ \ (escape character), <a href="#6.4.4.4">6.4.4.4</a>                                     <a href="#7.17.1">7.17.1</a>, <a href="#7.25.1">7.25.1</a>
+ \" (double-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>,                  __STDC_NO_VLA__ macro, <a href="#6.10.8.3">6.10.8.3</a>
+      <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                           __STDC_UTF_16__ macro, <a href="#6.10.8.2">6.10.8.2</a>
+ \\ (backslash escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>              __STDC_UTF_32__ macro, <a href="#6.10.8.2">6.10.8.2</a>
+ \' (single-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>            __STDC_VERSION__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+ \0 (null character), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                   __STDC_WANT_LIB_EXT1__ macro, <a href="#K.3.1.1">K.3.1.1</a>
+   padding of binary stream, <a href="#7.21.2">7.21.2</a>                           __TIME__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+ \? (question-mark escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                  __VA_ARGS__ identifier, <a href="#6.10.3">6.10.3</a>, <a href="#6.10.3.1">6.10.3.1</a>
+ \a (alert escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                   _Alignas, <a href="#6.7.5">6.7.5</a>
+ \b (backspace escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>               _Atomic type qualifier, <a href="#6.7.3">6.7.3</a>
+ \f (form-feed escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,              _Bool type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.17.1">7.17.1</a>,
+      <a href="#7.4.1.10">7.4.1.10</a>                                                     <a href="#F.4">F.4</a>
+ \n (new-line escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               _Bool type conversions, <a href="#6.3.1.2">6.3.1.2</a>
+      <a href="#7.4.1.10">7.4.1.10</a>                                                _Complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+ \octal digits (octal-character escape sequence),             _Complex_I macro, <a href="#7.3.1">7.3.1</a>
+      <a href="#6.4.4.4">6.4.4.4</a>                                                 _Exit function, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
+ \r (carriage-return escape sequence), <a href="#5.2.2">5.2.2</a>,                 _Imaginary keyword, <a href="#G.2">G.2</a>
+      <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                       _Imaginary types, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+ \t (horizontal-tab escape sequence), <a href="#5.2.2">5.2.2</a>,                  _Imaginary_I macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
+      <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>                  _IOFBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>
+ \U (universal character names), <a href="#6.4.3">6.4.3</a>                        _IOLBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.6">7.21.5.6</a>
+ \u (universal character names), <a href="#6.4.3">6.4.3</a>                        _IONBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>
+ \v (vertical-tab escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           _Noreturn, <a href="#6.7.4">6.7.4</a>
+      <a href="#7.4.1.10">7.4.1.10</a>                                                _Pragma operator, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>
+<!--page 673 indent 0-->
+ _Static_assert, <a href="#6.7.10">6.7.10</a>, <a href="#7.2">7.2</a>                                  allocated storage, order and contiguity, <a href="#7.22.3">7.22.3</a>
+ _Thread_local storage-class specifier, <a href="#6.2.4">6.2.4</a>,                 and macro, <a href="#7.9">7.9</a>
+      <a href="#6.7.1">6.7.1</a>                                                   AND operators
+ { } (braces punctuator), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>,               bitwise (&amp;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
+      <a href="#6.8.2">6.8.2</a>                                                      bitwise assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>
+ { } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                        logical (&amp;&amp;), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>
+ | (bitwise inclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>           and_eq macro, <a href="#7.9">7.9</a>
+ |= (bitwise inclusive OR assignment operator),               anonymous structure, <a href="#6.7.2.1">6.7.2.1</a>
+      <a href="#6.5.16.2">6.5.16.2</a>                                                anonymous union, <a href="#6.7.2.1">6.7.2.1</a>
+ || (logical OR operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>                    ANSI/IEEE 754, <a href="#F.1">F.1</a>
+ ~ (bitwise complement operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>            ANSI/IEEE 854, <a href="#F.1">F.1</a>
+                                                              argc (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ abort function, <a href="#7.2.1.1">7.2.1.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>,                   argument, <a href="#3.3">3.3</a>
+       <a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.25.3.6">7.25.3.6</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a>                             array, <a href="#6.9.1">6.9.1</a>
+ abort_handler_s function, <a href="#K.3.6.1.2">K.3.6.1.2</a>                             default promotions, <a href="#6.5.2.2">6.5.2.2</a>
+ abs function, <a href="#7.22.6.1">7.22.6.1</a>                                          function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+ absolute-value functions                                        macro, substitution, <a href="#6.10.3.1">6.10.3.1</a>
+    complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                     argument, complex, <a href="#7.3.9.1">7.3.9.1</a>
+    integer, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.22.6.1">7.22.6.1</a>                                argv (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+    real, <a href="#7.12.7">7.12.7</a>, <a href="#F.10.4">F.10.4</a>                                      arithmetic constant expression, <a href="#6.6">6.6</a>
+ abstract declarator, <a href="#6.7.7">6.7.7</a>                                   arithmetic conversions, usual, see usual arithmetic
+ abstract machine, <a href="#5.1.2.3">5.1.2.3</a>                                          conversions
+ access, <a href="#3.1">3.1</a>, <a href="#6.7.3">6.7.3</a>, <a href="#L.2.1">L.2.1</a>                                    arithmetic operators
+ accuracy, see floating-point accuracy                            additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>
+ acos functions, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#F.10.1.1">F.10.1.1</a>                              bitwise, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>
+ acos type-generic macro, <a href="#7.24">7.24</a>                                   increment and decrement, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>
+ acosh functions, <a href="#7.12.5.1">7.12.5.1</a>, <a href="#F.10.2.1">F.10.2.1</a>                             multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+ acosh type-generic macro, <a href="#7.24">7.24</a>                                  shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+ acquire fence, <a href="#7.17.4">7.17.4</a>                                           unary, <a href="#6.5.3.3">6.5.3.3</a>
+ acquire operation, <a href="#5.1.2.4">5.1.2.4</a>                                   arithmetic types, <a href="#6.2.5">6.2.5</a>
+ active position, <a href="#5.2.2">5.2.2</a>                                       arithmetic, pointer, <a href="#6.5.6">6.5.6</a>
+ actual argument, <a href="#3.3">3.3</a>                                         array
+ actual parameter (deprecated), <a href="#3.3">3.3</a>                              argument, <a href="#6.9.1">6.9.1</a>
+ addition assignment operator (+=), <a href="#6.5.16.2">6.5.16.2</a>                     declarator, <a href="#6.7.6.2">6.7.6.2</a>
+ addition operator (+), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>,               initialization, <a href="#6.7.9">6.7.9</a>
+       <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                                         multidimensional, <a href="#6.5.2.1">6.5.2.1</a>
+ additive expressions, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                              parameter, <a href="#6.9.1">6.9.1</a>
+ address constant, <a href="#6.6">6.6</a>                                           storage order, <a href="#6.5.2.1">6.5.2.1</a>
+ address operator (&amp;), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                          subscript operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+ address-free, <a href="#7.17.5">7.17.5</a>                                            subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+ aggregate initialization, <a href="#6.7.9">6.7.9</a>                                 type, <a href="#6.2.5">6.2.5</a>
+ aggregate types, <a href="#6.2.5">6.2.5</a>                                          type conversion, <a href="#6.3.2.1">6.3.2.1</a>
+ alert escape sequence (\a), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                      variable length, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>
+ aliasing, <a href="#6.5">6.5</a>                                                arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+ alignas macro, <a href="#7.15">7.15</a>                                          as-if rule, <a href="#5.1.2.3">5.1.2.3</a>
+ aligned_alloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.1">7.22.3.1</a>                     ASCII code set, <a href="#5.2.1.1">5.2.1.1</a>
+ alignment, <a href="#3.2">3.2</a>, <a href="#6.2.8">6.2.8</a>, <a href="#7.22.3.1">7.22.3.1</a>                              asctime function, <a href="#7.26.3.1">7.26.3.1</a>
+    pointer, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.3">6.3.2.3</a>                                   asctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>
+    structure/union member, <a href="#6.7.2.1">6.7.2.1</a>                           asin functions, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#F.10.1.2">F.10.1.2</a>
+ alignment specifier, <a href="#6.7.5">6.7.5</a>                                    asin type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+ alignof operator, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>                             asinh functions, <a href="#7.12.5.2">7.12.5.2</a>, <a href="#F.10.2.2">F.10.2.2</a>
+<!--page 674 indent 0-->
+ asinh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                           atomic_is_lock_free generic function,
+ asm keyword, <a href="#J.5.10">J.5.10</a>                                               <a href="#7.17.5.1">7.17.5.1</a>
+ assert macro, <a href="#7.2.1.1">7.2.1.1</a>                                         ATOMIC_LLONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+ assert.h header, <a href="#7.2">7.2</a>                                          atomic_load generic functions, <a href="#7.17.7.2">7.17.7.2</a>
+ assignment                                                    ATOMIC_LONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+    compound, <a href="#6.5.16.2">6.5.16.2</a>                                         ATOMIC_SHORT_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+    conversion, <a href="#6.5.16.1">6.5.16.1</a>                                       atomic_signal_fence function, <a href="#7.17.4.2">7.17.4.2</a>
+    expression, <a href="#6.5.16">6.5.16</a>                                         atomic_store generic functions, <a href="#7.17.7.1">7.17.7.1</a>
+    operators, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>                                 atomic_thread_fence function, <a href="#7.17.4.1">7.17.4.1</a>
+    simple, <a href="#6.5.16.1">6.5.16.1</a>                                           ATOMIC_VAR_INIT macro, <a href="#7.17.2.1">7.17.2.1</a>
+ associativity of operators, <a href="#6.5">6.5</a>                               ATOMIC_WCHAR_T_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+ asterisk punctuator (*), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a>                     atomics header, <a href="#7.17">7.17</a>
+ at_quick_exit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>,                   auto storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
+      <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>                             automatic storage duration, <a href="#5.2.3">5.2.3</a>, <a href="#6.2.4">6.2.4</a>
+ atan functions, <a href="#7.12.4.3">7.12.4.3</a>, <a href="#F.10.1.3">F.10.1.3</a>
+ atan type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                            backslash character (\), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+ atan2 functions, <a href="#7.12.4.4">7.12.4.4</a>, <a href="#F.10.1.4">F.10.1.4</a>                           backslash escape sequence (\\), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>
+ atan2 type-generic macro, <a href="#7.24">7.24</a>                                backspace escape sequence (\b), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+ atanh functions, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#F.10.2.3">F.10.2.3</a>                           basic character set, <a href="#3.6">3.6</a>, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>
+ atanh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                           basic types, <a href="#6.2.5">6.2.5</a>
+ atexit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>,                behavior, <a href="#3.4">3.4</a>
+      <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>, <a href="#J.5.13">J.5.13</a>                               binary streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
+ atof function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.1">7.22.1.1</a>                                     <a href="#7.21.9.4">7.21.9.4</a>
+ atoi function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                               bit, <a href="#3.5">3.5</a>
+ atol function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                                  high order, <a href="#3.6">3.6</a>
+ atoll function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                                 low order, <a href="#3.6">3.6</a>
+ atomic lock-free macros, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.5">7.17.5</a>                       bit-field, <a href="#6.7.2.1">6.7.2.1</a>
+ atomic operations, <a href="#5.1.2.4">5.1.2.4</a>                                    bitand macro, <a href="#7.9">7.9</a>
+ atomic types, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>,               bitor macro, <a href="#7.9">7.9</a>
+      <a href="#6.5.2.3">6.5.2.3</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>,           bitwise operators, <a href="#6.5">6.5</a>
+      <a href="#7.17.6">7.17.6</a>                                                      AND, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
+ atomic_address type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.6">7.17.6</a>                              AND assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>
+ ATOMIC_ADDRESS_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                           complement (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>
+ atomic_bool type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.6">7.17.6</a>                                 exclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
+ ATOMIC_CHAR16_T_LOCK_FREE macro,                                 exclusive OR assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
+      <a href="#7.17.1">7.17.1</a>                                                      inclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
+ ATOMIC_CHAR32_T_LOCK_FREE macro,                                 inclusive OR assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+      <a href="#7.17.1">7.17.1</a>                                                      shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+ ATOMIC_CHAR_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                           blank character, <a href="#7.4.1.3">7.4.1.3</a>
+ atomic_compare_exchange generic                               block, <a href="#6.8">6.8</a>, <a href="#6.8.2">6.8.2</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
+      functions, <a href="#7.17.7.4">7.17.7.4</a>                                      block scope, <a href="#6.2.1">6.2.1</a>
+ atomic_exchange generic functions, <a href="#7.17.7.3">7.17.7.3</a>                   block structure, <a href="#6.2.1">6.2.1</a>
+ atomic_fetch and modify generic functions,                    bold type convention, <a href="#6.1">6.1</a>
+      <a href="#7.17.7.5">7.17.7.5</a>                                                 bool macro, <a href="#7.18">7.18</a>
+ atomic_flag type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>                              boolean type, <a href="#6.3.1.2">6.3.1.2</a>
+ atomic_flag_clear functions, <a href="#7.17.8.2">7.17.8.2</a>                         boolean type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>
+ ATOMIC_FLAG_INIT macro, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>                        bounded undefined behavior, <a href="#L.2.2">L.2.2</a>
+ atomic_flag_test_and_set functions,                           braces punctuator ({ }), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>,
+      <a href="#7.17.8.1">7.17.8.1</a>                                                       <a href="#6.8.2">6.8.2</a>
+ atomic_init generic function, <a href="#7.17.2.2">7.17.2.2</a>                        brackets operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+ ATOMIC_INT_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                            brackets punctuator ([ ]), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>
+<!--page 675 indent 0-->
+ branch cuts, <a href="#7.3.3">7.3.3</a>                                                type-generic macro for, <a href="#7.24">7.24</a>
+ break statement, <a href="#6.8.6.3">6.8.6.3</a>                                       ccosh functions, <a href="#7.3.6.4">7.3.6.4</a>, <a href="#G.6.2.4">G.6.2.4</a>
+ broken-down time, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.3">7.26.3</a>,                       type-generic macro for, <a href="#7.24">7.24</a>
+      <a href="#7.26.3.1">7.26.3.1</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#7.26.3.5">7.26.3.5</a>,                   ceil functions, <a href="#7.12.9.1">7.12.9.1</a>, <a href="#F.10.6.1">F.10.6.1</a>
+      <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                           ceil type-generic macro, <a href="#7.24">7.24</a>
+ bsearch function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a>                             cerf function, <a href="#7.30.1">7.30.1</a>
+ bsearch_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>                         cerfc function, <a href="#7.30.1">7.30.1</a>
+ btowc function, <a href="#7.28.6.1.1">7.28.6.1.1</a>                                     cexp functions, <a href="#7.3.7.1">7.3.7.1</a>, <a href="#G.6.3.1">G.6.3.1</a>
+ BUFSIZ macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.5">7.21.5.5</a>                            type-generic macro for, <a href="#7.24">7.24</a>
+ byte, <a href="#3.6">3.6</a>, <a href="#6.5.3.4">6.5.3.4</a>                                             cexp2 function, <a href="#7.30.1">7.30.1</a>
+ byte input/output functions, <a href="#7.21.1">7.21.1</a>                            cexpm1 function, <a href="#7.30.1">7.30.1</a>
+ byte-oriented stream, <a href="#7.21.2">7.21.2</a>                                   char type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
+                                                                      <a href="#K.3.9.1.2">K.3.9.1.2</a>
+ <a href="#C">C</a> program, <a href="#5.1.1.1">5.1.1.1</a>                                             char type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+ c16rtomb function, <a href="#7.27.1.2">7.27.1.2</a>                                          <a href="#6.3.1.8">6.3.1.8</a>
+ c32rtomb function, <a href="#7.27.1.4">7.27.1.4</a>                                    char16_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.27">7.27</a>
+ cabs functions, <a href="#7.3.8.1">7.3.8.1</a>, <a href="#G.6">G.6</a>                                   char32_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.27">7.27</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                 CHAR_BIT macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+ cacos functions, <a href="#7.3.5.1">7.3.5.1</a>, <a href="#G.6.1.1">G.6.1.1</a>                              CHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                 CHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ cacosh functions, <a href="#7.3.6.1">7.3.6.1</a>, <a href="#G.6.2.1">G.6.2.1</a>                             character, <a href="#3.7">3.7</a>, <a href="#3.7.1">3.7.1</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                 character array initialization, <a href="#6.7.9">6.7.9</a>
+ calendar time, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.2">7.26.2.2</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.2.4">7.26.2.4</a>,           character case mapping functions, <a href="#7.4.2">7.4.2</a>
+       <a href="#7.26.3.2">7.26.3.2</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>,                    wide character, <a href="#7.29.3.1">7.29.3.1</a>
+       <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                           extensible, <a href="#7.29.3.2">7.29.3.2</a>
+ call by value, <a href="#6.5.2.2">6.5.2.2</a>                                         character classification functions, <a href="#7.4.1">7.4.1</a>
+ call_once function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.1">7.25.2.1</a>                              wide character, <a href="#7.29.2.1">7.29.2.1</a>
+ calloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.2">7.22.3.2</a>                                    extensible, <a href="#7.29.2.2">7.29.2.2</a>
+ carg functions, <a href="#7.3.9.1">7.3.9.1</a>, <a href="#G.6">G.6</a>                                   character constant, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+ carg type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                             character display semantics, <a href="#5.2.2">5.2.2</a>
+ carriage-return escape sequence (\r), <a href="#5.2.2">5.2.2</a>,                   character handling header, <a href="#7.4">7.4</a>, <a href="#7.11.1.1">7.11.1.1</a>
+       <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                        character input/output functions, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a>
+ carries a dependency, <a href="#5.1.2.4">5.1.2.4</a>                                     wide character, <a href="#7.28.3">7.28.3</a>
+ case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                                     character sets, <a href="#5.2.1">5.2.1</a>
+ case mapping functions                                         character string literal, see string literal
+   character, <a href="#7.4.2">7.4.2</a>                                             character type conversion, <a href="#6.3.1.1">6.3.1.1</a>
+   wide character, <a href="#7.29.3.1">7.29.3.1</a>                                     character types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.9">6.7.9</a>
+       extensible, <a href="#7.29.3.2">7.29.3.2</a>                                     cimag functions, <a href="#7.3.9.2">7.3.9.2</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>
+ casin functions, <a href="#7.3.5.2">7.3.5.2</a>, <a href="#G.6">G.6</a>                                  cimag type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                 cis function, <a href="#G.6">G.6</a>
+ casinh functions, <a href="#7.3.6.2">7.3.6.2</a>, <a href="#G.6.2.2">G.6.2.2</a>                             classification functions
+   type-generic macro for, <a href="#7.24">7.24</a>                                    character, <a href="#7.4.1">7.4.1</a>
+ cast expression, <a href="#6.5.4">6.5.4</a>                                            floating-point, <a href="#7.12.3">7.12.3</a>
+ cast operator (( )), <a href="#6.5.4">6.5.4</a>                                        wide character, <a href="#7.29.2.1">7.29.2.1</a>
+ catan functions, <a href="#7.3.5.3">7.3.5.3</a>, <a href="#G.6">G.6</a>                                        extensible, <a href="#7.29.2.2">7.29.2.2</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                 clearerr function, <a href="#7.21.10.1">7.21.10.1</a>
+ catanh functions, <a href="#7.3.6.3">7.3.6.3</a>, <a href="#G.6.2.3">G.6.2.3</a>                             clgamma function, <a href="#7.30.1">7.30.1</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                 clock function, <a href="#7.26.2.1">7.26.2.1</a>
+ cbrt functions, <a href="#7.12.7.1">7.12.7.1</a>, <a href="#F.10.4.1">F.10.4.1</a>                             clock_t type, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.1">7.26.2.1</a>
+ cbrt type-generic macro, <a href="#7.24">7.24</a>                                  CLOCKS_PER_SEC macro, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.1">7.26.2.1</a>
+ ccos functions, <a href="#7.3.5.4">7.3.5.4</a>, <a href="#G.6">G.6</a>                                   clog functions, <a href="#7.3.7.2">7.3.7.2</a>, <a href="#G.6.3.2">G.6.3.2</a>
+<!--page 676 indent 0-->
+   type-generic macro for, <a href="#7.24">7.24</a>                                  string, <a href="#7.23.3">7.23.3</a>, <a href="#K.3.7.2">K.3.7.2</a>
+ clog10 function, <a href="#7.30.1">7.30.1</a>                                         wide string, <a href="#7.28.4.3">7.28.4.3</a>, <a href="#K.3.9.2.2">K.3.9.2.2</a>
+ clog1p function, <a href="#7.30.1">7.30.1</a>                                       concatenation, preprocessing, see preprocessing
+ clog2 function, <a href="#7.30.1">7.30.1</a>                                             concatenation
+ CMPLX macros, <a href="#7.3.9.3">7.3.9.3</a>                                         conceptual models, <a href="#5.1">5.1</a>
+ cnd_broadcast function, <a href="#7.25.3.1">7.25.3.1</a>, <a href="#7.25.3.5">7.25.3.5</a>,                   conditional features, <a href="#4">4</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>,
+      <a href="#7.25.3.6">7.25.3.6</a>                                                      <a href="#7.1.2">7.1.2</a>, <a href="#F.1">F.1</a>, <a href="#G.1">G.1</a>, <a href="#K.2">K.2</a>, <a href="#L.1">L.1</a>
+ cnd_destroy function, <a href="#7.25.3.2">7.25.3.2</a>                                conditional inclusion, <a href="#6.10.1">6.10.1</a>
+ cnd_init function, <a href="#7.25.3.3">7.25.3.3</a>                                   conditional operator (? :), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a>
+ cnd_signal function, <a href="#7.25.3.4">7.25.3.4</a>, <a href="#7.25.3.5">7.25.3.5</a>,                      conflict, <a href="#5.1.2.4">5.1.2.4</a>
+      <a href="#7.25.3.6">7.25.3.6</a>                                                 conformance, <a href="#4">4</a>
+ cnd_t type, <a href="#7.25.1">7.25.1</a>                                            conj functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>
+ cnd_timedwait function, <a href="#7.25.3.5">7.25.3.5</a>                              conj type-generic macro, <a href="#7.24">7.24</a>
+ cnd_wait function, <a href="#7.25.3.3">7.25.3.3</a>, <a href="#7.25.3.6">7.25.3.6</a>                         const type qualifier, <a href="#6.7.3">6.7.3</a>
+ collating sequences, <a href="#5.2.1">5.2.1</a>                                    const-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.7.3">6.7.3</a>
+ colon punctuator (:), <a href="#6.7.2.1">6.7.2.1</a>                                 constant expression, <a href="#6.6">6.6</a>, <a href="#F.8.4">F.8.4</a>
+ comma operator (,), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a>                           constants, <a href="#6.4.4">6.4.4</a>
+ comma punctuator (,), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,             as primary expression, <a href="#6.5.1">6.5.1</a>
+      <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>                                             character, <a href="#6.4.4.4">6.4.4.4</a>
+ command processor, <a href="#7.22.4.8">7.22.4.8</a>                                     enumeration, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+ comment delimiters (/* */ and //), <a href="#6.4.9">6.4.9</a>                        floating, <a href="#6.4.4.2">6.4.4.2</a>
+ comments, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.4.9">6.4.9</a>                                   hexadecimal, <a href="#6.4.4.1">6.4.4.1</a>
+ common extensions, <a href="#J.5">J.5</a>                                          integer, <a href="#6.4.4.1">6.4.4.1</a>
+ common initial sequence, <a href="#6.5.2.3">6.5.2.3</a>                                octal, <a href="#6.4.4.1">6.4.4.1</a>
+ common real type, <a href="#6.3.1.8">6.3.1.8</a>                                     constraint, <a href="#3.8">3.8</a>, <a href="#4">4</a>
+ common warnings, <a href="#I">I</a>                                            constraint_handler_t type, <a href="#K.3.6">K.3.6</a>
+ comparison functions, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a>, <a href="#7.22.5.2">7.22.5.2</a>,             consume operation, <a href="#5.1.2.4">5.1.2.4</a>
+      <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>                            content of structure/union/enumeration, <a href="#6.7.2.3">6.7.2.3</a>
+   string, <a href="#7.23.4">7.23.4</a>                                              contiguity of allocated storage, <a href="#7.22.3">7.22.3</a>
+   wide string, <a href="#7.28.4.4">7.28.4.4</a>                                       continue statement, <a href="#6.8.6.2">6.8.6.2</a>
+ comparison macros, <a href="#7.12.14">7.12.14</a>                                    contracted expression, <a href="#6.5">6.5</a>, <a href="#7.12.2">7.12.2</a>, <a href="#F.7">F.7</a>
+ comparison, pointer, <a href="#6.5.8">6.5.8</a>                                    control character, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
+ compatible type, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a>                   control wide character, <a href="#7.29.2">7.29.2</a>
+ compl macro, <a href="#7.9">7.9</a>                                              conversion, <a href="#6.3">6.3</a>
+ complement operator (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>                       arithmetic operands, <a href="#6.3.1">6.3.1</a>
+ complete type, <a href="#6.2.5">6.2.5</a>                                            array argument, <a href="#6.9.1">6.9.1</a>
+ complex macro, <a href="#7.3.1">7.3.1</a>                                            array parameter, <a href="#6.9.1">6.9.1</a>
+ complex numbers, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>                                       arrays, <a href="#6.3.2.1">6.3.2.1</a>
+ complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>                       boolean, <a href="#6.3.1.2">6.3.1.2</a>
+ complex type domain, <a href="#6.2.5">6.2.5</a>                                      boolean, characters, and integers, <a href="#6.3.1.1">6.3.1.1</a>
+ complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G">G</a>                        by assignment, <a href="#6.5.16.1">6.5.16.1</a>
+ complex.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,                   by return statement, <a href="#6.8.6.4">6.8.6.4</a>
+      <a href="#7.3">7.3</a>, <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>                             complex types, <a href="#6.3.1.6">6.3.1.6</a>
+ compliance, see conformance                                     explicit, <a href="#6.3">6.3</a>
+ components of time, <a href="#7.26.1">7.26.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                             function, <a href="#6.3.2.1">6.3.2.1</a>
+ composite type, <a href="#6.2.7">6.2.7</a>                                           function argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+ compound assignment, <a href="#6.5.16.2">6.5.16.2</a>                                   function designators, <a href="#6.3.2.1">6.3.2.1</a>
+ compound literals, <a href="#6.5.2.5">6.5.2.5</a>                                      function parameter, <a href="#6.9.1">6.9.1</a>
+ compound statement, <a href="#6.8.2">6.8.2</a>                                       imaginary, <a href="#G.4.1">G.4.1</a>
+ compound-literal operator (( ){ }), <a href="#6.5.2.5">6.5.2.5</a>                     imaginary and complex, <a href="#G.4.3">G.4.3</a>
+ concatenation functions                                         implicit, <a href="#6.3">6.3</a>
+<!--page 677 indent 0-->
+    lvalues, <a href="#6.3.2.1">6.3.2.1</a>                                             csinh functions, <a href="#7.3.6.5">7.3.6.5</a>, <a href="#G.6.2.5">G.6.2.5</a>
+    pointer, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                                      type-generic macro for, <a href="#7.24">7.24</a>
+    real and complex, <a href="#6.3.1.7">6.3.1.7</a>                                    csqrt functions, <a href="#7.3.8.3">7.3.8.3</a>, <a href="#G.6.4.2">G.6.4.2</a>
+    real and imaginary, <a href="#G.4.2">G.4.2</a>                                      type-generic macro for, <a href="#7.24">7.24</a>
+    real floating and integer, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                  ctan functions, <a href="#7.3.5.6">7.3.5.6</a>, <a href="#G.6">G.6</a>
+    real floating types, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#F.3">F.3</a>                               type-generic macro for, <a href="#7.24">7.24</a>
+    signed and unsigned integers, <a href="#6.3.1.3">6.3.1.3</a>                        ctanh functions, <a href="#7.3.6.6">7.3.6.6</a>, <a href="#G.6.2.6">G.6.2.6</a>
+    usual arithmetic, see usual arithmetic                         type-generic macro for, <a href="#7.24">7.24</a>
+          conversions                                            ctgamma function, <a href="#7.30.1">7.30.1</a>
+    void type, <a href="#6.3.2.2">6.3.2.2</a>                                           ctime function, <a href="#7.26.3.2">7.26.3.2</a>
+ conversion functions                                            ctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>
+    multibyte/wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>                    ctype.h header, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>
+       extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>                                 current object, <a href="#6.7.9">6.7.9</a>
+       restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>                  CX_LIMITED_RANGE pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.3.4">7.3.4</a>
+    multibyte/wide string, <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
+       restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                          data race, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.4.6">7.22.4.6</a>,
+    numeric, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                                          <a href="#7.23.5.8">7.23.5.8</a>, <a href="#7.23.6.2">7.23.6.2</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>,
+       wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1">7.28.4.1</a>                                 <a href="#7.28.6.4">7.28.6.4</a>
+    single byte/wide character, <a href="#7.28.6.1">7.28.6.1</a>                         data stream, see streams
+    time, <a href="#7.26.3">7.26.3</a>, <a href="#K.3.8.2">K.3.8.2</a>                                        date and time header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>
+       wide character, <a href="#7.28.5">7.28.5</a>                                    Daylight Saving Time, <a href="#7.26.1">7.26.1</a>
+ conversion specifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>,              DBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.28.2.2">7.28.2.2</a>                                                  DBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ conversion state, <a href="#7.22.7">7.22.7</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.1.1">7.27.1.1</a>,                     DBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.6">7.28.6</a>,                     DBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.28.6.2.1">7.28.6.2.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>,             DBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.28.6.4">7.28.6.4</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.6.4">K.3.6.4</a>,                DBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>,           DBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>                                               DBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ conversion state functions, <a href="#7.28.6.2">7.28.6.2</a>                            DBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ copying functions                                               DBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+    string, <a href="#7.23.2">7.23.2</a>, <a href="#K.3.7.1">K.3.7.1</a>                                      DBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+    wide string, <a href="#7.28.4.2">7.28.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a>                             DBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ copysign functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12.11.1">7.12.11.1</a>, <a href="#F.3">F.3</a>,                    decimal constant, <a href="#6.4.4.1">6.4.4.1</a>
+       <a href="#F.10.8.1">F.10.8.1</a>                                                  decimal digit, <a href="#5.2.1">5.2.1</a>
+ copysign type-generic macro, <a href="#7.24">7.24</a>                               decimal-point character, <a href="#7.1.1">7.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ correctly rounded result, <a href="#3.9">3.9</a>                                   DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
+ corresponding real type, <a href="#6.2.5">6.2.5</a>                                       <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.5">F.5</a>
+ cos functions, <a href="#7.12.4.5">7.12.4.5</a>, <a href="#F.10.1.5">F.10.1.5</a>                               declaration specifiers, <a href="#6.7">6.7</a>
+ cos type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                               declarations, <a href="#6.7">6.7</a>
+ cosh functions, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#F.10.2.4">F.10.2.4</a>                                function, <a href="#6.7.6.3">6.7.6.3</a>
+ cosh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                pointer, <a href="#6.7.6.1">6.7.6.1</a>
+ cpow functions, <a href="#7.3.8.2">7.3.8.2</a>, <a href="#G.6.4.1">G.6.4.1</a>                                  structure/union, <a href="#6.7.2.1">6.7.2.1</a>
+    type-generic macro for, <a href="#7.24">7.24</a>                                   typedef, <a href="#6.7.8">6.7.8</a>
+ cproj functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                   declarator, <a href="#6.7.6">6.7.6</a>
+ cproj type-generic macro, <a href="#7.24">7.24</a>                                    abstract, <a href="#6.7.7">6.7.7</a>
+ creal functions, <a href="#7.3.9.6">7.3.9.6</a>, <a href="#G.6">G.6</a>                                   declarator type derivation, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6">6.7.6</a>
+ creal type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                             decrement operators, see arithmetic operators,
+ critical undefined behavior, <a href="#L.2.3">L.2.3</a>                                    increment and decrement
+ csin functions, <a href="#7.3.5.5">7.3.5.5</a>, <a href="#G.6">G.6</a>                                    default argument promotions, <a href="#6.5.2.2">6.5.2.2</a>
+    type-generic macro for, <a href="#7.24">7.24</a>                                 default initialization, <a href="#6.7.9">6.7.9</a>
+<!--page 678 indent 0-->
+ default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                                  elif preprocessing directive, <a href="#6.10.1">6.10.1</a>
+ define preprocessing directive, <a href="#6.10.3">6.10.3</a>                         ellipsis punctuator (...), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
+ defined operator, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.8">6.10.8</a>                               else preprocessing directive, <a href="#6.10.1">6.10.1</a>
+ definition, <a href="#6.7">6.7</a>                                                 else statement, <a href="#6.8.4.1">6.8.4.1</a>
+    function, <a href="#6.9.1">6.9.1</a>                                             empty statement, <a href="#6.8.3">6.8.3</a>
+ dependency-ordered before, <a href="#5.1.2.4">5.1.2.4</a>                             encoding error, <a href="#7.21.3">7.21.3</a>, <a href="#7.27.1.1">7.27.1.1</a>, <a href="#7.27.1.2">7.27.1.2</a>,
+ derived declarator types, <a href="#6.2.5">6.2.5</a>                                      <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>,
+ derived types, <a href="#6.2.5">6.2.5</a>                                                 <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>,
+ designated initializer, <a href="#6.7.9">6.7.9</a>                                        <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>,
+ destringizing, <a href="#6.10.9">6.10.9</a>                                                <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+ device input/output, <a href="#5.1.2.3">5.1.2.3</a>                                   end-of-file, <a href="#7.28.1">7.28.1</a>
+ diagnostic message, <a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>                              end-of-file indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,
+ diagnostics, <a href="#5.1.1.3">5.1.1.3</a>                                                 <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
+ diagnostics header, <a href="#7.2">7.2</a>                                              <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.2">7.21.10.2</a>, <a href="#7.28.3.1">7.28.3.1</a>,
+ difftime function, <a href="#7.26.2.2">7.26.2.2</a>                                          <a href="#7.28.3.10">7.28.3.10</a>
+ digit, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                              end-of-file macro, see EOF macro
+ digraphs, <a href="#6.4.6">6.4.6</a>                                                end-of-line indicator, <a href="#5.2.1">5.2.1</a>
+ direct input/output functions, <a href="#7.21.8">7.21.8</a>                          endif preprocessing directive, <a href="#6.10.1">6.10.1</a>
+ display device, <a href="#5.2.2">5.2.2</a>                                          enum type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.2">6.7.2.2</a>
+ div function, <a href="#7.22.6.2">7.22.6.2</a>                                         enumerated type, <a href="#6.2.5">6.2.5</a>
+ div_t type, <a href="#7.22">7.22</a>                                               enumeration, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.2">6.7.2.2</a>
+ division assignment operator (/=), <a href="#6.5.16.2">6.5.16.2</a>                    enumeration constant, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+ division operator (/), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>              enumeration content, <a href="#6.7.2.3">6.7.2.3</a>
+ do statement, <a href="#6.8.5.2">6.8.5.2</a>                                          enumeration members, <a href="#6.7.2.2">6.7.2.2</a>
+ documentation of implementation, <a href="#4">4</a>                             enumeration specifiers, <a href="#6.7.2.2">6.7.2.2</a>
+ domain error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#7.12.4.4">7.12.4.4</a>,            enumeration tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+       <a href="#7.12.5.1">7.12.5.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.7">7.12.6.7</a>,                  enumerator, <a href="#6.7.2.2">6.7.2.2</a>
+       <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>,                environment, <a href="#5">5</a>
+       <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>,                  environment functions, <a href="#7.22.4">7.22.4</a>, <a href="#K.3.6.2">K.3.6.2</a>
+       <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>                environment list, <a href="#7.22.4.6">7.22.4.6</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>
+ dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                      environmental considerations, <a href="#5.2">5.2</a>
+ double _Complex type, <a href="#6.2.5">6.2.5</a>                                    environmental limits, <a href="#5.2.4">5.2.4</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.21.2">7.21.2</a>,
+ double _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                            <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.4.2">7.22.4.2</a>,
+       <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                               <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
+ double _Imaginary type, <a href="#G.2">G.2</a>                                    EOF macro, <a href="#7.4">7.4</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.2">7.21.5.2</a>,
+ double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.2">7.21.6.2</a>,                        <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.11">7.21.6.11</a>,
+       <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.2">F.2</a>                                                  <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.4">7.21.7.4</a>,
+ double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,                   <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>,
+       <a href="#6.3.1.8">6.3.1.8</a>                                                        <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.2.4">7.28.2.4</a>,
+ double-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                                 <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.2.12">7.28.2.12</a>,
+ double-quote escape sequence (\"), <a href="#6.4.4.4">6.4.4.4</a>,                          <a href="#7.28.3.4">7.28.3.4</a>, <a href="#7.28.6.1.1">7.28.6.1.1</a>, <a href="#7.28.6.1.2">7.28.6.1.2</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>,
+       <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                                  <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>,
+ double_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                           <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>,
+                                                                      <a href="#K.3.9.1.14">K.3.9.1.14</a>
+ EDOM macro, <a href="#7.5">7.5</a>, <a href="#7.12.1">7.12.1</a>, see also domain error                 equal-sign punctuator (=), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a>
+ effective type, <a href="#6.5">6.5</a>                                            equal-to operator, see equality operator
+ EILSEQ macro, <a href="#7.5">7.5</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.27.1.1">7.27.1.1</a>, <a href="#7.27.1.2">7.27.1.2</a>,                 equality expressions, <a href="#6.5.9">6.5.9</a>
+      <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>,                   equality operator (==), <a href="#6.5.9">6.5.9</a>
+      <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>,           ERANGE macro, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.12.1">7.12.1</a>,
+      see also encoding error                                         <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, see
+ element type, <a href="#6.2.5">6.2.5</a>                                                  also range error, pole error
+<!--page 679 indent 0-->
+ erf functions, <a href="#7.12.8.1">7.12.8.1</a>, <a href="#F.10.5.1">F.10.5.1</a>                               exp2 functions, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#F.10.3.2">F.10.3.2</a>
+ erf type-generic macro, <a href="#7.24">7.24</a>                                    exp2 type-generic macro, <a href="#7.24">7.24</a>
+ erfc functions, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#F.10.5.2">F.10.5.2</a>                              explicit conversion, <a href="#6.3">6.3</a>
+ erfc type-generic macro, <a href="#7.24">7.24</a>                                   expm1 functions, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#F.10.3.3">F.10.3.3</a>
+ errno macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.3.2">7.3.2</a>, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>,               expm1 type-generic macro, <a href="#7.24">7.24</a>
+       <a href="#7.12.1">7.12.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.4">7.21.10.4</a>,            exponent part, <a href="#6.4.4.2">6.4.4.2</a>
+       <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.23.6.2">7.23.6.2</a>, <a href="#7.27.1.1">7.27.1.1</a>,           exponential functions
+       <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>,                     complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
+       <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>,               real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>
+       <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#J.5.17">J.5.17</a>,               expression, <a href="#6.5">6.5</a>
+       <a href="#K.3.1.3">K.3.1.3</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a>                                          assignment, <a href="#6.5.16">6.5.16</a>
+ errno.h header, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>                                cast, <a href="#6.5.4">6.5.4</a>
+ errno_t type, <a href="#K.3.2">K.3.2</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>,                     constant, <a href="#6.6">6.6</a>
+       <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>                                         evaluation, <a href="#5.1.2.3">5.1.2.3</a>
+ error                                                             full, <a href="#6.8">6.8</a>
+    domain, see domain error                                       order of evaluation, see order of evaluation
+    encoding, see encoding error                                   parenthesized, <a href="#6.5.1">6.5.1</a>
+    pole, see pole error                                           primary, <a href="#6.5.1">6.5.1</a>
+    range, see range error                                         unary, <a href="#6.5.3">6.5.3</a>
+ error conditions, <a href="#7.12.1">7.12.1</a>                                        expression statement, <a href="#6.8.3">6.8.3</a>
+ error functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a>                                 extended alignment, <a href="#6.2.8">6.2.8</a>
+ error indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,                    extended character set, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.1.2">5.2.1.2</a>
+       <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.7">7.21.7.7</a>,                   extended characters, <a href="#5.2.1">5.2.1</a>
+       <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.3">7.21.10.3</a>,                 extended integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>,
+       <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>                                             <a href="#7.20">7.20</a>
+ error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                        extended multibyte/wide character conversion
+ error-handling functions, <a href="#7.21.10">7.21.10</a>, <a href="#7.23.6.2">7.23.6.2</a>,                         utilities, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
+       <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a>                                      extensible wide character case mapping functions,
+ escape character (\), <a href="#6.4.4.4">6.4.4.4</a>                                        <a href="#7.29.3.2">7.29.3.2</a>
+ escape sequences, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.11.4">6.11.4</a>                 extensible wide character classification functions,
+ evaluation format, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#7.12">7.12</a>                          <a href="#7.29.2.2">7.29.2.2</a>
+ evaluation method, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#F.8.5">F.8.5</a>                        extern storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.7.1">6.7.1</a>
+ evaluation of expression, <a href="#5.1.2.3">5.1.2.3</a>                               external definition, <a href="#6.9">6.9</a>
+ evaluation order, see order of evaluation                       external identifiers, underscore, <a href="#7.1.3">7.1.3</a>
+ exceptional condition, <a href="#6.5">6.5</a>                                      external linkage, <a href="#6.2.2">6.2.2</a>
+ excess precision, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                   external name, <a href="#6.4.2.1">6.4.2.1</a>
+ excess range, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                       external object definitions, <a href="#6.9.2">6.9.2</a>
+ exclusive OR operators
+    bitwise (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>                                 fabs functions, <a href="#7.12.7.2">7.12.7.2</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.2">F.10.4.2</a>
+    bitwise assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                            fabs type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+ executable program, <a href="#5.1.1.1">5.1.1.1</a>                                     false macro, <a href="#7.18">7.18</a>
+ execution character set, <a href="#5.2.1">5.2.1</a>                                  fclose function, <a href="#7.21.5.1">7.21.5.1</a>
+ execution environment, <a href="#5">5</a>, <a href="#5.1.2">5.1.2</a>, see also                       fdim functions, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#F.10.9.1">F.10.9.1</a>
+       environmental limits                                      fdim type-generic macro, <a href="#7.24">7.24</a>
+ execution sequence, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.8">6.8</a>                                FE_ALL_EXCEPT macro, <a href="#7.6">7.6</a>
+ exit function, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>,               FE_DFL_ENV macro, <a href="#7.6">7.6</a>
+       <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>                                        FE_DIVBYZERO macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ EXIT_FAILURE macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>                              FE_DOWNWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+ EXIT_SUCCESS macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>                              FE_INEXACT macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+ exp functions, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#F.10.3.1">F.10.3.1</a>                               FE_INVALID macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+ exp type-generic macro, <a href="#7.24">7.24</a>                                    FE_OVERFLOW macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+<!--page 680 indent 0-->
+ FE_TONEAREST macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                 float _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,
+ FE_TOWARDZERO macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                     <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+ FE_UNDERFLOW macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                 float _Imaginary type, <a href="#G.2">G.2</a>
+ FE_UPWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                    float type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.2">F.2</a>
+ feclearexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.1">7.6.2.1</a>, <a href="#F.3">F.3</a>                  float type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
+ fegetenv function, <a href="#7.6.4.1">7.6.4.1</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                 <a href="#6.3.1.8">6.3.1.8</a>
+ fegetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.2">7.6.2.2</a>, <a href="#F.3">F.3</a>                float.h header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
+ fegetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.1">7.6.3.1</a>, <a href="#F.3">F.3</a>                            <a href="#7.28.4.1.1">7.28.4.1.1</a>
+ feholdexcept function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.3">7.6.4.3</a>,                     float_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>
+      <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                                            floating constant, <a href="#6.4.4.2">6.4.4.2</a>
+ fence, <a href="#5.1.2.4">5.1.2.4</a>                                               floating suffix, f or <a href="#F">F</a>, <a href="#6.4.4.2">6.4.4.2</a>
+ fences, <a href="#7.17.4">7.17.4</a>                                               floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
+ fenv.h header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>                <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
+ FENV_ACCESS pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#F.8">F.8</a>, <a href="#F.9">F.9</a>,                 floating types, <a href="#6.2.5">6.2.5</a>, <a href="#6.11.1">6.11.1</a>
+      <a href="#F.10">F.10</a>                                                    floating-point accuracy, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.5">6.5</a>,
+ fenv_t type, <a href="#7.6">7.6</a>                                                  <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.5">F.5</a>, see also contracted expression
+ feof function, <a href="#7.21.10.2">7.21.10.2</a>                                     floating-point arithmetic functions, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>
+ feraiseexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.3">7.6.2.3</a>, <a href="#F.3">F.3</a>                  floating-point classification functions, <a href="#7.12.3">7.12.3</a>
+ ferror function, <a href="#7.21.10.3">7.21.10.3</a>                                   floating-point control mode, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
+ fesetenv function, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#F.3">F.3</a>                              floating-point environment, <a href="#7.6">7.6</a>, <a href="#F.8">F.8</a>, <a href="#F.8.6">F.8.6</a>
+ fesetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.4">7.6.2.4</a>, <a href="#F.3">F.3</a>                floating-point exception, <a href="#7.6">7.6</a>, <a href="#7.6.2">7.6.2</a>, <a href="#F.10">F.10</a>
+ fesetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.2">7.6.3.2</a>, <a href="#F.3">F.3</a>                       floating-point number, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.2.5">6.2.5</a>
+ fetestexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.5">7.6.2.5</a>, <a href="#F.3">F.3</a>                   floating-point rounding mode, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ feupdateenv function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                  floating-point status flag, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
+ fexcept_t type, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                     floor functions, <a href="#7.12.9.2">7.12.9.2</a>, <a href="#F.10.6.2">F.10.6.2</a>
+ fflush function, <a href="#7.21.5.2">7.21.5.2</a>, <a href="#7.21.5.3">7.21.5.3</a>                          floor type-generic macro, <a href="#7.24">7.24</a>
+ fgetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,                    FLT_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.8.1">7.21.8.1</a>                                      FLT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ fgetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>                 FLT_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ fgets function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.2">7.21.7.2</a>, <a href="#K.3.5.4.1">K.3.5.4.1</a>                  FLT_EVAL_METHOD macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.6">6.6</a>, <a href="#7.12">7.12</a>,
+ fgetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.28.3.1">7.28.3.1</a>,                        <a href="#F.10.11">F.10.11</a>
+      <a href="#7.28.3.6">7.28.3.6</a>                                                FLT_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ fgetws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.2">7.28.3.2</a>                            FLT_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ field width, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>                               FLT_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ file, <a href="#7.21.3">7.21.3</a>                                                  FLT_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   access functions, <a href="#7.21.5">7.21.5</a>, <a href="#K.3.5.2">K.3.5.2</a>                          FLT_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   name, <a href="#7.21.3">7.21.3</a>                                               FLT_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   operations, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>                                FLT_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   position indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>,                FLT_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+         <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,             FLT_RADIX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,
+         <a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.2">7.21.9.2</a>,                   <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+         <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.28.3.1">7.28.3.1</a>,              FLT_ROUNDS macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+         <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.3.10">7.28.3.10</a>                                  FLT_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   positioning functions, <a href="#7.21.9">7.21.9</a>                              fma functions, <a href="#7.12">7.12</a>, <a href="#7.12.13.1">7.12.13.1</a>, <a href="#F.10.10.1">F.10.10.1</a>
+ file scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.9">6.9</a>                                        fma type-generic macro, <a href="#7.24">7.24</a>
+ FILE type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                    fmax functions, <a href="#7.12.12.2">7.12.12.2</a>, <a href="#F.10.9.2">F.10.9.2</a>
+ FILENAME_MAX macro, <a href="#7.21.1">7.21.1</a>                                   fmax type-generic macro, <a href="#7.24">7.24</a>
+ flags, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>, see also floating-point             fmin functions, <a href="#7.12.12.3">7.12.12.3</a>, <a href="#F.10.9.3">F.10.9.3</a>
+      status flag                                              fmin type-generic macro, <a href="#7.24">7.24</a>
+ flexible array member, <a href="#6.7.2.1">6.7.2.1</a>                                fmod functions, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#F.10.7.1">F.10.7.1</a>
+ float _Complex type, <a href="#6.2.5">6.2.5</a>                                   fmod type-generic macro, <a href="#7.24">7.24</a>
+<!--page 681 indent 0-->
+ fopen function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.5.4">7.21.5.4</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a>                       <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>
+ FOPEN_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.3">7.21.4.3</a>,                    fseek function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
+      <a href="#K.3.5.1.1">K.3.5.1.1</a>                                                      <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.28.3.10">7.28.3.10</a>
+ fopen_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a>,                       fsetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
+      <a href="#K.3.5.2.2">K.3.5.2.2</a>                                                      <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.28.3.10">7.28.3.10</a>
+ for statement, <a href="#6.8.5">6.8.5</a>, <a href="#6.8.5.3">6.8.5.3</a>                                 ftell function, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>
+ form-feed character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                               full declarator, <a href="#6.7.6">6.7.6</a>
+ form-feed escape sequence (\f), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               full expression, <a href="#6.8">6.8</a>
+      <a href="#7.4.1.10">7.4.1.10</a>                                                 fully buffered stream, <a href="#7.21.3">7.21.3</a>
+ formal argument (deprecated), <a href="#3.16">3.16</a>                            function
+ formal parameter, <a href="#3.16">3.16</a>                                           argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+ formatted input/output functions, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.6">7.21.6</a>,              body, <a href="#6.9.1">6.9.1</a>
+      <a href="#K.3.5.3">K.3.5.3</a>                                                     call, <a href="#6.5.2.2">6.5.2.2</a>
+    wide character, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                                  library, <a href="#7.1.4">7.1.4</a>
+ fortran keyword, <a href="#J.5.9">J.5.9</a>                                           declarator, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.11.6">6.11.6</a>
+ forward reference, <a href="#3.11">3.11</a>                                          definition, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.7">6.11.7</a>
+ FP_CONTRACT pragma, <a href="#6.5">6.5</a>, <a href="#6.10.6">6.10.6</a>, <a href="#7.12.2">7.12.2</a>, see                     designator, <a href="#6.3.2.1">6.3.2.1</a>
+      also contracted expression                                  image, <a href="#5.2.3">5.2.3</a>
+ FP_FAST_FMA macro, <a href="#7.12">7.12</a>                                          inline, <a href="#6.7.4">6.7.4</a>
+ FP_FAST_FMAF macro, <a href="#7.12">7.12</a>                                         library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.4">7.1.4</a>
+ FP_FAST_FMAL macro, <a href="#7.12">7.12</a>                                         name length, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+ FP_ILOGB0 macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                                  no-return, <a href="#6.7.4">6.7.4</a>
+ FP_ILOGBNAN macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                                parameter, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
+ FP_INFINITE macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                     prototype, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.7">6.2.7</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>,
+ FP_NAN macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                                <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.6">6.11.6</a>, <a href="#6.11.7">6.11.7</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.12">7.12</a>
+ FP_NORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                       prototype scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.7.6.2">6.7.6.2</a>
+ FP_SUBNORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                    recursive call, <a href="#6.5.2.2">6.5.2.2</a>
+ FP_ZERO macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                         return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
+ fpclassify macro, <a href="#7.12.3.1">7.12.3.1</a>, <a href="#F.3">F.3</a>                                  scope, <a href="#6.2.1">6.2.1</a>
+ fpos_t type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>                                      type, <a href="#6.2.5">6.2.5</a>
+ fprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.1">7.21.6.1</a>,                       type conversion, <a href="#6.3.2.1">6.3.2.1</a>
+      <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.6">7.21.6.6</a>,                  function specifiers, <a href="#6.7.4">6.7.4</a>
+      <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.1">K.3.5.3.1</a>                       function type, <a href="#6.2.5">6.2.5</a>
+ fprintf_s function, <a href="#K.3.5.3.1">K.3.5.3.1</a>                                 function-call operator (( )), <a href="#6.5.2.2">6.5.2.2</a>
+ fputc function, <a href="#5.2.2">5.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.3">7.21.7.3</a>,              function-like macro, <a href="#6.10.3">6.10.3</a>
+      <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.8.2">7.21.8.2</a>                                       fundamental alignment, <a href="#6.2.8">6.2.8</a>
+ fputs function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.4">7.21.7.4</a>                              future directions
+ fputwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.28.3.3">7.28.3.3</a>,                       language, <a href="#6.11">6.11</a>
+      <a href="#7.28.3.8">7.28.3.8</a>                                                    library, <a href="#7.30">7.30</a>
+ fputws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.4">7.28.3.4</a>                             fwide function, <a href="#7.21.2">7.21.2</a>, <a href="#7.28.3.5">7.28.3.5</a>
+ fread function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.1">7.21.8.1</a>                              fwprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+ free function, <a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>                                   <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.2.3">7.28.2.3</a>, <a href="#7.28.2.5">7.28.2.5</a>,
+ freestanding execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>,                       <a href="#7.28.2.11">7.28.2.11</a>, <a href="#K.3.9.1.1">K.3.9.1.1</a>
+      <a href="#5.1.2.1">5.1.2.1</a>                                                  fwprintf_s function, <a href="#K.3.9.1.1">K.3.9.1.1</a>
+ freopen function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.4">7.21.5.4</a>                            fwrite function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.2">7.21.8.2</a>
+ freopen_s function, <a href="#K.3.5.2.2">K.3.5.2.2</a>                                 fwscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+ frexp functions, <a href="#7.12.6.4">7.12.6.4</a>, <a href="#F.10.3.4">F.10.3.4</a>                                 <a href="#7.28.2.4">7.28.2.4</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.12">7.28.2.12</a>, <a href="#7.28.3.10">7.28.3.10</a>,
+ frexp type-generic macro, <a href="#7.24">7.24</a>                                      <a href="#K.3.9.1.2">K.3.9.1.2</a>
+ fscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                     fwscanf_s function, <a href="#K.3.9.1.2">K.3.9.1.2</a>, <a href="#K.3.9.1.5">K.3.9.1.5</a>,
+      <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>                   <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
+ fscanf_s function, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
+<!--page 682 indent 0-->
+ gamma functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a>                               name spaces, <a href="#6.2.3">6.2.3</a>
+ general utilities, <a href="#7.22">7.22</a>, <a href="#K.3.6">K.3.6</a>                                reserved, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>
+   wide string, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>                                 scope, <a href="#6.2.1">6.2.1</a>
+ general wide string utilities, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>                 type, <a href="#6.2.5">6.2.5</a>
+ generic parameters, <a href="#7.24">7.24</a>                                    identifier list, <a href="#6.7.6">6.7.6</a>
+ generic selection, <a href="#6.5.1.1">6.5.1.1</a>                                  identifier nondigit, <a href="#6.4.2.1">6.4.2.1</a>
+ getc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>                   IEC 559, <a href="#F.1">F.1</a>
+ getchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.6">7.21.7.6</a>                          IEC 60559, <a href="#2">2</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.3.3">7.3.3</a>,
+ getenv function, <a href="#7.22.4.6">7.22.4.6</a>                                         <a href="#7.6">7.6</a>, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.14">7.12.14</a>, <a href="#F">F</a>, <a href="#G">G</a>,
+ getenv_s function, <a href="#K.3.6.2.1">K.3.6.2.1</a>                                      <a href="#H.1">H.1</a>
+ gets function, <a href="#K.3.5.4.1">K.3.5.4.1</a>                                    IEEE 754, <a href="#F.1">F.1</a>
+ gets_s function, <a href="#K.3.5.4.1">K.3.5.4.1</a>                                  IEEE 854, <a href="#F.1">F.1</a>
+ getwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.6">7.28.3.6</a>, <a href="#7.28.3.7">7.28.3.7</a>                  IEEE floating-point arithmetic standard, see
+ getwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.7">7.28.3.7</a>                               IEC 60559, ANSI/IEEE 754,
+ gmtime function, <a href="#7.26.3.3">7.26.3.3</a>                                         ANSI/IEEE 854
+ gmtime_s function, <a href="#K.3.8.2.3">K.3.8.2.3</a>                                if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,
+ goto statement, <a href="#6.2.1">6.2.1</a>, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.6.1">6.8.6.1</a>                             <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>
+ graphic characters, <a href="#5.2.1">5.2.1</a>                                   if statement, <a href="#6.8.4.1">6.8.4.1</a>
+ greater-than operator (&gt;), <a href="#6.5.8">6.5.8</a>                            ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>
+ greater-than-or-equal-to operator (&gt;=), <a href="#6.5.8">6.5.8</a>               ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>
+                                                             ignore_handler_s function, <a href="#K.3.6.1.3">K.3.6.1.3</a>
+ happens before, <a href="#5.1.2.4">5.1.2.4</a>                                     ilogb functions, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>
+ header, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.2">7.1.2</a>, see also standard headers           ilogb type-generic macro, <a href="#7.24">7.24</a>
+ header names, <a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>, <a href="#6.10.2">6.10.2</a>                            imaginary macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
+ hexadecimal constant, <a href="#6.4.4.1">6.4.4.1</a>                               imaginary numbers, <a href="#G">G</a>
+ hexadecimal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                imaginary type domain, <a href="#G.2">G.2</a>
+ hexadecimal prefix, <a href="#6.4.4.1">6.4.4.1</a>                                  imaginary types, <a href="#G">G</a>
+ hexadecimal-character escape sequence                       imaxabs function, <a href="#7.8.2.1">7.8.2.1</a>
+      (\x hexadecimal digits), <a href="#6.4.4.4">6.4.4.4</a>                       imaxdiv function, <a href="#7.8">7.8</a>, <a href="#7.8.2.2">7.8.2.2</a>
+ high-order bit, <a href="#3.6">3.6</a>                                         imaxdiv_t type, <a href="#7.8">7.8</a>
+ horizontal-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                        implementation, <a href="#3.12">3.12</a>
+ horizontal-tab escape sequence (\r), <a href="#7.29.2.1.3">7.29.2.1.3</a>             implementation limit, <a href="#3.13">3.13</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.4.2.1">6.4.2.1</a>,
+ horizontal-tab escape sequence (\t), <a href="#5.2.2">5.2.2</a>,                       <a href="#6.7.6">6.7.6</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#E">E</a>, see also environmental
+      <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>                                   limits
+ hosted execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.2">5.1.2.2</a>             implementation-defined behavior, <a href="#3.4.1">3.4.1</a>, <a href="#4">4</a>, <a href="#J.3">J.3</a>
+ HUGE_VAL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                     implementation-defined value, <a href="#3.19.1">3.19.1</a>
+      <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                       implicit conversion, <a href="#6.3">6.3</a>
+ HUGE_VALF macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    implicit initialization, <a href="#6.7.9">6.7.9</a>
+      <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                       include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.2">6.10.2</a>
+ HUGE_VALL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    inclusive OR operators
+      <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                         bitwise (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
+ hyperbolic functions                                           bitwise assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+   complex, <a href="#7.3.6">7.3.6</a>, <a href="#G.6.2">G.6.2</a>                                     incomplete type, <a href="#6.2.5">6.2.5</a>
+   real, <a href="#7.12.5">7.12.5</a>, <a href="#F.10.2">F.10.2</a>                                      increment operators, see arithmetic operators,
+ hypot functions, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#F.10.4.3">F.10.4.3</a>                               increment and decrement
+ hypot type-generic macro, <a href="#7.24">7.24</a>                              indeterminate value, <a href="#3.19.2">3.19.2</a>
+                                                             indeterminately sequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>,
+ <a href="#I">I</a> macro, <a href="#7.3.1">7.3.1</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                      <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, see also sequenced before,
+ identifier, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.5.1">6.5.1</a>                                         unsequenced
+    linkage, see linkage                                     indirection operator (*), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+    maximum length, <a href="#6.4.2.1">6.4.2.1</a>                                  inequality operator (!=), <a href="#6.5.9">6.5.9</a>
+<!--page 683 indent 0-->
+ infinitary, <a href="#7.12.1">7.12.1</a>                                                    extended, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#7.20">7.20</a>
+ INFINITY macro, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                              inter-thread happens before, <a href="#5.1.2.4">5.1.2.4</a>
+ initial position, <a href="#5.2.2">5.2.2</a>                                           interactive device, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a>
+ initial shift state, <a href="#5.2.1.2">5.2.1.2</a>                                      internal linkage, <a href="#6.2.2">6.2.2</a>
+ initialization, <a href="#5.1.2">5.1.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.5">6.5.2.5</a>, <a href="#6.7.9">6.7.9</a>,            internal name, <a href="#6.4.2.1">6.4.2.1</a>
+       <a href="#F.8.5">F.8.5</a>                                                       interrupt, <a href="#5.2.3">5.2.3</a>
+    in blocks, <a href="#6.8">6.8</a>                                                 INTMAX_C macro, <a href="#7.20.4.2">7.20.4.2</a>
+ initializer, <a href="#6.7.9">6.7.9</a>                                                INTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
+    permitted form, <a href="#6.6">6.6</a>                                            INTMAX_MIN macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
+    string literal, <a href="#6.3.2.1">6.3.2.1</a>                                        intmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+ inline, <a href="#6.7.4">6.7.4</a>                                                           <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+ inner scope, <a href="#6.2.1">6.2.1</a>                                                INTN_C macros, <a href="#7.20.4.1">7.20.4.1</a>
+ input failure, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>,                     INTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>
+       <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>,                 INTN_MIN macros, <a href="#7.20.2.1">7.20.2.1</a>
+       <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>, <a href="#K.3.9.1.5">K.3.9.1.5</a>,               intN_t types, <a href="#7.20.1.1">7.20.1.1</a>
+       <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>               INTPTR_MAX macro, <a href="#7.20.2.4">7.20.2.4</a>
+ input/output functions                                            INTPTR_MIN macro, <a href="#7.20.2.4">7.20.2.4</a>
+    character, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a>                                     intptr_t type, <a href="#7.20.1.4">7.20.1.4</a>
+    direct, <a href="#7.21.8">7.21.8</a>                                                 inttypes.h header, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>
+    formatted, <a href="#7.21.6">7.21.6</a>, <a href="#K.3.5.3">K.3.5.3</a>                                     isalnum function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>
+       wide character, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                             isalpha function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>
+    wide character, <a href="#7.28.3">7.28.3</a>                                         isblank function, <a href="#7.4.1.3">7.4.1.3</a>
+       formatted, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                                  iscntrl function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.4">7.4.1.4</a>, <a href="#7.4.1.7">7.4.1.7</a>,
+ input/output header, <a href="#7.21">7.21</a>, <a href="#K.3.5">K.3.5</a>                                        <a href="#7.4.1.11">7.4.1.11</a>
+ input/output, device, <a href="#5.1.2.3">5.1.2.3</a>                                     isdigit function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.5">7.4.1.5</a>,
+ int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.7.2">6.7.2</a>                       <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.11.1.1">7.11.1.1</a>
+ int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,                   isfinite macro, <a href="#7.12.3.2">7.12.3.2</a>, <a href="#F.3">F.3</a>
+       <a href="#6.3.1.8">6.3.1.8</a>                                                     isgraph function, <a href="#7.4.1.6">7.4.1.6</a>
+ INT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>                                    isgreater macro, <a href="#7.12.14.1">7.12.14.1</a>, <a href="#F.3">F.3</a>
+ INT_FASTN_MIN macros, <a href="#7.20.2.3">7.20.2.3</a>                                    isgreaterequal macro, <a href="#7.12.14.2">7.12.14.2</a>, <a href="#F.3">F.3</a>
+ int_fastN_t types, <a href="#7.20.1.3">7.20.1.3</a>                                       isinf macro, <a href="#7.12.3.3">7.12.3.3</a>
+ INT_LEASTN_MAX macros, <a href="#7.20.2.2">7.20.2.2</a>                                   isless macro, <a href="#7.12.14.3">7.12.14.3</a>, <a href="#F.3">F.3</a>
+ INT_LEASTN_MIN macros, <a href="#7.20.2.2">7.20.2.2</a>                                   islessequal macro, <a href="#7.12.14.4">7.12.14.4</a>, <a href="#F.3">F.3</a>
+ int_leastN_t types, <a href="#7.20.1.2">7.20.1.2</a>                                      islessgreater macro, <a href="#7.12.14.5">7.12.14.5</a>, <a href="#F.3">F.3</a>
+ INT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                          islower function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.2.1">7.4.2.1</a>,
+ INT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>                                          <a href="#7.4.2.2">7.4.2.2</a>
+ integer arithmetic functions, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>,                   isnan macro, <a href="#7.12.3.4">7.12.3.4</a>, <a href="#F.3">F.3</a>
+       <a href="#7.22.6">7.22.6</a>                                                      isnormal macro, <a href="#7.12.3.5">7.12.3.5</a>
+ integer character constant, <a href="#6.4.4.4">6.4.4.4</a>                               ISO 31-11, <a href="#2">2</a>, <a href="#3">3</a>
+ integer constant, <a href="#6.4.4.1">6.4.4.1</a>                                         ISO 4217, <a href="#2">2</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ integer constant expression, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.6">6.6</a>, <a href="#6.7.2.1">6.7.2.1</a>,               ISO 8601, <a href="#2">2</a>, <a href="#7.26.3.5">7.26.3.5</a>
+       <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.7.10">6.7.10</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#6.10.1">6.10.1</a>,           ISO/IEC 10646, <a href="#2">2</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.4.3">6.4.3</a>, <a href="#6.10.8.2">6.10.8.2</a>
+       <a href="#7.1.4">7.1.4</a>                                                       ISO/IEC 10976-1, <a href="#H.1">H.1</a>
+ integer conversion rank, <a href="#6.3.1.1">6.3.1.1</a>                                  ISO/IEC 2382-1, <a href="#2">2</a>, <a href="#3">3</a>
+ integer promotions, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.3.1.1">6.3.1.1</a>,                  ISO/IEC 646, <a href="#2">2</a>, <a href="#5.2.1.1">5.2.1.1</a>
+       <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.7">6.5.7</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>,           ISO/IEC 9945-2, <a href="#7.11">7.11</a>
+       <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>                                          iso646.h header, <a href="#4">4</a>, <a href="#7.9">7.9</a>                          *
+ integer suffix, <a href="#6.4.4.1">6.4.4.1</a>                                            isprint function, <a href="#5.2.2">5.2.2</a>, <a href="#7.4.1.8">7.4.1.8</a>
+ integer type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,               ispunct function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,
+       <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                                          <a href="#7.4.1.11">7.4.1.11</a>
+ integer types, <a href="#6.2.5">6.2.5</a>, <a href="#7.20">7.20</a>                                        isspace function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,
+<!--page 684 indent 0-->
+       <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>,                   LC_ALL macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+       <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>                                        LC_COLLATE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.3">7.23.4.3</a>,
+ isunordered macro, <a href="#7.12.14.6">7.12.14.6</a>, <a href="#F.3">F.3</a>                                     <a href="#7.28.4.4.2">7.28.4.4.2</a>
+ isupper function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.4.2.1">7.4.2.1</a>,                   LC_CTYPE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7">7.22.7</a>,
+       <a href="#7.4.2.2">7.4.2.2</a>                                                         <a href="#7.22.8">7.22.8</a>, <a href="#7.28.6">7.28.6</a>, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>,
+ iswalnum function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>,                            <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>, <a href="#K.3.6.4">K.3.6.4</a>, <a href="#K.3.6.5">K.3.6.5</a>
+       <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   LC_MONETARY macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+ iswalpha function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                      LC_NUMERIC macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+       <a href="#7.29.2.2.1">7.29.2.2.1</a>                                                LC_TIME macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.26.3.5">7.26.3.5</a>
+ iswblank function, <a href="#7.29.2.1.3">7.29.2.1.3</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                       lconv structure type, <a href="#7.11">7.11</a>
+ iswcntrl function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.4">7.29.2.1.4</a>,                      LDBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                       LDBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ iswctype function, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>                       LDBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ iswdigit function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                      LDBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.29.2.1.5">7.29.2.1.5</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>           LDBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ iswgraph function, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.1.6">7.29.2.1.6</a>,                        LDBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   LDBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ iswlower function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>,                      LDBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.1.2">7.29.3.1.2</a>                        LDBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ iswprint function, <a href="#7.29.2.1.6">7.29.2.1.6</a>, <a href="#7.29.2.1.8">7.29.2.1.8</a>,                      LDBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.29.2.2.1">7.29.2.2.1</a>                                                LDBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ iswpunct function, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                        LDBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>,                      ldexp functions, <a href="#7.12.6.6">7.12.6.6</a>, <a href="#F.10.3.6">F.10.3.6</a>
+       <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   ldexp type-generic macro, <a href="#7.24">7.24</a>
+ iswspace function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,                          ldiv function, <a href="#7.22.6.2">7.22.6.2</a>
+       <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.6">7.29.2.1.6</a>,           ldiv_t type, <a href="#7.22">7.22</a>
+       <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>,                      leading underscore in identifiers, <a href="#7.1.3">7.1.3</a>
+       <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   left-shift assignment operator (&lt;&lt;=), <a href="#6.5.16.2">6.5.16.2</a>
+ iswupper function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>,                     left-shift operator (&lt;&lt;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+       <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.1.2">7.29.3.1.2</a>                        length
+ iswxdigit function, <a href="#7.29.2.1.12">7.29.2.1.12</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                        external name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+ isxdigit function, <a href="#7.4.1.12">7.4.1.12</a>, <a href="#7.11.1.1">7.11.1.1</a>                              function name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+ italic type convention, <a href="#3">3</a>, <a href="#6.1">6.1</a>                                     identifier, <a href="#6.4.2.1">6.4.2.1</a>
+ iteration statements, <a href="#6.8.5">6.8.5</a>                                        internal name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+                                                                 length function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.23.6.3">7.23.6.3</a>, <a href="#7.28.4.6.1">7.28.4.6.1</a>,
+ jmp_buf type, <a href="#7.13">7.13</a>                                                    <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#K.3.7.4.4">K.3.7.4.4</a>, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a>
+ jump statements, <a href="#6.8.6">6.8.6</a>                                          length modifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>,
+                                                                       <a href="#7.28.2.2">7.28.2.2</a>
+ keywords, <a href="#6.4.1">6.4.1</a>, <a href="#G.2">G.2</a>, <a href="#J.5.9">J.5.9</a>, <a href="#J.5.10">J.5.10</a>                             less-than operator (&lt;), <a href="#6.5.8">6.5.8</a>
+ kill_dependency macro, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.17.3.1">7.17.3.1</a>                        less-than-or-equal-to operator (&lt;=), <a href="#6.5.8">6.5.8</a>
+ known constant size, <a href="#6.2.5">6.2.5</a>                                      letter, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
+                                                                 lexical elements, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>
+ L_tmpnam macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.4">7.21.4.4</a>                                lgamma functions, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#F.10.5.3">F.10.5.3</a>
+ L_tmpnam_s macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                              lgamma type-generic macro, <a href="#7.24">7.24</a>
+ label name, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.3">6.2.3</a>                                        library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7">7</a>, <a href="#K.3">K.3</a>
+ labeled statement, <a href="#6.8.1">6.8.1</a>                                           future directions, <a href="#7.30">7.30</a>
+ labs function, <a href="#7.22.6.1">7.22.6.1</a>                                            summary, <a href="#B">B</a>
+ language, <a href="#6">6</a>                                                        terms, <a href="#7.1.1">7.1.1</a>
+    future directions, <a href="#6.11">6.11</a>                                         use of functions, <a href="#7.1.4">7.1.4</a>
+    syntax summary, <a href="#A">A</a>                                            lifetime, <a href="#6.2.4">6.2.4</a>
+ Latin alphabet, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.2.1">6.4.2.1</a>                                  limits
+<!--page 685 indent 0-->
+    environmental, see environmental limits                      <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+    implementation, see implementation limits               long double _Imaginary type, <a href="#G.2">G.2</a>
+    numerical, see numerical limits                         long double suffix, l or <a href="#L">L</a>, <a href="#6.4.4.2">6.4.4.2</a>
+    translation, see translation limits                     long double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>,
+ limits.h header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                      <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.2">F.2</a>
+ line buffered stream, <a href="#7.21.3">7.21.3</a>                               long double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,
+ line number, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a>                                   <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+ line preprocessing directive, <a href="#6.10.4">6.10.4</a>                       long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
+ lines, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#7.21.2">7.21.2</a>                                          <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+    preprocessing directive, <a href="#6.10">6.10</a>                           long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+ linkage, <a href="#6.2.2">6.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.4">6.7.4</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.9">6.9</a>, <a href="#6.9.2">6.9.2</a>,                <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+       <a href="#6.11.2">6.11.2</a>                                               long integer suffix, l or <a href="#L">L</a>, <a href="#6.4.4.1">6.4.4.1</a>
+ llabs function, <a href="#7.22.6.1">7.22.6.1</a>                                   long long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>,
+ lldiv function, <a href="#7.22.6.2">7.22.6.2</a>                                        <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+ lldiv_t type, <a href="#7.22">7.22</a>                                         long long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>,
+ LLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                           <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+       <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           long long integer suffix, ll or LL, <a href="#6.4.4.1">6.4.4.1</a>
+ LLONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                      LONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
+       <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           LONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
+ llrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a>                  longjmp function, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>, <a href="#7.22.4.4">7.22.4.4</a>,
+ llrint type-generic macro, <a href="#7.24">7.24</a>                                 <a href="#7.22.4.7">7.22.4.7</a>
+ llround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a>                      loop body, <a href="#6.8.5">6.8.5</a>
+ llround type-generic macro, <a href="#7.24">7.24</a>                           low-order bit, <a href="#3.6">3.6</a>
+ local time, <a href="#7.26.1">7.26.1</a>                                         lowercase letter, <a href="#5.2.1">5.2.1</a>
+ locale, <a href="#3.4.2">3.4.2</a>                                              lrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a>
+ locale-specific behavior, <a href="#3.4.2">3.4.2</a>, <a href="#J.4">J.4</a>                        lrint type-generic macro, <a href="#7.24">7.24</a>
+ locale.h header, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>                              lround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a>
+ localeconv function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>                    lround type-generic macro, <a href="#7.24">7.24</a>
+ localization, <a href="#7.11">7.11</a>                                         lvalue, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>, <a href="#6.5.16">6.5.16</a>,
+ localtime function, <a href="#7.26.3.4">7.26.3.4</a>                                    <a href="#6.7.2.4">6.7.2.4</a>
+ localtime_s function, <a href="#K.3.8.2.4">K.3.8.2.4</a>                            lvalue conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.5.16.1">6.5.16.1</a>,
+ log functions, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#F.10.3.7">F.10.3.7</a>                               <a href="#6.5.16.2">6.5.16.2</a>
+ log type-generic macro, <a href="#7.24">7.24</a>
+ log10 functions, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#F.10.3.8">F.10.3.8</a>                        macro argument substitution, <a href="#6.10.3.1">6.10.3.1</a>
+ log10 type-generic macro, <a href="#7.24">7.24</a>                             macro definition
+ log1p functions, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#F.10.3.9">F.10.3.9</a>                          library function, <a href="#7.1.4">7.1.4</a>
+ log1p type-generic macro, <a href="#7.24">7.24</a>                             macro invocation, <a href="#6.10.3">6.10.3</a>
+ log2 functions, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#F.10.3.10">F.10.3.10</a>                       macro name, <a href="#6.10.3">6.10.3</a>
+ log2 type-generic macro, <a href="#7.24">7.24</a>                                length, <a href="#5.2.4.1">5.2.4.1</a>
+ logarithmic functions                                        predefined, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>
+    complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>                                     redefinition, <a href="#6.10.3">6.10.3</a>
+    real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>                                      scope, <a href="#6.10.3.5">6.10.3.5</a>
+ logb functions, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.11">F.10.3.11</a>                  macro parameter, <a href="#6.10.3">6.10.3</a>
+ logb type-generic macro, <a href="#7.24">7.24</a>                              macro preprocessor, <a href="#6.10">6.10</a>
+ logical operators                                          macro replacement, <a href="#6.10.3">6.10.3</a>
+    AND (&amp;&amp;), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>                               magnitude, complex, <a href="#7.3.8.1">7.3.8.1</a>
+    negation (!), <a href="#6.5.3.3">6.5.3.3</a>                                   main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.4">6.7.4</a>,
+    OR (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>                                     <a href="#7.21.3">7.21.3</a>
+ logical source lines, <a href="#5.1.1.2">5.1.1.2</a>                              malloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.4">7.22.3.4</a>, <a href="#7.22.3.5">7.22.3.5</a>
+ long double _Complex type, <a href="#6.2.5">6.2.5</a>                           manipulation functions
+ long double _Complex type conversion,                        complex, <a href="#7.3.9">7.3.9</a>
+<!--page 686 indent 0-->
+   real, <a href="#7.12.11">7.12.11</a>, <a href="#F.10.8">F.10.8</a>                                    modf functions, <a href="#7.12.6.12">7.12.6.12</a>, <a href="#F.10.3.12">F.10.3.12</a>
+ matching failure, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>,           modifiable lvalue, <a href="#6.3.2.1">6.3.2.1</a>
+      <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>                     modification order, <a href="#5.1.2.4">5.1.2.4</a>
+ math.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>,              modulus functions, <a href="#7.12.6.12">7.12.6.12</a>
+      <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a>                                          modulus, complex, <a href="#7.3.8.1">7.3.8.1</a>
+ MATH_ERREXCEPT macro, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>                           mtx_destroy function, <a href="#7.25.4.1">7.25.4.1</a>
+ math_errhandling macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>                  mtx_init function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.4.2">7.25.4.2</a>
+ MATH_ERRNO macro, <a href="#7.12">7.12</a>                                     mtx_lock function, <a href="#7.25.4.3">7.25.4.3</a>
+ max_align_t type, <a href="#7.19">7.19</a>                                     mtx_t type, <a href="#7.25.1">7.25.1</a>
+ maximum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                         mtx_timedlock function, <a href="#7.25.4.4">7.25.4.4</a>
+ MB_CUR_MAX macro, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7.2">7.22.7.2</a>,                   mtx_trylock function, <a href="#7.25.4.5">7.25.4.5</a>
+      <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>,             mtx_unlock function, <a href="#7.25.4.3">7.25.4.3</a>, <a href="#7.25.4.4">7.25.4.4</a>,
+      <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>                                     <a href="#7.25.4.5">7.25.4.5</a>, <a href="#7.25.4.6">7.25.4.6</a>
+ MB_LEN_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a>                   multibyte character, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+ mblen function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.28.6.3">7.28.6.3</a>                         multibyte conversion functions
+ mbrlen function, <a href="#7.28.6.3.1">7.28.6.3.1</a>                                  wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
+ mbrtoc16 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27.1.1">7.27.1.1</a>                     extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
+ mbrtoc32 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27.1.3">7.27.1.3</a>                     restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
+ mbrtowc function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                wide string, <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
+      <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>,                restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
+      <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>                    multibyte string, <a href="#7.1.1">7.1.1</a>
+ mbsinit function, <a href="#7.28.6.2.1">7.28.6.2.1</a>                               multibyte/wide character conversion functions,
+ mbsrtowcs function, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                       <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
+ mbsrtowcs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>                 extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
+ mbstate_t type, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>,                    restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
+      <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.27">7.27</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>,             multibyte/wide string conversion functions,
+      <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.6">7.28.6</a>, <a href="#7.28.6.2.1">7.28.6.2.1</a>, <a href="#7.28.6.3">7.28.6.3</a>,                    <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
+      <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#7.28.6.4">7.28.6.4</a>                                    restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
+ mbstowcs function, <a href="#6.4.5">6.4.5</a>, <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.28.6.4">7.28.6.4</a>               multidimensional array, <a href="#6.5.2.1">6.5.2.1</a>
+ mbstowcs_s function, <a href="#K.3.6.5.1">K.3.6.5.1</a>                             multiplication assignment operator (*=), <a href="#6.5.16.2">6.5.16.2</a>
+ mbtowc function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.22.7.2">7.22.7.2</a>,              multiplication operator (*), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>,
+      <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.28.6.3">7.28.6.3</a>                                         <a href="#G.5.1">G.5.1</a>
+ member access operators (. and -&gt;), <a href="#6.5.2.3">6.5.2.3</a>                multiplicative expressions, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+ member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+ memchr function, <a href="#7.23.5.1">7.23.5.1</a>                                  n-char sequence, <a href="#7.22.1.3">7.22.1.3</a>
+ memcmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.1">7.23.4.1</a>                          n-wchar sequence, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+ memcpy function, <a href="#7.23.2.1">7.23.2.1</a>                                  name
+ memcpy_s function, <a href="#K.3.7.1.1">K.3.7.1.1</a>                                 external, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+ memmove function, <a href="#7.23.2.2">7.23.2.2</a>                                   file, <a href="#7.21.3">7.21.3</a>
+ memmove_s function, <a href="#K.3.7.1.2">K.3.7.1.2</a>                                internal, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+ memory location, <a href="#3.14">3.14</a>                                        label, <a href="#6.2.3">6.2.3</a>
+ memory management functions, <a href="#7.22.3">7.22.3</a>                          structure/union member, <a href="#6.2.3">6.2.3</a>
+ memory_order type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.3">7.17.3</a>                          name spaces, <a href="#6.2.3">6.2.3</a>
+ memset function, <a href="#7.23.6.1">7.23.6.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>                       named label, <a href="#6.8.1">6.8.1</a>
+ memset_s function, <a href="#K.3.7.4.1">K.3.7.4.1</a>                               NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ minimum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                         nan functions, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#F.2.1">F.2.1</a>, <a href="#F.10.8.2">F.10.8.2</a>
+ minus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                             NAN macro, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>
+ miscellaneous functions                                    NDEBUG macro, <a href="#7.2">7.2</a>
+   string, <a href="#7.23.6">7.23.6</a>, <a href="#K.3.7.4">K.3.7.4</a>                                  nearbyint functions, <a href="#7.12.9.3">7.12.9.3</a>, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>,
+   wide string, <a href="#7.28.4.6">7.28.4.6</a>, <a href="#K.3.9.2.4">K.3.9.2.4</a>                              <a href="#F.10.6.3">F.10.6.3</a>
+ mktime function, <a href="#7.26.2.3">7.26.2.3</a>                                  nearbyint type-generic macro, <a href="#7.24">7.24</a>
+<!--page 687 indent 0-->
+ nearest integer functions, <a href="#7.12.9">7.12.9</a>, <a href="#F.10.6">F.10.6</a>                       operating system, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#7.22.4.8">7.22.4.8</a>
+ negation operator (!), <a href="#6.5.3.3">6.5.3.3</a>                                  operations on files, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>
+ negative zero, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.12.11.1">7.12.11.1</a>                               operator, <a href="#6.4.6">6.4.6</a>
+ new-line character, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#6.10.4">6.10.4</a>           operators, <a href="#6.5">6.5</a>
+ new-line escape sequence (\n), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,                     additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>
+      <a href="#7.4.1.10">7.4.1.10</a>                                                      alignof, <a href="#6.5.3.4">6.5.3.4</a>
+ nextafter functions, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>,                    assignment, <a href="#6.5.16">6.5.16</a>
+      <a href="#F.10.8.3">F.10.8.3</a>                                                      associativity, <a href="#6.5">6.5</a>
+ nextafter type-generic macro, <a href="#7.24">7.24</a>                                 equality, <a href="#6.5.9">6.5.9</a>
+ nexttoward functions, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.8.4">F.10.8.4</a>                     multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+ nexttoward type-generic macro, <a href="#7.24">7.24</a>                                postfix, <a href="#6.5.2">6.5.2</a>
+ no linkage, <a href="#6.2.2">6.2.2</a>                                                  precedence, <a href="#6.5">6.5</a>
+ no-return function, <a href="#6.7.4">6.7.4</a>                                          preprocessing, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, <a href="#6.10.9">6.10.9</a>
+ non-stop floating-point control mode, <a href="#7.6.4.2">7.6.4.2</a>                       relational, <a href="#6.5.8">6.5.8</a>
+ nongraphic characters, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                              shift, <a href="#6.5.7">6.5.7</a>
+ nonlocal jumps header, <a href="#7.13">7.13</a>                                        sizeof, <a href="#6.5.3.4">6.5.3.4</a>
+ norm, complex, <a href="#7.3.8.1">7.3.8.1</a>                                             unary, <a href="#6.5.3">6.5.3</a>
+ normalized broken-down time, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>                    unary arithmetic, <a href="#6.5.3.3">6.5.3.3</a>
+ not macro, <a href="#7.9">7.9</a>                                                  optional features, see conditional features
+ not-equal-to operator, see inequality operator                  or macro, <a href="#7.9">7.9</a>
+ not_eq macro, <a href="#7.9">7.9</a>                                               OR operators
+ null character (\0), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                         bitwise exclusive (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
+   padding of binary stream, <a href="#7.21.2">7.21.2</a>                                 bitwise exclusive assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
+ NULL macro, <a href="#7.11">7.11</a>, <a href="#7.19">7.19</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.22">7.22</a>, <a href="#7.23.1">7.23.1</a>,                      bitwise inclusive (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
+      <a href="#7.26.1">7.26.1</a>, <a href="#7.28.1">7.28.1</a>                                                bitwise inclusive assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+ null pointer, <a href="#6.3.2.3">6.3.2.3</a>                                              logical (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>
+ null pointer constant, <a href="#6.3.2.3">6.3.2.3</a>                                  or_eq macro, <a href="#7.9">7.9</a>
+ null preprocessing directive, <a href="#6.10.7">6.10.7</a>                            order of allocated storage, <a href="#7.22.3">7.22.3</a>
+ null statement, <a href="#6.8.3">6.8.3</a>                                           order of evaluation, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>,
+ null wide character, <a href="#7.1.1">7.1.1</a>                                            see also sequence points
+ number classification macros, <a href="#7.12">7.12</a>, <a href="#7.12.3.1">7.12.3.1</a>                     ordinary identifier name space, <a href="#6.2.3">6.2.3</a>
+ numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                   orientation of stream, <a href="#7.21.2">7.21.2</a>, <a href="#7.28.3.5">7.28.3.5</a>
+   wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1">7.28.4.1</a>                                out-of-bounds store, <a href="#L.2.1">L.2.1</a>
+ numerical limits, <a href="#5.2.4.2">5.2.4.2</a>                                       outer scope, <a href="#6.2.1">6.2.1</a>
+                                                                 over-aligned, <a href="#6.2.8">6.2.8</a>
+ object, <a href="#3.15">3.15</a>
+ object representation, <a href="#6.2.6.1">6.2.6.1</a>                                  padding
+ object type, <a href="#6.2.5">6.2.5</a>                                                binary stream, <a href="#7.21.2">7.21.2</a>
+ object-like macro, <a href="#6.10.3">6.10.3</a>                                         bits, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a>
+ observable behavior, <a href="#5.1.2.3">5.1.2.3</a>                                      structure/union, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+ obsolescence, <a href="#6.11">6.11</a>, <a href="#7.30">7.30</a>                                        parameter, <a href="#3.16">3.16</a>
+ octal constant, <a href="#6.4.4.1">6.4.4.1</a>                                           array, <a href="#6.9.1">6.9.1</a>
+ octal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.4">6.4.4.4</a>                                     ellipsis, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
+ octal-character escape sequence (\octal digits),                  function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
+      <a href="#6.4.4.4">6.4.4.4</a>                                                      macro, <a href="#6.10.3">6.10.3</a>
+ offsetof macro, <a href="#7.19">7.19</a>                                              main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ on-off switch, <a href="#6.10.6">6.10.6</a>                                             program, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ once_flag type, <a href="#7.25.1">7.25.1</a>                                          parameter type list, <a href="#6.7.6.3">6.7.6.3</a>
+ ONCE_FLAG_INIT macro, <a href="#7.25.1">7.25.1</a>                                    parentheses punctuator (( )), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
+ ones' complement, <a href="#6.2.6.2">6.2.6.2</a>                                       parenthesized expression, <a href="#6.5.1">6.5.1</a>
+ operand, <a href="#6.4.6">6.4.6</a>, <a href="#6.5">6.5</a>                                             parse state, <a href="#7.21.2">7.21.2</a>
+<!--page 688 indent 0-->
+ perform a trap, <a href="#3.19.5">3.19.5</a>                                        preprocessor, <a href="#6.10">6.10</a>
+ permitted form of initializer, <a href="#6.6">6.6</a>                            PRIcFASTN macros, <a href="#7.8.1">7.8.1</a>
+ perror function, <a href="#7.21.10.4">7.21.10.4</a>                                    PRIcLEASTN macros, <a href="#7.8.1">7.8.1</a>
+ phase angle, complex, <a href="#7.3.9.1">7.3.9.1</a>                                 PRIcMAX macros, <a href="#7.8.1">7.8.1</a>
+ physical source lines, <a href="#5.1.1.2">5.1.1.2</a>                                PRIcN macros, <a href="#7.8.1">7.8.1</a>
+ placemarker, <a href="#6.10.3.3">6.10.3.3</a>                                         PRIcPTR macros, <a href="#7.8.1">7.8.1</a>
+ plus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                                 primary expression, <a href="#6.5.1">6.5.1</a>
+ pointer arithmetic, <a href="#6.5.6">6.5.6</a>                                     printf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.10">7.21.6.10</a>,
+ pointer comparison, <a href="#6.5.8">6.5.8</a>                                           <a href="#K.3.5.3.3">K.3.5.3.3</a>
+ pointer declarator, <a href="#6.7.6.1">6.7.6.1</a>                                   printf_s function, <a href="#K.3.5.3.3">K.3.5.3.3</a>
+ pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                printing character, <a href="#5.2.2">5.2.2</a>, <a href="#7.4">7.4</a>, <a href="#7.4.1.8">7.4.1.8</a>
+ pointer to function, <a href="#6.5.2.2">6.5.2.2</a>                                  printing wide character, <a href="#7.29.2">7.29.2</a>
+ pointer type, <a href="#6.2.5">6.2.5</a>                                           program diagnostics, <a href="#7.2.1">7.2.1</a>
+ pointer type conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                     program execution, <a href="#5.1.2.2.2">5.1.2.2.2</a>, <a href="#5.1.2.3">5.1.2.3</a>
+ pointer, null, <a href="#6.3.2.3">6.3.2.3</a>                                        program file, <a href="#5.1.1.1">5.1.1.1</a>
+ pole error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#7.12.6.8">7.12.6.8</a>,             program image, <a href="#5.1.1.2">5.1.1.2</a>
+      <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#7.12.7.4">7.12.7.4</a>,                program name (argv[0]), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+      <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>                                       program parameters, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ portability, <a href="#4">4</a>, <a href="#J">J</a>                                             program startup, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+ position indicator, file, see file position indicator           program structure, <a href="#5.1.1.1">5.1.1.1</a>
+ positive difference, <a href="#7.12.12.1">7.12.12.1</a>                                program termination, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>,
+ positive difference functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                      <a href="#5.1.2.3">5.1.2.3</a>
+ postfix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              program, conforming, <a href="#4">4</a>
+ postfix expressions, <a href="#6.5.2">6.5.2</a>                                     program, strictly conforming, <a href="#4">4</a>
+ postfix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              promotions
+ pow functions, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#F.10.4.4">F.10.4.4</a>                                default argument, <a href="#6.5.2.2">6.5.2.2</a>
+ pow type-generic macro, <a href="#7.24">7.24</a>                                     integer, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.3.1.1">6.3.1.1</a>
+ power functions                                               prototype, see function prototype
+   complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                       pseudo-random sequence functions, <a href="#7.22.2">7.22.2</a>
+   real, <a href="#7.12.7">7.12.7</a>, <a href="#F.10.4">F.10.4</a>                                        PTRDIFF_MAX macro, <a href="#7.20.3">7.20.3</a>
+ pp-number, <a href="#6.4.8">6.4.8</a>                                              PTRDIFF_MIN macro, <a href="#7.20.3">7.20.3</a>
+ pragma operator, <a href="#6.10.9">6.10.9</a>                                       ptrdiff_t type, <a href="#7.17.1">7.17.1</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>,
+ pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                      <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+ precedence of operators, <a href="#6.5">6.5</a>                                  punctuators, <a href="#6.4.6">6.4.6</a>
+ precedence of syntax rules, <a href="#5.1.1.2">5.1.1.2</a>                           putc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.7.8">7.21.7.8</a>
+ precision, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>               putchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.8">7.21.7.8</a>
+   excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                         puts function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.9">7.21.7.9</a>
+ predefined macro names, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>                         putwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#7.28.3.9">7.28.3.9</a>
+ prefix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               putwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.9">7.28.3.9</a>
+ prefix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
+ preprocessing concatenation, <a href="#6.10.3.3">6.10.3.3</a>                         qsort function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.2">7.22.5.2</a>
+ preprocessing directives, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10">6.10</a>                       qsort_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>
+ preprocessing file, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.10">6.10</a>                              qualified types, <a href="#6.2.5">6.2.5</a>
+ preprocessing numbers, <a href="#6.4">6.4</a>, <a href="#6.4.8">6.4.8</a>                             qualified version of type, <a href="#6.2.5">6.2.5</a>
+ preprocessing operators                                       question-mark escape sequence (\?), <a href="#6.4.4.4">6.4.4.4</a>
+   #, <a href="#6.10.3.2">6.10.3.2</a>                                                 quick_exit function, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>,
+   ##, <a href="#6.10.3.3">6.10.3.3</a>                                                     <a href="#7.22.4.7">7.22.4.7</a>
+   _Pragma, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>                                    quiet NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   defined, <a href="#6.10.1">6.10.1</a>
+ preprocessing tokens, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>                      raise function, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>, <a href="#7.22.4.1">7.22.4.1</a>
+ preprocessing translation unit, <a href="#5.1.1.1">5.1.1.1</a>                       rand function, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.2.2">7.22.2.2</a>
+<!--page 689 indent 0-->
+ RAND_MAX macro, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a>                               restrict-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
+ range                                                        return statement, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
+    excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                       rewind function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.5">7.21.9.5</a>,
+ range error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#7.12.6.1">7.12.6.1</a>,                 <a href="#7.28.3.10">7.28.3.10</a>
+       <a href="#7.12.6.2">7.12.6.2</a>, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.6">7.12.6.6</a>,                right-shift assignment operator (&gt;&gt;=), <a href="#6.5.16.2">6.5.16.2</a>
+       <a href="#7.12.6.13">7.12.6.13</a>, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.8.2">7.12.8.2</a>,               right-shift operator (&gt;&gt;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+       <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>,                rint functions, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.4">F.10.6.4</a>
+       <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#7.12.13.1">7.12.13.1</a>                        rint type-generic macro, <a href="#7.24">7.24</a>
+ rank, see integer conversion rank                            round functions, <a href="#7.12.9.6">7.12.9.6</a>, <a href="#F.10.6.6">F.10.6.6</a>
+ read-modify-write operations, <a href="#5.1.2.4">5.1.2.4</a>                        round type-generic macro, <a href="#7.24">7.24</a>
+ real floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,              rounding mode, floating point, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+       <a href="#6.3.1.7">6.3.1.7</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                      RSIZE_MAX macro, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>,
+ real floating types, <a href="#6.2.5">6.2.5</a>                                          <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>, <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>,
+ real type domain, <a href="#6.2.5">6.2.5</a>                                            <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>,
+ real types, <a href="#6.2.5">6.2.5</a>                                                  <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.7.1.1">K.3.7.1.1</a>,
+ real-floating, <a href="#7.12.3">7.12.3</a>                                               <a href="#K.3.7.1.2">K.3.7.1.2</a>, <a href="#K.3.7.1.3">K.3.7.1.3</a>, <a href="#K.3.7.1.4">K.3.7.1.4</a>, <a href="#K.3.7.2.1">K.3.7.2.1</a>,
+ realloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.5">7.22.3.5</a>                                 <a href="#K.3.7.2.2">K.3.7.2.2</a>, <a href="#K.3.7.3.1">K.3.7.3.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a>,
+ recommended practice, <a href="#3.17">3.17</a>                                         <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>,
+ recursion, <a href="#6.5.2.2">6.5.2.2</a>                                                 <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a>, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a>,
+ recursive function call, <a href="#6.5.2.2">6.5.2.2</a>                                   <a href="#K.3.9.2.1.3">K.3.9.2.1.3</a>, <a href="#K.3.9.2.1.4">K.3.9.2.1.4</a>, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a>,
+ redefinition of macro, <a href="#6.10.3">6.10.3</a>                                       <a href="#K.3.9.2.2.2">K.3.9.2.2.2</a>, <a href="#K.3.9.2.3.1">K.3.9.2.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>,
+ reentrancy, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>                                         <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+    library functions, <a href="#7.1.4">7.1.4</a>                                  rsize_t type, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
+ referenced type, <a href="#6.2.5">6.2.5</a>                                             <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+ register storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>                  runtime-constraint, <a href="#3.18">3.18</a>
+ relational expressions, <a href="#6.5.8">6.5.8</a>                                Runtime-constraint handling functions, <a href="#K.3.6.1">K.3.6.1</a>
+ relaxed atomic operations, <a href="#5.1.2.4">5.1.2.4</a>                           rvalue, <a href="#6.3.2.1">6.3.2.1</a>
+ release fence, <a href="#7.17.4">7.17.4</a>
+ release operation, <a href="#5.1.2.4">5.1.2.4</a>                                   same scope, <a href="#6.2.1">6.2.1</a>
+ release sequence, <a href="#5.1.2.4">5.1.2.4</a>                                    save calling environment function, <a href="#7.13.1">7.13.1</a>
+ reliability of data, interrupted, <a href="#5.1.2.3">5.1.2.3</a>                    scalar types, <a href="#6.2.5">6.2.5</a>
+ remainder assignment operator (%=), <a href="#6.5.16.2">6.5.16.2</a>                 scalbln function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a>
+ remainder functions, <a href="#7.12.10">7.12.10</a>, <a href="#F.10.7">F.10.7</a>                         scalbln type-generic macro, <a href="#7.24">7.24</a>
+ remainder functions, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>,              scalbn function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a>
+       <a href="#F.10.7.2">F.10.7.2</a>                                               scalbn type-generic macro, <a href="#7.24">7.24</a>
+ remainder operator (%), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>                       scanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.11">7.21.6.11</a>
+ remainder type-generic macro, <a href="#7.24">7.24</a>                           scanf_s function, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>
+ remove function, <a href="#7.21.4.1">7.21.4.1</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>               scanlist, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
+ remquo functions, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>, <a href="#F.10.7.3">F.10.7.3</a>                   scanset, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
+ remquo type-generic macro, <a href="#7.24">7.24</a>                              SCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ rename function, <a href="#7.21.4.2">7.21.4.2</a>                                    SCHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+ representations of types, <a href="#6.2.6">6.2.6</a>                              SCNcFASTN macros, <a href="#7.8.1">7.8.1</a>
+    pointer, <a href="#6.2.5">6.2.5</a>                                            SCNcLEASTN macros, <a href="#7.8.1">7.8.1</a>
+ rescanning and replacement, <a href="#6.10.3.4">6.10.3.4</a>                         SCNcMAX macros, <a href="#7.8.1">7.8.1</a>
+ reserved identifiers, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>                   SCNcN macros, <a href="#7.8.1">7.8.1</a>
+ restartable multibyte/wide character conversion              SCNcPTR macros, <a href="#7.8.1">7.8.1</a>
+       functions, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>                 scope of identifier, <a href="#6.2.1">6.2.1</a>, <a href="#6.9.2">6.9.2</a>
+ restartable multibyte/wide string conversion                 search functions
+       functions, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                           string, <a href="#7.23.5">7.23.5</a>, <a href="#K.3.7.3">K.3.7.3</a>
+ restore calling environment function, <a href="#7.13.2">7.13.2</a>                   utility, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a>
+ restrict type qualifier, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>                         wide string, <a href="#7.28.4.5">7.28.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a>
+<!--page 690 indent 0-->
+ SEEK_CUR macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 sign and magnitude, <a href="#6.2.6.2">6.2.6.2</a>
+ SEEK_END macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 sign bit, <a href="#6.2.6.2">6.2.6.2</a>
+ SEEK_SET macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 signal function, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
+ selection statements, <a href="#6.8.4">6.8.4</a>                                      signal handler, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>
+ self-referential structure, <a href="#6.7.2.3">6.7.2.3</a>                              signal handling functions, <a href="#7.14.1">7.14.1</a>
+ semicolon punctuator (;), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,                   signal.h header, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>
+       <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>                                               signaling NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#F.2.1">F.2.1</a>
+ separate compilation, <a href="#5.1.1.1">5.1.1.1</a>                                    signals, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1">7.14.1</a>
+ separate translation, <a href="#5.1.1.1">5.1.1.1</a>                                    signbit macro, <a href="#7.12.3.6">7.12.3.6</a>, <a href="#F.3">F.3</a>
+ sequence points, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.13">6.5.13</a>, <a href="#6.5.14">6.5.14</a>,               signed char type, <a href="#6.2.5">6.2.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+       <a href="#6.5.15">6.5.15</a>, <a href="#6.5.17">6.5.17</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.6">6.7.6</a>, <a href="#6.8">6.8</a>,                     <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+       <a href="#7.1.4">7.1.4</a>, <a href="#7.21.6">7.21.6</a>, <a href="#7.22.5">7.22.5</a>, <a href="#7.28.2">7.28.2</a>, <a href="#C">C</a>, <a href="#K.3.6.3">K.3.6.3</a>                  signed character, <a href="#6.3.1.1">6.3.1.1</a>
+ sequenced after, see sequenced before                            signed integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>
+ sequenced before, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.2.4">6.5.2.4</a>,                signed type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+       <a href="#6.5.16">6.5.16</a>, see also indeterminately sequenced,                     <a href="#6.3.1.8">6.3.1.8</a>
+       unsequenced                                                signed types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>
+ sequencing of statements, <a href="#6.8">6.8</a>                                    significand part, <a href="#6.4.4.2">6.4.4.2</a>
+ set_constraint_handler_s function,                               SIGSEGV macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>
+       <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a>, <a href="#K.3.6.1.3">K.3.6.1.3</a>                   SIGTERM macro, <a href="#7.14">7.14</a>
+ setbuf function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.5">7.21.5.5</a>                      simple assignment operator (=), <a href="#6.5.16.1">6.5.16.1</a>
+ setjmp macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>                          sin functions, <a href="#7.12.4.6">7.12.4.6</a>, <a href="#F.10.1.6">F.10.1.6</a>
+ setjmp.h header, <a href="#7.13">7.13</a>                                            sin type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+ setlocale function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>                           single-byte character, <a href="#3.7.1">3.7.1</a>, <a href="#5.2.1.2">5.2.1.2</a>
+ setvbuf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>,                      single-byte/wide character conversion functions,
+       <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>                                              <a href="#7.28.6.1">7.28.6.1</a>
+ shall, <a href="#4">4</a>                                                         single-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>
+ shift expressions, <a href="#6.5.7">6.5.7</a>                                         single-quote escape sequence (\'), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>
+ shift sequence, <a href="#7.1.1">7.1.1</a>                                            singularity, <a href="#7.12.1">7.12.1</a>
+ shift states, <a href="#5.2.1.2">5.2.1.2</a>                                            sinh functions, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#F.10.2.5">F.10.2.5</a>
+ short identifier, character, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.3">6.4.3</a>                       sinh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+ short int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,                 SIZE_MAX macro, <a href="#7.20.3">7.20.3</a>
+       <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>                               size_t type, <a href="#6.2.8">6.2.8</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.1">7.21.1</a>,
+ short int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,                          <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.23.1">7.23.1</a>, <a href="#7.26.1">7.26.1</a>, <a href="#7.27">7.27</a>,
+       <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                                <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>,
+ SHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                             <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+ SHRT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                        sizeof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>
+ side effects, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.4">6.5.2.4</a>,           snprintf function, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.12">7.21.6.12</a>,
+       <a href="#6.5.16">6.5.16</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8.3">6.8.3</a>, <a href="#7.6">7.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.21.7.5">7.21.7.5</a>,                     <a href="#K.3.5.3.5">K.3.5.3.5</a>
+       <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.28.3.6">7.28.3.6</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#F.8.1">F.8.1</a>, <a href="#F.9.1">F.9.1</a>,                snprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
+       <a href="#F.9.3">F.9.3</a>                                                      snwprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
+ SIG_ATOMIC_MAX macro, <a href="#7.20.3">7.20.3</a>                                     sorting utility functions, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a>
+ SIG_ATOMIC_MIN macro, <a href="#7.20.3">7.20.3</a>                                     source character set, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>
+ sig_atomic_t type, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>,                      source file, <a href="#5.1.1.1">5.1.1.1</a>
+       <a href="#7.20.3">7.20.3</a>                                                        name, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a>
+ SIG_DFL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source file inclusion, <a href="#6.10.2">6.10.2</a>
+ SIG_ERR macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source lines, <a href="#5.1.1.2">5.1.1.2</a>
+ SIG_IGN macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source text, <a href="#5.1.1.2">5.1.1.2</a>
+ SIGABRT macro, <a href="#7.14">7.14</a>, <a href="#7.22.4.1">7.22.4.1</a>                                    space character (' '), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,
+ SIGFPE macro, <a href="#7.12.1">7.12.1</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.5.17">J.5.17</a>                          <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>
+ SIGILL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                     sprintf function, <a href="#7.21.6.6">7.21.6.6</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
+ SIGINT macro, <a href="#7.14">7.14</a>                                               sprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
+<!--page 691 indent 0-->
+ sqrt functions, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.5">F.10.4.5</a>                         do, <a href="#6.8.5.2">6.8.5.2</a>
+ sqrt type-generic macro, <a href="#7.24">7.24</a>                                   else, <a href="#6.8.4.1">6.8.4.1</a>
+ srand function, <a href="#7.22.2.2">7.22.2.2</a>                                        expression, <a href="#6.8.3">6.8.3</a>
+ sscanf function, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.14">7.21.6.14</a>                            for, <a href="#6.8.5.3">6.8.5.3</a>
+ sscanf_s function, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                        goto, <a href="#6.8.6.1">6.8.6.1</a>
+ standard error stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.10.4">7.21.10.4</a>                if, <a href="#6.8.4.1">6.8.4.1</a>
+ standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a>                                      iteration, <a href="#6.8.5">6.8.5</a>
+    &lt;assert.h&gt;, <a href="#7.2">7.2</a>                                              jump, <a href="#6.8.6">6.8.6</a>
+    &lt;complex.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.3">7.3</a>,                labeled, <a href="#6.8.1">6.8.1</a>
+         <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>                               null, <a href="#6.8.3">6.8.3</a>
+    &lt;ctype.h&gt;, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>                                       return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
+    &lt;errno.h&gt;, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>                                selection, <a href="#6.8.4">6.8.4</a>
+    &lt;fenv.h&gt;, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>                sequencing, <a href="#6.8">6.8</a>
+    &lt;float.h&gt;, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,                      switch, <a href="#6.8.4.2">6.8.4.2</a>
+         <a href="#7.28.4.1.1">7.28.4.1.1</a>                                              while, <a href="#6.8.5.1">6.8.5.1</a>
+    &lt;inttypes.h&gt;, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>                                 static assertions, <a href="#6.7.10">6.7.10</a>
+    &lt;iso646.h&gt;, <a href="#4">4</a>, <a href="#7.9">7.9</a>                                        static storage duration, <a href="#6.2.4">6.2.4</a>
+    &lt;limits.h&gt;, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                     static storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.7.1">6.7.1</a>
+    &lt;locale.h&gt;, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>                                  static, in array declarators, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.6.3">6.7.6.3</a>
+    &lt;math.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>, <a href="#F.10">F.10</a>,            static_assert declaration, <a href="#6.7.10">6.7.10</a>
+         <a href="#J.5.17">J.5.17</a>                                               static_assert macro, <a href="#7.2">7.2</a>
+    &lt;setjmp.h&gt;, <a href="#7.13">7.13</a>                                          stdalign.h header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
+    &lt;signal.h&gt;, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>                                  stdarg.h header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
+    &lt;stdalign.h&gt;, <a href="#4">4</a>, <a href="#7.15">7.15</a>                                     stdatomic.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>
+    &lt;stdarg.h&gt;, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>                              stdbool.h header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>
+    &lt;stdatomic.h&gt;, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>                      STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>
+    &lt;stdbool.h&gt;, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>                           stddef.h header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+    &lt;stddef.h&gt;, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,                       <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>
+         <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>                   stderr macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>
+    &lt;stdint.h&gt;, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>,                stdin macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.4">7.21.6.4</a>,
+         <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>                                       <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.28.2.12">7.28.2.12</a>, <a href="#7.28.3.7">7.28.3.7</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
+    &lt;stdio.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>                    <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
+    &lt;stdlib.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,                  stdint.h header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>,
+         <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>                                             <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>
+    &lt;string.h&gt;, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                          stdio.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>
+    &lt;tgmath.h&gt;, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                     stdlib.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,
+    &lt;threads.h&gt;, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                              <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>
+    &lt;time.h&gt;, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                     stdout macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.3">7.21.6.3</a>,
+    &lt;uchar.h&gt;, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                                 <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>, <a href="#7.28.2.11">7.28.2.11</a>, <a href="#7.28.3.9">7.28.3.9</a>
+    &lt;wchar.h&gt;, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>, <a href="#7.30.12">7.30.12</a>,              storage duration, <a href="#6.2.4">6.2.4</a>
+         <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>                                             storage order of array, <a href="#6.5.2.1">6.5.2.1</a>
+    &lt;wctype.h&gt;, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                                 storage unit (bit-field), <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+ standard input stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                        storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a>
+ standard integer types, <a href="#6.2.5">6.2.5</a>                                strcat function, <a href="#7.23.3.1">7.23.3.1</a>
+ standard output stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                       strcat_s function, <a href="#K.3.7.2.1">K.3.7.2.1</a>
+ standard signed integer types, <a href="#6.2.5">6.2.5</a>                         strchr function, <a href="#7.23.5.2">7.23.5.2</a>
+ state-dependent encoding, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>           strcmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.2">7.23.4.2</a>
+ statements, <a href="#6.8">6.8</a>                                              strcoll function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.3">7.23.4.3</a>, <a href="#7.23.4.5">7.23.4.5</a>
+    break, <a href="#6.8.6.3">6.8.6.3</a>                                            strcpy function, <a href="#7.23.2.3">7.23.2.3</a>
+    compound, <a href="#6.8.2">6.8.2</a>                                           strcpy_s function, <a href="#K.3.7.1.3">K.3.7.1.3</a>
+    continue, <a href="#6.8.6.2">6.8.6.2</a>                                         strcspn function, <a href="#7.23.5.3">7.23.5.3</a>
+<!--page 692 indent 0-->
+ streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.22.4.4">7.22.4.4</a>                                                <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>
+    fully buffered, <a href="#7.21.3">7.21.3</a>                                          strtoull function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>
+    line buffered, <a href="#7.21.3">7.21.3</a>                                           strtoumax function, <a href="#7.8.2.3">7.8.2.3</a>
+    orientation, <a href="#7.21.2">7.21.2</a>                                             struct hack, see flexible array member
+    standard error, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                  struct lconv, <a href="#7.11">7.11</a>
+    standard input, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                  struct tm, <a href="#7.26.1">7.26.1</a>
+    standard output, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                 structure
+    unbuffered, <a href="#7.21.3">7.21.3</a>                                                 arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+ strerror function, <a href="#7.21.10.4">7.21.10.4</a>, <a href="#7.23.6.2">7.23.6.2</a>                                content, <a href="#6.7.2.3">6.7.2.3</a>
+ strerror_s function, <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a>                             dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>
+ strerrorlen_s function, <a href="#K.3.7.4.3">K.3.7.4.3</a>                                     initialization, <a href="#6.7.9">6.7.9</a>
+ strftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.26.3.5">7.26.3.5</a>,                        member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+       <a href="#7.28.5.1">7.28.5.1</a>, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>                         member name space, <a href="#6.2.3">6.2.3</a>
+ stricter, <a href="#6.2.8">6.2.8</a>                                                       member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>
+ strictly conforming program, <a href="#4">4</a>                                        pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+ string, <a href="#7.1.1">7.1.1</a>                                                         specifier, <a href="#6.7.2.1">6.7.2.1</a>
+    comparison functions, <a href="#7.23.4">7.23.4</a>                                       tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+    concatenation functions, <a href="#7.23.3">7.23.3</a>, <a href="#K.3.7.2">K.3.7.2</a>                           type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>
+    conversion functions, <a href="#7.11.1.1">7.11.1.1</a>                                  strxfrm function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.5">7.23.4.5</a>
+    copying functions, <a href="#7.23.2">7.23.2</a>, <a href="#K.3.7.1">K.3.7.1</a>                              subnormal floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+    library function conventions, <a href="#7.23.1">7.23.1</a>                            subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+    literal, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.7.9">6.7.9</a>           subtraction assignment operator (-=), <a href="#6.5.16.2">6.5.16.2</a>
+    miscellaneous functions, <a href="#7.23.6">7.23.6</a>, <a href="#K.3.7.4">K.3.7.4</a>                        subtraction operator (-), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
+    numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                   suffix
+    search functions, <a href="#7.23.5">7.23.5</a>, <a href="#K.3.7.3">K.3.7.3</a>                                  floating constant, <a href="#6.4.4.2">6.4.4.2</a>
+ string handling header, <a href="#7.23">7.23</a>, <a href="#K.3.7">K.3.7</a>                                   integer constant, <a href="#6.4.4.1">6.4.4.1</a>
+ string.h header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                              switch body, <a href="#6.8.4.2">6.8.4.2</a>
+ stringizing, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.9">6.10.9</a>                                      switch case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+ strlen function, <a href="#7.23.6.3">7.23.6.3</a>                                          switch default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+ strncat function, <a href="#7.23.3.2">7.23.3.2</a>                                         switch statement, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+ strncat_s function, <a href="#K.3.7.2.2">K.3.7.2.2</a>                                      swprintf function, <a href="#7.28.2.3">7.28.2.3</a>, <a href="#7.28.2.7">7.28.2.7</a>,
+ strncmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.4">7.23.4.4</a>                                       <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
+ strncpy function, <a href="#7.23.2.4">7.23.2.4</a>                                         swprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
+ strncpy_s function, <a href="#K.3.7.1.4">K.3.7.1.4</a>                                      swscanf function, <a href="#7.28.2.4">7.28.2.4</a>, <a href="#7.28.2.8">7.28.2.8</a>
+ strnlen_s function, <a href="#K.3.7.4.4">K.3.7.4.4</a>                                      swscanf_s function, <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>
+ stronger, <a href="#6.2.8">6.2.8</a>                                                    symbols, <a href="#3">3</a>
+ strpbrk function, <a href="#7.23.5.4">7.23.5.4</a>                                         synchronization operation, <a href="#5.1.2.4">5.1.2.4</a>
+ strrchr function, <a href="#7.23.5.5">7.23.5.5</a>                                         synchronize with, <a href="#5.1.2.4">5.1.2.4</a>
+ strspn function, <a href="#7.23.5.6">7.23.5.6</a>                                          syntactic categories, <a href="#6.1">6.1</a>
+ strstr function, <a href="#7.23.5.7">7.23.5.7</a>                                          syntax notation, <a href="#6.1">6.1</a>
+ strtod function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    syntax rule precedence, <a href="#5.1.1.2">5.1.1.2</a>
+       <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.3">F.3</a>                                                syntax summary, language, <a href="#A">A</a>
+ strtof function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>                          system function, <a href="#7.22.4.8">7.22.4.8</a>
+ strtoimax function, <a href="#7.8.2.3">7.8.2.3</a>
+ strtok function, <a href="#7.23.5.8">7.23.5.8</a>                                          tab characters, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+ strtok_s function, <a href="#K.3.7.3.1">K.3.7.3.1</a>                                       tag compatibility, <a href="#6.2.7">6.2.7</a>
+ strtol function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,                      tag name space, <a href="#6.2.3">6.2.3</a>
+       <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>                                           tags, <a href="#6.7.2.3">6.7.2.3</a>
+ strtold function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>                         tan functions, <a href="#7.12.4.7">7.12.4.7</a>, <a href="#F.10.1.7">F.10.1.7</a>
+ strtoll function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>                      tan type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+ strtoul function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,                     tanh functions, <a href="#7.12.5.6">7.12.5.6</a>, <a href="#F.10.2.6">F.10.2.6</a>
+<!--page 693 indent 0-->
+ tanh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                            toupper function, <a href="#7.4.2.2">7.4.2.2</a>
+ temporary lifetime, <a href="#6.2.4">6.2.4</a>                                     towctrans function, <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>
+ tentative definition, <a href="#6.9.2">6.9.2</a>                                    towlower function, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.2.1">7.29.3.2.1</a>
+ terms, <a href="#3">3</a>                                                      towupper function, <a href="#7.29.3.1.2">7.29.3.1.2</a>, <a href="#7.29.3.2.1">7.29.3.2.1</a>
+ text streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>           translation environment, <a href="#5">5</a>, <a href="#5.1.1">5.1.1</a>
+ tgamma functions, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#F.10.5.4">F.10.5.4</a>                          translation limits, <a href="#5.2.4.1">5.2.4.1</a>
+ tgamma type-generic macro, <a href="#7.24">7.24</a>                               translation phases, <a href="#5.1.1.2">5.1.1.2</a>
+ tgmath.h header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                    translation unit, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.9">6.9</a>
+ thrd_create function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.5.1">7.25.5.1</a>                        trap, see perform a trap
+ thrd_current function, <a href="#7.25.5.2">7.25.5.2</a>                               trap representation, <a href="#3.19.4">3.19.4</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.2.6.2">6.2.6.2</a>,
+ thrd_detach function, <a href="#7.25.5.3">7.25.5.3</a>                                      <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.5.2.3">6.5.2.3</a>
+ thrd_equal function, <a href="#7.25.5.4">7.25.5.4</a>                                 trigonometric functions
+ thrd_exit function, <a href="#7.25.5.5">7.25.5.5</a>                                     complex, <a href="#7.3.5">7.3.5</a>, <a href="#G.6.1">G.6.1</a>
+ thrd_join function, <a href="#7.25.5.6">7.25.5.6</a>                                     real, <a href="#7.12.4">7.12.4</a>, <a href="#F.10.1">F.10.1</a>
+ thrd_sleep function, <a href="#7.25.5.7">7.25.5.7</a>                                 trigraph sequences, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1.1">5.2.1.1</a>
+ thrd_start_t type, <a href="#7.25.1">7.25.1</a>                                     true macro, <a href="#7.18">7.18</a>
+ thrd_t type, <a href="#7.25.1">7.25.1</a>                                           trunc functions, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#F.10.6.8">F.10.6.8</a>
+ thrd_yield function, <a href="#7.25.5.8">7.25.5.8</a>                                 trunc type-generic macro, <a href="#7.24">7.24</a>
+ thread of execution, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.6">7.6</a>, <a href="#7.22.4.6">7.22.4.6</a>            truncation, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a>
+ thread storage duration, <a href="#6.2.4">6.2.4</a>, <a href="#7.6">7.6</a>                           truncation toward zero, <a href="#6.5.5">6.5.5</a>
+ threads header, <a href="#7.25">7.25</a>                                          tss_create function, <a href="#7.25.6.1">7.25.6.1</a>
+ threads.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                       tss_delete function, <a href="#7.25.6.2">7.25.6.2</a>
+ time                                                          TSS_DTOR_ITERATIONS macro, <a href="#7.25.1">7.25.1</a>
+    broken down, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.26.3.1">7.26.3.1</a>,           tss_dtor_t type, <a href="#7.25.1">7.25.1</a>
+          <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>,             tss_get function, <a href="#7.25.6.3">7.25.6.3</a>
+          <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                 tss_set function, <a href="#7.25.6.4">7.25.6.4</a>
+    calendar, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.2">7.26.2.2</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.2.4">7.26.2.4</a>,            tss_t type, <a href="#7.25.1">7.25.1</a>
+          <a href="#7.26.3.2">7.26.3.2</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>,             two's complement, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a>
+          <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                 type category, <a href="#6.2.5">6.2.5</a>
+    components, <a href="#7.26.1">7.26.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                                type conversion, <a href="#6.3">6.3</a>
+    conversion functions, <a href="#7.26.3">7.26.3</a>, <a href="#K.3.8.2">K.3.8.2</a>                      type definitions, <a href="#6.7.8">6.7.8</a>
+       wide character, <a href="#7.28.5">7.28.5</a>                                  type domain, <a href="#6.2.5">6.2.5</a>, <a href="#G.2">G.2</a>
+    local, <a href="#7.26.1">7.26.1</a>                                              type names, <a href="#6.7.7">6.7.7</a>
+    manipulation functions, <a href="#7.26.2">7.26.2</a>                             type punning, <a href="#6.5.2.3">6.5.2.3</a>
+    normalized broken down, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>                 type qualifiers, <a href="#6.7.3">6.7.3</a>
+ time function, <a href="#7.26.2.4">7.26.2.4</a>                                       type specifiers, <a href="#6.7.2">6.7.2</a>
+ time.h header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                    type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+ time_t type, <a href="#7.26.1">7.26.1</a>                                           typedef declaration, <a href="#6.7.8">6.7.8</a>
+ TIME_UTC macro, <a href="#7.25.7.1">7.25.7.1</a>                                      typedef storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.7.8">6.7.8</a>
+ tm structure type, <a href="#7.26.1">7.26.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                    types, <a href="#6.2.5">6.2.5</a>
+ TMP_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>                        atomic, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>,
+ TMP_MAX_S macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                           <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.17.6">7.17.6</a>
+ tmpfile function, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>                             character, <a href="#6.7.9">6.7.9</a>
+ tmpfile_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                         compatible, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a>
+ tmpnam function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>,                     complex, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>
+       <a href="#K.3.5.1.2">K.3.5.1.2</a>                                                  composite, <a href="#6.2.7">6.2.7</a>
+ tmpnam_s function, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                   const qualified, <a href="#6.7.3">6.7.3</a>
+ token, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, see also preprocessing tokens               conversions, <a href="#6.3">6.3</a>
+ token concatenation, <a href="#6.10.3.3">6.10.3.3</a>                                    imaginary, <a href="#G">G</a>
+ token pasting, <a href="#6.10.3.3">6.10.3.3</a>                                          restrict qualified, <a href="#6.7.3">6.7.3</a>
+ tolower function, <a href="#7.4.2.1">7.4.2.1</a>                                        volatile qualified, <a href="#6.7.3">6.7.3</a>
+<!--page 694 indent 0-->
+ uchar.h header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                      universal character name, <a href="#6.4.3">6.4.3</a>
+ UCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                unnormalized floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+ UINT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>                           unqualified type, <a href="#6.2.5">6.2.5</a>
+ uint_fastN_t types, <a href="#7.20.1.3">7.20.1.3</a>                              unqualified version of type, <a href="#6.2.5">6.2.5</a>
+ uint_least16_t type, <a href="#7.27">7.27</a>                                 unsequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, see also
+ uint_least32_t type, <a href="#7.27">7.27</a>                                       indeterminately sequenced, sequenced
+ UINT_LEASTN_MAX macros, <a href="#7.20.2.2">7.20.2.2</a>                                before
+ uint_leastN_t types, <a href="#7.20.1.2">7.20.1.2</a>                             unsigned char type, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+ UINT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                 unsigned integer suffix, u or <a href="#U">U</a>, <a href="#6.4.4.1">6.4.4.1</a>
+ UINTMAX_C macro, <a href="#7.20.4.2">7.20.4.2</a>                                 unsigned integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>
+ UINTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>             unsigned type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+ uintmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                   <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+      <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>                                   unsigned types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+ UINTN_C macros, <a href="#7.20.4.1">7.20.4.1</a>                                        <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+ UINTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>                                unspecified behavior, <a href="#3.4.4">3.4.4</a>, <a href="#4">4</a>, <a href="#J.1">J.1</a>
+ uintN_t types, <a href="#7.20.1.1">7.20.1.1</a>                                   unspecified value, <a href="#3.19.3">3.19.3</a>
+ UINTPTR_MAX macro, <a href="#7.20.2.4">7.20.2.4</a>                               uppercase letter, <a href="#5.2.1">5.2.1</a>
+ uintptr_t type, <a href="#7.20.1.4">7.20.1.4</a>                                  use of library functions, <a href="#7.1.4">7.1.4</a>
+ ULLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                    USHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+      <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           usual arithmetic conversions, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.5.5">6.5.5</a>, <a href="#6.5.6">6.5.6</a>,
+ ULONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                           <a href="#6.5.8">6.5.8</a>, <a href="#6.5.9">6.5.9</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>, <a href="#6.5.15">6.5.15</a>
+      <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           UTF-16, <a href="#6.10.8.2">6.10.8.2</a>
+ unary arithmetic operators, <a href="#6.5.3.3">6.5.3.3</a>                       UTF-32, <a href="#6.10.8.2">6.10.8.2</a>
+ unary expression, <a href="#6.5.3">6.5.3</a>                                   UTF-8 string literal, see string literal
+ unary minus operator (-), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>                    utilities, general, <a href="#7.22">7.22</a>, <a href="#K.3.6">K.3.6</a>
+ unary operators, <a href="#6.5.3">6.5.3</a>                                       wide string, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>
+ unary plus operator (+), <a href="#6.5.3.3">6.5.3.3</a>
+ unbuffered stream, <a href="#7.21.3">7.21.3</a>                                 va_arg macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.2">7.16.1.2</a>,
+ undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,                <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>,
+      <a href="#7.1.4">7.1.4</a>                                                     <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
+ undefined behavior, <a href="#3.4.3">3.4.3</a>, <a href="#4">4</a>, <a href="#J.2">J.2</a>                               <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>,
+ underscore character, <a href="#6.4.2.1">6.4.2.1</a>                                  <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
+ underscore, leading, in identifier, <a href="#7.1.3">7.1.3</a>                       <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+ ungetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,             va_copy macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>,
+      <a href="#7.21.9.3">7.21.9.3</a>                                                  <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>
+ ungetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.10">7.28.3.10</a>                       va_end macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.3">7.16.1.3</a>,
+ Unicode, <a href="#7.27">7.27</a>, see also char16_t type,                         <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>,
+      char32_t type, wchar_t type                               <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
+ Unicode required set, <a href="#6.10.8.2">6.10.8.2</a>                                 <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>,
+ union                                                          <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
+   arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                 <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+   content, <a href="#6.7.2.3">6.7.2.3</a>                                        va_list type, <a href="#7.16">7.16</a>, <a href="#7.16.1.3">7.16.1.3</a>
+   dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                               va_start macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>,
+   initialization, <a href="#6.7.9">6.7.9</a>                                        <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>, <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>,
+   member alignment, <a href="#6.7.2.1">6.7.2.1</a>                                    <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>,
+   member name space, <a href="#6.2.3">6.2.3</a>                                     <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>,
+   member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>                        <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>,
+   pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                               <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>,
+   specifier, <a href="#6.7.2.1">6.7.2.1</a>                                            <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+   tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>                                     value, <a href="#3.19">3.19</a>
+   type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>                                    value bits, <a href="#6.2.6.2">6.2.6.2</a>
+<!--page 695 indent 0-->
+ variable arguments, <a href="#6.10.3">6.10.3</a>, <a href="#7.16">7.16</a>                             vswscanf function, <a href="#7.28.2.8">7.28.2.8</a>
+ variable arguments header, <a href="#7.16">7.16</a>                              vswscanf_s function, <a href="#K.3.9.1.10">K.3.9.1.10</a>
+ variable length array, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>              vwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#K.3.9.1.11">K.3.9.1.11</a>
+ variably modified type, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>              vwprintf_s function, <a href="#K.3.9.1.11">K.3.9.1.11</a>
+ vertical-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                           vwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.3.10">7.28.3.10</a>
+ vertical-tab escape sequence (\v), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           vwscanf_s function, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+      <a href="#7.4.1.10">7.4.1.10</a>
+ vfprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#K.3.5.3.8">K.3.5.3.8</a>               warnings, <a href="#I">I</a>
+ vfprintf_s function, <a href="#K.3.5.3.8">K.3.5.3.8</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>,                   wchar.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>, <a href="#7.30.12">7.30.12</a>,
+      <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                                      <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>
+ vfscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>                 WCHAR_MAX macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.28.1">7.28.1</a>
+ vfscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                   WCHAR_MIN macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.28.1">7.28.1</a>
+      <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wchar_t type, <a href="#3.7.3">3.7.3</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>,
+ vfwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.5">7.28.2.5</a>, <a href="#K.3.9.1.6">K.3.9.1.6</a>                  <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.28.1">7.28.1</a>,
+ vfwprintf_s function, <a href="#K.3.9.1.6">K.3.9.1.6</a>                                  <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+ vfwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.3.10">7.28.3.10</a>               wcrtomb function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+ vfwscanf_s function, <a href="#K.3.9.1.7">K.3.9.1.7</a>                                   <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>,
+ visibility of identifier, <a href="#6.2.1">6.2.1</a>                                   <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+ visible sequence of side effects, <a href="#5.1.2.4">5.1.2.4</a>                    wcrtomb_s function, <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>
+ visible side effect, <a href="#5.1.2.4">5.1.2.4</a>                                 wcscat function, <a href="#7.28.4.3.1">7.28.4.3.1</a>
+ VLA, see variable length array                               wcscat_s function, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a>
+ void expression, <a href="#6.3.2.2">6.3.2.2</a>                                     wcschr function, <a href="#7.28.4.5.1">7.28.4.5.1</a>
+ void function parameter, <a href="#6.7.6.3">6.7.6.3</a>                             wcscmp function, <a href="#7.28.4.4.1">7.28.4.4.1</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>
+ void type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,                 wcscoll function, <a href="#7.28.4.4.2">7.28.4.4.2</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>
+      <a href="#K.3.9.1.2">K.3.9.1.2</a>                                               wcscpy function, <a href="#7.28.4.2.1">7.28.4.2.1</a>
+ void type conversion, <a href="#6.3.2.2">6.3.2.2</a>                                wcscpy_s function, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a>
+ volatile storage, <a href="#5.1.2.3">5.1.2.3</a>                                    wcscspn function, <a href="#7.28.4.5.2">7.28.4.5.2</a>
+ volatile type qualifier, <a href="#6.7.3">6.7.3</a>                                wcsftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.28.5.1">7.28.5.1</a>
+ volatile-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>                         wcslen function, <a href="#7.28.4.6.1">7.28.4.6.1</a>
+ vprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.10">7.21.6.10</a>,               wcsncat function, <a href="#7.28.4.3.2">7.28.4.3.2</a>
+      <a href="#K.3.5.3.10">K.3.5.3.10</a>                                              wcsncat_s function, <a href="#K.3.9.2.2.2">K.3.9.2.2.2</a>
+ vprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.10">K.3.5.3.10</a>,                   wcsncmp function, <a href="#7.28.4.4.3">7.28.4.4.3</a>
+      <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                                  wcsncpy function, <a href="#7.28.4.2.2">7.28.4.2.2</a>
+ vscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.11">7.21.6.11</a>                 wcsncpy_s function, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a>
+ vscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                    wcsnlen_s function, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a>
+      <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wcspbrk function, <a href="#7.28.4.5.3">7.28.4.5.3</a>
+ vsnprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.12">7.21.6.12</a>,                     wcsrchr function, <a href="#7.28.4.5.4">7.28.4.5.4</a>
+      <a href="#K.3.5.3.12">K.3.5.3.12</a>                                              wcsrtombs function, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
+ vsnprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                 wcsrtombs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+      <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                      wcsspn function, <a href="#7.28.4.5.5">7.28.4.5.5</a>
+ vsnwprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>                  wcsstr function, <a href="#7.28.4.5.6">7.28.4.5.6</a>
+ vsprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.13">7.21.6.13</a>,                      wcstod function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
+      <a href="#K.3.5.3.13">K.3.5.3.13</a>                                              wcstod function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+ vsprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                  wcstof function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+      <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                      wcstoimax function, <a href="#7.8.2.4">7.8.2.4</a>
+ vsscanf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.14">7.21.6.14</a>                        wcstok function, <a href="#7.28.4.5.7">7.28.4.5.7</a>
+ vsscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                   wcstok_s function, <a href="#K.3.9.2.3.1">K.3.9.2.3.1</a>
+      <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wcstol function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+ vswprintf function, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#K.3.9.1.8">K.3.9.1.8</a>,                         <a href="#7.28.4.1.2">7.28.4.1.2</a>
+      <a href="#K.3.9.1.9">K.3.9.1.9</a>                                               wcstold function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+ vswprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>                   wcstoll function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
+<!--page 696 indent 0-->
+ wcstombs function, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.28.6.4">7.28.6.4</a>                           <a href="#7.29.1">7.29.1</a>
+ wcstombs_s function, <a href="#K.3.6.5.2">K.3.6.5.2</a>                               wmemchr function, <a href="#7.28.4.5.8">7.28.4.5.8</a>
+ wcstoul function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,               wmemcmp function, <a href="#7.28.4.4.5">7.28.4.4.5</a>
+      <a href="#7.28.4.1.2">7.28.4.1.2</a>                                              wmemcpy function, <a href="#7.28.4.2.3">7.28.4.2.3</a>
+ wcstoull function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>                       wmemcpy_s function, <a href="#K.3.9.2.1.3">K.3.9.2.1.3</a>
+ wcstoumax function, <a href="#7.8.2.4">7.8.2.4</a>                                  wmemmove function, <a href="#7.28.4.2.4">7.28.4.2.4</a>
+ wcsxfrm function, <a href="#7.28.4.4.4">7.28.4.4.4</a>                                 wmemmove_s function, <a href="#K.3.9.2.1.4">K.3.9.2.1.4</a>
+ wctob function, <a href="#7.28.6.1.2">7.28.6.1.2</a>, <a href="#7.29.2.1">7.29.2.1</a>                         wmemset function, <a href="#7.28.4.6.2">7.28.4.6.2</a>
+ wctomb function, <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.28.6.3">7.28.6.3</a>                wprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.11">7.28.2.11</a>,
+ wctomb_s function, <a href="#K.3.6.4.1">K.3.6.4.1</a>                                    <a href="#K.3.9.1.13">K.3.9.1.13</a>
+ wctrans function, <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>                     wprintf_s function, <a href="#K.3.9.1.13">K.3.9.1.13</a>
+ wctrans_t type, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>                           wscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.2.12">7.28.2.12</a>,
+ wctype function, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>                         <a href="#7.28.3.10">7.28.3.10</a>
+ wctype.h header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                               wscanf_s function, <a href="#K.3.9.1.12">K.3.9.1.12</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
+ wctype_t type, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>
+ weaker, <a href="#6.2.8">6.2.8</a>                                                xor macro, <a href="#7.9">7.9</a>
+ WEOF macro, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.3.6">7.28.3.6</a>,            xor_eq macro, <a href="#7.9">7.9</a>
+      <a href="#7.28.3.7">7.28.3.7</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#7.28.3.9">7.28.3.9</a>, <a href="#7.28.3.10">7.28.3.10</a>,                xtime type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.3.5">7.25.3.5</a>, <a href="#7.25.4.4">7.25.4.4</a>, <a href="#7.25.5.7">7.25.5.7</a>,
+      <a href="#7.28.6.1.1">7.28.6.1.1</a>, <a href="#7.29.1">7.29.1</a>                                          <a href="#7.25.7.1">7.25.7.1</a>
+ while statement, <a href="#6.8.5.1">6.8.5.1</a>                                     xtime_get function, <a href="#7.25.7.1">7.25.7.1</a>
+ white space, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+      <a href="#7.29.2.1.10">7.29.2.1.10</a>
+ white-space characters, <a href="#6.4">6.4</a>
+ wide character, <a href="#3.7.3">3.7.3</a>
+   case mapping functions, <a href="#7.29.3.1">7.29.3.1</a>
+      extensible, <a href="#7.29.3.2">7.29.3.2</a>
+   classification functions, <a href="#7.29.2.1">7.29.2.1</a>
+      extensible, <a href="#7.29.2.2">7.29.2.2</a>
+   constant, <a href="#6.4.4.4">6.4.4.4</a>
+   formatted input/output functions, <a href="#7.28.2">7.28.2</a>,
+         <a href="#K.3.9.1">K.3.9.1</a>
+   input functions, <a href="#7.21.1">7.21.1</a>
+   input/output functions, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3">7.28.3</a>
+   output functions, <a href="#7.21.1">7.21.1</a>
+   single-byte conversion functions, <a href="#7.28.6.1">7.28.6.1</a>
+ wide string, <a href="#7.1.1">7.1.1</a>
+ wide string comparison functions, <a href="#7.28.4.4">7.28.4.4</a>
+ wide string concatenation functions, <a href="#7.28.4.3">7.28.4.3</a>,
+      <a href="#K.3.9.2.2">K.3.9.2.2</a>
+ wide string copying functions, <a href="#7.28.4.2">7.28.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a>
+ wide string literal, see string literal
+ wide string miscellaneous functions, <a href="#7.28.4.6">7.28.4.6</a>,
+      <a href="#K.3.9.2.4">K.3.9.2.4</a>
+ wide string numeric conversion functions, <a href="#7.8.2.4">7.8.2.4</a>,
+      <a href="#7.28.4.1">7.28.4.1</a>
+ wide string search functions, <a href="#7.28.4.5">7.28.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a>
+ wide-oriented stream, <a href="#7.21.2">7.21.2</a>
+ width, <a href="#6.2.6.2">6.2.6.2</a>
+ WINT_MAX macro, <a href="#7.20.3">7.20.3</a>
+ WINT_MIN macro, <a href="#7.20.3">7.20.3</a>
+ wint_t type, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>,
+</pre>
+</body></html>
diff --git a/n1548.pre.html b/n1548.pre.html
new file mode 100644
index 0000000..8ef750a
--- /dev/null
+++ b/n1548.pre.html
@@ -0,0 +1,26323 @@
+<html><head><title>N1548                    Committee Draft -- December 2, 2010          ISO/IEC 9899:201x</title></head><body><pre>
+N1548                    Committee Draft -- December 2, 2010          ISO/IEC 9899:201x
+
+
+
+
+INTERNATIONAL STANDARD                         (C)ISO/IEC              ISO/IEC 9899:201x
+
+
+
+
+Programming languages -- C
+
+
+                                       ABSTRACT
+
+
+
+                     (Cover sheet to be provided by ISO Secretariat.)
+
+This International Standard specifies the form and establishes the interpretation of
+programs expressed in the programming language C. Its purpose is to promote
+portability, reliability, maintainability, and efficient execution of C language programs on
+a variety of computing systems.
+
+Clauses are included that detail the C language itself and the contents of the C language
+execution library. Annexes summarize aspects of both of them, and enumerate factors
+that influence the portability of C programs.
+
+Although this International Standard is intended to guide knowledgeable C language
+programmers as well as implementors of C language translation systems, the document
+itself is not designed to serve as a tutorial.
+
+Recipients of this draft are invited to submit, with their comments, notification of any
+relevant patent rights of which they are aware and to provide supporting documentation.
+
+Changes from the previous draft (N1256) are indicated by ''diff marks'' in the right
+margin: deleted text is marked with ''*'', new or changed text with '' ''.
+
+[page i]
+
+
+[page ii]
+
+<a name="Contents" href="#Contents">Contents</a>
+<a href="#Foreword">Foreword       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                 xiii</a>
+<a href="#Introduction">Introduction    . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii</a>
+<a href="#1">1. Scope       . . . . . . . . . . . . . . . . . . . . . . . . . . . . .                                   1</a>
+<a href="#2">2. Normative references     . . . . . . . . . . . . . . . . . . . . . . .                                  2</a>
+<a href="#3">3. Terms, definitions, and symbols    . . . . . . . . . . . . . . . . . . .                                 3</a>
+<a href="#4">4. Conformance       . . . . . . . . . . . . . . . . . . . . . . . . . .                                   8</a>
+<a href="#5">5. Environment    . . . . . . . . . . .       . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10</a>
+<a href="#5.1">   5.1 Conceptual models       . . . . . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10</a>
+<a href="#5.1.1">        5.1.1  Translation environment .      . .   .   .   .   .   .   .   .    .   .   .   .   .   .    10</a>
+<a href="#5.1.2">        5.1.2  Execution environments     .   . .   .   .   .   .   .   .   .    .   .   .   .   .   .    12</a>
+<a href="#5.2">   5.2 Environmental considerations    . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    22</a>
+<a href="#5.2.1">        5.2.1  Character sets    . . . . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    22</a>
+<a href="#5.2.2">        5.2.2  Character display semantics      .   .   .   .   .   .   .   .    .   .   .   .   .   .    24</a>
+<a href="#5.2.3">        5.2.3  Signals and interrupts . .     . .   .   .   .   .   .   .   .    .   .   .   .   .   .    25</a>
+<a href="#5.2.4">        5.2.4  Environmental limits    . .    . .   .   .   .   .   .   .   .    .   .   .   .   .   .    25</a>
+<a href="#6">6. Language . . . . . . . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .    35</a>
+<a href="#6.1">   6.1 Notation . . . . . . . . . . . . . .             .   .   .   .   .   .    .   .   .   .   .   .    35</a>
+<a href="#6.2">   6.2 Concepts       . . . . . . . . . . . . .         .   .   .   .   .   .    .   .   .   .   .   .    35</a>
+<a href="#6.2.1">        6.2.1   Scopes of identifiers     . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    35</a>
+<a href="#6.2.2">        6.2.2   Linkages of identifiers . . . . .        .   .   .   .   .   .    .   .   .   .   .   .    36</a>
+<a href="#6.2.3">        6.2.3   Name spaces of identifiers      . . .    .   .   .   .   .   .    .   .   .   .   .   .    37</a>
+<a href="#6.2.4">        6.2.4   Storage durations of objects     . .    .   .   .   .   .   .    .   .   .   .   .   .    38</a>
+<a href="#6.2.5">        6.2.5   Types       . . . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    39</a>
+<a href="#6.2.6">        6.2.6   Representations of types . . . .        .   .   .   .   .   .    .   .   .   .   .   .    44</a>
+<a href="#6.2.7">        6.2.7   Compatible type and composite type          .   .   .   .   .    .   .   .   .   .   .    47</a>
+<a href="#6.2.8">        6.2.8   Alignment of objects     . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    48</a>
+<a href="#6.3">   6.3 Conversions       . . . . . . . . . . . .        .   .   .   .   .   .    .   .   .   .   .   .    50</a>
+<a href="#6.3.1">        6.3.1   Arithmetic operands      . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    50</a>
+<a href="#6.3.2">        6.3.2   Other operands       . . . . . . .      .   .   .   .   .   .    .   .   .   .   .   .    54</a>
+<a href="#6.4">   6.4 Lexical elements       . . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    57</a>
+<a href="#6.4.1">        6.4.1   Keywords . . . . . . . . . .            .   .   .   .   .   .    .   .   .   .   .   .    58</a>
+<a href="#6.4.2">        6.4.2   Identifiers . . . . . . . . . .          .   .   .   .   .   .    .   .   .   .   .   .    59</a>
+<a href="#6.4.3">        6.4.3   Universal character names      . . .    .   .   .   .   .   .    .   .   .   .   .   .    61</a>
+<a href="#6.4.4">        6.4.4   Constants . . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .    62</a>
+<a href="#6.4.5">        6.4.5   String literals   . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    70</a>
+<a href="#6.4.6">        6.4.6   Punctuators . . . . . . . . .           .   .   .   .   .   .    .   .   .   .   .   .    72</a>
+<a href="#6.4.7">        6.4.7   Header names      . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    73</a>
+<a href="#6.4.8">        6.4.8   Preprocessing numbers        . . . .    .   .   .   .   .   .    .   .   .   .   .   .    74</a>
+<a href="#6.4.9">        6.4.9   Comments        . . . . . . . . .       .   .   .   .   .   .    .   .   .   .   .   .    75</a>
+
+[page iii]
+
+<a href="#6.5">     6.5  Expressions      . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    76</a>
+<a href="#6.5.1">          6.5.1   Primary expressions      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    78</a>
+<a href="#6.5.2">          6.5.2   Postfix operators . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    79</a>
+<a href="#6.5.3">          6.5.3   Unary operators      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    88</a>
+<a href="#6.5.4">          6.5.4   Cast operators . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .    91</a>
+<a href="#6.5.5">          6.5.5   Multiplicative operators   . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    92</a>
+<a href="#6.5.6">          6.5.6   Additive operators     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    92</a>
+<a href="#6.5.7">          6.5.7   Bitwise shift operators . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .    94</a>
+<a href="#6.5.8">          6.5.8   Relational operators . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .    95</a>
+<a href="#6.5.9">          6.5.9   Equality operators     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    96</a>
+<a href="#6.5.10">          6.5.10 Bitwise AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    97</a>
+<a href="#6.5.11">          6.5.11 Bitwise exclusive OR operator         .   .   .   .   .   .   .   .   .   .   .   .   .    98</a>
+<a href="#6.5.12">          6.5.12 Bitwise inclusive OR operator     .   .   .   .   .   .   .   .   .   .   .   .   .   .    98</a>
+<a href="#6.5.13">          6.5.13 Logical AND operator . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .    99</a>
+<a href="#6.5.14">          6.5.14 Logical OR operator       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .    99</a>
+<a href="#6.5.15">          6.5.15 Conditional operator      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   100</a>
+<a href="#6.5.16">          6.5.16 Assignment operators . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   101</a>
+<a href="#6.5.17">          6.5.17 Comma operator . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .   104</a>
+<a href="#6.6">     6.6 Constant expressions . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   105</a>
+<a href="#6.7">     6.7 Declarations      . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   107</a>
+<a href="#6.7.1">          6.7.1   Storage-class specifiers    . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   108</a>
+<a href="#6.7.2">          6.7.2   Type specifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   109</a>
+<a href="#6.7.3">          6.7.3   Type qualifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   120</a>
+<a href="#6.7.4">          6.7.4   Function specifiers     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   124</a>
+<a href="#6.7.5">          6.7.5   Alignment specifier . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   126</a>
+<a href="#6.7.6">          6.7.6   Declarators     . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   127</a>
+<a href="#6.7.7">          6.7.7   Type names . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   135</a>
+<a href="#6.7.8">          6.7.8   Type definitions      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   136</a>
+<a href="#6.7.9">          6.7.9   Initialization    . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   138</a>
+<a href="#6.7.10">          6.7.10 Static assertions     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   144</a>
+<a href="#6.8">     6.8 Statements and blocks      . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   145</a>
+<a href="#6.8.1">          6.8.1   Labeled statements     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   145</a>
+<a href="#6.8.2">          6.8.2   Compound statement       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   146</a>
+<a href="#6.8.3">          6.8.3   Expression and null statements       .   .   .   .   .   .   .   .   .   .   .   .   .   146</a>
+<a href="#6.8.4">          6.8.4   Selection statements     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147</a>
+<a href="#6.8.5">          6.8.5   Iteration statements . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   149</a>
+<a href="#6.8.6">          6.8.6   Jump statements      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   150</a>
+<a href="#6.9">     6.9 External definitions      . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   154</a>
+<a href="#6.9.1">          6.9.1   Function definitions . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   155</a>
+<a href="#6.9.2">          6.9.2   External object definitions   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   157</a>
+<a href="#6.10">     6.10 Preprocessing directives     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   159</a>
+<a href="#6.10.1">          6.10.1 Conditional inclusion     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   161</a>
+<a href="#6.10.2">          6.10.2 Source file inclusion      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   163</a>
+<a href="#6.10.3">          6.10.3 Macro replacement . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   165</a>
+
+[page iv]
+
+<a href="#6.10.4">       6.10.4 Line control . . . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   172</a>
+<a href="#6.10.5">       6.10.5 Error directive . . . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   173</a>
+<a href="#6.10.6">       6.10.6 Pragma directive . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   173</a>
+<a href="#6.10.7">       6.10.7 Null directive      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174</a>
+<a href="#6.10.8">       6.10.8 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174</a>
+<a href="#6.10.9">       6.10.9 Pragma operator       . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   176</a>
+<a href="#6.11">  6.11 Future language directions     . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.1">       6.11.1 Floating types      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.2">       6.11.2 Linkages of identifiers . .      .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.3">       6.11.3 External names        . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.4">       6.11.4 Character escape sequences          .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.5">       6.11.5 Storage-class specifiers     .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.6">       6.11.6 Function declarators      . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.7">       6.11.7 Function definitions . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.8">       6.11.8 Pragma directives       . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11.9">       6.11.9 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#7">7. Library . . . . . . . . . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#7.1">   7.1 Introduction     . . . . . . . . . . . . .             .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#7.1.1">         7.1.1 Definitions of terms . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#7.1.2">         7.1.2 Standard headers . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   180</a>
+<a href="#7.1.3">         7.1.3 Reserved identifiers . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   181</a>
+<a href="#7.1.4">         7.1.4 Use of library functions    . . . . .          .   .   .   .   .    .   .   .   .   .   .   182</a>
+<a href="#7.2">   7.2 Diagnostics &lt;assert.h&gt;          . . . . . . .          .   .   .   .   .    .   .   .   .   .   .   185</a>
+<a href="#7.2.1">         7.2.1 Program diagnostics       . . . . . .          .   .   .   .   .    .   .   .   .   .   .   185</a>
+<a href="#7.3">   7.3 Complex arithmetic &lt;complex.h&gt;           . . .         .   .   .   .   .    .   .   .   .   .   .   187</a>
+<a href="#7.3.1">         7.3.1 Introduction . . . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   187</a>
+<a href="#7.3.2">         7.3.2 Conventions . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   188</a>
+<a href="#7.3.3">         7.3.3 Branch cuts . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   188</a>
+<a href="#7.3.4">         7.3.4 The CX_LIMITED_RANGE pragma                    .   .   .   .   .    .   .   .   .   .   .   188</a>
+<a href="#7.3.5">         7.3.5 Trigonometric functions . . . . .              .   .   .   .   .    .   .   .   .   .   .   189</a>
+<a href="#7.3.6">         7.3.6 Hyperbolic functions      . . . . . .          .   .   .   .   .    .   .   .   .   .   .   191</a>
+<a href="#7.3.7">         7.3.7 Exponential and logarithmic functions              .   .   .   .    .   .   .   .   .   .   193</a>
+<a href="#7.3.8">         7.3.8 Power and absolute-value functions             .   .   .   .   .    .   .   .   .   .   .   194</a>
+<a href="#7.3.9">         7.3.9 Manipulation functions      . . . . .          .   .   .   .   .    .   .   .   .   .   .   195</a>
+<a href="#7.4">   7.4 Character handling &lt;ctype.h&gt; . . . . .                 .   .   .   .   .    .   .   .   .   .   .   199</a>
+<a href="#7.4.1">         7.4.1 Character classification functions    .         .   .   .   .   .    .   .   .   .   .   .   199</a>
+<a href="#7.4.2">         7.4.2 Character case mapping functions     .         .   .   .   .   .    .   .   .   .   .   .   202</a>
+<a href="#7.5">   7.5 Errors &lt;errno.h&gt;         . . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   204</a>
+<a href="#7.6">   7.6 Floating-point environment &lt;fenv.h&gt;        . .         .   .   .   .   .    .   .   .   .   .   .   205</a>
+<a href="#7.6.1">         7.6.1 The FENV_ACCESS pragma           . . .         .   .   .   .   .    .   .   .   .   .   .   207</a>
+<a href="#7.6.2">         7.6.2 Floating-point exceptions      . . . .         .   .   .   .   .    .   .   .   .   .   .   208</a>
+<a href="#7.6.3">         7.6.3 Rounding . . . . . . . . . . .                 .   .   .   .   .    .   .   .   .   .   .   211</a>
+<a href="#7.6.4">         7.6.4 Environment        . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   212</a>
+<a href="#7.7">   7.7 Characteristics of floating types &lt;float.h&gt;             .   .   .   .   .    .   .   .   .   .   .   215</a>
+
+[page v]
+
+<a href="#7.8">     7.8    Format conversion of integer types &lt;inttypes.h&gt; . . . .           .   .   .   .   216</a>
+<a href="#7.8.1">            7.8.1    Macros for format specifiers      . . . . . . . . . .     .   .   .   .   216</a>
+<a href="#7.8.2">            7.8.2    Functions for greatest-width integer types   . . . . .   .   .   .   .   217</a>
+<a href="#7.9">     7.9    Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . .            .   .   .   .   220</a>
+<a href="#7.10">     7.10   Sizes of integer types &lt;limits.h&gt;         . . . . . . . . . .     .   .   .   .   221</a>
+<a href="#7.11">     7.11   Localization &lt;locale.h&gt; . . . . . . . . . . . . . .               .   .   .   .   222</a>
+<a href="#7.11.1">            7.11.1 Locale control . . . . . . . . . . . . . . . .             .   .   .   .   223</a>
+<a href="#7.11.2">            7.11.2 Numeric formatting convention inquiry . . . . . .          .   .   .   .   224</a>
+<a href="#7.12">     7.12   Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                .   .   .   .   230</a>
+<a href="#7.12.1">            7.12.1 Treatment of error conditions . . . . . . . . . .          .   .   .   .   232</a>
+<a href="#7.12.2">            7.12.2 The FP_CONTRACT pragma             . . . . . . . . . .     .   .   .   .   234</a>
+<a href="#7.12.3">            7.12.3 Classification macros       . . . . . . . . . . . . .       .   .   .   .   234</a>
+<a href="#7.12.4">            7.12.4 Trigonometric functions . . . . . . . . . . . .            .   .   .   .   237</a>
+<a href="#7.12.5">            7.12.5 Hyperbolic functions       . . . . . . . . . . . . .       .   .   .   .   239</a>
+<a href="#7.12.6">            7.12.6 Exponential and logarithmic functions        . . . . . .   .   .   .   .   241</a>
+<a href="#7.12.7">            7.12.7 Power and absolute-value functions         . . . . . . .   .   .   .   .   246</a>
+<a href="#7.12.8">            7.12.8 Error and gamma functions . . . . . . . . . . .            .   .   .   .   248</a>
+<a href="#7.12.9">            7.12.9 Nearest integer functions . . . . . . . . . . . .          .   .   .   .   250</a>
+<a href="#7.12.10">            7.12.10 Remainder functions       . . . . . . . . . . . . .       .   .   .   .   253</a>
+<a href="#7.12.11">            7.12.11 Manipulation functions       . . . . . . . . . . . .      .   .   .   .   254</a>
+<a href="#7.12.12">            7.12.12 Maximum, minimum, and positive difference functions           .   .   .   256</a>
+<a href="#7.12.13">            7.12.13 Floating multiply-add . . . . . . . . . . . . .           .   .   .   .   257</a>
+<a href="#7.12.14">            7.12.14 Comparison macros . . . . . . . . . . . . . .             .   .   .   .   258</a>
+<a href="#7.13">     7.13   Nonlocal jumps &lt;setjmp.h&gt;            . . . . . . . . . . . .      .   .   .   .   261</a>
+<a href="#7.13.1">            7.13.1 Save calling environment         . . . . . . . . . . .     .   .   .   .   261</a>
+<a href="#7.13.2">            7.13.2 Restore calling environment        . . . . . . . . . .     .   .   .   .   262</a>
+<a href="#7.14">     7.14   Signal handling &lt;signal.h&gt; . . . . . . . . . . . . .              .   .   .   .   264</a>
+<a href="#7.14.1">            7.14.1 Specify signal handling       . . . . . . . . . . . .      .   .   .   .   265</a>
+<a href="#7.14.2">            7.14.2 Send signal      . . . . . . . . . . . . . . . . .         .   .   .   .   266</a>
+<a href="#7.15">     7.15   Alignment &lt;stdalign.h&gt;            . . . . . . . . . . . . .       .   .   .   .   267</a>
+<a href="#7.16">     7.16   Variable arguments &lt;stdarg.h&gt;           . . . . . . . . . . .     .   .   .   .   268</a>
+<a href="#7.16.1">            7.16.1 Variable argument list access macros . . . . . . .         .   .   .   .   268</a>
+<a href="#7.17">     7.17   Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . .                 .   .   .   .   272</a>
+<a href="#7.17.1">            7.17.1 Introduction . . . . . . . . . . . . . . . . .             .   .   .   .   272</a>
+<a href="#7.17.2">            7.17.2 Initialization      . . . . . . . . . . . . . . . .        .   .   .   .   273</a>
+<a href="#7.17.3">            7.17.3 Order and consistency . . . . . . . . . . . . .            .   .   .   .   274</a>
+<a href="#7.17.4">            7.17.4 Fences . . . . . . . . . . . . . . . . . . .               .   .   .   .   277</a>
+<a href="#7.17.5">            7.17.5 Lock-free property       . . . . . . . . . . . . . .       .   .   .   .   278</a>
+<a href="#7.17.6">            7.17.6 Atomic integer and address types         . . . . . . . .   .   .   .   .   279</a>
+<a href="#7.17.7">            7.17.7 Operations on atomic types . . . . . . . . . . .           .   .   .   .   281</a>
+<a href="#7.17.8">            7.17.8 Atomic flag type and operations . . . . . . . . .           .   .   .   .   284</a>
+<a href="#7.18">     7.18   Boolean type and values &lt;stdbool.h&gt;             . . . . . . . .   .   .   .   .   286</a>
+<a href="#7.19">     7.19   Common definitions &lt;stddef.h&gt; . . . . . . . . . . .                .   .   .   .   287</a>
+<a href="#7.20">     7.20   Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . .              .   .   .   .   289</a>
+
+[page vi]
+
+<a href="#7.20.1">         7.20.1 Integer types      . . . . . . . . . . . .      .   .    .   .   .   .   .   .   289</a>
+<a href="#7.20.2">         7.20.2 Limits of specified-width integer types    . .   .   .    .   .   .   .   .   .   291</a>
+<a href="#7.20.3">         7.20.3 Limits of other integer types    . . . . . .    .   .    .   .   .   .   .   .   293</a>
+<a href="#7.20.4">         7.20.4 Macros for integer constants     . . . . . .    .   .    .   .   .   .   .   .   294</a>
+<a href="#7.21">  7.21   Input/output &lt;stdio.h&gt;         . . . . . . . . . .     .   .    .   .   .   .   .   .   296</a>
+<a href="#7.21.1">         7.21.1 Introduction . . . . . . . . . . . . .          .   .    .   .   .   .   .   .   296</a>
+<a href="#7.21.2">         7.21.2 Streams       . . . . . . . . . . . . . .       .   .    .   .   .   .   .   .   298</a>
+<a href="#7.21.3">         7.21.3 Files . . . . . . . . . . . . . . . .           .   .    .   .   .   .   .   .   300</a>
+<a href="#7.21.4">         7.21.4 Operations on files      . . . . . . . . . .     .   .    .   .   .   .   .   .   302</a>
+<a href="#7.21.5">         7.21.5 File access functions     . . . . . . . . .     .   .    .   .   .   .   .   .   304</a>
+<a href="#7.21.6">         7.21.6 Formatted input/output functions     . . . .    .   .    .   .   .   .   .   .   309</a>
+<a href="#7.21.7">         7.21.7 Character input/output functions . . . . .      .   .    .   .   .   .   .   .   330</a>
+<a href="#7.21.8">         7.21.8 Direct input/output functions    . . . . . .    .   .    .   .   .   .   .   .   334</a>
+<a href="#7.21.9">         7.21.9 File positioning functions     . . . . . . .    .   .    .   .   .   .   .   .   335</a>
+<a href="#7.21.10">         7.21.10 Error-handling functions . . . . . . . .       .   .    .   .   .   .   .   .   338</a>
+<a href="#7.22">  7.22   General utilities &lt;stdlib.h&gt;        . . . . . . . .    .   .    .   .   .   .   .   .   340</a>
+<a href="#7.22.1">         7.22.1 Numeric conversion functions . . . . . .        .   .    .   .   .   .   .   .   341</a>
+<a href="#7.22.2">         7.22.2 Pseudo-random sequence generation functions         .    .   .   .   .   .   .   346</a>
+<a href="#7.22.3">         7.22.3 Memory management functions . . . . .           .   .    .   .   .   .   .   .   347</a>
+<a href="#7.22.4">         7.22.4 Communication with the environment        . .   .   .    .   .   .   .   .   .   349</a>
+<a href="#7.22.5">         7.22.5 Searching and sorting utilities . . . . . .     .   .    .   .   .   .   .   .   353</a>
+<a href="#7.22.6">         7.22.6 Integer arithmetic functions     . . . . . .    .   .    .   .   .   .   .   .   355</a>
+<a href="#7.22.7">         7.22.7 Multibyte/wide character conversion functions       .    .   .   .   .   .   .   356</a>
+<a href="#7.22.8">         7.22.8 Multibyte/wide string conversion functions      .   .    .   .   .   .   .   .   358</a>
+<a href="#7.23">  7.23   String handling &lt;string.h&gt; . . . . . . . . .           .   .    .   .   .   .   .   .   360</a>
+<a href="#7.23.1">         7.23.1 String function conventions . . . . . . .       .   .    .   .   .   .   .   .   360</a>
+<a href="#7.23.2">         7.23.2 Copying functions       . . . . . . . . . .     .   .    .   .   .   .   .   .   360</a>
+<a href="#7.23.3">         7.23.3 Concatenation functions . . . . . . . .         .   .    .   .   .   .   .   .   362</a>
+<a href="#7.23.4">         7.23.4 Comparison functions . . . . . . . . .          .   .    .   .   .   .   .   .   363</a>
+<a href="#7.23.5">         7.23.5 Search functions      . . . . . . . . . . .     .   .    .   .   .   .   .   .   365</a>
+<a href="#7.23.6">         7.23.6 Miscellaneous functions . . . . . . . .         .   .    .   .   .   .   .   .   368</a>
+<a href="#7.24">  7.24   Type-generic math &lt;tgmath.h&gt;          . . . . . . .    .   .    .   .   .   .   .   .   370</a>
+<a href="#7.25">  7.25   Threads &lt;threads.h&gt;          . . . . . . . . . . .     .   .    .   .   .   .   .   .   373</a>
+<a href="#7.25.1">         7.25.1 Introduction . . . . . . . . . . . . .          .   .    .   .   .   .   .   .   373</a>
+<a href="#7.25.2">         7.25.2 Initialization functions . . . . . . . . .      .   .    .   .   .   .   .   .   375</a>
+<a href="#7.25.3">         7.25.3 Condition variable functions     . . . . . .    .   .    .   .   .   .   .   .   375</a>
+<a href="#7.25.4">         7.25.4 Mutex functions       . . . . . . . . . . .     .   .    .   .   .   .   .   .   377</a>
+<a href="#7.25.5">         7.25.5 Thread functions . . . . . . . . . . .          .   .    .   .   .   .   .   .   380</a>
+<a href="#7.25.6">         7.25.6 Thread-specific storage functions     . . . .    .   .    .   .   .   .   .   .   382</a>
+<a href="#7.25.7">         7.25.7 Time functions . . . . . . . . . . . .          .   .    .   .   .   .   .   .   384</a>
+<a href="#7.26">  7.26   Date and time &lt;time.h&gt;         . . . . . . . . . .     .   .    .   .   .   .   .   .   385</a>
+<a href="#7.26.1">         7.26.1 Components of time        . . . . . . . . .     .   .    .   .   .   .   .   .   385</a>
+<a href="#7.26.2">         7.26.2 Time manipulation functions      . . . . . .    .   .    .   .   .   .   .   .   386</a>
+<a href="#7.26.3">         7.26.3 Time conversion functions      . . . . . . .    .   .    .   .   .   .   .   .   388</a>
+
+[page vii]
+
+<a href="#7.27">   7.27 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .               . .     .   395</a>
+<a href="#7.27.1">        7.27.1 Restartable multibyte/wide character conversion functions        .     .   395</a>
+<a href="#7.28">   7.28 Extended multibyte and wide character utilities &lt;wchar.h&gt; . .         . .     .   399</a>
+<a href="#7.28.1">        7.28.1 Introduction . . . . . . . . . . . . . . . . . .               . .     .   399</a>
+<a href="#7.28.2">        7.28.2 Formatted wide character input/output functions       . . .    . .     .   400</a>
+<a href="#7.28.3">        7.28.3 Wide character input/output functions        . . . . . . .     . .     .   418</a>
+<a href="#7.28.4">        7.28.4 General wide string utilities     . . . . . . . . . . .        . .     .   422</a>
+<a href="#7.28.4.1">                 7.28.4.1 Wide string numeric conversion functions     . .    . .     .   423</a>
+<a href="#7.28.4.2">                 7.28.4.2 Wide string copying functions . . . . . . .         . .     .   427</a>
+<a href="#7.28.4.3">                 7.28.4.3 Wide string concatenation functions      . . . .    . .     .   429</a>
+<a href="#7.28.4.4">                 7.28.4.4 Wide string comparison functions      . . . . .     . .     .   430</a>
+<a href="#7.28.4.5">                 7.28.4.5 Wide string search functions      . . . . . . .     . .     .   432</a>
+<a href="#7.28.4.6">                 7.28.4.6 Miscellaneous functions      . . . . . . . . .      . .     .   436</a>
+<a href="#7.28.5">        7.28.5 Wide character time conversion functions       . . . . . .     . .     .   436</a>
+<a href="#7.28.6">        7.28.6 Extended multibyte/wide character conversion utilities .       . .     .   437</a>
+<a href="#7.28.6.1">                 7.28.6.1 Single-byte/wide character conversion functions     . .     .   438</a>
+<a href="#7.28.6.2">                 7.28.6.2 Conversion state functions     . . . . . . . .      . .     .   438</a>
+<a href="#7.28.6.3">                 7.28.6.3 Restartable multibyte/wide character conversion
+                           functions   . . . . . . . . . . . . . . .          . . . 439</a>
+<a href="#7.28.6.4">                 7.28.6.4 Restartable multibyte/wide string conversion
+                           functions   . . . . . . . . . . . . . . .          .   .   .   441</a>
+<a href="#7.29">   7.29 Wide character classification and mapping utilities &lt;wctype.h&gt;         .   .   .   444</a>
+<a href="#7.29.1">        7.29.1 Introduction . . . . . . . . . . . . . . . . . .               .   .   .   444</a>
+<a href="#7.29.2">        7.29.2 Wide character classification utilities . . . . . . . .         .   .   .   445</a>
+<a href="#7.29.2.1">                 7.29.2.1 Wide character classification functions     . . .    .   .   .   445</a>
+<a href="#7.29.2.2">                 7.29.2.2 Extensible wide character classification
+                           functions   . . . . . . . . . . . . . . .          . . . 448</a>
+<a href="#7.29.3">        7.29.3 Wide character case mapping utilities . . . . . . . .          . . . 450</a>
+<a href="#7.29.3.1">                 7.29.3.1 Wide character case mapping functions      . . .    . . . 450</a>
+<a href="#7.29.3.2">                 7.29.3.2 Extensible wide character case mapping
+                           functions   . . . . . . . . . . . . . . .          .   .   .   450</a>
+<a href="#7.30">   7.30 Future library directions    . . . . . . . . . . . . . . . .          .   .   .   452</a>
+<a href="#7.30.1">        7.30.1 Complex arithmetic &lt;complex.h&gt; . . . . . . . .                 .   .   .   452</a>
+<a href="#7.30.2">        7.30.2 Character handling &lt;ctype.h&gt;            . . . . . . . . .      .   .   .   452</a>
+<a href="#7.30.3">        7.30.3 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .         .   .   .   452</a>
+<a href="#7.30.4">        7.30.4 Format conversion of integer types &lt;inttypes.h&gt;            .   .   .   .   452</a>
+<a href="#7.30.5">        7.30.5 Localization &lt;locale.h&gt;           . . . . . . . . . . .        .   .   .   452</a>
+<a href="#7.30.6">        7.30.6 Signal handling &lt;signal.h&gt;           . . . . . . . . . .       .   .   .   452</a>
+<a href="#7.30.7">        7.30.7 Boolean type and values &lt;stdbool.h&gt;            . . . . . .     .   .   .   452</a>
+<a href="#7.30.8">        7.30.8 Integer types &lt;stdint.h&gt;          . . . . . . . . . . .        .   .   .   452</a>
+<a href="#7.30.9">        7.30.9 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .        .   .   .   453</a>
+<a href="#7.30.10">        7.30.10 General utilities &lt;stdlib.h&gt;        . . . . . . . . . .       .   .   .   453</a>
+<a href="#7.30.11">        7.30.11 String handling &lt;string.h&gt;          . . . . . . . . . .       .   .   .   453</a>
+
+[page viii]
+
+<a href="#7.30.12">        7.30.12 Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;        . . . . . . . . . . . . . . . . . . . . 453</a>
+<a href="#7.30.13">        7.30.13 Wide character classification and mapping utilities
+                &lt;wctype.h&gt; . . . . . . . . . . . . . . . . . . . . 453</a>
+<a href="#A">Annex A (informative) Language syntax summary   . .       .   .   .   .    .   .   .   .   .   .   454</a>
+<a href="#A.1">  A.1 Lexical grammar       . . . . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   454</a>
+<a href="#A.2">  A.2 Phrase structure grammar . . . . . . . . .          .   .   .   .    .   .   .   .   .   .   461</a>
+<a href="#A.3">  A.3 Preprocessing directives    . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   469</a>
+<a href="#B">Annex B (informative) Library summary     . . . . . . . . . . . . .                    .   .   .   471</a>
+<a href="#B.1">  B.1 Diagnostics &lt;assert.h&gt;          . . . . . . . . . . . . . . .                    .   .   .   471</a>
+<a href="#B.2">  B.2 Complex &lt;complex.h&gt; . . . . . . . . . . . . . . . .                              .   .   .   471</a>
+<a href="#B.3">  B.3 Character handling &lt;ctype.h&gt; . . . . . . . . . . . . .                           .   .   .   473</a>
+<a href="#B.4">  B.4 Errors &lt;errno.h&gt;         . . . . . . . . . . . . . . . . . .                     .   .   .   473</a>
+<a href="#B.5">  B.5 Floating-point environment &lt;fenv.h&gt;          . . . . . . . . . .                 .   .   .   473</a>
+<a href="#B.6">  B.6 Characteristics of floating types &lt;float.h&gt; . . . . . . . .                       .   .   .   474</a>
+<a href="#B.7">  B.7 Format conversion of integer types &lt;inttypes.h&gt; . . . . .                        .   .   .   474</a>
+<a href="#B.8">  B.8 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . . .                         .   .   .   475</a>
+<a href="#B.9">  B.9 Sizes of integer types &lt;limits.h&gt;          . . . . . . . . . . .                 .   .   .   475</a>
+<a href="#B.10">  B.10 Localization &lt;locale.h&gt; . . . . . . . . . . . . . . .                           .   .   .   475</a>
+<a href="#B.11">  B.11 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . . .                            .   .   .   475</a>
+<a href="#B.12">  B.12 Nonlocal jumps &lt;setjmp.h&gt;          . . . . . . . . . . . . .                    .   .   .   480</a>
+<a href="#B.13">  B.13 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . . .                          .   .   .   480</a>
+<a href="#B.14">  B.14 Alignment &lt;stdalign.h&gt;           . . . . . . . . . . . . . .                    .   .   .   481</a>
+<a href="#B.15">  B.15 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . . .                   .   .   .   481</a>
+<a href="#B.16">  B.16 Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . . .                             .   .   .   481</a>
+<a href="#B.17">  B.17 Boolean type and values &lt;stdbool.h&gt;           . . . . . . . . .                 .   .   .   483</a>
+<a href="#B.18">  B.18 Common definitions &lt;stddef.h&gt; . . . . . . . . . . . .                            .   .   .   483</a>
+<a href="#B.19">  B.19 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . . .                          .   .   .   483</a>
+<a href="#B.20">  B.20 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   484</a>
+<a href="#B.21">  B.21 General utilities &lt;stdlib.h&gt;       . . . . . . . . . . . . .                    .   .   .   487</a>
+<a href="#B.22">  B.22 String handling &lt;string.h&gt; . . . . . . . . . . . . . .                          .   .   .   489</a>
+<a href="#B.23">  B.23 Type-generic math &lt;tgmath.h&gt;          . . . . . . . . . . . .                   .   .   .   491</a>
+<a href="#B.24">  B.24 Threads &lt;threads.h&gt;          . . . . . . . . . . . . . . . .                    .   .   .   491</a>
+<a href="#B.25">  B.25 Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   492</a>
+<a href="#B.26">  B.26 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .                         .   .   .   493</a>
+<a href="#B.27">  B.27 Extended multibyte/wide character utilities &lt;wchar.h&gt;     . . .                 .   .   .   493</a>
+<a href="#B.28">  B.28 Wide character classification and mapping utilities &lt;wctype.h&gt;                   .   .   .   498</a>
+<a href="#C">Annex C (informative) Sequence points     . . . . . . . . . . . . . . . . . 499</a>
+<a href="#D">Annex D (normative) Universal character names for identifiers . . . . . . . 500</a>
+<a href="#D.1">  D.1 Ranges of characters allowed       . . . . . . . . . . . . . . . . . 500</a>
+<a href="#D.2">  D.2 Ranges of characters disallowed initially . . . . . . . . . . . . . 500</a>
+<a href="#E">Annex E (informative) Implementation limits        . . . . . . . . . . . . . . 501</a>
+
+[page ix]
+
+<a href="#F">Annex F (normative) IEC 60559 floating-point arithmetic . . . . . .          . .     .   .   503</a>
+<a href="#F.1">  F.1 Introduction      . . . . . . . . . . . . . . . . . . . .             . .     .   .   503</a>
+<a href="#F.2">  F.2 Types . . . . . . . . . . . . . . . . . . . . . . .                   . .     .   .   503</a>
+<a href="#F.3">  F.3 Operators and functions       . . . . . . . . . . . . . . .           . .     .   .   504</a>
+<a href="#F.4">  F.4 Floating to integer conversion    . . . . . . . . . . . . .           . .     .   .   506</a>
+<a href="#F.5">  F.5 Binary-decimal conversion       . . . . . . . . . . . . . .           . .     .   .   506</a>
+<a href="#F.6">  F.6 The return statement . . . . . . . . . . . . . . . .                  . .     .   .   507</a>
+<a href="#F.7">  F.7 Contracted expressions . . . . . . . . . . . . . . . .                . .     .   .   507</a>
+<a href="#F.8">  F.8 Floating-point environment      . . . . . . . . . . . . . .           . .     .   .   507</a>
+<a href="#F.9">  F.9 Optimization . . . . . . . . . . . . . . . . . . . .                  . .     .   .   510</a>
+<a href="#F.10">  F.10 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                   . .     .   .   513</a>
+<a href="#F.10.1">        F.10.1 Trigonometric functions . . . . . . . . . . . .              . .     .   .   514</a>
+<a href="#F.10.2">        F.10.2 Hyperbolic functions     . . . . . . . . . . . . .           . .     .   .   516</a>
+<a href="#F.10.3">        F.10.3 Exponential and logarithmic functions    . . . . . .         . .     .   .   516</a>
+<a href="#F.10.4">        F.10.4 Power and absolute value functions     . . . . . . .         . .     .   .   520</a>
+<a href="#F.10.5">        F.10.5 Error and gamma functions . . . . . . . . . . .              . .     .   .   521</a>
+<a href="#F.10.6">        F.10.6 Nearest integer functions . . . . . . . . . . . .            . .     .   .   522</a>
+<a href="#F.10.7">        F.10.7 Remainder functions      . . . . . . . . . . . . .           . .     .   .   524</a>
+<a href="#F.10.8">        F.10.8 Manipulation functions     . . . . . . . . . . . .           . .     .   .   525</a>
+<a href="#F.10.9">        F.10.9 Maximum, minimum, and positive difference functions            .     .   .   526</a>
+<a href="#F.10.10">        F.10.10 Floating multiply-add . . . . . . . . . . . . .             . .     .   .   526</a>
+<a href="#F.10.11">        F.10.11 Comparison macros . . . . . . . . . . . . . .               . .     .   .   527</a>
+<a href="#G">Annex G (normative) IEC 60559-compatible complex arithmetic     .   .   .   .   .   .   .   528</a>
+<a href="#G.1">  G.1 Introduction     . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   528</a>
+<a href="#G.2">  G.2 Types . . . . . . . . . . . . . . . . . . . .             .   .   .   .   .   .   .   528</a>
+<a href="#G.3">  G.3 Conventions      . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   528</a>
+<a href="#G.4">  G.4 Conversions      . . . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   529</a>
+<a href="#G.4.1">       G.4.1 Imaginary types     . . . . . . . . . . . .        .   .   .   .   .   .   .   529</a>
+<a href="#G.4.2">       G.4.2 Real and imaginary . . . . . . . . . . .           .   .   .   .   .   .   .   529</a>
+<a href="#G.4.3">       G.4.3 Imaginary and complex       . . . . . . . . .      .   .   .   .   .   .   .   529</a>
+<a href="#G.5">  G.5 Binary operators     . . . . . . . . . . . . . . .        .   .   .   .   .   .   .   529</a>
+<a href="#G.5.1">       G.5.1 Multiplicative operators    . . . . . . . . .      .   .   .   .   .   .   .   530</a>
+<a href="#G.5.2">       G.5.2 Additive operators     . . . . . . . . . . .       .   .   .   .   .   .   .   533</a>
+<a href="#G.6">  G.6 Complex arithmetic &lt;complex.h&gt;         . . . . . . .      .   .   .   .   .   .   .   533</a>
+<a href="#G.6.1">       G.6.1 Trigonometric functions . . . . . . . . .          .   .   .   .   .   .   .   535</a>
+<a href="#G.6.2">       G.6.2 Hyperbolic functions     . . . . . . . . . .       .   .   .   .   .   .   .   535</a>
+<a href="#G.6.3">       G.6.3 Exponential and logarithmic functions     . . .    .   .   .   .   .   .   .   539</a>
+<a href="#G.6.4">       G.6.4 Power and absolute-value functions      . . . .    .   .   .   .   .   .   .   540</a>
+<a href="#G.7">  G.7 Type-generic math &lt;tgmath.h&gt;         . . . . . . . .      .   .   .   .   .   .   .   541</a>
+<a href="#H">Annex H (informative) Language independent arithmetic . .   .   .   .   .   .   .   .   .   542</a>
+<a href="#H.1">  H.1 Introduction     . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   542</a>
+<a href="#H.2">  H.2 Types . . . . . . . . . . . . . . . . . . .           .   .   .   .   .   .   .   .   542</a>
+<a href="#H.3">  H.3 Notification      . . . . . . . . . . . . . . . .      .   .   .   .   .   .   .   .   546</a>
+
+[page x]
+
+<a href="#I">Annex I (informative) Common warnings         . . . . . . . . . . . . . . . . 548</a>
+<a href="#J">Annex J (informative) Portability issues    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   550</a>
+<a href="#J.1">  J.1 Unspecified behavior . . . .           . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   550</a>
+<a href="#J.2">  J.2 Undefined behavior          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   553</a>
+<a href="#J.3">  J.3 Implementation-defined behavior          . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   566</a>
+<a href="#J.4">  J.4 Locale-specific behavior         . .   . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   574</a>
+<a href="#J.5">  J.5 Common extensions          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   575</a>
+<a href="#K">Annex K (normative) Bounds-checking interfaces . . . . . . . . . .                             .   .   .   578</a>
+<a href="#K.1">  K.1 Background       . . . . . . . . . . . . . . . . . . . . .                               .   .   .   578</a>
+<a href="#K.2">  K.2 Scope . . . . . . . . . . . . . . . . . . . . . . . .                                    .   .   .   579</a>
+<a href="#K.3">  K.3 Library     . . . . . . . . . . . . . . . . . . . . . . .                                .   .   .   579</a>
+<a href="#K.3.1">       K.3.1 Introduction . . . . . . . . . . . . . . . . . .                                  .   .   .   579</a>
+<a href="#K.3.1.1">                K.3.1.1 Standard headers     . . . . . . . . . . . .                           .   .   .   579</a>
+<a href="#K.3.1.2">                K.3.1.2 Reserved identifiers     . . . . . . . . . . .                          .   .   .   580</a>
+<a href="#K.3.1.3">                K.3.1.3 Use of errno . . . . . . . . . . . . . .                               .   .   .   580</a>
+<a href="#K.3.1.4">                K.3.1.4 Runtime-constraint violations     . . . . . . .                        .   .   .   580</a>
+<a href="#K.3.2">       K.3.2 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .                            .   .   .   581</a>
+<a href="#K.3.3">       K.3.3 Common definitions &lt;stddef.h&gt;               . . . . . . . .                        .   .   .   581</a>
+<a href="#K.3.4">       K.3.4 Integer types &lt;stdint.h&gt;           . . . . . . . . . . .                          .   .   .   581</a>
+<a href="#K.3.5">       K.3.5 Input/output &lt;stdio.h&gt;          . . . . . . . . . . . .                           .   .   .   582</a>
+<a href="#K.3.5.1">                K.3.5.1 Operations on files      . . . . . . . . . . .                          .   .   .   582</a>
+<a href="#K.3.5.2">                K.3.5.2 File access functions . . . . . . . . . . .                            .   .   .   584</a>
+<a href="#K.3.5.3">                K.3.5.3 Formatted input/output functions . . . . . .                           .   .   .   587</a>
+<a href="#K.3.5.4">                K.3.5.4 Character input/output functions . . . . . .                           .   .   .   598</a>
+<a href="#K.3.6">       K.3.6 General utilities &lt;stdlib.h&gt;          . . . . . . . . . .                         .   .   .   600</a>
+<a href="#K.3.6.1">                K.3.6.1 Runtime-constraint handling       . . . . . . .                        .   .   .   600</a>
+<a href="#K.3.6.2">                K.3.6.2 Communication with the environment . . . .                             .   .   .   602</a>
+<a href="#K.3.6.3">                K.3.6.3 Searching and sorting utilities . . . . . . .                          .   .   .   603</a>
+<a href="#K.3.6.4">                K.3.6.4 Multibyte/wide character conversion functions                          .   .   .   606</a>
+<a href="#K.3.6.5">                K.3.6.5 Multibyte/wide string conversion functions . .                         .   .   .   607</a>
+<a href="#K.3.7">       K.3.7 String handling &lt;string.h&gt;            . . . . . . . . . .                         .   .   .   610</a>
+<a href="#K.3.7.1">                K.3.7.1 Copying functions       . . . . . . . . . . .                          .   .   .   610</a>
+<a href="#K.3.7.2">                K.3.7.2 Concatenation functions       . . . . . . . . .                        .   .   .   613</a>
+<a href="#K.3.7.3">                K.3.7.3 Search functions     . . . . . . . . . . . .                           .   .   .   616</a>
+<a href="#K.3.7.4">                K.3.7.4 Miscellaneous functions       . . . . . . . . .                        .   .   .   617</a>
+<a href="#K.3.8">       K.3.8 Date and time &lt;time.h&gt;          . . . . . . . . . . . .                           .   .   .   620</a>
+<a href="#K.3.8.1">                K.3.8.1 Components of time . . . . . . . . . . .                               .   .   .   620</a>
+<a href="#K.3.8.2">                K.3.8.2 Time conversion functions       . . . . . . . .                        .   .   .   620</a>
+<a href="#K.3.9">       K.3.9 Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;        . . . . . . . . . . . . . . . . .                             . . . 623</a>
+<a href="#K.3.9.1">                K.3.9.1 Formatted wide character input/output functions                        . . . 624</a>
+<a href="#K.3.9.2">                K.3.9.2 General wide string utilities . . . . . . . .                          . . . 635</a>
+
+[page xi]
+
+<a href="#K.3.9.3">               K.3.9.3 Extended multibyte/wide character conversion
+                       utilities . . . . . . . . . . . . . . . . . . . 643</a>
+<a href="#L">Annex L (normative) Analyzability . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648</a>
+<a href="#L.1">  L.1 Scope . . . . . . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648</a>
+<a href="#L.2">  L.2 Definitions . . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   648</a>
+<a href="#L.3">  L.3 Requirements . . . . . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   649</a>
+<a href="#Bibliography">Bibliography   . . . . . . . . . . . . . . . . . . . . . . . . . . . 650</a>
+<a href="#Index">Index    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653</a>
+
+[<a name="pxii" href="#pxii">page xii</a>] (<a href="#Contents">Contents</a>)
+
+<a name="Foreword" href="#Foreword"><b>    Foreword</b></a>
+1   ISO (the International Organization for Standardization) and IEC (the International
+    Electrotechnical Commission) form the specialized system for worldwide
+    standardization. National bodies that are member of ISO or IEC participate in the
+    development of International Standards through technical committees established by the
+    respective organization to deal with particular fields of technical activity. ISO and IEC
+    technical committees collaborate in fields of mutual interest. Other international
+    organizations, governmental and non-governmental, in liaison with ISO and IEC, also
+    take part in the work.
+2   International Standards are drafted in accordance with the rules given in the ISO/IEC
+    Directives, Part 2. This International Standard was drafted in accordance with the fifth
+    edition (2004).
+3   In the field of information technology, ISO and IEC have established a joint technical
+    committee, ISO/IEC JTC 1. Draft International Standards adopted by the joint technical
+    committee are circulated to national bodies for voting. Publication as an International
+    Standard requires approval by at least 75% of the national bodies casting a vote.
+4   Attention is drawn to the possibility that some of the elements of this document may be
+    the subject of patent rights. ISO and IEC shall not be held responsible for identifying any
+    or all such patent rights.
+5   This International Standard was prepared by Joint Technical Committee ISO/IEC JTC 1,
+    Information technology, Subcommittee SC 22, Programming languages, their
+    environments and system software interfaces. The Working Group responsible for this
+    standard (WG 14) maintains a site on the World Wide Web at http://www.open-
+    std.org/JTC1/SC22/WG14/ containing additional information relevant to this
+    standard such as a Rationale for many of the decisions made during its preparation and a
+    log of Defect Reports and Responses.
+6   This third edition cancels and replaces the second edition, ISO/IEC 9899:1999, as
+    corrected by ISO/IEC 9899:1999/Cor 1:2001, ISO/IEC 9899:1999/Cor 2:2004, and
+    ISO/IEC 9899:1999/Cor 3:2007. Major changes from the previous edition include:
+    -- conditional (optional) features (including some that were previously mandatory)
+    -- support for multiple threads of execution including an improved memory sequencing
+      model, atomic objects, and thread-local storage (<a href="#7.17">&lt;stdatomic.h&gt;</a> and
+      <a href="#7.25">&lt;threads.h&gt;</a>)
+    -- additional floating-point characteristic macros (<a href="#7.7">&lt;float.h&gt;</a>)
+    -- querying and specifying alignment of objects (<a href="#7.15">&lt;stdalign.h&gt;</a>, <a href="#7.22">&lt;stdlib.h&gt;</a>)
+    -- Unicode characters and           strings   (<a href="#7.27">&lt;uchar.h&gt;</a>)       (originally   specified    in
+      ISO/IEC TR 19769:2004)
+    -- type-generic expressions
+
+[<a name="pxiii" href="#pxiii">page xiii</a>] (<a href="#Contents">Contents</a>)
+
+    -- static assertions
+    -- anonymous structures and unions
+    -- no-return functions
+    -- macros to create complex numbers (<a href="#7.3">&lt;complex.h&gt;</a>)
+    -- support for opening files for exclusive access
+    -- removed the gets function (<a href="#7.21">&lt;stdio.h&gt;</a>)
+    -- added the aligned_alloc, at_quick_exit, and quick_exit functions
+      (<a href="#7.22">&lt;stdlib.h&gt;</a>)
+    -- (conditional) support for bounds-checking interfaces (originally specified in
+      ISO/IEC TR 24731-1:2007)
+    -- (conditional) support for analyzability
+7   Major changes in the second edition included:
+    -- restricted character set support via digraphs and <a href="#7.9">&lt;iso646.h&gt;</a> (originally specified
+      in AMD1)
+    -- wide character library support in <a href="#7.28">&lt;wchar.h&gt;</a> and <a href="#7.29">&lt;wctype.h&gt;</a> (originally
+      specified in AMD1)
+    -- more precise aliasing rules via effective type
+    -- restricted pointers
+    -- variable length arrays
+    -- flexible array members
+    -- static and type qualifiers in parameter array declarators
+    -- complex (and imaginary) support in <a href="#7.3">&lt;complex.h&gt;</a>
+    -- type-generic math macros in <a href="#7.24">&lt;tgmath.h&gt;</a>
+    -- the long long int type and library functions
+    -- increased minimum translation limits
+    -- additional floating-point characteristics in <a href="#7.7">&lt;float.h&gt;</a>
+    -- remove implicit int
+    -- reliable integer division
+    -- universal character names (\u and \U)
+    -- extended identifiers
+    -- hexadecimal floating-point constants and %a and %A printf/scanf conversion
+      specifiers
+
+[<a name="pxiv" href="#pxiv">page xiv</a>] (<a href="#Contents">Contents</a>)
+
+-- compound literals
+-- designated initializers
+-- // comments
+-- extended integer types and library functions in <a href="#7.8">&lt;inttypes.h&gt;</a> and <a href="#7.20">&lt;stdint.h&gt;</a>
+-- remove implicit function declaration
+-- preprocessor arithmetic done in intmax_t/uintmax_t
+-- mixed declarations and code
+-- new block scopes for selection and iteration statements
+-- integer constant type rules
+-- integer promotion rules
+-- macros with a variable number of arguments
+-- the vscanf family of functions in <a href="#7.21">&lt;stdio.h&gt;</a> and <a href="#7.28">&lt;wchar.h&gt;</a>
+-- additional math library functions in <a href="#7.12">&lt;math.h&gt;</a>
+-- treatment of error conditions by math library functions (math_errhandling)
+-- floating-point environment access in <a href="#7.6">&lt;fenv.h&gt;</a>
+-- IEC 60559 (also known as IEC 559 or IEEE arithmetic) support
+-- trailing comma allowed in enum declaration
+-- %lf conversion specifier allowed in printf
+-- inline functions
+-- the snprintf family of functions in <a href="#7.21">&lt;stdio.h&gt;</a>
+-- boolean type in <a href="#7.18">&lt;stdbool.h&gt;</a>
+-- idempotent type qualifiers
+-- empty macro arguments
+-- new structure type compatibility rules (tag compatibility)
+-- additional predefined macro names
+-- _Pragma preprocessing operator
+-- standard pragmas
+-- __func__ predefined identifier
+-- va_copy macro
+-- additional strftime conversion specifiers
+-- LIA compatibility annex
+
+[<a name="pxv" href="#pxv">page xv</a>] (<a href="#Contents">Contents</a>)
+
+    -- deprecate ungetc at the beginning of a binary file
+    -- remove deprecation of aliased array parameters
+    -- conversion of array to pointer not limited to lvalues
+    -- relaxed constraints on aggregate and union initialization
+    -- relaxed restrictions on portable header names
+    -- return without expression not permitted in function that returns a value (and vice
+      versa)
+8   Annexes D, F, G, K, and L form a normative part of this standard; annexes A, B, C, E, H, *
+    I, J, the bibliography, and the index are for information only. In accordance with Part 2 of
+    the ISO/IEC Directives, this foreword, the introduction, notes, footnotes, and examples
+    are also for information only.
+
+[<a name="pxvi" href="#pxvi">page xvi</a>] (<a href="#Contents">Contents</a>)
+
+<a name="Introduction" href="#Introduction"><b>    Introduction</b></a>
+1   With the introduction of new devices and extended character sets, new features may be
+    added to this International Standard. Subclauses in the language and library clauses warn
+    implementors and programmers of usages which, though valid in themselves, may
+    conflict with future additions.
+2   Certain features are obsolescent, which means that they may be considered for
+    withdrawal in future revisions of this International Standard. They are retained because
+    of their widespread use, but their use in new implementations (for implementation
+    features) or new programs (for language [6.11] or library features [7.30]) is discouraged.
+3   This International Standard is divided into four major subdivisions:
+    -- preliminary elements (clauses 1-4);
+    -- the characteristics of environments that translate and execute C programs (clause 5);
+    -- the language syntax, constraints, and semantics (clause 6);
+    -- the library facilities (clause 7).
+4   Examples are provided to illustrate possible forms of the constructions described.
+    Footnotes are provided to emphasize consequences of the rules described in that
+    subclause or elsewhere in this International Standard. References are used to refer to
+    other related subclauses. Recommendations are provided to give advice or guidance to
+    implementors. Annexes provide additional information and summarize the information
+    contained in this International Standard. A bibliography lists documents that were
+    referred to during the preparation of the standard.
+5   The language clause (clause 6) is derived from ''The C Reference Manual''.
+6   The library clause (clause 7) is based on the 1984 /usr/group Standard.
+
+[<a name="pxvii" href="#pxvii">page xvii</a>] (<a href="#Contents">Contents</a>)
+
+
+[<a name="pxviii" href="#pxviii">page xviii</a>] (<a href="#Contents">Contents</a>)
+
+
+
+    Programming languages -- C
+
+
+
+<a name="1" href="#1"><b>    1. Scope</b></a>
+1   This International Standard specifies the form and establishes the interpretation of
+    programs written in the C programming language.<sup><a href="#note1"><b>1)</b></a></sup> It specifies
+    -- the representation of C programs;
+    -- the syntax and constraints of the C language;
+    -- the semantic rules for interpreting C programs;
+    -- the representation of input data to be processed by C programs;
+    -- the representation of output data produced by C programs;
+    -- the restrictions and limits imposed by a conforming implementation of C.
+2   This International Standard does not specify
+    -- the mechanism by which C programs are transformed for use by a data-processing
+      system;
+    -- the mechanism by which C programs are invoked for use by a data-processing
+      system;
+    -- the mechanism by which input data are transformed for use by a C program;
+    -- the mechanism by which output data are transformed after being produced by a C
+      program;
+    -- the size or complexity of a program and its data that will exceed the capacity of any
+      specific data-processing system or the capacity of a particular processor;
+    -- all minimal requirements of a data-processing system that is capable of supporting a
+      conforming implementation.
+
+
+    <sup><a name="note1" href="#note1"><b>1)</b></a></sup>   This International Standard is designed to promote the portability of C programs among a variety of
+         data-processing systems. It is intended for use by implementors and programmers.
+
+[<a name="p1" href="#p1">page 1</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="2" href="#2"><b>    2. Normative references</b></a>
+1   The following referenced documents are indispensable for the application of this
+    document. For dated references, only the edition cited applies. For undated references,
+    the latest edition of the referenced document (including any amendments) applies.
+2   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and symbols for
+    use in the physical sciences and technology.
+3   ISO/IEC 646, Information technology -- ISO 7-bit coded character set for information
+    interchange.
+4   ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1: Fundamental
+    terms.
+5   ISO 4217, Codes for the representation of currencies and funds.
+6   ISO 8601, Data elements and interchange formats -- Information interchange --
+    Representation of dates and times.
+7   ISO/IEC 10646 (all parts), Information technology -- Universal Multiple-Octet Coded
+    Character Set (UCS).
+8   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously
+    designated IEC 559:1989).
+
+[<a name="p2" href="#p2">page 2</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="3" href="#3"><b>    3. Terms, definitions, and symbols</b></a>
+1   For the purposes of this International Standard, the following definitions apply. Other
+    terms are defined where they appear in italic type or on the left side of a syntax rule.
+    Terms explicitly defined in this International Standard are not to be presumed to refer
+    implicitly to similar terms defined elsewhere. Terms not defined in this International
+    Standard are to be interpreted according to ISO/IEC 2382-1. Mathematical symbols not
+    defined in this International Standard are to be interpreted according to ISO 31-11.
+<a name="3.1" href="#3.1"><b>    3.1</b></a>
+1   access
+    &lt;execution-time action&gt; to read or modify the value of an object
+2   NOTE 1   Where only one of these two actions is meant, ''read'' or ''modify'' is used.
+
+3   NOTE 2   ''Modify'' includes the case where the new value being stored is the same as the previous value.
+
+4   NOTE 3   Expressions that are not evaluated do not access objects.
+
+<a name="3.2" href="#3.2"><b>    3.2</b></a>
+1   alignment
+    requirement that objects of a particular type be located on storage boundaries with
+    addresses that are particular multiples of a byte address
+<a name="3.3" href="#3.3"><b>    3.3</b></a>
+1   argument
+    actual argument
+    actual parameter (deprecated)
+    expression in the comma-separated list bounded by the parentheses in a function call
+    expression, or a sequence of preprocessing tokens in the comma-separated list bounded
+    by the parentheses in a function-like macro invocation
+<a name="3.4" href="#3.4"><b>    3.4</b></a>
+1   behavior
+    external appearance or action
+<a name="3.4.1" href="#3.4.1"><b>    3.4.1</b></a>
+1   implementation-defined behavior
+    unspecified behavior where each implementation documents how the choice is made
+2   EXAMPLE An example of implementation-defined behavior is the propagation of the high-order bit
+    when a signed integer is shifted right.
+
+<a name="3.4.2" href="#3.4.2"><b>    3.4.2</b></a>
+1   locale-specific behavior
+    behavior that depends on local conventions of nationality, culture, and language that each
+    implementation documents
+
+[<a name="p3" href="#p3">page 3</a>] (<a href="#Contents">Contents</a>)
+
+2   EXAMPLE An example of locale-specific behavior is whether the islower function returns true for
+    characters other than the 26 lowercase Latin letters.
+
+<a name="3.4.3" href="#3.4.3"><b>    3.4.3</b></a>
+1   undefined behavior
+    behavior, upon use of a nonportable or erroneous program construct or of erroneous data,
+    for which this International Standard imposes no requirements
+2   NOTE Possible undefined behavior ranges from ignoring the situation completely with unpredictable
+    results, to behaving during translation or program execution in a documented manner characteristic of the
+    environment (with or without the issuance of a diagnostic message), to terminating a translation or
+    execution (with the issuance of a diagnostic message).
+
+3   EXAMPLE        An example of undefined behavior is the behavior on integer overflow.
+
+<a name="3.4.4" href="#3.4.4"><b>    3.4.4</b></a>
+1   unspecified behavior
+    use of an unspecified value, or other behavior where this International Standard provides
+    two or more possibilities and imposes no further requirements on which is chosen in any
+    instance
+2   EXAMPLE        An example of unspecified behavior is the order in which the arguments to a function are
+    evaluated.
+
+<a name="3.5" href="#3.5"><b>    3.5</b></a>
+1   bit
+    unit of data storage in the execution environment large enough to hold an object that may
+    have one of two values
+2   NOTE     It need not be possible to express the address of each individual bit of an object.
+
+<a name="3.6" href="#3.6"><b>    3.6</b></a>
+1   byte
+    addressable unit of data storage large enough to hold any member of the basic character
+    set of the execution environment
+2   NOTE 1     It is possible to express the address of each individual byte of an object uniquely.
+
+3   NOTE 2 A byte is composed of a contiguous sequence of bits, the number of which is implementation-
+    defined. The least significant bit is called the low-order bit; the most significant bit is called the high-order
+    bit.
+
+<a name="3.7" href="#3.7"><b>    3.7</b></a>
+1   character
+    &lt;abstract&gt; member of a set of elements used for the organization, control, or
+    representation of data
+<a name="3.7.1" href="#3.7.1"><b>    3.7.1</b></a>
+1   character
+    single-byte character
+    &lt;C&gt; bit representation that fits in a byte
+
+[<a name="p4" href="#p4">page 4</a>] (<a href="#Contents">Contents</a>)
+
+<a name="3.7.2" href="#3.7.2"><b>    3.7.2</b></a>
+1   multibyte character
+    sequence of one or more bytes representing a member of the extended character set of
+    either the source or the execution environment
+2   NOTE    The extended character set is a superset of the basic character set.
+
+<a name="3.7.3" href="#3.7.3"><b>    3.7.3</b></a>
+1   wide character
+    bit representation that fits in an object of type wchar_t, capable of representing any
+    character in the current locale
+<a name="3.8" href="#3.8"><b>    3.8</b></a>
+1   constraint
+    restriction, either syntactic or semantic, by which the exposition of language elements is
+    to be interpreted
+<a name="3.9" href="#3.9"><b>    3.9</b></a>
+1   correctly rounded result
+    representation in the result format that is nearest in value, subject to the current rounding
+    mode, to what the result would be given unlimited range and precision
+<a name="3.10" href="#3.10"><b>    3.10</b></a>
+1   diagnostic message
+    message belonging to an implementation-defined subset of the implementation's message
+    output
+<a name="3.11" href="#3.11"><b>    3.11</b></a>
+1   forward reference
+    reference to a later subclause of this International Standard that contains additional
+    information relevant to this subclause
+<a name="3.12" href="#3.12"><b>    3.12</b></a>
+1   implementation
+    particular set of software, running in a particular translation environment under particular
+    control options, that performs translation of programs for, and supports execution of
+    functions in, a particular execution environment
+<a name="3.13" href="#3.13"><b>    3.13</b></a>
+1   implementation limit
+    restriction imposed upon programs by the implementation
+<a name="3.14" href="#3.14"><b>    3.14</b></a>
+1   memory location
+    either an object of scalar type, or a maximal sequence of adjacent bit-fields all having
+    nonzero width
+
+[<a name="p5" href="#p5">page 5</a>] (<a href="#Contents">Contents</a>)
+
+2   NOTE 1 Two threads of execution can update and access separate memory locations without interfering
+    with each other.
+
+3   NOTE 2 A bit-field and an adjacent non-bit-field member are in separate memory locations. The same
+    applies to two bit-fields, if one is declared inside a nested structure declaration and the other is not, or if the
+    two are separated by a zero-length bit-field declaration, or if they are separated by a non-bit-field member
+    declaration. It is not safe to concurrently update two non-atomic bit-fields in the same structure if all
+    members declared between them are also (non-zero-length) bit-fields, no matter what the sizes of those
+    intervening bit-fields happen to be.
+
+4   EXAMPLE        A structure declared as
+             struct {
+                   char a;
+                   int b:5, c:11, :0, d:8;
+                   struct { int ee:8; } e;
+             }
+    contains four separate memory locations: The member a, and bit-fields d and e.ee are each separate
+    memory locations, and can be modified concurrently without interfering with each other. The bit-fields b
+    and c together constitute the fourth memory location. The bit-fields b and c cannot be concurrently
+    modified, but b and a, for example, can be.
+
+<a name="3.15" href="#3.15"><b>    3.15</b></a>
+1   object
+    region of data storage in the execution environment, the contents of which can represent
+    values
+2   NOTE      When referenced, an object may be interpreted as having a particular type; see <a href="#6.3.2.1">6.3.2.1</a>.
+
+<a name="3.16" href="#3.16"><b>    3.16</b></a>
+1   parameter
+    formal parameter
+    formal argument (deprecated)
+    object declared as part of a function declaration or definition that acquires a value on
+    entry to the function, or an identifier from the comma-separated list bounded by the
+    parentheses immediately following the macro name in a function-like macro definition
+<a name="3.17" href="#3.17"><b>    3.17</b></a>
+1   recommended practice
+    specification that is strongly recommended as being in keeping with the intent of the
+    standard, but that may be impractical for some implementations
+<a name="3.18" href="#3.18"><b>    3.18</b></a>
+1   runtime-constraint
+    requirement on a program when calling a library function
+2   NOTE 1 Despite the similar terms, a runtime-constraint is not a kind of constraint as defined by <a href="#3.8">3.8</a>, and
+    need not be diagnosed at translation time.
+
+3   NOTE 2 Implementations that support the extensions in <a href="#K">annex K</a> are required to verify that the runtime-
+    constraints for a library function are not violated by the program; see <a href="#K.3.1.4">K.3.1.4</a>.
+
+[<a name="p6" href="#p6">page 6</a>] (<a href="#Contents">Contents</a>)
+
+<a name="3.19" href="#3.19"><b>    3.19</b></a>
+1   value
+    precise meaning of the contents of an object when interpreted as having a specific type
+<a name="3.19.1" href="#3.19.1"><b>    3.19.1</b></a>
+1   implementation-defined value
+    unspecified value where each implementation documents how the choice is made
+<a name="3.19.2" href="#3.19.2"><b>    3.19.2</b></a>
+1   indeterminate value
+    either an unspecified value or a trap representation
+<a name="3.19.3" href="#3.19.3"><b>    3.19.3</b></a>
+1   unspecified value
+    valid value of the relevant type where this International Standard imposes no
+    requirements on which value is chosen in any instance
+2   NOTE     An unspecified value cannot be a trap representation.
+
+<a name="3.19.4" href="#3.19.4"><b>    3.19.4</b></a>
+1   trap representation
+    an object representation that need not represent a value of the object type
+<a name="3.19.5" href="#3.19.5"><b>    3.19.5</b></a>
+1   perform a trap
+    interrupt execution of the program such that no further operations are performed
+2   NOTE In this International Standard, when the word ''trap'' is not immediately followed by
+    ''representation'', this is the intended usage.<sup><a href="#note2"><b>2)</b></a></sup>
+
+<a name="3.20" href="#3.20"><b>    3.20</b></a>
+1   [^ x^]
+    ceiling of x: the least integer greater than or equal to x
+2   EXAMPLE       [^2.4^] is 3, [^-2.4^] is -2.
+
+<a name="3.21" href="#3.21"><b>    3.21</b></a>
+1   [_ x_]
+    floor of x: the greatest integer less than or equal to x
+2   EXAMPLE       [_2.4_] is 2, [_-2.4_] is -3.
+
+
+
+
+    <sup><a name="note2" href="#note2"><b>2)</b></a></sup>   For example, ''Trapping or stopping (if supported) is disabled...'' (<a href="#F.8.2">F.8.2</a>). Note that fetching a trap
+         representation might perform a trap but is not required to (see <a href="#6.2.6.1">6.2.6.1</a>).
+
+[<a name="p7" href="#p7">page 7</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="4" href="#4"><b>    4. Conformance</b></a>
+1   In this International Standard, ''shall'' is to be interpreted as a requirement on an
+    implementation or on a program; conversely, ''shall not'' is to be interpreted as a
+    prohibition.
+2   If a ''shall'' or ''shall not'' requirement that appears outside of a constraint or runtime-
+    constraint is violated, the behavior is undefined. Undefined behavior is otherwise
+    indicated in this International Standard by the words ''undefined behavior'' or by the
+    omission of any explicit definition of behavior. There is no difference in emphasis among
+    these three; they all describe ''behavior that is undefined''.
+3   A program that is correct in all other aspects, operating on correct data, containing
+    unspecified behavior shall be a correct program and act in accordance with <a href="#5.1.2.3">5.1.2.3</a>.
+4   The implementation shall not successfully translate a preprocessing translation unit
+    containing a #error preprocessing directive unless it is part of a group skipped by
+    conditional inclusion.
+5   A strictly conforming program shall use only those features of the language and library
+    specified in this International Standard.<sup><a href="#note3"><b>3)</b></a></sup> It shall not produce output dependent on any
+    unspecified, undefined, or implementation-defined behavior, and shall not exceed any
+    minimum implementation limit.
+6   The two forms of conforming implementation are hosted and freestanding. A conforming
+    hosted implementation shall accept any strictly conforming program. A conforming
+    freestanding implementation shall accept any strictly conforming program that does not
+    use complex types and in which the use of the features specified in the library clause
+    (clause 7) is confined to the contents of the standard headers <a href="#7.7">&lt;float.h&gt;</a>,
+    <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#7.15">&lt;stdalign.h&gt;</a>, <a href="#7.16">&lt;stdarg.h&gt;</a>, <a href="#7.18">&lt;stdbool.h&gt;</a>,
+    <a href="#7.19">&lt;stddef.h&gt;</a>, and <a href="#7.20">&lt;stdint.h&gt;</a>. A conforming implementation may have extensions
+    (including additional library functions), provided they do not alter the behavior of any
+    strictly conforming program.<sup><a href="#note4"><b>4)</b></a></sup>
+
+
+
+    <sup><a name="note3" href="#note3"><b>3)</b></a></sup>   A strictly conforming program can use conditional features (see <a href="#6.10.8.3">6.10.8.3</a>) provided the use is guarded
+         by an appropriate conditional inclusion preprocessing directive using the related macro. For example:
+                 #ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
+                    /* ... */
+                    fesetround(FE_UPWARD);
+                    /* ... */
+                 #endif
+
+    <sup><a name="note4" href="#note4"><b>4)</b></a></sup>   This implies that a conforming implementation reserves no identifiers other than those explicitly
+         reserved in this International Standard.
+
+[<a name="p8" href="#p8">page 8</a>] (<a href="#Contents">Contents</a>)
+
+7   A conforming program is one that is acceptable to a conforming implementation.<sup><a href="#note5"><b>5)</b></a></sup>
+8   An implementation shall be accompanied by a document that defines all implementation-
+    defined and locale-specific characteristics and all extensions.
+    Forward references: conditional inclusion (<a href="#6.10.1">6.10.1</a>), error directive (<a href="#6.10.5">6.10.5</a>),
+    characteristics of floating types <a href="#7.7">&lt;float.h&gt;</a> (<a href="#7.7">7.7</a>), alternative spellings <a href="#7.9">&lt;iso646.h&gt;</a>
+    (<a href="#7.9">7.9</a>), sizes of integer types <a href="#7.10">&lt;limits.h&gt;</a> (<a href="#7.10">7.10</a>), alignment <a href="#7.15">&lt;stdalign.h&gt;</a> (<a href="#7.15">7.15</a>),
+    variable arguments <a href="#7.16">&lt;stdarg.h&gt;</a> (<a href="#7.16">7.16</a>), boolean type and values <a href="#7.18">&lt;stdbool.h&gt;</a>
+    (<a href="#7.18">7.18</a>), common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), integer types <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#7.20">7.20</a>).
+
+
+
+
+    <sup><a name="note5" href="#note5"><b>5)</b></a></sup>   Strictly conforming programs are intended to be maximally portable among conforming
+         implementations. Conforming programs may depend upon nonportable features of a conforming
+         implementation.
+
+[<a name="p9" href="#p9">page 9</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="5" href="#5"><b>    5. Environment</b></a>
+1   An implementation translates C source files and executes C programs in two data-
+    processing-system environments, which will be called the translation environment and
+    the execution environment in this International Standard. Their characteristics define and
+    constrain the results of executing conforming C programs constructed according to the
+    syntactic and semantic rules for conforming implementations.
+    Forward references: In this clause, only a few of many possible forward references
+    have been noted.
+<a name="5.1" href="#5.1"><b>    5.1 Conceptual models</b></a>
+<a name="5.1.1" href="#5.1.1"><b>    5.1.1 Translation environment</b></a>
+<a name="5.1.1.1" href="#5.1.1.1"><b>    5.1.1.1 Program structure</b></a>
+1   A C program need not all be translated at the same time. The text of the program is kept
+    in units called source files, (or preprocessing files) in this International Standard. A
+    source file together with all the headers and source files included via the preprocessing
+    directive #include is known as a preprocessing translation unit. After preprocessing, a
+    preprocessing translation unit is called a translation unit. Previously translated translation
+    units may be preserved individually or in libraries. The separate translation units of a
+    program communicate by (for example) calls to functions whose identifiers have external
+    linkage, manipulation of objects whose identifiers have external linkage, or manipulation
+    of data files. Translation units may be separately translated and then later linked to
+    produce an executable program.
+    Forward references: linkages of identifiers (<a href="#6.2.2">6.2.2</a>), external definitions (<a href="#6.9">6.9</a>),
+    preprocessing directives (<a href="#6.10">6.10</a>).
+<a name="5.1.1.2" href="#5.1.1.2"><b>    5.1.1.2 Translation phases</b></a>
+1   The precedence among the syntax rules of translation is specified by the following
+    phases.<sup><a href="#note6"><b>6)</b></a></sup>
+         1.   Physical source file multibyte characters are mapped, in an implementation-
+              defined manner, to the source character set (introducing new-line characters for
+              end-of-line indicators) if necessary. Trigraph sequences are replaced by
+              corresponding single-character internal representations.
+
+
+
+    <sup><a name="note6" href="#note6"><b>6)</b></a></sup>    Implementations shall behave as if these separate phases occur, even though many are typically folded
+          together in practice. Source files, translation units, and translated translation units need not
+          necessarily be stored as files, nor need there be any one-to-one correspondence between these entities
+          and any external representation. The description is conceptual only, and does not specify any
+          particular implementation.
+
+[<a name="p10" href="#p10">page 10</a>] (<a href="#Contents">Contents</a>)
+
+     2.   Each instance of a backslash character (\) immediately followed by a new-line
+          character is deleted, splicing physical source lines to form logical source lines.
+          Only the last backslash on any physical source line shall be eligible for being part
+          of such a splice. A source file that is not empty shall end in a new-line character,
+          which shall not be immediately preceded by a backslash character before any such
+          splicing takes place.
+     3.   The source file is decomposed into preprocessing tokens<sup><a href="#note7"><b>7)</b></a></sup> and sequences of
+          white-space characters (including comments). A source file shall not end in a
+          partial preprocessing token or in a partial comment. Each comment is replaced by
+          one space character. New-line characters are retained. Whether each nonempty
+          sequence of white-space characters other than new-line is retained or replaced by
+          one space character is implementation-defined.
+     4. Preprocessing directives are executed, macro invocations are expanded, and
+        _Pragma unary operator expressions are executed. If a character sequence that
+        matches the syntax of a universal character name is produced by token
+        concatenation (<a href="#6.10.3.3">6.10.3.3</a>), the behavior is undefined. A #include preprocessing
+        directive causes the named header or source file to be processed from phase 1
+        through phase 4, recursively. All preprocessing directives are then deleted.
+     5. Each source character set member and escape sequence in character constants and
+        string literals is converted to the corresponding member of the execution character
+        set; if there is no corresponding member, it is converted to an implementation-
+        defined member other than the null (wide) character.<sup><a href="#note8"><b>8)</b></a></sup>
+     6.   Adjacent string literal tokens are concatenated.
+     7. White-space characters separating tokens are no longer significant. Each
+        preprocessing token is converted into a token. The resulting tokens are
+        syntactically and semantically analyzed and translated as a translation unit.
+     8.   All external object and function references are resolved. Library components are
+          linked to satisfy external references to functions and objects not defined in the
+          current translation. All such translator output is collected into a program image
+          which contains information needed for execution in its execution environment.
+Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), lexical elements (<a href="#6.4">6.4</a>),
+preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href="#5.2.1.1">5.2.1.1</a>), external definitions (<a href="#6.9">6.9</a>).
+
+
+
+<sup><a name="note7" href="#note7"><b>7)</b></a></sup>    As described in <a href="#6.4">6.4</a>, the process of dividing a source file's characters into preprocessing tokens is
+      context-dependent. For example, see the handling of &lt; within a #include preprocessing directive.
+<sup><a name="note8" href="#note8"><b>8)</b></a></sup>    An implementation need not convert all non-corresponding source characters to the same execution
+      character.
+
+[<a name="p11" href="#p11">page 11</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.1.1.3" href="#5.1.1.3"><b>    5.1.1.3 Diagnostics</b></a>
+1   A conforming implementation shall produce at least one diagnostic message (identified in
+    an implementation-defined manner) if a preprocessing translation unit or translation unit
+    contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
+    specified as undefined or implementation-defined. Diagnostic messages need not be
+    produced in other circumstances.<sup><a href="#note9"><b>9)</b></a></sup>
+2   EXAMPLE        An implementation shall issue a diagnostic for the translation unit:
+             char i;
+             int i;
+    because in those cases where wording in this International Standard describes the behavior for a construct
+    as being both a constraint error and resulting in undefined behavior, the constraint error shall be diagnosed.
+
+<a name="5.1.2" href="#5.1.2"><b>    5.1.2 Execution environments</b></a>
+1   Two execution environments are defined: freestanding and hosted. In both cases,
+    program startup occurs when a designated C function is called by the execution
+    environment. All objects with static storage duration shall be initialized (set to their
+    initial values) before program startup. The manner and timing of such initialization are
+    otherwise unspecified. Program termination returns control to the execution
+    environment.
+    Forward references: storage durations of objects (<a href="#6.2.4">6.2.4</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+<a name="5.1.2.1" href="#5.1.2.1"><b>    5.1.2.1 Freestanding environment</b></a>
+1   In a freestanding environment (in which C program execution may take place without any
+    benefit of an operating system), the name and type of the function called at program
+    startup are implementation-defined. Any library facilities available to a freestanding
+    program, other than the minimal set required by clause 4, are implementation-defined.
+2   The effect of program termination in a freestanding environment is implementation-
+    defined.
+<a name="5.1.2.2" href="#5.1.2.2"><b>    5.1.2.2 Hosted environment</b></a>
+1   A hosted environment need not be provided, but shall conform to the following
+    specifications if present.
+
+
+
+
+    <sup><a name="note9" href="#note9"><b>9)</b></a></sup>   The intent is that an implementation should identify the nature of, and where possible localize, each
+         violation. Of course, an implementation is free to produce any number of diagnostics as long as a
+         valid program is still correctly translated. It may also successfully translate an invalid program.
+
+[<a name="p12" href="#p12">page 12</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.1.2.2.1" href="#5.1.2.2.1"><b>    5.1.2.2.1 Program startup</b></a>
+1   The function called at program startup is named main. The implementation declares no
+    prototype for this function. It shall be defined with a return type of int and with no
+    parameters:
+            int main(void) { /* ... */ }
+    or with two parameters (referred to here as argc and argv, though any names may be
+    used, as they are local to the function in which they are declared):
+            int main(int argc, char *argv[]) { /* ... */ }
+    or equivalent;<sup><a href="#note10"><b>10)</b></a></sup> or in some other implementation-defined manner.
+2   If they are declared, the parameters to the main function shall obey the following
+    constraints:
+    -- The value of argc shall be nonnegative.
+    -- argv[argc] shall be a null pointer.
+    -- If the value of argc is greater than zero, the array members argv[0] through
+      argv[argc-1] inclusive shall contain pointers to strings, which are given
+      implementation-defined values by the host environment prior to program startup. The
+      intent is to supply to the program information determined prior to program startup
+      from elsewhere in the hosted environment. If the host environment is not capable of
+      supplying strings with letters in both uppercase and lowercase, the implementation
+      shall ensure that the strings are received in lowercase.
+    -- If the value of argc is greater than zero, the string pointed to by argv[0]
+      represents the program name; argv[0][0] shall be the null character if the
+      program name is not available from the host environment. If the value of argc is
+      greater than one, the strings pointed to by argv[1] through argv[argc-1]
+      represent the program parameters.
+    -- The parameters argc and argv and the strings pointed to by the argv array shall
+      be modifiable by the program, and retain their last-stored values between program
+      startup and program termination.
+<a name="5.1.2.2.2" href="#5.1.2.2.2"><b>    5.1.2.2.2 Program execution</b></a>
+1   In a hosted environment, a program may use all the functions, macros, type definitions,
+    and objects described in the library clause (clause 7).
+
+
+
+
+    <sup><a name="note10" href="#note10"><b>10)</b></a></sup> Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
+        char ** argv, and so on.
+
+[<a name="p13" href="#p13">page 13</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.1.2.2.3" href="#5.1.2.2.3"><b>    5.1.2.2.3 Program termination</b></a>
+1   If the return type of the main function is a type compatible with int, a return from the
+    initial call to the main function is equivalent to calling the exit function with the value
+    returned by the main function as its argument;<sup><a href="#note11"><b>11)</b></a></sup> reaching the } that terminates the
+    main function returns a value of 0. If the return type is not compatible with int, the
+    termination status returned to the host environment is unspecified.
+    Forward references: definition of terms (<a href="#7.1.1">7.1.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>).
+<a name="5.1.2.3" href="#5.1.2.3"><b>    5.1.2.3 Program execution</b></a>
+1   The semantic descriptions in this International Standard describe the behavior of an
+    abstract machine in which issues of optimization are irrelevant.
+2   Accessing a volatile object, modifying an object, modifying a file, or calling a function
+    that does any of those operations are all side effects,<sup><a href="#note12"><b>12)</b></a></sup> which are changes in the state of
+    the execution environment. Evaluation of an expression in general includes both value
+    computations and initiation of side effects. Value computation for an lvalue expression
+    includes determining the identity of the designated object.
+3   Sequenced before is an asymmetric, transitive, pair-wise relation between evaluations
+    executed by a single thread, which induces a partial order among those evaluations.
+    Given any two evaluations A and B, if A is sequenced before B, then the execution of A
+    shall precede the execution of B. (Conversely, if A is sequenced before B, then B is
+    sequenced after A.) If A is not sequenced before or after B, then A and B are
+    unsequenced. Evaluations A and B are indeterminately sequenced when A is sequenced
+    either before or after B, but it is unspecified which.<sup><a href="#note13"><b>13)</b></a></sup> The presence of a sequence point
+    between the evaluation of expressions A and B implies that every value computation and
+    side effect associated with A is sequenced before every value computation and side effect
+    associated with B. (A summary of the sequence points is given in <a href="#C">annex C</a>.)
+4   In the abstract machine, all expressions are evaluated as specified by the semantics. An
+    actual implementation need not evaluate part of an expression if it can deduce that its
+    value is not used and that no needed side effects are produced (including any caused by
+
+    <sup><a name="note11" href="#note11"><b>11)</b></a></sup> In accordance with <a href="#6.2.4">6.2.4</a>, the lifetimes of objects with automatic storage duration declared in main
+        will have ended in the former case, even where they would not have in the latter.
+    <sup><a name="note12" href="#note12"><b>12)</b></a></sup> The IEC 60559 standard for binary floating-point arithmetic requires certain user-accessible status
+        flags and control modes. Floating-point operations implicitly set the status flags; modes affect result
+        values of floating-point operations. Implementations that support such floating-point state are
+        required to regard changes to it as side effects -- see <a href="#F">annex F</a> for details. The floating-point
+        environment library <a href="#7.6">&lt;fenv.h&gt;</a> provides a programming facility for indicating when these side
+        effects matter, freeing the implementations in other cases.
+    <sup><a name="note13" href="#note13"><b>13)</b></a></sup> The executions of unsequenced evaluations can interleave. Indeterminately sequenced evaluations
+        cannot interleave, but can be executed in any order.
+
+[<a name="p14" href="#p14">page 14</a>] (<a href="#Contents">Contents</a>)
+
+     calling a function or accessing a volatile object).
+5    When the processing of the abstract machine is interrupted by receipt of a signal, the
+     values of objects that are neither lock-free atomic objects nor of type volatile
+     sig_atomic_t are unspecified, and the value of any object that is modified by the
+     handler that is neither a lock-free atomic object nor of type volatile
+     sig_atomic_t becomes undefined.
+6    The least requirements on a conforming implementation are:
+     -- Accesses to volatile objects are evaluated strictly according to the rules of the abstract
+       machine.
+     -- At program termination, all data written into files shall be identical to the result that
+       execution of the program according to the abstract semantics would have produced.
+     -- The input and output dynamics of interactive devices shall take place as specified in
+<a name="7.21.3" href="#7.21.3"><b>       7.21.3. The intent of these requirements is that unbuffered or line-buffered output</b></a>
+       appear as soon as possible, to ensure that prompting messages actually appear prior to
+       a program waiting for input.
+     This is the observable behavior of the program.
+7    What constitutes an interactive device is implementation-defined.
+8    More stringent correspondences between abstract and actual semantics may be defined by
+     each implementation.
+9    EXAMPLE 1 An implementation might define a one-to-one correspondence between abstract and actual
+     semantics: at every sequence point, the values of the actual objects would agree with those specified by the
+     abstract semantics. The keyword volatile would then be redundant.
+10   Alternatively, an implementation might perform various optimizations within each translation unit, such
+     that the actual semantics would agree with the abstract semantics only when making function calls across
+     translation unit boundaries. In such an implementation, at the time of each function entry and function
+     return where the calling function and the called function are in different translation units, the values of all
+     externally linked objects and of all objects accessible via pointers therein would agree with the abstract
+     semantics. Furthermore, at the time of each such function entry the values of the parameters of the called
+     function and of all objects accessible via pointers therein would agree with the abstract semantics. In this
+     type of implementation, objects referred to by interrupt service routines activated by the signal function
+     would require explicit specification of volatile storage, as well as other implementation-defined
+     restrictions.
+
+11   EXAMPLE 2       In executing the fragment
+              char c1, c2;
+              /* ... */
+              c1 = c1 + c2;
+     the ''integer promotions'' require that the abstract machine promote the value of each variable to int size
+     and then add the two ints and truncate the sum. Provided the addition of two chars can be done without
+     overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
+     produce the same result, possibly omitting the promotions.
+
+[<a name="p15" href="#p15">page 15</a>] (<a href="#Contents">Contents</a>)
+
+12   EXAMPLE 3       Similarly, in the fragment
+              float f1, f2;
+              double d;
+              /* ... */
+              f1 = f2 * d;
+     the multiplication may be executed using single-precision arithmetic if the implementation can ascertain
+     that the result would be the same as if it were executed using double-precision arithmetic (for example, if d
+     were replaced by the constant 2.0, which has type double).
+
+13   EXAMPLE 4 Implementations employing wide registers have to take care to honor appropriate
+     semantics. Values are independent of whether they are represented in a register or in memory. For
+     example, an implicit spilling of a register is not permitted to alter the value. Also, an explicit store and load
+     is required to round to the precision of the storage type. In particular, casts and assignments are required to
+     perform their specified conversion. For the fragment
+              double d1, d2;
+              float f;
+              d1 = f = expression;
+              d2 = (float) expression;
+     the values assigned to d1 and d2 are required to have been converted to float.
+
+14   EXAMPLE 5 Rearrangement for floating-point expressions is often restricted because of limitations in
+     precision as well as range. The implementation cannot generally apply the mathematical associative rules
+     for addition or multiplication, nor the distributive rule, because of roundoff error, even in the absence of
+     overflow and underflow. Likewise, implementations cannot generally replace decimal constants in order to
+     rearrange expressions. In the following fragment, rearrangements suggested by mathematical rules for real
+     numbers are often not valid (see <a href="#F.9">F.9</a>).
+              double x, y, z;
+              /* ... */
+              x = (x * y) * z;            //   not equivalent to x   *= y * z;
+              z = (x - y) + y ;           //   not equivalent to z   = x;
+              z = x + x * y;              //   not equivalent to z   = x * (1.0 + y);
+              y = x / 5.0;                //   not equivalent to y   = x * 0.2;
+
+15   EXAMPLE 6       To illustrate the grouping behavior of expressions, in the following fragment
+              int a, b;
+              /* ... */
+              a = a + 32760 + b + 5;
+     the expression statement behaves exactly the same as
+              a = (((a + 32760) + b) + 5);
+     due to the associativity and precedence of these operators. Thus, the result of the sum (a + 32760) is
+     next added to b, and that result is then added to 5 which results in the value assigned to a. On a machine in
+     which overflows produce an explicit trap and in which the range of values representable by an int is
+     [-32768, +32767], the implementation cannot rewrite this expression as
+              a = ((a + b) + 32765);
+     since if the values for a and b were, respectively, -32754 and -15, the sum a + b would produce a trap
+     while the original expression would not; nor can the expression be rewritten either as
+
+[<a name="p16" href="#p16">page 16</a>] (<a href="#Contents">Contents</a>)
+
+              a = ((a + 32765) + b);
+     or
+              a = (a + (b + 32765));
+     since the values for a and b might have been, respectively, 4 and -8 or -17 and 12. However, on a machine
+     in which overflow silently generates some value and where positive and negative overflows cancel, the
+     above expression statement can be rewritten by the implementation in any of the above ways because the
+     same result will occur.
+
+16   EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the
+     following fragment
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              int sum;
+              char *p;
+              /* ... */
+              sum = sum * 10 - '0' + (*p++ = getchar());
+     the expression statement is grouped as if it were written as
+              sum = (((sum * 10) - '0') + ((*(p++)) = (getchar())));
+     but the actual increment of p can occur at any time between the previous sequence point and the next
+     sequence point (the ;), and the call to getchar can occur at any point prior to the need of its returned
+     value.
+
+     Forward references: expressions (<a href="#6.5">6.5</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>), statements (<a href="#6.8">6.8</a>), the
+     signal function (<a href="#7.14">7.14</a>), files (<a href="#7.21.3">7.21.3</a>).
+<a name="5.1.2.4" href="#5.1.2.4"><b>     5.1.2.4 Multi-threaded executions and data races</b></a>
+1    Under a hosted implementation, a program can have more than one thread of execution
+     (or thread) running concurrently. The execution of each thread proceeds as defined by
+     the remainder of this standard. The execution of the entire program consists of an
+     execution of all of its threads.<sup><a href="#note14"><b>14)</b></a></sup> Under a freestanding implementation, it is
+     implementation-defined whether a program can have more than one thread of execution.
+2    The value of an object visible to a thread T at a particular point is the initial value of the
+     object, a value stored in the object by T , or a value stored in the object by another thread,
+     according to the rules below.
+3    NOTE 1 In some cases, there may instead be undefined behavior. Much of this section is motivated by
+     the desire to support atomic operations with explicit and detailed visibility constraints. However, it also
+     implicitly supports a simpler view for more restricted programs.
+
+4    Two expression evaluations conflict if one of them modifies a memory location and the
+     other one reads or modifies the same memory location.
+
+
+
+
+     <sup><a name="note14" href="#note14"><b>14)</b></a></sup> The execution can usually be viewed as an interleaving of all of the threads. However, some kinds of
+         atomic operations, for example, allow executions inconsistent with a simple interleaving as described
+         below.
+
+[<a name="p17" href="#p17">page 17</a>] (<a href="#Contents">Contents</a>)
+
+5    The library defines a number of atomic operations (<a href="#7.17">7.17</a>) and operations on mutexes
+     (<a href="#7.25.4">7.25.4</a>) that are specially identified as synchronization operations. These operations play
+     a special role in making assignments in one thread visible to another. A synchronization
+     operation on one or more memory locations is either an acquire operation, a release
+     operation, both an acquire and release operation, or a consume operation. A
+     synchronization operation without an associated memory location is a fence and can be
+     either an acquire fence, a release fence, or both an acquire and release fence. In addition,
+     there are relaxed atomic operations, which are not synchronization operations, and
+     atomic read-modify-write operations, which have special characteristics.
+6    NOTE 2 For example, a call that acquires a mutex will perform an acquire operation on the locations
+     composing the mutex. Correspondingly, a call that releases the same mutex will perform a release
+     operation on those same locations. Informally, performing a release operation on A forces prior side effects
+     on other memory locations to become visible to other threads that later perform an acquire or consume
+     operation on A. We do not include relaxed atomic operations as synchronization operations although, like
+     synchronization operations, they cannot contribute to data races.
+
+7    All modifications to a particular atomic object M occur in some particular total order,
+     called the modification order of M. If A and B are modifications of an atomic object M,
+     and A happens before B, then A shall precede B in the modification order of M, which is
+     defined below.
+8    NOTE 3     This states that the modification orders must respect the ''happens before'' relation.
+
+9    NOTE 4 There is a separate order for each atomic object. There is no requirement that these can be
+     combined into a single total order for all objects. In general this will be impossible since different threads
+     may observe modifications to different variables in inconsistent orders.
+
+10   A release sequence on an atomic object M is a maximal contiguous sub-sequence of side
+     effects in the modification order of M, where the first operation is a release and every
+     subsequent operation either is performed by the same thread that performed the release or
+     is an atomic read-modify-write operation.
+11   Certain library calls synchronize with other library calls performed by another thread. In
+     particular, an atomic operation A that performs a release operation on an object M
+     synchronizes with an atomic operation B that performs an acquire operation on M and
+     reads a value written by any side effect in the release sequence headed by A.
+12   NOTE 5 Except in the specified cases, reading a later value does not necessarily ensure visibility as
+     described below. Such a requirement would sometimes interfere with efficient implementation.
+
+13   NOTE 6 The specifications of the synchronization operations define when one reads the value written by
+     another. For atomic variables, the definition is clear. All operations on a given mutex occur in a single total
+     order. Each mutex acquisition ''reads the value written'' by the last mutex release.
+
+14   An evaluation A carries a dependency <sup><a href="#note15"><b>15)</b></a></sup> to an evaluation B if:
+
+
+     <sup><a name="note15" href="#note15"><b>15)</b></a></sup> The ''carries a dependency'' relation is a subset of the ''sequenced before'' relation, and is similarly
+         strictly intra-thread.
+
+[<a name="p18" href="#p18">page 18</a>] (<a href="#Contents">Contents</a>)
+
+     -- the value of A is used as an operand of B, unless:
+           o B is an invocation of the kill_dependency macro,
+
+           o A is the left operand of a &amp;&amp; or || operator,
+
+           o A is the left operand of a ? : operator, or
+
+           o A is the left operand of a , operator;
+         or
+     -- A writes a scalar object or bit-field M, B reads from M the value written by A, and A
+       is sequenced before B, or
+     -- for some evaluation X, A carries a dependency to X and X carries a dependency to B.
+15   An evaluation A is dependency-ordered before<sup><a href="#note16"><b>16)</b></a></sup> an evaluation B if:
+     -- A performs a release operation on an atomic object M, and B performs a consume
+       operation on M and reads a value written by any side effect in the release sequence
+       headed by A, or
+     -- for some evaluation X, A is dependency-ordered before X and X carries a
+       dependency to B.
+16   An evaluation A inter-thread happens before an evaluation B if A synchronizes with B, A
+     is dependency-ordered before B, or, for some evaluation X:
+     -- A synchronizes with X and X is sequenced before B,
+     -- A is sequenced before X and X inter-thread happens before B, or
+     -- A inter-thread happens before X and X inter-thread happens before B.
+17   NOTE 7 The ''inter-thread happens before'' relation describes arbitrary concatenations of ''sequenced
+     before'', ''synchronizes with'', and ''dependency-ordered before'' relationships, with two exceptions. The
+     first exception is that a concatenation is not permitted to end with ''dependency-ordered before'' followed
+     by ''sequenced before''. The reason for this limitation is that a consume operation participating in a
+     ''dependency-ordered before'' relationship provides ordering only with respect to operations to which this
+     consume operation actually carries a dependency. The reason that this limitation applies only to the end of
+     such a concatenation is that any subsequent release operation will provide the required ordering for a prior
+     consume operation. The second exception is that a concatenation is not permitted to consist entirely of
+     ''sequenced before''. The reasons for this limitation are (1) to permit ''inter-thread happens before'' to be
+     transitively closed and (2) the ''happens before'' relation, defined below, provides for relationships
+     consisting entirely of ''sequenced before''.
+
+18   An evaluation A happens before an evaluation B if A is sequenced before B or A inter-
+     thread happens before B.
+
+
+
+     <sup><a name="note16" href="#note16"><b>16)</b></a></sup> The ''dependency-ordered before'' relation is analogous to the ''synchronizes with'' relation, but uses
+         release/consume in place of release/acquire.
+
+[<a name="p19" href="#p19">page 19</a>] (<a href="#Contents">Contents</a>)
+
+19   A visible side effect A on an object M with respect to a value computation B of M
+     satisfies the conditions:
+     -- A happens before B, and
+     -- there is no other side effect X to M such that A happens before X and X happens
+         before B.
+     The value of a non-atomic scalar object M, as determined by evaluation B, shall be the
+     value stored by the visible side effect A.
+20   NOTE 8 If there is ambiguity about which side effect to a non-atomic object is visible, then there is a data
+     race and the behavior is undefined.
+
+21   NOTE 9 This states that operations on ordinary variables are not visibly reordered. This is not actually
+     detectable without data races, but it is necessary to ensure that data races, as defined here, and with suitable
+     restrictions on the use of atomics, correspond to data races in a simple interleaved (sequentially consistent)
+     execution.
+
+22   The visible sequence of side effects on an atomic object M, with respect to a value
+     computation B of M, is a maximal contiguous sub-sequence of side effects in the
+     modification order of M, where the first side effect is visible with respect to B, and for
+     every subsequent side effect, it is not the case that B happens before it. The value of an
+     atomic object M, as determined by evaluation B, shall be the value stored by some
+     operation in the visible sequence of M with respect to B. Furthermore, if a value
+     computation A of an atomic object M happens before a value computation B of M, and
+     the value computed by A corresponds to the value stored by side effect X, then the value
+     computed by B shall either equal the value computed by A, or be the value stored by side
+     effect Y , where Y follows X in the modification order of M.
+23   NOTE 10 This effectively disallows compiler reordering of atomic operations to a single object, even if
+     both operations are ''relaxed'' loads. By doing so, we effectively make the ''cache coherence'' guarantee
+     provided by most hardware available to C atomic operations.
+
+24   NOTE 11 The visible sequence depends on the ''happens before'' relation, which in turn depends on the
+     values observed by loads of atomics, which we are restricting here. The intended reading is that there must
+     exist an association of atomic loads with modifications they observe that, together with suitably chosen
+     modification orders and the ''happens before'' relation derived as described above, satisfy the resulting
+     constraints as imposed here.
+
+25   The execution of a program contains a data race if it contains two conflicting actions in
+     different threads, at least one of which is not atomic, and neither happens before the
+     other. Any such data race results in undefined behavior.
+26   NOTE 12 It can be shown that programs that correctly use simple mutexes and
+     memory_order_seq_cst operations to prevent all data races, and use no other synchronization
+     operations, behave as though the operations executed by their constituent threads were simply interleaved,
+     with each value computation of an object being the last value stored in that interleaving. This is normally
+     referred to as ''sequential consistency''. However, this applies only to data-race-free programs, and data-
+     race-free programs cannot observe most program transformations that do not change single-threaded
+     program semantics. In fact, most single-threaded program transformations continue to be allowed, since
+     any program that behaves differently as a result must contain undefined behavior.
+
+[<a name="p20" href="#p20">page 20</a>] (<a href="#Contents">Contents</a>)
+
+27   NOTE 13 Compiler transformations that introduce assignments to a potentially shared memory location
+     that would not be modified by the abstract machine are generally precluded by this standard, since such an
+     assignment might overwrite another assignment by a different thread in cases in which an abstract machine
+     execution would not have encountered a data race. This includes implementations of data member
+     assignment that overwrite adjacent members in separate memory locations. We also generally preclude
+     reordering of atomic loads in cases in which the atomics in question may alias, since this may violate the
+     "visible sequence" rules.
+
+28   NOTE 14 Transformations that introduce a speculative read of a potentially shared memory location may
+     not preserve the semantics of the program as defined in this standard, since they potentially introduce a data
+     race. However, they are typically valid in the context of an optimizing compiler that targets a specific
+     machine with well-defined semantics for data races. They would be invalid for a hypothetical machine that
+     is not tolerant of races or provides hardware race detection.
+
+[<a name="p21" href="#p21">page 21</a>] (<a href="#Contents">Contents</a>)
+
+<a name="5.2" href="#5.2"><b>    5.2 Environmental considerations</b></a>
+<a name="5.2.1" href="#5.2.1"><b>    5.2.1 Character sets</b></a>
+1   Two sets of characters and their associated collating sequences shall be defined: the set in
+    which source files are written (the source character set), and the set interpreted in the
+    execution environment (the execution character set). Each set is further divided into a
+    basic character set, whose contents are given by this subclause, and a set of zero or more
+    locale-specific members (which are not members of the basic character set) called
+    extended characters. The combined set is also called the extended character set. The
+    values of the members of the execution character set are implementation-defined.
+2   In a character constant or string literal, members of the execution character set shall be
+    represented by corresponding members of the source character set or by escape
+    sequences consisting of the backslash \ followed by one or more characters. A byte with
+    all bits set to 0, called the null character, shall exist in the basic execution character set; it
+    is used to terminate a character string.
+3   Both the basic source and basic execution character sets shall have the following
+    members: the 26 uppercase letters of the Latin alphabet
+            A    B   C      D   E   F    G    H    I    J    K    L   M
+            N    O   P      Q   R   S    T    U    V    W    X    Y   Z
+    the 26 lowercase letters of the Latin alphabet
+            a    b   c      d   e   f    g    h    i    j    k    l   m
+            n    o   p      q   r   s    t    u    v    w    x    y   z
+    the 10 decimal digits
+            0    1   2      3   4   5    6    7    8    9
+    the following 29 graphic characters
+            !    "   #      %   &amp;   '    (    )    *    +    ,    -   .    /    :
+            ;    &lt;   =      &gt;   ?   [    \    ]    ^    _    {    |   }    ~
+    the space character, and control characters representing horizontal tab, vertical tab, and
+    form feed. The representation of each member of the source and execution basic
+    character sets shall fit in a byte. In both the source and execution basic character sets, the
+    value of each character after 0 in the above list of decimal digits shall be one greater than
+    the value of the previous. In source files, there shall be some way of indicating the end of
+    each line of text; this International Standard treats such an end-of-line indicator as if it
+    were a single new-line character. In the basic execution character set, there shall be
+    control characters representing alert, backspace, carriage return, and new line. If any
+    other characters are encountered in a source file (except in an identifier, a character
+    constant, a string literal, a header name, a comment, or a preprocessing token that is never
+
+[<a name="p22" href="#p22">page 22</a>] (<a href="#Contents">Contents</a>)
+
+    converted to a token), the behavior is undefined.
+4   A letter is an uppercase letter or a lowercase letter as defined above; in this International
+    Standard the term does not include other characters that are letters in other alphabets.
+5   The universal character name construct provides a way to name other characters.
+    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), character constants (<a href="#6.4.4.4">6.4.4.4</a>),
+    preprocessing directives (<a href="#6.10">6.10</a>), string literals (<a href="#6.4.5">6.4.5</a>), comments (<a href="#6.4.9">6.4.9</a>), string (<a href="#7.1.1">7.1.1</a>).
+<a name="5.2.1.1" href="#5.2.1.1"><b>    5.2.1.1 Trigraph sequences</b></a>
+1   Before any other processing takes place, each occurrence of one of the following
+    sequences of three characters (called trigraph sequences<sup><a href="#note17"><b>17)</b></a></sup>) is replaced with the
+    corresponding single character.
+           ??=      #                       ??)      ]                       ??!     |
+           ??(      [                       ??'      ^                       ??&gt;     }
+           ??/      \                       ??&lt;      {                       ??-     ~
+    No other trigraph sequences exist. Each ? that does not begin one of the trigraphs listed
+    above is not changed.
+2   EXAMPLE 1
+              ??=define arraycheck(a, b) a??(b??) ??!??! b??(a??)
+    becomes
+              #define arraycheck(a, b) a[b] || b[a]
+
+3   EXAMPLE 2      The following source line
+              printf("Eh???/n");
+    becomes (after replacement of the trigraph sequence ??/)
+              printf("Eh?\n");
+
+<a name="5.2.1.2" href="#5.2.1.2"><b>    5.2.1.2 Multibyte characters</b></a>
+1   The source character set may contain multibyte characters, used to represent members of
+    the extended character set. The execution character set may also contain multibyte
+    characters, which need not have the same encoding as for the source character set. For
+    both character sets, the following shall hold:
+    -- The basic character set shall be present and each character shall be encoded as a
+      single byte.
+    -- The presence, meaning, and representation of any additional members is locale-
+      specific.
+
+    <sup><a name="note17" href="#note17"><b>17)</b></a></sup> The trigraph sequences enable the input of characters that are not defined in the Invariant Code Set as
+        described in ISO/IEC 646, which is a subset of the seven-bit US ASCII code set.
+
+[<a name="p23" href="#p23">page 23</a>] (<a href="#Contents">Contents</a>)
+
+    -- A multibyte character set may have a state-dependent encoding, wherein each
+      sequence of multibyte characters begins in an initial shift state and enters other
+      locale-specific shift states when specific multibyte characters are encountered in the
+      sequence. While in the initial shift state, all single-byte characters retain their usual
+      interpretation and do not alter the shift state. The interpretation for subsequent bytes
+      in the sequence is a function of the current shift state.
+    -- A byte with all bits zero shall be interpreted as a null character independent of shift
+      state. Such a byte shall not occur as part of any other multibyte character.
+2   For source files, the following shall hold:
+    -- An identifier, comment, string literal, character constant, or header name shall begin
+      and end in the initial shift state.
+    -- An identifier, comment, string literal, character constant, or header name shall consist
+      of a sequence of valid multibyte characters.
+<a name="5.2.2" href="#5.2.2"><b>    5.2.2 Character display semantics</b></a>
+1   The active position is that location on a display device where the next character output by
+    the fputc function would appear. The intent of writing a printing character (as defined
+    by the isprint function) to a display device is to display a graphic representation of
+    that character at the active position and then advance the active position to the next
+    position on the current line. The direction of writing is locale-specific. If the active
+    position is at the final position of a line (if there is one), the behavior of the display device
+    is unspecified.
+2   Alphabetic escape sequences representing nongraphic characters in the execution
+    character set are intended to produce actions on display devices as follows:
+    \a (alert) Produces an audible or visible alert without changing the active position.
+    \b (backspace) Moves the active position to the previous position on the current line. If
+       the active position is at the initial position of a line, the behavior of the display
+       device is unspecified.
+    \f ( form feed) Moves the active position to the initial position at the start of the next
+       logical page.
+    \n (new line) Moves the active position to the initial position of the next line.
+    \r (carriage return) Moves the active position to the initial position of the current line.
+    \t (horizontal tab) Moves the active position to the next horizontal tabulation position
+       on the current line. If the active position is at or past the last defined horizontal
+       tabulation position, the behavior of the display device is unspecified.
+    \v (vertical tab) Moves the active position to the initial position of the next vertical
+       tabulation position. If the active position is at or past the last defined vertical
+
+[<a name="p24" href="#p24">page 24</a>] (<a href="#Contents">Contents</a>)
+
+         tabulation position, the behavior of the display device is unspecified.
+3   Each of these escape sequences shall produce a unique implementation-defined value
+    which can be stored in a single char object. The external representations in a text file
+    need not be identical to the internal representations, and are outside the scope of this
+    International Standard.
+    Forward references: the isprint function (<a href="#7.4.1.8">7.4.1.8</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>).
+<a name="5.2.3" href="#5.2.3"><b>    5.2.3 Signals and interrupts</b></a>
+1   Functions shall be implemented such that they may be interrupted at any time by a signal,
+    or may be called by a signal handler, or both, with no alteration to earlier, but still active,
+    invocations' control flow (after the interruption), function return values, or objects with
+    automatic storage duration. All such objects shall be maintained outside the function
+    image (the instructions that compose the executable representation of a function) on a
+    per-invocation basis.
+<a name="5.2.4" href="#5.2.4"><b>    5.2.4 Environmental limits</b></a>
+1   Both the translation and execution environments constrain the implementation of
+    language translators and libraries. The following summarizes the language-related
+    environmental limits on a conforming implementation; the library-related limits are
+    discussed in clause 7.
+<a name="5.2.4.1" href="#5.2.4.1"><b>    5.2.4.1 Translation limits</b></a>
+1   The implementation shall be able to translate and execute at least one program that
+    contains at least one instance of every one of the following limits:<sup><a href="#note18"><b>18)</b></a></sup>
+    -- 127 nesting levels of blocks
+    -- 63 nesting levels of conditional inclusion
+    -- 12 pointer, array, and function declarators (in any combinations) modifying an
+      arithmetic, structure, union, or void type in a declaration
+    -- 63 nesting levels of parenthesized declarators within a full declarator
+    -- 63 nesting levels of parenthesized expressions within a full expression
+    -- 63 significant initial characters in an internal identifier or a macro name (each
+      universal character name or extended source character is considered a single
+      character)
+    -- 31 significant initial characters in an external identifier (each universal character name
+      specifying a short identifier of 0000FFFF or less is considered 6 characters, each
+
+
+    <sup><a name="note18" href="#note18"><b>18)</b></a></sup> Implementations should avoid imposing fixed translation limits whenever possible.
+
+[<a name="p25" href="#p25">page 25</a>] (<a href="#Contents">Contents</a>)
+
+         universal character name specifying a short identifier of 00010000 or more is
+         considered 10 characters, and each extended source character is considered the same
+         number of characters as the corresponding universal character name, if any)<sup><a href="#note19"><b>19)</b></a></sup>
+    -- 4095 external identifiers in one translation unit
+    -- 511 identifiers with block scope declared in one block
+    -- 4095 macro identifiers simultaneously defined in one preprocessing translation unit
+    -- 127 parameters in one function definition
+    -- 127 arguments in one function call
+    -- 127 parameters in one macro definition
+    -- 127 arguments in one macro invocation
+    -- 4095 characters in a logical source line
+    -- 4095 characters in a string literal (after concatenation)
+    -- 65535 bytes in an object (in a hosted environment only)
+    -- 15 nesting levels for #included files
+    -- 1023 case labels for a switch statement (excluding those for any nested switch
+      statements)
+    -- 1023 members in a single structure or union
+    -- 1023 enumeration constants in a single enumeration
+    -- 63 levels of nested structure or union definitions in a single struct-declaration-list
+<a name="5.2.4.2" href="#5.2.4.2"><b>    5.2.4.2 Numerical limits</b></a>
+1   An implementation is required to document all the limits specified in this subclause,
+    which are specified in the headers <a href="#7.10">&lt;limits.h&gt;</a> and <a href="#7.7">&lt;float.h&gt;</a>. Additional limits are
+    specified in <a href="#7.20">&lt;stdint.h&gt;</a>.
+    Forward references: integer types <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#7.20">7.20</a>).
+<a name="5.2.4.2.1" href="#5.2.4.2.1"><b>    5.2.4.2.1 Sizes of integer types &lt;limits.h&gt;</b></a>
+1   The values given below shall be replaced by constant expressions suitable for use in #if
+    preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX, the
+    following shall be replaced by expressions that have the same type as would an
+    expression that is an object of the corresponding type converted according to the integer
+    promotions. Their implementation-defined values shall be equal or greater in magnitude
+
+
+    <sup><a name="note19" href="#note19"><b>19)</b></a></sup> See ''future language directions'' (<a href="#6.11.3">6.11.3</a>).
+
+[<a name="p26" href="#p26">page 26</a>] (<a href="#Contents">Contents</a>)
+
+(absolute value) to those shown, with the same sign.
+-- number of bits for smallest object that is not a bit-field (byte)
+  CHAR_BIT                                            8
+-- minimum value for an object of type signed char
+  SCHAR_MIN                                -127 // -(27 - 1)
+-- maximum value for an object of type signed char
+  SCHAR_MAX                                +127 // 27 - 1
+-- maximum value for an object of type unsigned char
+  UCHAR_MAX                                 255 // 28 - 1
+-- minimum value for an object of type char
+  CHAR_MIN                               see below
+-- maximum value for an object of type char
+  CHAR_MAX                              see below
+-- maximum number of bytes in a multibyte character, for any supported locale
+  MB_LEN_MAX                                    1
+-- minimum value for an object of type short int
+  SHRT_MIN                               -32767 // -(215 - 1)
+-- maximum value for an object of type short int
+  SHRT_MAX                               +32767 // 215 - 1
+-- maximum value for an object of type unsigned short int
+  USHRT_MAX                               65535 // 216 - 1
+-- minimum value for an object of type int
+  INT_MIN                                 -32767 // -(215 - 1)
+-- maximum value for an object of type int
+  INT_MAX                                +32767 // 215 - 1
+-- maximum value for an object of type unsigned int
+  UINT_MAX                                65535 // 216 - 1
+-- minimum value for an object of type long int
+  LONG_MIN                         -2147483647 // -(231 - 1)
+-- maximum value for an object of type long int
+  LONG_MAX                         +2147483647 // 231 - 1
+-- maximum value for an object of type unsigned long int
+  ULONG_MAX                         4294967295 // 232 - 1
+
+[<a name="p27" href="#p27">page 27</a>] (<a href="#Contents">Contents</a>)
+
+    -- minimum value for an object of type long long int
+      LLONG_MIN          -9223372036854775807 // -(263 - 1)
+    -- maximum value for an object of type long long int
+      LLONG_MAX          +9223372036854775807 // 263 - 1
+    -- maximum value for an object of type unsigned long long int
+      ULLONG_MAX         18446744073709551615 // 264 - 1
+2   If the value of an object of type char is treated as a signed integer when used in an
+    expression, the value of CHAR_MIN shall be the same as that of SCHAR_MIN and the
+    value of CHAR_MAX shall be the same as that of SCHAR_MAX. Otherwise, the value of
+    CHAR_MIN shall be 0 and the value of CHAR_MAX shall be the same as that of
+    UCHAR_MAX.<sup><a href="#note20"><b>20)</b></a></sup> The value UCHAR_MAX shall equal 2CHAR_BIT - 1.
+    Forward references: representations of types (<a href="#6.2.6">6.2.6</a>), conditional inclusion (<a href="#6.10.1">6.10.1</a>).
+<a name="5.2.4.2.2" href="#5.2.4.2.2"><b>    5.2.4.2.2 Characteristics of floating types &lt;float.h&gt;</b></a>
+1   The characteristics of floating types are defined in terms of a model that describes a
+    representation of floating-point numbers and values that provide information about an
+    implementation's floating-point arithmetic.<sup><a href="#note21"><b>21)</b></a></sup> The following parameters are used to
+    define the model for each floating-point type:
+           s          sign ((+-)1)
+           b          base or radix of exponent representation (an integer &gt; 1)
+           e          exponent (an integer between a minimum emin and a maximum emax )
+           p          precision (the number of base-b digits in the significand)
+            fk        nonnegative integers less than b (the significand digits)
+2   A floating-point number (x) is defined by the following model:
+                       p
+           x = sb e   (Sum) f k b-k ,
+                      k=1
+                                    emin &lt;= e &lt;= emax
+
+3   In addition to normalized floating-point numbers ( f 1 &gt; 0 if x != 0), floating types may be
+    able to contain other kinds of floating-point numbers, such as subnormal floating-point
+    numbers (x != 0, e = emin , f 1 = 0) and unnormalized floating-point numbers (x != 0,
+    e &gt; emin , f 1 = 0), and values that are not floating-point numbers, such as infinities and
+    NaNs. A NaN is an encoding signifying Not-a-Number. A quiet NaN propagates
+    through almost every arithmetic operation without raising a floating-point exception; a
+    signaling NaN generally raises a floating-point exception when occurring as an
+
+
+    <sup><a name="note20" href="#note20"><b>20)</b></a></sup> See <a href="#6.2.5">6.2.5</a>.
+    <sup><a name="note21" href="#note21"><b>21)</b></a></sup> The floating-point model is intended to clarify the description of each floating-point characteristic and
+        does not require the floating-point arithmetic of the implementation to be identical.
+
+[<a name="p28" href="#p28">page 28</a>] (<a href="#Contents">Contents</a>)
+
+    arithmetic operand.<sup><a href="#note22"><b>22)</b></a></sup>
+4   An implementation may give zero and values that are not floating-point numbers (such as
+    infinities and NaNs) a sign or may leave them unsigned. Wherever such values are
+    unsigned, any requirement in this International Standard to retrieve the sign shall produce
+    an unspecified sign, and any requirement to set the sign shall be ignored.
+5   The minimum range of representable values for a floating type is the most negative finite
+    floating-point number representable in that type through the most positive finite floating-
+    point number representable in that type. In addition, if negative infinity is representable
+    in a type, the range of that type is extended to all negative real numbers; likewise, if
+    positive infinity is representable in a type, the range of that type is extended to all positive
+    real numbers.
+6   The accuracy of the floating-point operations (+, -, *, /) and of the library functions in
+    <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results is implementation-
+    defined, as is the accuracy of the conversion between floating-point internal
+    representations and string representations performed by the library functions in
+    <a href="#7.21">&lt;stdio.h&gt;</a>, <a href="#7.22">&lt;stdlib.h&gt;</a>, and <a href="#7.28">&lt;wchar.h&gt;</a>. The implementation may state that the
+    accuracy is unknown.
+7   All integer values in the <a href="#7.7">&lt;float.h&gt;</a> header, except FLT_ROUNDS, shall be constant
+    expressions suitable for use in #if preprocessing directives; all floating values shall be
+    constant expressions. All except DECIMAL_DIG, FLT_EVAL_METHOD, FLT_RADIX,
+    and FLT_ROUNDS have separate names for all three floating-point types. The floating-
+    point model representation is provided for all values except FLT_EVAL_METHOD and
+    FLT_ROUNDS.
+8   The rounding mode for floating-point addition is characterized by the implementation-
+    defined value of FLT_ROUNDS:<sup><a href="#note23"><b>23)</b></a></sup>
+          -1      indeterminable
+           0      toward zero
+           1      to nearest
+           2      toward positive infinity
+           3      toward negative infinity
+    All other values for FLT_ROUNDS characterize implementation-defined rounding
+    behavior.
+
+
+    <sup><a name="note22" href="#note22"><b>22)</b></a></sup> IEC 60559:1989 specifies quiet and signaling NaNs. For implementations that do not support
+        IEC 60559:1989, the terms quiet NaN and signaling NaN are intended to apply to encodings with
+        similar behavior.
+    <sup><a name="note23" href="#note23"><b>23)</b></a></sup> Evaluation of FLT_ROUNDS correctly reflects any execution-time change of rounding mode through
+        the function fesetround in <a href="#7.6">&lt;fenv.h&gt;</a>.
+
+[<a name="p29" href="#p29">page 29</a>] (<a href="#Contents">Contents</a>)
+
+9    Except for assignment and cast (which remove all extra range and precision), the values
+     yielded by operators with floating operands and values subject to the usual arithmetic
+     conversions and of floating constants are evaluated to a format whose range and precision
+     may be greater than required by the type. The use of evaluation formats is characterized
+     by the implementation-defined value of FLT_EVAL_METHOD:<sup><a href="#note24"><b>24)</b></a></sup>
+            -1         indeterminable;
+              0        evaluate all operations and constants just to the range and precision of the
+                       type;
+              1        evaluate operations and constants of type float and double to the
+                       range and precision of the double type, evaluate long double
+                       operations and constants to the range and precision of the long double
+                       type;
+              2        evaluate all operations and constants to the range and precision of the
+                       long double type.
+     All other negative values for FLT_EVAL_METHOD characterize implementation-defined
+     behavior.
+10   The presence or absence of subnormal numbers is characterized by the implementation-
+     defined     values     of    FLT_HAS_SUBNORM,          DBL_HAS_SUBNORM,           and
+     LDBL_HAS_SUBNORM:
+            -1       indeterminable<sup><a href="#note25"><b>25)</b></a></sup>
+             0       absent<sup><a href="#note26"><b>26)</b></a></sup> (type does not support subnormal numbers)
+             1       present (type does support subnormal numbers)
+11   The values given in the following list shall be replaced by constant expressions with
+     implementation-defined values that are greater or equal in magnitude (absolute value) to
+     those shown, with the same sign:
+     -- radix of exponent representation, b
+       FLT_RADIX                                                    2
+
+
+
+
+     <sup><a name="note24" href="#note24"><b>24)</b></a></sup> The evaluation method determines evaluation formats of expressions involving all floating types, not
+         just real types. For example, if FLT_EVAL_METHOD is 1, then the product of two float
+         _Complex operands is represented in the double _Complex format, and its parts are evaluated to
+         double.
+     <sup><a name="note25" href="#note25"><b>25)</b></a></sup> Characterization as indeterminable is intended if floating-point operations do not consistently interpret
+         subnormal representations as zero, nor as nonzero.
+     <sup><a name="note26" href="#note26"><b>26)</b></a></sup> Characterization as absent is intended if no floating-point operations produce subnormal results from
+         non-subnormal inputs, even if the type format includes representations of subnormal numbers.
+
+[<a name="p30" href="#p30">page 30</a>] (<a href="#Contents">Contents</a>)
+
+-- number of base-FLT_RADIX digits in the floating-point significand, p
+   FLT_MANT_DIG
+   DBL_MANT_DIG
+   LDBL_MANT_DIG
+-- number of decimal digits, n, such that any floating-point number with p radix b digits
+  can be rounded to a floating-point number with n decimal digits and back again
+  without change to the value,
+       { p log10 b        if b is a power of 10
+       {
+       { [^1 + p log10 b^] otherwise
+   FLT_DECIMAL_DIG                                   6
+   DBL_DECIMAL_DIG                                  10
+   LDBL_DECIMAL_DIG                                 10
+-- number of decimal digits, n, such that any floating-point number in the widest
+  supported floating type with pmax radix b digits can be rounded to a floating-point
+  number with n decimal digits and back again without change to the value,
+       { pmax log10 b       if b is a power of 10
+       {
+       { [^1 + pmax log10 b^] otherwise
+   DECIMAL_DIG                                     10
+-- number of decimal digits, q, such that any floating-point number with q decimal digits
+  can be rounded into a floating-point number with p radix b digits and back again
+  without change to the q decimal digits,
+       { p log10 b          if b is a power of 10
+       {
+       { [_( p - 1) log10 b_] otherwise
+   FLT_DIG                                          6
+   DBL_DIG                                         10
+   LDBL_DIG                                        10
+-- minimum negative integer such that FLT_RADIX raised to one less than that power is
+  a normalized floating-point number, emin
+   FLT_MIN_EXP
+   DBL_MIN_EXP
+   LDBL_MIN_EXP
+
+[<a name="p31" href="#p31">page 31</a>] (<a href="#Contents">Contents</a>)
+
+     -- minimum negative integer such that 10 raised to that power is in the range of
+       normalized floating-point numbers, [^log10 b emin -1 ^]
+                                         [                  ]
+       FLT_MIN_10_EXP                                 -37
+       DBL_MIN_10_EXP                                 -37
+       LDBL_MIN_10_EXP                                -37
+     -- maximum integer such that FLT_RADIX raised to one less than that power is a
+       representable finite floating-point number, emax
+          FLT_MAX_EXP
+          DBL_MAX_EXP
+          LDBL_MAX_EXP
+     -- maximum integer such that 10 raised to that power is in the range of representable
+       finite floating-point numbers, [_log10 ((1 - b- p )b emax )_]
+          FLT_MAX_10_EXP                               +37
+          DBL_MAX_10_EXP                               +37
+          LDBL_MAX_10_EXP                              +37
+12   The values given in the following list shall be replaced by constant expressions with
+     implementation-defined values that are greater than or equal to those shown:
+     -- maximum representable finite floating-point number, (1 - b- p )b emax
+          FLT_MAX                                   1E+37
+          DBL_MAX                                   1E+37
+          LDBL_MAX                                  1E+37
+13   The values given in the following list shall be replaced by constant expressions with
+     implementation-defined (positive) values that are less than or equal to those shown:
+     -- the difference between 1 and the least value greater than 1 that is representable in the
+       given floating point type, b1- p
+          FLT_EPSILON                                1E-5
+          DBL_EPSILON                                1E-9
+          LDBL_EPSILON                               1E-9
+     -- minimum normalized positive floating-point number, b emin -1
+          FLT_MIN                                   1E-37
+          DBL_MIN                                   1E-37
+          LDBL_MIN                                  1E-37
+
+[<a name="p32" href="#p32">page 32</a>] (<a href="#Contents">Contents</a>)
+
+     -- minimum positive floating-point number<sup><a href="#note27"><b>27)</b></a></sup>
+         FLT_TRUE_MIN                                       1E-37
+         DBL_TRUE_MIN                                       1E-37
+         LDBL_TRUE_MIN                                      1E-37
+     Recommended practice
+14   Conversion from (at least) double to decimal with DECIMAL_DIG digits and back
+     should be the identity function.
+15   EXAMPLE 1 The following describes an artificial floating-point representation that meets the minimum
+     requirements of this International Standard, and the appropriate values in a <a href="#7.7">&lt;float.h&gt;</a> header for type
+     float:
+                        6
+           x = s16e    (Sum) f k 16-k ,
+                       k=1
+                                       -31 &lt;= e &lt;= +32
+
+             FLT_RADIX                                    16
+             FLT_MANT_DIG                                  6
+             FLT_EPSILON                     9.53674316E-07F
+             FLT_DECIMAL_DIG                               9
+             FLT_DIG                                       6
+             FLT_MIN_EXP                                 -31
+             FLT_MIN                         2.93873588E-39F
+             FLT_MIN_10_EXP                              -38
+             FLT_MAX_EXP                                 +32
+             FLT_MAX                         3.40282347E+38F
+             FLT_MAX_10_EXP                              +38
+
+16   EXAMPLE 2 The following describes floating-point representations that also meet the requirements for
+     single-precision and double-precision numbers in IEC 60559,<sup><a href="#note28"><b>28)</b></a></sup> and the appropriate values in a
+     <a href="#7.7">&lt;float.h&gt;</a> header for types float and double:
+                       24
+           x f = s2e   (Sum) f k 2-k ,
+                       k=1
+                                      -125 &lt;= e &lt;= +128
+
+                       53
+           x d = s2e   (Sum) f k 2-k ,
+                       k=1
+                                      -1021 &lt;= e &lt;= +1024
+
+             FLT_RADIX                                     2
+             DECIMAL_DIG                                  17
+             FLT_MANT_DIG                                 24
+             FLT_EPSILON                     1.19209290E-07F // decimal constant
+             FLT_EPSILON                            0X1P-23F // hex constant
+             FLT_DECIMAL_DIG                               9
+
+
+     <sup><a name="note27" href="#note27"><b>27)</b></a></sup> If the presence or absence of subnormal numbers is indeterminable, then the value is intended to be a
+         positive number no greater than the minimum normalized positive number for the type.
+     <sup><a name="note28" href="#note28"><b>28)</b></a></sup> The floating-point model in that standard sums powers of b from zero, so the values of the exponent
+         limits are one less than shown here.
+
+[<a name="p33" href="#p33">page 33</a>] (<a href="#Contents">Contents</a>)
+
+        FLT_DIG                             6
+        FLT_MIN_EXP                      -125
+        FLT_MIN               1.17549435E-38F               //   decimal constant
+        FLT_MIN                     0X1P-126F               //   hex constant
+        FLT_TRUE_MIN          1.40129846E-45F               //   decimal constant
+        FLT_TRUE_MIN                0X1P-149F               //   hex constant
+        FLT_HAS_SUBNORM                     1
+        FLT_MIN_10_EXP                    -37
+        FLT_MAX_EXP                      +128
+        FLT_MAX               3.40282347E+38F               // decimal constant
+        FLT_MAX               0X1.fffffeP127F               // hex constant
+        FLT_MAX_10_EXP                    +38
+        DBL_MANT_DIG                       53
+        DBL_EPSILON    2.2204460492503131E-16               // decimal constant
+        DBL_EPSILON                   0X1P-52               // hex constant
+        DBL_DECIMAL_DIG                    17
+        DBL_DIG                            15
+        DBL_MIN_EXP                     -1021
+        DBL_MIN      2.2250738585072014E-308                //   decimal constant
+        DBL_MIN                     0X1P-1022               //   hex constant
+        DBL_TRUE_MIN 4.9406564584124654E-324                //   decimal constant
+        DBL_TRUE_MIN                0X1P-1074               //   hex constant
+        DBL_HAS_SUBNORM                     1
+        DBL_MIN_10_EXP                   -307
+        DBL_MAX_EXP                     +1024
+        DBL_MAX      1.7976931348623157E+308                // decimal constant
+        DBL_MAX        0X1.fffffffffffffP1023               // hex constant
+        DBL_MAX_10_EXP                   +308
+If a type wider than double were supported, then DECIMAL_DIG would be greater than 17. For
+example, if the widest type were to use the minimal-width IEC 60559 double-extended format (64 bits of
+precision), then DECIMAL_DIG would be 21.
+
+Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>), complex arithmetic
+<a href="#7.3">&lt;complex.h&gt;</a> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <a href="#7.28">&lt;wchar.h&gt;</a>
+(<a href="#7.28">7.28</a>), floating-point environment <a href="#7.6">&lt;fenv.h&gt;</a> (<a href="#7.6">7.6</a>), general utilities <a href="#7.22">&lt;stdlib.h&gt;</a>
+(<a href="#7.22">7.22</a>), input/output <a href="#7.21">&lt;stdio.h&gt;</a> (<a href="#7.21">7.21</a>), mathematics <a href="#7.12">&lt;math.h&gt;</a> (<a href="#7.12">7.12</a>).
+
+[<a name="p34" href="#p34">page 34</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="6" href="#6"><b>    6. Language</b></a>
+<a name="6.1" href="#6.1"><b>    6.1 Notation</b></a>
+1   In the syntax notation used in this clause, syntactic categories (nonterminals) are
+    indicated by italic type, and literal words and character set members (terminals) by bold
+    type. A colon (:) following a nonterminal introduces its definition. Alternative
+    definitions are listed on separate lines, except when prefaced by the words ''one of''. An
+    optional symbol is indicated by the subscript ''opt'', so that
+             { expressionopt }
+    indicates an optional expression enclosed in braces.
+2   When syntactic categories are referred to in the main text, they are not italicized and
+    words are separated by spaces instead of hyphens.
+3   A summary of the language syntax is given in <a href="#A">annex A</a>.
+<a name="6.2" href="#6.2"><b>    6.2 Concepts</b></a>
+<a name="6.2.1" href="#6.2.1"><b>    6.2.1 Scopes of identifiers</b></a>
+1   An identifier can denote an object; a function; a tag or a member of a structure, union, or
+    enumeration; a typedef name; a label name; a macro name; or a macro parameter. The
+    same identifier can denote different entities at different points in the program. A member
+    of an enumeration is called an enumeration constant. Macro names and macro
+    parameters are not considered further here, because prior to the semantic phase of
+    program translation any occurrences of macro names in the source file are replaced by the
+    preprocessing token sequences that constitute their macro definitions.
+2   For each different entity that an identifier designates, the identifier is visible (i.e., can be
+    used) only within a region of program text called its scope. Different entities designated
+    by the same identifier either have different scopes, or are in different name spaces. There
+    are four kinds of scopes: function, file, block, and function prototype. (A function
+    prototype is a declaration of a function that declares the types of its parameters.)
+3   A label name is the only kind of identifier that has function scope. It can be used (in a
+    goto statement) anywhere in the function in which it appears, and is declared implicitly
+    by its syntactic appearance (followed by a : and a statement).
+4   Every other identifier has scope determined by the placement of its declaration (in a
+    declarator or type specifier). If the declarator or type specifier that declares the identifier
+    appears outside of any block or list of parameters, the identifier has file scope, which
+    terminates at the end of the translation unit. If the declarator or type specifier that
+    declares the identifier appears inside a block or within the list of parameter declarations in
+    a function definition, the identifier has block scope, which terminates at the end of the
+    associated block. If the declarator or type specifier that declares the identifier appears
+
+[<a name="p35" href="#p35">page 35</a>] (<a href="#Contents">Contents</a>)
+
+    within the list of parameter declarations in a function prototype (not part of a function
+    definition), the identifier has function prototype scope, which terminates at the end of the
+    function declarator. If an identifier designates two different entities in the same name
+    space, the scopes might overlap. If so, the scope of one entity (the inner scope) will end
+    strictly before the scope of the other entity (the outer scope). Within the inner scope, the
+    identifier designates the entity declared in the inner scope; the entity declared in the outer
+    scope is hidden (and not visible) within the inner scope.
+5   Unless explicitly stated otherwise, where this International Standard uses the term
+    ''identifier'' to refer to some entity (as opposed to the syntactic construct), it refers to the
+    entity in the relevant name space whose declaration is visible at the point the identifier
+    occurs.
+6   Two identifiers have the same scope if and only if their scopes terminate at the same
+    point.
+7   Structure, union, and enumeration tags have scope that begins just after the appearance of
+    the tag in a type specifier that declares the tag. Each enumeration constant has scope that
+    begins just after the appearance of its defining enumerator in an enumerator list. Any
+    other identifier has scope that begins just after the completion of its declarator.
+8   As a special case, a type name (which is not a declaration of an identifier) is considered to
+    have a scope that begins just after the place within the type name where the omitted
+    identifier would appear were it not omitted.
+    Forward references: declarations (<a href="#6.7">6.7</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), function definitions
+    (<a href="#6.9.1">6.9.1</a>), identifiers (<a href="#6.4.2">6.4.2</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), name spaces of identifiers (<a href="#6.2.3">6.2.3</a>),
+    source file inclusion (<a href="#6.10.2">6.10.2</a>), statements (<a href="#6.8">6.8</a>).
+<a name="6.2.2" href="#6.2.2"><b>    6.2.2 Linkages of identifiers</b></a>
+1   An identifier declared in different scopes or in the same scope more than once can be
+    made to refer to the same object or function by a process called linkage.<sup><a href="#note29"><b>29)</b></a></sup> There are
+    three kinds of linkage: external, internal, and none.
+2   In the set of translation units and libraries that constitutes an entire program, each
+    declaration of a particular identifier with external linkage denotes the same object or
+    function. Within one translation unit, each declaration of an identifier with internal
+    linkage denotes the same object or function. Each declaration of an identifier with no
+    linkage denotes a unique entity.
+3   If the declaration of a file scope identifier for an object or a function contains the storage-
+    class specifier static, the identifier has internal linkage.<sup><a href="#note30"><b>30)</b></a></sup>
+
+
+
+    <sup><a name="note29" href="#note29"><b>29)</b></a></sup> There is no linkage between different identifiers.
+
+[<a name="p36" href="#p36">page 36</a>] (<a href="#Contents">Contents</a>)
+
+4   For an identifier declared with the storage-class specifier extern in a scope in which a
+    prior declaration of that identifier is visible,<sup><a href="#note31"><b>31)</b></a></sup> if the prior declaration specifies internal or
+    external linkage, the linkage of the identifier at the later declaration is the same as the
+    linkage specified at the prior declaration. If no prior declaration is visible, or if the prior
+    declaration specifies no linkage, then the identifier has external linkage.
+5   If the declaration of an identifier for a function has no storage-class specifier, its linkage
+    is determined exactly as if it were declared with the storage-class specifier extern. If
+    the declaration of an identifier for an object has file scope and no storage-class specifier,
+    its linkage is external.
+6   The following identifiers have no linkage: an identifier declared to be anything other than
+    an object or a function; an identifier declared to be a function parameter; a block scope
+    identifier for an object declared without the storage-class specifier extern.
+7   If, within a translation unit, the same identifier appears with both internal and external
+    linkage, the behavior is undefined.
+    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), external definitions (<a href="#6.9">6.9</a>),
+    statements (<a href="#6.8">6.8</a>).
+<a name="6.2.3" href="#6.2.3"><b>    6.2.3 Name spaces of identifiers</b></a>
+1   If more than one declaration of a particular identifier is visible at any point in a
+    translation unit, the syntactic context disambiguates uses that refer to different entities.
+    Thus, there are separate name spaces for various categories of identifiers, as follows:
+    -- label names (disambiguated by the syntax of the label declaration and use);
+    -- the tags of structures, unions, and enumerations (disambiguated by following any<sup><a href="#note32"><b>32)</b></a></sup>
+      of the keywords struct, union, or enum);
+    -- the members of structures or unions; each structure or union has a separate name
+      space for its members (disambiguated by the type of the expression used to access the
+      member via the . or -&gt; operator);
+    -- all other identifiers, called ordinary identifiers (declared in ordinary declarators or as
+      enumeration constants).
+    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), labeled statements (<a href="#6.8.1">6.8.1</a>),
+    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>), tags
+    (<a href="#6.7.2.3">6.7.2.3</a>), the goto statement (<a href="#6.8.6.1">6.8.6.1</a>).
+
+    <sup><a name="note30" href="#note30"><b>30)</b></a></sup> A function declaration can contain the storage-class specifier static only if it is at file scope; see
+        <a href="#6.7.1">6.7.1</a>.
+    <sup><a name="note31" href="#note31"><b>31)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+    <sup><a name="note32" href="#note32"><b>32)</b></a></sup> There is only one name space for tags even though three are possible.
+
+[<a name="p37" href="#p37">page 37</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.2.4" href="#6.2.4"><b>    6.2.4 Storage durations of objects</b></a>
+1   An object has a storage duration that determines its lifetime. There are four storage
+    durations: static, thread, automatic, and allocated. Allocated storage is described in
+    <a href="#7.22.3">7.22.3</a>.
+2   The lifetime of an object is the portion of program execution during which storage is
+    guaranteed to be reserved for it. An object exists, has a constant address,<sup><a href="#note33"><b>33)</b></a></sup> and retains
+    its last-stored value throughout its lifetime.<sup><a href="#note34"><b>34)</b></a></sup> If an object is referred to outside of its
+    lifetime, the behavior is undefined. The value of a pointer becomes indeterminate when
+    the object it points to (or just past) reaches the end of its lifetime.
+3   An object whose identifier is declared without the storage-class specifier
+    _Thread_local, and either with external or internal linkage or with the storage-class
+    specifier static, has static storage duration. Its lifetime is the entire execution of the
+    program and its stored value is initialized only once, prior to program startup.
+4   An object whose identifier is declared with the storage-class specifier _Thread_local
+    has thread storage duration. Its lifetime is the entire execution of the thread for which it
+    is created, and its stored value is initialized when the thread is started. There is a distinct
+    object per thread, and use of the declared name in an expression refers to the object
+    associated with the thread evaluating the expression. The result of attempting to
+    indirectly access an object with thread storage duration from a thread other than the one
+    with which the object is associated is implementation-defined.
+5   An object whose identifier is declared with no linkage and without the storage-class
+    specifier static has automatic storage duration, as do some compound literals. The
+    result of attempting to indirectly access an object with automatic storage duration from a
+    thread other than the one with which the object is associated is implementation-defined.
+6   For such an object that does not have a variable length array type, its lifetime extends
+    from entry into the block with which it is associated until execution of that block ends in
+    any way. (Entering an enclosed block or calling a function suspends, but does not end,
+    execution of the current block.) If the block is entered recursively, a new instance of the
+    object is created each time. The initial value of the object is indeterminate. If an
+    initialization is specified for the object, it is performed each time the declaration or
+    compound literal is reached in the execution of the block; otherwise, the value becomes
+    indeterminate each time the declaration is reached.
+
+
+
+    <sup><a name="note33" href="#note33"><b>33)</b></a></sup> The term ''constant address'' means that two pointers to the object constructed at possibly different
+        times will compare equal. The address may be different during two different executions of the same
+        program.
+    <sup><a name="note34" href="#note34"><b>34)</b></a></sup> In the case of a volatile object, the last store need not be explicit in the program.
+
+[<a name="p38" href="#p38">page 38</a>] (<a href="#Contents">Contents</a>)
+
+7   For such an object that does have a variable length array type, its lifetime extends from
+    the declaration of the object until execution of the program leaves the scope of the
+    declaration.<sup><a href="#note35"><b>35)</b></a></sup> If the scope is entered recursively, a new instance of the object is created
+    each time. The initial value of the object is indeterminate.
+8   A non-lvalue expression with structure or union type, where the structure or union
+    contains a member with array type (including, recursively, members of all contained
+    structures and unions) refers to an object with automatic storage duration and temporary
+    lifetime.<sup><a href="#note36"><b>36)</b></a></sup> Its lifetime begins when the expression is evaluated and its initial value is the
+    value of the expression. Its lifetime ends when the evaluation of the containing full
+    expression or full declarator ends. Any attempt to modify an object with temporary
+    lifetime results in undefined behavior.
+    Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), compound literals (<a href="#6.5.2.5">6.5.2.5</a>), declarators
+    (<a href="#6.7.6">6.7.6</a>), function calls (<a href="#6.5.2.2">6.5.2.2</a>), initialization (<a href="#6.7.9">6.7.9</a>), statements (<a href="#6.8">6.8</a>).
+<a name="6.2.5" href="#6.2.5"><b>    6.2.5 Types</b></a>
+1   The meaning of a value stored in an object or returned by a function is determined by the
+    type of the expression used to access it. (An identifier declared to be an object is the
+    simplest such expression; the type is specified in the declaration of the identifier.) Types
+    are partitioned into object types (types that describe objects) and function types (types
+    that describe functions). At various points within a translation unit an object type may be
+    incomplete (lacking sufficient information to determine the size of objects of that type) or
+    complete (having sufficient information).<sup><a href="#note37"><b>37)</b></a></sup>
+2   An object declared as type _Bool is large enough to store the values 0 and 1.
+3   An object declared as type char is large enough to store any member of the basic
+    execution character set. If a member of the basic execution character set is stored in a
+    char object, its value is guaranteed to be nonnegative. If any other character is stored in
+    a char object, the resulting value is implementation-defined but shall be within the range
+    of values that can be represented in that type.
+4   There are five standard signed integer types, designated as signed char, short
+    int, int, long int, and long long int. (These and other types may be
+    designated in several additional ways, as described in <a href="#6.7.2">6.7.2</a>.) There may also be
+    implementation-defined extended signed integer types.<sup><a href="#note38"><b>38)</b></a></sup> The standard and extended
+    signed integer types are collectively called signed integer types.<sup><a href="#note39"><b>39)</b></a></sup>
+
+    <sup><a name="note35" href="#note35"><b>35)</b></a></sup> Leaving the innermost block containing the declaration, or jumping to a point in that block or an
+        embedded block prior to the declaration, leaves the scope of the declaration.
+    <sup><a name="note36" href="#note36"><b>36)</b></a></sup> The address of such an object is taken implicitly when an array member is accessed.
+    <sup><a name="note37" href="#note37"><b>37)</b></a></sup> A type may be incomplete or complete throughout an entire translation unit, or it may change states at
+        different points within a translation unit.
+
+[<a name="p39" href="#p39">page 39</a>] (<a href="#Contents">Contents</a>)
+
+5    An object declared as type signed char occupies the same amount of storage as a
+     ''plain'' char object. A ''plain'' int object has the natural size suggested by the
+     architecture of the execution environment (large enough to contain any value in the range
+     INT_MIN to INT_MAX as defined in the header <a href="#7.10">&lt;limits.h&gt;</a>).
+6    For each of the signed integer types, there is a corresponding (but different) unsigned
+     integer type (designated with the keyword unsigned) that uses the same amount of
+     storage (including sign information) and has the same alignment requirements. The type
+     _Bool and the unsigned integer types that correspond to the standard signed integer
+     types are the standard unsigned integer types. The unsigned integer types that
+     correspond to the extended signed integer types are the extended unsigned integer types.
+     The standard and extended unsigned integer types are collectively called unsigned integer
+     types.<sup><a href="#note40"><b>40)</b></a></sup>
+7    The standard signed integer types and standard unsigned integer types are collectively
+     called the standard integer types, the extended signed integer types and extended
+     unsigned integer types are collectively called the extended integer types.
+8    For any two integer types with the same signedness and different integer conversion rank
+     (see <a href="#6.3.1.1">6.3.1.1</a>), the range of values of the type with smaller integer conversion rank is a
+     subrange of the values of the other type.
+9    The range of nonnegative values of a signed integer type is a subrange of the
+     corresponding unsigned integer type, and the representation of the same value in each
+     type is the same.<sup><a href="#note41"><b>41)</b></a></sup> A computation involving unsigned operands can never overflow,
+     because a result that cannot be represented by the resulting unsigned integer type is
+     reduced modulo the number that is one greater than the largest value that can be
+     represented by the resulting type.
+10   There are three real floating types, designated as float, double, and long
+     double.<sup><a href="#note42"><b>42)</b></a></sup> The set of values of the type float is a subset of the set of values of the
+     type double; the set of values of the type double is a subset of the set of values of the
+     type long double.
+
+
+     <sup><a name="note38" href="#note38"><b>38)</b></a></sup> Implementation-defined keywords shall have the form of an identifier reserved for any use as
+         described in <a href="#7.1.3">7.1.3</a>.
+     <sup><a name="note39" href="#note39"><b>39)</b></a></sup> Therefore, any statement in this Standard about signed integer types also applies to the extended
+         signed integer types.
+     <sup><a name="note40" href="#note40"><b>40)</b></a></sup> Therefore, any statement in this Standard about unsigned integer types also applies to the extended
+         unsigned integer types.
+     <sup><a name="note41" href="#note41"><b>41)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
+         arguments to functions, return values from functions, and members of unions.
+     <sup><a name="note42" href="#note42"><b>42)</b></a></sup> See ''future language directions'' (<a href="#6.11.1">6.11.1</a>).
+
+[<a name="p40" href="#p40">page 40</a>] (<a href="#Contents">Contents</a>)
+
+11   There are three complex types, designated as float _Complex, double
+     _Complex, and long double _Complex.<sup><a href="#note43"><b>43)</b></a></sup> (Complex types are a conditional
+     feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.) The real floating and
+     complex types are collectively called the floating types.
+12   For each floating type there is a corresponding real type, which is always a real floating
+     type. For real floating types, it is the same type. For complex types, it is the type given
+     by deleting the keyword _Complex from the type name.
+13   Each complex type has the same representation and alignment requirements as an array
+     type containing exactly two elements of the corresponding real type; the first element is
+     equal to the real part, and the second element to the imaginary part, of the complex
+     number.
+14   The type char, the signed and unsigned integer types, and the floating types are
+     collectively called the basic types. The basic types are complete object types. Even if the
+     implementation defines two or more basic types to have the same representation, they are
+     nevertheless different types.<sup><a href="#note44"><b>44)</b></a></sup>
+15   The three types char, signed char, and unsigned char are collectively called
+     the character types. The implementation shall define char to have the same range,
+     representation, and behavior as either signed char or unsigned char.<sup><a href="#note45"><b>45)</b></a></sup>
+16   An enumeration comprises a set of named integer constant values. Each distinct
+     enumeration constitutes a different enumerated type.
+17   The type char, the signed and unsigned integer types, and the enumerated types are
+     collectively called integer types. The integer and real floating types are collectively called
+     real types.
+18   Integer and floating types are collectively called arithmetic types. Each arithmetic type
+     belongs to one type domain: the real type domain comprises the real types, the complex
+     type domain comprises the complex types.
+19   The void type comprises an empty set of values; it is an incomplete object type that
+     cannot be completed.
+
+
+
+     <sup><a name="note43" href="#note43"><b>43)</b></a></sup> A specification for imaginary types is in <a href="#G">annex G</a>.
+     <sup><a name="note44" href="#note44"><b>44)</b></a></sup> An implementation may define new keywords that provide alternative ways to designate a basic (or
+         any other) type; this does not violate the requirement that all basic types be different.
+         Implementation-defined keywords shall have the form of an identifier reserved for any use as
+         described in <a href="#7.1.3">7.1.3</a>.
+     <sup><a name="note45" href="#note45"><b>45)</b></a></sup> CHAR_MIN, defined in <a href="#7.10">&lt;limits.h&gt;</a>, will have one of the values 0 or SCHAR_MIN, and this can be
+         used to distinguish the two options. Irrespective of the choice made, char is a separate type from the
+         other two and is not compatible with either.
+
+[<a name="p41" href="#p41">page 41</a>] (<a href="#Contents">Contents</a>)
+
+20   Any number of derived types can be constructed from the object and function types, as
+     follows:
+     -- An array type describes a contiguously allocated nonempty set of objects with a
+       particular member object type, called the element type. The element type shall be
+       complete whenever the array type is specified. Array types are characterized by their
+       element type and by the number of elements in the array. An array type is said to be
+       derived from its element type, and if its element type is T , the array type is sometimes
+       called ''array of T ''. The construction of an array type from an element type is called
+       ''array type derivation''.
+     -- A structure type describes a sequentially allocated nonempty set of member objects
+       (and, in certain circumstances, an incomplete array), each of which has an optionally
+       specified name and possibly distinct type.
+     -- A union type describes an overlapping nonempty set of member objects, each of
+       which has an optionally specified name and possibly distinct type.
+     -- A function type describes a function with specified return type. A function type is
+       characterized by its return type and the number and types of its parameters. A
+       function type is said to be derived from its return type, and if its return type is T , the
+       function type is sometimes called ''function returning T ''. The construction of a
+       function type from a return type is called ''function type derivation''.
+     -- A pointer type may be derived from a function type or an object type, called the
+       referenced type. A pointer type describes an object whose value provides a reference
+       to an entity of the referenced type. A pointer type derived from the referenced type T
+       is sometimes called ''pointer to T ''. The construction of a pointer type from a
+       referenced type is called ''pointer type derivation''. A pointer type is a complete
+       object type.
+     -- An atomic type describes the type designated by the construct _Atomic ( type-
+       name ). (Atomic types are a conditional feature that implementations need not
+       support; see <a href="#6.10.8.3">6.10.8.3</a>.)
+     These methods of constructing derived types can be applied recursively.
+21   Arithmetic types and pointer types are collectively called scalar types. Array and
+     structure types are collectively called aggregate types.<sup><a href="#note46"><b>46)</b></a></sup>
+22   An array type of unknown size is an incomplete type. It is completed, for an identifier of
+     that type, by specifying the size in a later declaration (with internal or external linkage).
+     A structure or union type of unknown content (as described in <a href="#6.7.2.3">6.7.2.3</a>) is an incomplete
+
+
+     <sup><a name="note46" href="#note46"><b>46)</b></a></sup> Note that aggregate type does not include union type because an object with union type can only
+         contain one member at a time.
+
+[<a name="p42" href="#p42">page 42</a>] (<a href="#Contents">Contents</a>)
+
+     type. It is completed, for all declarations of that type, by declaring the same structure or
+     union tag with its defining content later in the same scope.
+23   A type has known constant size if the type is not incomplete and is not a variable length
+     array type.
+24   Array, function, and pointer types are collectively called derived declarator types. A
+     declarator type derivation from a type T is the construction of a derived declarator type
+     from T by the application of an array-type, a function-type, or a pointer-type derivation to
+     T.
+25   A type is characterized by its type category, which is either the outermost derivation of a
+     derived type (as noted above in the construction of derived types), or the type itself if the
+     type consists of no derived types.
+26   Any type so far mentioned is an unqualified type. Each unqualified type has several
+     qualified versions of its type,<sup><a href="#note47"><b>47)</b></a></sup> corresponding to the combinations of one, two, or all
+     three of the const, volatile, and restrict qualifiers. The qualified or unqualified
+     versions of a type are distinct types that belong to the same type category and have the
+     same representation and alignment requirements.<sup><a href="#note48"><b>48)</b></a></sup> A derived type is not qualified by the
+     qualifiers (if any) of the type from which it is derived.
+27   Further, there is the _Atomic qualifier. The presence of the _Atomic qualifier
+     designates an atomic type. The size, representation, and alignment of an atomic type
+     need not be the same as those of the corresponding unqualified type. Therefore, this
+     Standard explicitly uses the phrase ''atomic, qualified or unqualified type'' whenever the
+     atomic version of a type is permitted along with the other qualified versions of a type.
+     The phrase ''qualified or unqualified type'', without specific mention of atomic, does not
+     include the atomic types.
+28   A pointer to void shall have the same representation and alignment requirements as a
+     pointer to a character type.48) Similarly, pointers to qualified or unqualified versions of
+     compatible types shall have the same representation and alignment requirements. All
+     pointers to structure types shall have the same representation and alignment requirements
+     as each other. All pointers to union types shall have the same representation and
+     alignment requirements as each other. Pointers to other types need not have the same
+     representation or alignment requirements.
+29   EXAMPLE 1 The type designated as ''float *'' has type ''pointer to float''. Its type category is
+     pointer, not a floating type. The const-qualified version of this type is designated as ''float * const''
+     whereas the type designated as ''const float *'' is not a qualified type -- its type is ''pointer to const-
+
+
+     <sup><a name="note47" href="#note47"><b>47)</b></a></sup> See <a href="#6.7.3">6.7.3</a> regarding qualified array and function types.
+     <sup><a name="note48" href="#note48"><b>48)</b></a></sup> The same representation and alignment requirements are meant to imply interchangeability as
+         arguments to functions, return values from functions, and members of unions.
+
+[<a name="p43" href="#p43">page 43</a>] (<a href="#Contents">Contents</a>)
+
+     qualified float'' and is a pointer to a qualified type.
+
+30   EXAMPLE 2 The type designated as ''struct tag (*[5])(float)'' has type ''array of pointer to
+     function returning struct tag''. The array has length five and the function has a single parameter of type
+     float. Its type category is array.
+
+     Forward references: compatible type and composite type (<a href="#6.2.7">6.2.7</a>), declarations (<a href="#6.7">6.7</a>).
+<a name="6.2.6" href="#6.2.6"><b>     6.2.6 Representations of types</b></a>
+<a name="6.2.6.1" href="#6.2.6.1"><b>     6.2.6.1 General</b></a>
+1    The representations of all types are unspecified except as stated in this subclause.
+2    Except for bit-fields, objects are composed of contiguous sequences of one or more bytes,
+     the number, order, and encoding of which are either explicitly specified or
+     implementation-defined.
+3    Values stored in unsigned bit-fields and objects of type unsigned char shall be
+     represented using a pure binary notation.<sup><a href="#note49"><b>49)</b></a></sup>
+4    Values stored in non-bit-field objects of any other object type consist of n x CHAR_BIT
+     bits, where n is the size of an object of that type, in bytes. The value may be copied into
+     an object of type unsigned char [n] (e.g., by memcpy); the resulting set of bytes is
+     called the object representation of the value. Values stored in bit-fields consist of m bits,
+     where m is the size specified for the bit-field. The object representation is the set of m
+     bits the bit-field comprises in the addressable storage unit holding it. Two values (other
+     than NaNs) with the same object representation compare equal, but values that compare
+     equal may have different object representations.
+5    Certain object representations need not represent a value of the object type. If the stored
+     value of an object has such a representation and is read by an lvalue expression that does
+     not have character type, the behavior is undefined. If such a representation is produced
+     by a side effect that modifies all or any part of the object by an lvalue expression that
+     does not have character type, the behavior is undefined.<sup><a href="#note50"><b>50)</b></a></sup> Such a representation is called
+     a trap representation.
+6    When a value is stored in an object of structure or union type, including in a member
+     object, the bytes of the object representation that correspond to any padding bytes take
+     unspecified values.<sup><a href="#note51"><b>51)</b></a></sup> The value of a structure or union object is never a trap
+
+
+     <sup><a name="note49" href="#note49"><b>49)</b></a></sup> A positional representation for integers that uses the binary digits 0 and 1, in which the values
+         represented by successive bits are additive, begin with 1, and are multiplied by successive integral
+         powers of 2, except perhaps the bit with the highest position. (Adapted from the American National
+         Dictionary for Information Processing Systems.) A byte contains CHAR_BIT bits, and the values of
+         type unsigned char range from 0 to 2
+                                                   CHAR_BIT
+                                                             - 1.
+     <sup><a name="note50" href="#note50"><b>50)</b></a></sup> Thus, an automatic variable can be initialized to a trap representation without causing undefined
+         behavior, but the value of the variable cannot be used until a proper value is stored in it.
+
+[<a name="p44" href="#p44">page 44</a>] (<a href="#Contents">Contents</a>)
+
+    representation, even though the value of a member of the structure or union object may be
+    a trap representation.
+7   When a value is stored in a member of an object of union type, the bytes of the object
+    representation that do not correspond to that member but do correspond to other members
+    take unspecified values.
+8   Where an operator is applied to a value that has more than one object representation,
+    which object representation is used shall not affect the value of the result.<sup><a href="#note52"><b>52)</b></a></sup> Where a
+    value is stored in an object using a type that has more than one object representation for
+    that value, it is unspecified which representation is used, but a trap representation shall
+    not be generated.
+9   Loads and stores of objects with                            atomic       types     are     done      with
+    memory_order_seq_cst semantics.
+    Forward references: declarations (<a href="#6.7">6.7</a>), expressions (<a href="#6.5">6.5</a>), lvalues, arrays, and function
+    designators (<a href="#6.3.2.1">6.3.2.1</a>), order and consistency (<a href="#7.17.3">7.17.3</a>).
+<a name="6.2.6.2" href="#6.2.6.2"><b>    6.2.6.2 Integer types</b></a>
+1   For unsigned integer types other than unsigned char, the bits of the object
+    representation shall be divided into two groups: value bits and padding bits (there need
+    not be any of the latter). If there are N value bits, each bit shall represent a different
+    power of 2 between 1 and 2 N -1 , so that objects of that type shall be capable of
+    representing values from 0 to 2 N - 1 using a pure binary representation; this shall be
+    known as the value representation. The values of any padding bits are unspecified.<sup><a href="#note53"><b>53)</b></a></sup>
+2   For signed integer types, the bits of the object representation shall be divided into three
+    groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
+    signed char shall not have any padding bits. There shall be exactly one sign bit.
+    Each bit that is a value bit shall have the same value as the same bit in the object
+    representation of the corresponding unsigned type (if there are M value bits in the signed
+    type and N in the unsigned type, then M &lt;= N ). If the sign bit is zero, it shall not affect
+
+    <sup><a name="note51" href="#note51"><b>51)</b></a></sup> Thus, for example, structure assignment need not copy any padding bits.
+    <sup><a name="note52" href="#note52"><b>52)</b></a></sup> It is possible for objects x and y with the same effective type T to have the same value when they are
+        accessed as objects of type T, but to have different values in other contexts. In particular, if == is
+        defined for type T, then x == y does not imply that memcmp(&amp;x, &amp;y, sizeof (T)) == 0.
+        Furthermore, x == y does not necessarily imply that x and y have the same value; other operations
+        on values of type T may distinguish between them.
+    <sup><a name="note53" href="#note53"><b>53)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
+        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+        representation other than as part of an exceptional condition such as an overflow, and this cannot occur
+        with unsigned types. All other combinations of padding bits are alternative object representations of
+        the value specified by the value bits.
+
+[<a name="p45" href="#p45">page 45</a>] (<a href="#Contents">Contents</a>)
+
+    the resulting value. If the sign bit is one, the value shall be modified in one of the
+    following ways:
+    -- the corresponding value with sign bit 0 is negated (sign and magnitude);
+    -- the sign bit has the value -(2 M ) (two's complement);
+    -- the sign bit has the value -(2 M - 1) (ones' complement).
+    Which of these applies is implementation-defined, as is whether the value with sign bit 1
+    and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones'
+    complement), is a trap representation or a normal value. In the case of sign and
+    magnitude and ones' complement, if this representation is a normal value it is called a
+    negative zero.
+3   If the implementation supports negative zeros, they shall be generated only by:
+    -- the &amp;, |, ^, ~, &lt;&lt;, and &gt;&gt; operators with operands that produce such a value;
+    -- the +, -, *, /, and % operators where one operand is a negative zero and the result is
+      zero;
+    -- compound assignment operators based on the above cases.
+    It is unspecified whether these cases actually generate a negative zero or a normal zero,
+    and whether a negative zero becomes a normal zero when stored in an object.
+4   If the implementation does not support negative zeros, the behavior of the &amp;, |, ^, ~, &lt;&lt;,
+    and &gt;&gt; operators with operands that would produce such a value is undefined.
+5   The values of any padding bits are unspecified.<sup><a href="#note54"><b>54)</b></a></sup> A valid (non-trap) object representation
+    of a signed integer type where the sign bit is zero is a valid object representation of the
+    corresponding unsigned type, and shall represent the same value. For any integer type,
+    the object representation where all the bits are zero shall be a representation of the value
+    zero in that type.
+6   The precision of an integer type is the number of bits it uses to represent values,
+    excluding any sign and padding bits. The width of an integer type is the same but
+    including any sign bit; thus for unsigned integer types the two values are the same, while
+    for signed integer types the width is one greater than the precision.
+
+
+
+
+    <sup><a name="note54" href="#note54"><b>54)</b></a></sup> Some combinations of padding bits might generate trap representations, for example, if one padding
+        bit is a parity bit. Regardless, no arithmetic operation on valid values can generate a trap
+        representation other than as part of an exceptional condition such as an overflow. All other
+        combinations of padding bits are alternative object representations of the value specified by the value
+        bits.
+
+[<a name="p46" href="#p46">page 46</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.2.7" href="#6.2.7"><b>    6.2.7 Compatible type and composite type</b></a>
+1   Two types have compatible type if their types are the same. Additional rules for
+    determining whether two types are compatible are described in <a href="#6.7.2">6.7.2</a> for type specifiers,
+    in <a href="#6.7.3">6.7.3</a> for type qualifiers, and in <a href="#6.7.6">6.7.6</a> for declarators.<sup><a href="#note55"><b>55)</b></a></sup> Moreover, two structure,
+    union, or enumerated types declared in separate translation units are compatible if their
+    tags and members satisfy the following requirements: If one is declared with a tag, the
+    other shall be declared with the same tag. If both are completed anywhere within their
+    respective translation units, then the following additional requirements apply: there shall
+    be a one-to-one correspondence between their members such that each pair of
+    corresponding members are declared with compatible types; if one member of the pair is
+    declared with an alignment specifier, the other is declared with an equivalent alignment
+    specifier; and if one member of the pair is declared with a name, the other is declared
+    with the same name. For two structures, corresponding members shall be declared in the
+    same order. For two structures or unions, corresponding bit-fields shall have the same
+    widths. For two enumerations, corresponding members shall have the same values.
+2   All declarations that refer to the same object or function shall have compatible type;
+    otherwise, the behavior is undefined.
+3   A composite type can be constructed from two types that are compatible; it is a type that
+    is compatible with both of the two types and satisfies the following conditions:
+    -- If both types are array types, the following rules are applied:
+          o If one type is an array of known constant size, the composite type is an array of
+             that size.
+          o Otherwise, if one type is a variable length array whose size is specified by an
+             expression that is not evaluated, the behavior is undefined.
+          o Otherwise, if one type is a variable length array whose size is specified, the
+             composite type is a variable length array of that size.
+          o Otherwise, if one type is a variable length array of unspecified size, the composite
+             type is a variable length array of unspecified size.
+          o Otherwise, both types are arrays of unknown size and the composite type is an
+             array of unknown size.
+        The element type of the composite type is the composite type of the two element
+        types.
+    -- If only one type is a function type with a parameter type list (a function prototype),
+      the composite type is a function prototype with the parameter type list.
+
+
+    <sup><a name="note55" href="#note55"><b>55)</b></a></sup> Two types need not be identical to be compatible.
+
+[<a name="p47" href="#p47">page 47</a>] (<a href="#Contents">Contents</a>)
+
+    -- If both types are function types with parameter type lists, the type of each parameter
+      in the composite parameter type list is the composite type of the corresponding
+      parameters.
+    These rules apply recursively to the types from which the two types are derived.
+4   For an identifier with internal or external linkage declared in a scope in which a prior
+    declaration of that identifier is visible,<sup><a href="#note56"><b>56)</b></a></sup> if the prior declaration specifies internal or
+    external linkage, the type of the identifier at the later declaration becomes the composite
+    type.
+    Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
+5   EXAMPLE        Given the following two file scope declarations:
+             int f(int (*)(), double (*)[3]);
+             int f(int (*)(char *), double (*)[]);
+    The resulting composite type for the function is:
+             int f(int (*)(char *), double (*)[3]);
+
+<a name="6.2.8" href="#6.2.8"><b>    6.2.8 Alignment of objects</b></a>
+1   Complete object types have alignment requirements which place restrictions on the
+    addresses at which objects of that type may be allocated. An alignment is an
+    implementation-defined integer value representing the number of bytes between
+    successive addresses at which a given object can be allocated. An object type imposes an
+    alignment requirement on every object of that type: stricter alignment can be requested
+    using the _Alignas keyword.
+2   A fundamental alignment is represented by an alignment less than or equal to the greatest
+    alignment supported by the implementation in all contexts, which is equal to
+    alignof(max_align_t).
+3   An extended alignment is represented by an alignment greater than
+    alignof(max_align_t). It is implementation-defined whether any extended
+    alignments are supported and the contexts in which they are supported. A type having an
+    extended alignment requirement is an over-aligned type.<sup><a href="#note57"><b>57)</b></a></sup>
+4   Alignments are represented as values of the type size_t. Valid alignments include only
+    those values returned by an alignof expression for fundamental types, plus an
+    additional implementation-defined set of values, which may be empty. Every valid
+    alignment value shall be a nonnegative integral power of two.
+
+
+    <sup><a name="note56" href="#note56"><b>56)</b></a></sup> As specified in <a href="#6.2.1">6.2.1</a>, the later declaration might hide the prior declaration.
+    <sup><a name="note57" href="#note57"><b>57)</b></a></sup> Every over-aligned type is, or contains, a structure or union type with a member to which an extended
+        alignment has been applied.
+
+[<a name="p48" href="#p48">page 48</a>] (<a href="#Contents">Contents</a>)
+
+5   Alignments have an order from weaker to stronger or stricter alignments. Stricter
+    alignments have larger alignment values. An address that satisfies an alignment
+    requirement also satisfies any weaker valid alignment requirement.
+6   The alignment requirement of a complete type can be queried using an alignof
+    expression. The types char, signed char, and unsigned char shall have the
+    weakest alignment requirement.
+7   Comparing alignments is meaningful and provides the obvious results:
+    -- Two alignments are equal when their numeric values are equal.
+    -- Two alignments are different when their numeric values are not equal.
+    -- When an alignment is larger than another it represents a stricter alignment.
+
+[<a name="p49" href="#p49">page 49</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.3" href="#6.3"><b>    6.3 Conversions</b></a>
+1   Several operators convert operand values from one type to another automatically. This
+    subclause specifies the result required from such an implicit conversion, as well as those
+    that result from a cast operation (an explicit conversion). The list in <a href="#6.3.1.8">6.3.1.8</a> summarizes
+    the conversions performed by most ordinary operators; it is supplemented as required by
+    the discussion of each operator in <a href="#6.5">6.5</a>.
+2   Conversion of an operand value to a compatible type causes no change to the value or the
+    representation.
+    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>).
+<a name="6.3.1" href="#6.3.1"><b>    6.3.1 Arithmetic operands</b></a>
+<a name="6.3.1.1" href="#6.3.1.1"><b>    6.3.1.1 Boolean, characters, and integers</b></a>
+1   Every integer type has an integer conversion rank defined as follows:
+    -- No two signed integer types shall have the same rank, even if they have the same
+      representation.
+    -- The rank of a signed integer type shall be greater than the rank of any signed integer
+      type with less precision.
+    -- The rank of long long int shall be greater than the rank of long int, which
+      shall be greater than the rank of int, which shall be greater than the rank of short
+      int, which shall be greater than the rank of signed char.
+    -- The rank of any unsigned integer type shall equal the rank of the corresponding
+      signed integer type, if any.
+    -- The rank of any standard integer type shall be greater than the rank of any extended
+      integer type with the same width.
+    -- The rank of char shall equal the rank of signed char and unsigned char.
+    -- The rank of _Bool shall be less than the rank of all other standard integer types.
+    -- The rank of any enumerated type shall equal the rank of the compatible integer type
+      (see <a href="#6.7.2.2">6.7.2.2</a>).
+    -- The rank of any extended signed integer type relative to another extended signed
+      integer type with the same precision is implementation-defined, but still subject to the
+      other rules for determining the integer conversion rank.
+    -- For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has
+      greater rank than T3, then T1 has greater rank than T3.
+2   The following may be used in an expression wherever an int or unsigned int may
+    be used:
+
+[<a name="p50" href="#p50">page 50</a>] (<a href="#Contents">Contents</a>)
+
+    -- An object or expression with an integer type (other than int or unsigned int)
+      whose integer conversion rank is less than or equal to the rank of int and
+      unsigned int.
+    -- A bit-field of type _Bool, int, signed int, or unsigned int.
+    If an int can represent all values of the original type (as restricted by the width, for a
+    bit-field), the value is converted to an int; otherwise, it is converted to an unsigned
+    int. These are called the integer promotions.<sup><a href="#note58"><b>58)</b></a></sup> All other types are unchanged by the
+    integer promotions.
+3   The integer promotions preserve value including sign. As discussed earlier, whether a
+    ''plain'' char is treated as signed is implementation-defined.
+    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), structure and union specifiers
+    (<a href="#6.7.2.1">6.7.2.1</a>).
+<a name="6.3.1.2" href="#6.3.1.2"><b>    6.3.1.2 Boolean type</b></a>
+1   When any scalar value is converted to _Bool, the result is 0 if the value compares equal
+    to 0; otherwise, the result is 1.<sup><a href="#note59"><b>59)</b></a></sup>
+<a name="6.3.1.3" href="#6.3.1.3"><b>    6.3.1.3 Signed and unsigned integers</b></a>
+1   When a value with integer type is converted to another integer type other than _Bool, if
+    the value can be represented by the new type, it is unchanged.
+2   Otherwise, if the new type is unsigned, the value is converted by repeatedly adding or
+    subtracting one more than the maximum value that can be represented in the new type
+    until the value is in the range of the new type.<sup><a href="#note60"><b>60)</b></a></sup>
+3   Otherwise, the new type is signed and the value cannot be represented in it; either the
+    result is implementation-defined or an implementation-defined signal is raised.
+<a name="6.3.1.4" href="#6.3.1.4"><b>    6.3.1.4 Real floating and integer</b></a>
+1   When a finite value of real floating type is converted to an integer type other than _Bool,
+    the fractional part is discarded (i.e., the value is truncated toward zero). If the value of
+    the integral part cannot be represented by the integer type, the behavior is undefined.<sup><a href="#note61"><b>61)</b></a></sup>
+
+
+    <sup><a name="note58" href="#note58"><b>58)</b></a></sup> The integer promotions are applied only: as part of the usual arithmetic conversions, to certain
+        argument expressions, to the operands of the unary +, -, and ~ operators, and to both operands of the
+        shift operators, as specified by their respective subclauses.
+    <sup><a name="note59" href="#note59"><b>59)</b></a></sup> NaNs do not compare equal to 0 and thus convert to 1.
+    <sup><a name="note60" href="#note60"><b>60)</b></a></sup> The rules describe arithmetic on the mathematical value, not the value of a given type of expression.
+    <sup><a name="note61" href="#note61"><b>61)</b></a></sup> The remaindering operation performed when a value of integer type is converted to unsigned type
+        need not be performed when a value of real floating type is converted to unsigned type. Thus, the
+        range of portable real floating values is (-1, Utype_MAX+1).
+
+[<a name="p51" href="#p51">page 51</a>] (<a href="#Contents">Contents</a>)
+
+2   When a value of integer type is converted to a real floating type, if the value being
+    converted can be represented exactly in the new type, it is unchanged. If the value being
+    converted is in the range of values that can be represented but cannot be represented
+    exactly, the result is either the nearest higher or nearest lower representable value, chosen
+    in an implementation-defined manner. If the value being converted is outside the range of
+    values that can be represented, the behavior is undefined. Results of some implicit
+    conversions (<a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>) may be represented in greater precision and range than that
+    required by the new type.
+<a name="6.3.1.5" href="#6.3.1.5"><b>    6.3.1.5 Real floating types</b></a>
+1   When a value of real floating type is converted to a real floating type, if the value being
+    converted can be represented exactly in the new type, it is unchanged. If the value being
+    converted is in the range of values that can be represented but cannot be represented
+    exactly, the result is either the nearest higher or nearest lower representable value, chosen
+    in an implementation-defined manner. If the value being converted is outside the range of
+    values that can be represented, the behavior is undefined. Results of some implicit
+    conversions (<a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>) may be represented in greater precision and range than that
+    required by the new type.
+<a name="6.3.1.6" href="#6.3.1.6"><b>    6.3.1.6 Complex types</b></a>
+1   When a value of complex type is converted to another complex type, both the real and
+    imaginary parts follow the conversion rules for the corresponding real types.
+<a name="6.3.1.7" href="#6.3.1.7"><b>    6.3.1.7 Real and complex</b></a>
+1   When a value of real type is converted to a complex type, the real part of the complex
+    result value is determined by the rules of conversion to the corresponding real type and
+    the imaginary part of the complex result value is a positive zero or an unsigned zero.
+2   When a value of complex type is converted to a real type, the imaginary part of the
+    complex value is discarded and the value of the real part is converted according to the
+    conversion rules for the corresponding real type.
+<a name="6.3.1.8" href="#6.3.1.8"><b>    6.3.1.8 Usual arithmetic conversions</b></a>
+1   Many operators that expect operands of arithmetic type cause conversions and yield result
+    types in a similar way. The purpose is to determine a common real type for the operands
+    and result. For the specified operands, each operand is converted, without change of type
+    domain, to a type whose corresponding real type is the common real type. Unless
+    explicitly stated otherwise, the common real type is also the corresponding real type of
+    the result, whose type domain is the type domain of the operands if they are the same,
+    and complex otherwise. This pattern is called the usual arithmetic conversions:
+          First, if the corresponding real type of either operand is long double, the other
+          operand is converted, without change of type domain, to a type whose
+
+[<a name="p52" href="#p52">page 52</a>] (<a href="#Contents">Contents</a>)
+
+           corresponding real type is long double.
+           Otherwise, if the corresponding real type of either operand is double, the other
+           operand is converted, without change of type domain, to a type whose
+           corresponding real type is double.
+           Otherwise, if the corresponding real type of either operand is float, the other
+           operand is converted, without change of type domain, to a type whose
+           corresponding real type is float.<sup><a href="#note62"><b>62)</b></a></sup>
+           Otherwise, the integer promotions are performed on both operands. Then the
+           following rules are applied to the promoted operands:
+                  If both operands have the same type, then no further conversion is needed.
+                  Otherwise, if both operands have signed integer types or both have unsigned
+                  integer types, the operand with the type of lesser integer conversion rank is
+                  converted to the type of the operand with greater rank.
+                  Otherwise, if the operand that has unsigned integer type has rank greater or
+                  equal to the rank of the type of the other operand, then the operand with
+                  signed integer type is converted to the type of the operand with unsigned
+                  integer type.
+                  Otherwise, if the type of the operand with signed integer type can represent
+                  all of the values of the type of the operand with unsigned integer type, then
+                  the operand with unsigned integer type is converted to the type of the
+                  operand with signed integer type.
+                  Otherwise, both operands are converted to the unsigned integer type
+                  corresponding to the type of the operand with signed integer type.
+2   The values of floating operands and of the results of floating expressions may be
+    represented in greater precision and range than that required by the type; the types are not
+    changed thereby.<sup><a href="#note63"><b>63)</b></a></sup>
+
+
+
+
+    <sup><a name="note62" href="#note62"><b>62)</b></a></sup> For example, addition of a double _Complex and a float entails just the conversion of the
+        float operand to double (and yields a double _Complex result).
+    <sup><a name="note63" href="#note63"><b>63)</b></a></sup> The cast and assignment operators are still required to remove extra range and precision.
+
+[<a name="p53" href="#p53">page 53</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.3.2" href="#6.3.2"><b>    6.3.2 Other operands</b></a>
+<a name="6.3.2.1" href="#6.3.2.1"><b>    6.3.2.1 Lvalues, arrays, and function designators</b></a>
+1   An lvalue is an expression (with an object type other than void) that potentially
+    designates an object;<sup><a href="#note64"><b>64)</b></a></sup> if an lvalue does not designate an object when it is evaluated, the
+    behavior is undefined. When an object is said to have a particular type, the type is
+    specified by the lvalue used to designate the object. A modifiable lvalue is an lvalue that
+    does not have array type, does not have an incomplete type, does not have a const-
+    qualified type, and if it is a structure or union, does not have any member (including,
+    recursively, any member or element of all contained aggregates or unions) with a const-
+    qualified type.
+2   Except when it is the operand of the sizeof operator, the unary &amp; operator, the ++
+    operator, the -- operator, or the left operand of the . operator or an assignment operator,
+    an lvalue that does not have array type is converted to the value stored in the designated
+    object (and is no longer an lvalue); this is called lvalue conversion. If the lvalue has
+    qualified type, the value has the unqualified version of the type of the lvalue; additionally,
+    if the lvalue has atomic type, the value has the non-atomic version of the type of the
+    lvalue; otherwise, the value has the type of the lvalue. If the lvalue has an incomplete
+    type and does not have array type, the behavior is undefined. If the lvalue designates an
+    object of automatic storage duration that could have been declared with the register
+    storage class (never had its address taken), and that object is uninitialized (not declared
+    with an initializer and no assignment to it has been performed prior to use), the behavior
+    is undefined.
+3   Except when it is the operand of the sizeof operator or the unary &amp; operator, or is a
+    string literal used to initialize an array, an expression that has type ''array of type'' is
+    converted to an expression with type ''pointer to type'' that points to the initial element of
+    the array object and is not an lvalue. If the array object has register storage class, the
+    behavior is undefined.
+4   A function designator is an expression that has function type. Except when it is the
+    operand of the sizeof operator<sup><a href="#note65"><b>65)</b></a></sup> or the unary &amp; operator, a function designator with
+    type ''function returning type'' is converted to an expression that has type ''pointer to
+
+
+    <sup><a name="note64" href="#note64"><b>64)</b></a></sup> The name ''lvalue'' comes originally from the assignment expression E1 = E2, in which the left
+        operand E1 is required to be a (modifiable) lvalue. It is perhaps better considered as representing an
+        object ''locator value''. What is sometimes called ''rvalue'' is in this International Standard described
+        as the ''value of an expression''.
+         An obvious example of an lvalue is an identifier of an object. As a further example, if E is a unary
+         expression that is a pointer to an object, *E is an lvalue that designates the object to which E points.
+    <sup><a name="note65" href="#note65"><b>65)</b></a></sup> Because this conversion does not occur, the operand of the sizeof operator remains a function
+        designator and violates the constraint in <a href="#6.5.3.4">6.5.3.4</a>.
+
+[<a name="p54" href="#p54">page 54</a>] (<a href="#Contents">Contents</a>)
+
+    function returning type''.
+    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), assignment operators
+    (<a href="#6.5.16">6.5.16</a>), common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), initialization (<a href="#6.7.9">6.7.9</a>), postfix
+    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+    (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof operator (<a href="#6.5.3.4">6.5.3.4</a>), structure and union members (<a href="#6.5.2.3">6.5.2.3</a>).
+    <a href="#6.3.2.2">6.3.2.2</a> void
+1   The (nonexistent) value of a void expression (an expression that has type void) shall not
+    be used in any way, and implicit or explicit conversions (except to void) shall not be
+    applied to such an expression. If an expression of any other type is evaluated as a void
+    expression, its value or designator is discarded. (A void expression is evaluated for its
+    side effects.)
+<a name="6.3.2.3" href="#6.3.2.3"><b>    6.3.2.3 Pointers</b></a>
+1   A pointer to void may be converted to or from a pointer to any object type. A pointer to
+    any object type may be converted to a pointer to void and back again; the result shall
+    compare equal to the original pointer.
+2   For any qualifier q, a pointer to a non-q-qualified type may be converted to a pointer to
+    the q-qualified version of the type; the values stored in the original and converted pointers
+    shall compare equal.
+3   An integer constant expression with the value 0, or such an expression cast to type
+    void *, is called a null pointer constant.<sup><a href="#note66"><b>66)</b></a></sup> If a null pointer constant is converted to a
+    pointer type, the resulting pointer, called a null pointer, is guaranteed to compare unequal
+    to a pointer to any object or function.
+4   Conversion of a null pointer to another pointer type yields a null pointer of that type.
+    Any two null pointers shall compare equal.
+5   An integer may be converted to any pointer type. Except as previously specified, the
+    result is implementation-defined, might not be correctly aligned, might not point to an
+    entity of the referenced type, and might be a trap representation.<sup><a href="#note67"><b>67)</b></a></sup>
+6   Any pointer type may be converted to an integer type. Except as previously specified, the
+    result is implementation-defined. If the result cannot be represented in the integer type,
+    the behavior is undefined. The result need not be in the range of values of any integer
+    type.
+
+
+
+
+    <sup><a name="note66" href="#note66"><b>66)</b></a></sup> The macro NULL is defined in <a href="#7.19">&lt;stddef.h&gt;</a> (and other headers) as a null pointer constant; see <a href="#7.19">7.19</a>.
+    <sup><a name="note67" href="#note67"><b>67)</b></a></sup> The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to
+        be consistent with the addressing structure of the execution environment.
+
+[<a name="p55" href="#p55">page 55</a>] (<a href="#Contents">Contents</a>)
+
+7   A pointer to an object type may be converted to a pointer to a different object type. If the
+    resulting pointer is not correctly aligned<sup><a href="#note68"><b>68)</b></a></sup> for the referenced type, the behavior is
+    undefined. Otherwise, when converted back again, the result shall compare equal to the
+    original pointer. When a pointer to an object is converted to a pointer to a character type,
+    the result points to the lowest addressed byte of the object. Successive increments of the
+    result, up to the size of the object, yield pointers to the remaining bytes of the object.
+8   A pointer to a function of one type may be converted to a pointer to a function of another
+    type and back again; the result shall compare equal to the original pointer. If a converted
+    pointer is used to call a function whose type is not compatible with the referenced type,
+    the behavior is undefined.
+    Forward references: cast operators (<a href="#6.5.4">6.5.4</a>), equality operators (<a href="#6.5.9">6.5.9</a>), integer types
+    capable of holding object pointers (<a href="#7.20.1.4">7.20.1.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+
+
+
+
+    <sup><a name="note68" href="#note68"><b>68)</b></a></sup> In general, the concept ''correctly aligned'' is transitive: if a pointer to type A is correctly aligned for a
+        pointer to type B, which in turn is correctly aligned for a pointer to type C, then a pointer to type A is
+        correctly aligned for a pointer to type C.
+
+[<a name="p56" href="#p56">page 56</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4" href="#6.4"><b>    6.4 Lexical elements</b></a>
+<b>    Syntax</b>
+1            token:
+                      keyword
+                      identifier
+                      constant
+                      string-literal
+                      punctuator
+             preprocessing-token:
+                    header-name
+                    identifier
+                    pp-number
+                    character-constant
+                    string-literal
+                    punctuator
+                    each non-white-space character that cannot be one of the above
+<b>    Constraints</b>
+2   Each preprocessing token that is converted to a token shall have the lexical form of a
+    keyword, an identifier, a constant, a string literal, or a punctuator.
+<b>    Semantics</b>
+3   A token is the minimal lexical element of the language in translation phases 7 and 8. The
+    categories of tokens are: keywords, identifiers, constants, string literals, and punctuators.
+    A preprocessing token is the minimal lexical element of the language in translation
+    phases 3 through 6. The categories of preprocessing tokens are: header names,
+    identifiers, preprocessing numbers, character constants, string literals, punctuators, and
+    single non-white-space characters that do not lexically match the other preprocessing
+    token categories.<sup><a href="#note69"><b>69)</b></a></sup> If a ' or a " character matches the last category, the behavior is
+    undefined. Preprocessing tokens can be separated by white space; this consists of
+    comments (described later), or white-space characters (space, horizontal tab, new-line,
+    vertical tab, and form-feed), or both. As described in <a href="#6.10">6.10</a>, in certain circumstances
+    during translation phase 4, white space (or the absence thereof) serves as more than
+    preprocessing token separation. White space may appear within a preprocessing token
+    only as part of a header name or between the quotation characters in a character constant
+    or string literal.
+
+
+
+    <sup><a name="note69" href="#note69"><b>69)</b></a></sup> An additional category, placemarkers, is used internally in translation phase 4 (see <a href="#6.10.3.3">6.10.3.3</a>); it cannot
+        occur in source files.
+
+[<a name="p57" href="#p57">page 57</a>] (<a href="#Contents">Contents</a>)
+
+4   If the input stream has been parsed into preprocessing tokens up to a given character, the
+    next preprocessing token is the longest sequence of characters that could constitute a
+    preprocessing token. There is one exception to this rule: header name preprocessing
+    tokens are recognized only within #include preprocessing directives and in
+    implementation-defined locations within #pragma directives. In such contexts, a
+    sequence of characters that could be either a header name or a string literal is recognized
+    as the former.
+5   EXAMPLE 1 The program fragment 1Ex is parsed as a preprocessing number token (one that is not a
+    valid floating or integer constant token), even though a parse as the pair of preprocessing tokens 1 and Ex
+    might produce a valid expression (for example, if Ex were a macro defined as +1). Similarly, the program
+    fragment 1E1 is parsed as a preprocessing number (one that is a valid floating constant token), whether or
+    not E is a macro name.
+
+6   EXAMPLE 2 The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on
+    increment operators, even though the parse x ++ + ++ y might yield a correct expression.
+
+    Forward references: character constants (<a href="#6.4.4.4">6.4.4.4</a>), comments (<a href="#6.4.9">6.4.9</a>), expressions (<a href="#6.5">6.5</a>),
+    floating constants (<a href="#6.4.4.2">6.4.4.2</a>), header names (<a href="#6.4.7">6.4.7</a>), macro replacement (<a href="#6.10.3">6.10.3</a>), postfix
+    increment and decrement operators (<a href="#6.5.2.4">6.5.2.4</a>), prefix increment and decrement operators
+    (<a href="#6.5.3.1">6.5.3.1</a>), preprocessing directives (<a href="#6.10">6.10</a>), preprocessing numbers (<a href="#6.4.8">6.4.8</a>), string literals
+    (<a href="#6.4.5">6.4.5</a>).
+<a name="6.4.1" href="#6.4.1"><b>    6.4.1 Keywords</b></a>
+<b>    Syntax</b>
+1            keyword: one of
+                   alignof                         goto                         union
+                   auto                            if                           unsigned
+                   break                           inline                       void
+                   case                            int                          volatile
+                   char                            long                         while
+                   const                           register                     _Alignas
+                   continue                        restrict                     _Atomic
+                   default                         return                       _Bool
+                   do                              short                        _Complex
+                   double                          signed                       _Generic
+                   else                            sizeof                       _Imaginary
+                   enum                            static                       _Noreturn
+                   extern                          struct                       _Static_assert
+                   float                           switch                       _Thread_local
+                   for                             typedef
+<b>    Semantics</b>
+2   The above tokens (case sensitive) are reserved (in translation phases 7 and 8) for use as
+    keywords, and shall not be used otherwise. The keyword _Imaginary is reserved for
+
+[<a name="p58" href="#p58">page 58</a>] (<a href="#Contents">Contents</a>)
+
+    specifying imaginary types.<sup><a href="#note70"><b>70)</b></a></sup>
+<a name="6.4.2" href="#6.4.2"><b>    6.4.2 Identifiers</b></a>
+<a name="6.4.2.1" href="#6.4.2.1"><b>    6.4.2.1 General</b></a>
+<b>    Syntax</b>
+1            identifier:
+                    identifier-nondigit
+                    identifier identifier-nondigit
+                    identifier digit
+             identifier-nondigit:
+                    nondigit
+                    universal-character-name
+                    other implementation-defined characters
+             nondigit: one of
+                    _ a b            c    d    e    f     g    h    i    j     k    l    m
+                        n o          p    q    r    s     t    u    v    w     x    y    z
+                        A B          C    D    E    F     G    H    I    J     K    L    M
+                        N O          P    Q    R    S     T    U    V    W     X    Y    Z
+             digit: one of
+                    0 1        2     3    4    5    6     7    8    9
+<b>    Semantics</b>
+2   An identifier is a sequence of nondigit characters (including the underscore _, the
+    lowercase and uppercase Latin letters, and other characters) and digits, which designates
+    one or more entities as described in <a href="#6.2.1">6.2.1</a>. Lowercase and uppercase letters are distinct.
+    There is no specific limit on the maximum length of an identifier.
+3   Each universal character name in an identifier shall designate a character whose encoding
+    in ISO/IEC 10646 falls into one of the ranges specified in D.1.<sup><a href="#note71"><b>71)</b></a></sup> The initial character
+    shall not be a universal character name designating a character whose encoding falls into
+    one of the ranges specified in <a href="#D.2">D.2</a>. An implementation may allow multibyte characters
+    that are not part of the basic source character set to appear in identifiers; which characters
+    and their correspondence to universal character names is implementation-defined.
+
+
+
+    <sup><a name="note70" href="#note70"><b>70)</b></a></sup> One possible specification for imaginary types appears in <a href="#G">annex G</a>.
+    <sup><a name="note71" href="#note71"><b>71)</b></a></sup> On systems in which linkers cannot accept extended characters, an encoding of the universal character
+        name may be used in forming valid external identifiers. For example, some otherwise unused
+        character or sequence of characters may be used to encode the \u in a universal character name.
+        Extended characters may produce a long external identifier.
+
+[<a name="p59" href="#p59">page 59</a>] (<a href="#Contents">Contents</a>)
+
+4   When preprocessing tokens are converted to tokens during translation phase 7, if a
+    preprocessing token could be converted to either a keyword or an identifier, it is converted
+    to a keyword.
+    Implementation limits
+5   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of significant initial
+    characters in an identifier; the limit for an external name (an identifier that has external
+    linkage) may be more restrictive than that for an internal name (a macro name or an
+    identifier that does not have external linkage). The number of significant characters in an
+    identifier is implementation-defined.
+6   Any identifiers that differ in a significant character are different identifiers. If two
+    identifiers differ only in nonsignificant characters, the behavior is undefined.
+    Forward references: universal character names (<a href="#6.4.3">6.4.3</a>), macro replacement (<a href="#6.10.3">6.10.3</a>).
+<a name="6.4.2.2" href="#6.4.2.2"><b>    6.4.2.2 Predefined identifiers</b></a>
+<b>    Semantics</b>
+1   The identifier __func__ shall be implicitly declared by the translator as if,
+    immediately following the opening brace of each function definition, the declaration
+             static const char __func__[] = "function-name";
+    appeared, where function-name is the name of the lexically-enclosing function.<sup><a href="#note72"><b>72)</b></a></sup>
+2   This name is encoded as if the implicit declaration had been written in the source
+    character set and then translated into the execution character set as indicated in translation
+    phase 5.
+3   EXAMPLE        Consider the code fragment:
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             void myfunc(void)
+             {
+                   printf("%s\n", __func__);
+                   /* ... */
+             }
+    Each time the function is called, it will print to the standard output stream:
+             myfunc
+
+    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+
+
+
+
+    <sup><a name="note72" href="#note72"><b>72)</b></a></sup> Since the name __func__ is reserved for any use by the implementation (<a href="#7.1.3">7.1.3</a>), if any other
+        identifier is explicitly declared using the name __func__, the behavior is undefined.
+
+[<a name="p60" href="#p60">page 60</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.3" href="#6.4.3"><b>    6.4.3 Universal character names</b></a>
+<b>    Syntax</b>
+1            universal-character-name:
+                    \u hex-quad
+                    \U hex-quad hex-quad
+             hex-quad:
+                    hexadecimal-digit hexadecimal-digit
+                                 hexadecimal-digit hexadecimal-digit
+<b>    Constraints</b>
+2   A universal character name shall not specify a character whose short identifier is less than
+    00A0 other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through
+    DFFF inclusive.<sup><a href="#note73"><b>73)</b></a></sup>
+<b>    Description</b>
+3   Universal character names may be used in identifiers, character constants, and string
+    literals to designate characters that are not in the basic character set.
+<b>    Semantics</b>
+4   The universal character name \Unnnnnnnn designates the character whose eight-digit
+    short identifier (as specified by ISO/IEC 10646) is nnnnnnnn.<sup><a href="#note74"><b>74)</b></a></sup> Similarly, the universal
+    character name \unnnn designates the character whose four-digit short identifier is nnnn
+    (and whose eight-digit short identifier is 0000nnnn).
+
+
+
+
+    <sup><a name="note73" href="#note73"><b>73)</b></a></sup> The disallowed characters are the characters in the basic character set and the code positions reserved
+        by ISO/IEC 10646 for control characters, the character DELETE, and the S-zone (reserved for use by
+        UTF-16).
+
+    <sup><a name="note74" href="#note74"><b>74)</b></a></sup> Short identifiers for characters were first specified in ISO/IEC 10646-1/AMD9:1997.
+
+[<a name="p61" href="#p61">page 61</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.4" href="#6.4.4"><b>    6.4.4 Constants</b></a>
+<b>    Syntax</b>
+1            constant:
+                    integer-constant
+                    floating-constant
+                    enumeration-constant
+                    character-constant
+<b>    Constraints</b>
+2   Each constant shall have a type and the value of a constant shall be in the range of
+    representable values for its type.
+<b>    Semantics</b>
+3   Each constant has a type, determined by its form and value, as detailed later.
+<a name="6.4.4.1" href="#6.4.4.1"><b>    6.4.4.1 Integer constants</b></a>
+<b>    Syntax</b>
+1            integer-constant:
+                     decimal-constant integer-suffixopt
+                     octal-constant integer-suffixopt
+                     hexadecimal-constant integer-suffixopt
+             decimal-constant:
+                   nonzero-digit
+                   decimal-constant digit
+             octal-constant:
+                    0
+                    octal-constant octal-digit
+             hexadecimal-constant:
+                   hexadecimal-prefix hexadecimal-digit
+                   hexadecimal-constant hexadecimal-digit
+             hexadecimal-prefix: one of
+                   0x 0X
+             nonzero-digit: one of
+                    1 2 3 4          5     6     7   8    9
+             octal-digit: one of
+                     0 1 2 3         4     5     6   7
+
+[<a name="p62" href="#p62">page 62</a>] (<a href="#Contents">Contents</a>)
+
+            hexadecimal-digit:   one of
+                  0 1 2           3 4     5    6   7     8   9
+                  a b c           d e     f
+                  A B C           D E     F
+            integer-suffix:
+                    unsigned-suffix long-suffixopt
+                    unsigned-suffix long-long-suffix
+                    long-suffix unsigned-suffixopt
+                    long-long-suffix unsigned-suffixopt
+            unsigned-suffix: one of
+                   u U
+            long-suffix: one of
+                   l L
+            long-long-suffix: one of
+                   ll LL
+<b>    Description</b>
+2   An integer constant begins with a digit, but has no period or exponent part. It may have a
+    prefix that specifies its base and a suffix that specifies its type.
+3   A decimal constant begins with a nonzero digit and consists of a sequence of decimal
+    digits. An octal constant consists of the prefix 0 optionally followed by a sequence of the
+    digits 0 through 7 only. A hexadecimal constant consists of the prefix 0x or 0X followed
+    by a sequence of the decimal digits and the letters a (or A) through f (or F) with values
+    10 through 15 respectively.
+<b>    Semantics</b>
+4   The value of a decimal constant is computed base 10; that of an octal constant, base 8;
+    that of a hexadecimal constant, base 16. The lexically first digit is the most significant.
+5   The type of an integer constant is the first of the corresponding list in which its value can
+    be represented.
+
+[<a name="p63" href="#p63">page 63</a>] (<a href="#Contents">Contents</a>)
+
+                                                                     Octal or Hexadecimal
+    Suffix                       Decimal Constant                           Constant
+
+    none                int                                    int
+                        long int                               unsigned int
+                        long long int                          long int
+                                                               unsigned long int
+                                                               long long int
+                                                               unsigned long long int
+
+    u or U              unsigned int                           unsigned int
+                        unsigned long int                      unsigned long int
+                        unsigned long long int                 unsigned long long int
+
+    l or L              long int                               long int
+                        long long int                          unsigned long int
+                                                               long long int
+                                                               unsigned long long int
+
+    Both u or U         unsigned long int                      unsigned long int
+    and l or L          unsigned long long int                 unsigned long long int
+
+    ll or LL            long long int                          long long int
+                                                               unsigned long long int
+
+    Both u or U         unsigned long long int                 unsigned long long int
+    and ll or LL
+6   If an integer constant cannot be represented by any type in its list, it may have an
+    extended integer type, if the extended integer type can represent its value. If all of the
+    types in the list for the constant are signed, the extended integer type shall be signed. If
+    all of the types in the list for the constant are unsigned, the extended integer type shall be
+    unsigned. If the list contains both signed and unsigned types, the extended integer type
+    may be signed or unsigned. If an integer constant cannot be represented by any type in
+    its list and has no extended integer type, then the integer constant has no type.
+
+[<a name="p64" href="#p64">page 64</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.4.2" href="#6.4.4.2"><b>    6.4.4.2 Floating constants</b></a>
+<b>    Syntax</b>
+1            floating-constant:
+                    decimal-floating-constant
+                    hexadecimal-floating-constant
+             decimal-floating-constant:
+                   fractional-constant exponent-partopt floating-suffixopt
+                   digit-sequence exponent-part floating-suffixopt
+             hexadecimal-floating-constant:
+                   hexadecimal-prefix hexadecimal-fractional-constant
+                                  binary-exponent-part floating-suffixopt
+                   hexadecimal-prefix hexadecimal-digit-sequence
+                                  binary-exponent-part floating-suffixopt
+             fractional-constant:
+                     digit-sequenceopt . digit-sequence
+                     digit-sequence .
+             exponent-part:
+                   e signopt digit-sequence
+                   E signopt digit-sequence
+             sign: one of
+                    + -
+             digit-sequence:
+                     digit
+                     digit-sequence digit
+             hexadecimal-fractional-constant:
+                   hexadecimal-digit-sequenceopt .
+                                  hexadecimal-digit-sequence
+                   hexadecimal-digit-sequence .
+             binary-exponent-part:
+                    p signopt digit-sequence
+                    P signopt digit-sequence
+             hexadecimal-digit-sequence:
+                   hexadecimal-digit
+                   hexadecimal-digit-sequence hexadecimal-digit
+             floating-suffix: one of
+                    f l F L
+
+[<a name="p65" href="#p65">page 65</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   A floating constant has a significand part that may be followed by an exponent part and a
+    suffix that specifies its type. The components of the significand part may include a digit
+    sequence representing the whole-number part, followed by a period (.), followed by a
+    digit sequence representing the fraction part. The components of the exponent part are an
+    e, E, p, or P followed by an exponent consisting of an optionally signed digit sequence.
+    Either the whole-number part or the fraction part has to be present; for decimal floating
+    constants, either the period or the exponent part has to be present.
+<b>    Semantics</b>
+3   The significand part is interpreted as a (decimal or hexadecimal) rational number; the
+    digit sequence in the exponent part is interpreted as a decimal integer. For decimal
+    floating constants, the exponent indicates the power of 10 by which the significand part is
+    to be scaled. For hexadecimal floating constants, the exponent indicates the power of 2
+    by which the significand part is to be scaled. For decimal floating constants, and also for
+    hexadecimal floating constants when FLT_RADIX is not a power of 2, the result is either
+    the nearest representable value, or the larger or smaller representable value immediately
+    adjacent to the nearest representable value, chosen in an implementation-defined manner.
+    For hexadecimal floating constants when FLT_RADIX is a power of 2, the result is
+    correctly rounded.
+4   An unsuffixed floating constant has type double. If suffixed by the letter f or F, it has
+    type float. If suffixed by the letter l or L, it has type long double.
+5   Floating constants are converted to internal format as if at translation-time. The
+    conversion of a floating constant shall not raise an exceptional condition or a floating-
+    point exception at execution time. All floating constants of the same source form<sup><a href="#note75"><b>75)</b></a></sup> shall
+    convert to the same internal format with the same value.
+    Recommended practice
+6   The implementation should produce a diagnostic message if a hexadecimal constant
+    cannot be represented exactly in its evaluation format; the implementation should then
+    proceed with the translation of the program.
+7   The translation-time conversion of floating constants should match the execution-time
+    conversion of character strings by library functions, such as strtod, given matching
+    inputs suitable for both conversions, the same result format, and default execution-time
+    rounding.<sup><a href="#note76"><b>76)</b></a></sup>
+
+    <sup><a name="note75" href="#note75"><b>75)</b></a></sup> <a href="#1.23">1.23</a>, 1.230, 123e-2, 123e-02, and 1.23L are all different source forms and thus need not
+        convert to the same internal format and value.
+    <sup><a name="note76" href="#note76"><b>76)</b></a></sup> The specification for the library functions recommends more accurate conversion than required for
+        floating constants (see <a href="#7.22.1.3">7.22.1.3</a>).
+
+[<a name="p66" href="#p66">page 66</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.4.3" href="#6.4.4.3"><b>    6.4.4.3 Enumeration constants</b></a>
+<b>    Syntax</b>
+1            enumeration-constant:
+                   identifier
+<b>    Semantics</b>
+2   An identifier declared as an enumeration constant has type int.
+    Forward references: enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>).
+<a name="6.4.4.4" href="#6.4.4.4"><b>    6.4.4.4 Character constants</b></a>
+<b>    Syntax</b>
+1            character-constant:
+                    ' c-char-sequence '
+                    L' c-char-sequence '
+                    u' c-char-sequence '
+                    U' c-char-sequence '
+             c-char-sequence:
+                    c-char
+                    c-char-sequence c-char
+             c-char:
+                       any member of the source character set except
+                                    the single-quote ', backslash \, or new-line character
+                       escape-sequence
+             escape-sequence:
+                    simple-escape-sequence
+                    octal-escape-sequence
+                    hexadecimal-escape-sequence
+                    universal-character-name
+             simple-escape-sequence: one of
+                    \' \" \? \\
+                    \a \b \f \n \r                  \t    \v
+             octal-escape-sequence:
+                     \ octal-digit
+                     \ octal-digit octal-digit
+                     \ octal-digit octal-digit octal-digit
+
+[<a name="p67" href="#p67">page 67</a>] (<a href="#Contents">Contents</a>)
+
+           hexadecimal-escape-sequence:
+                 \x hexadecimal-digit
+                 hexadecimal-escape-sequence hexadecimal-digit
+<b>    Description</b>
+2   An integer character constant is a sequence of one or more multibyte characters enclosed
+    in single-quotes, as in 'x'. A wide character constant is the same, except prefixed by the
+    letter L, u, or U. With a few exceptions detailed later, the elements of the sequence are
+    any members of the source character set; they are mapped in an implementation-defined
+    manner to members of the execution character set.
+3   The single-quote ', the double-quote ", the question-mark ?, the backslash \, and
+    arbitrary integer values are representable according to the following table of escape
+    sequences:
+          single quote '            \'
+          double quote "            \"
+          question mark ?           \?
+          backslash \               \\
+          octal character           \octal digits
+          hexadecimal character     \x hexadecimal digits
+4   The double-quote " and question-mark ? are representable either by themselves or by the
+    escape sequences \" and \?, respectively, but the single-quote ' and the backslash \
+    shall be represented, respectively, by the escape sequences \' and \\.
+5   The octal digits that follow the backslash in an octal escape sequence are taken to be part
+    of the construction of a single character for an integer character constant or of a single
+    wide character for a wide character constant. The numerical value of the octal integer so
+    formed specifies the value of the desired character or wide character.
+6   The hexadecimal digits that follow the backslash and the letter x in a hexadecimal escape
+    sequence are taken to be part of the construction of a single character for an integer
+    character constant or of a single wide character for a wide character constant. The
+    numerical value of the hexadecimal integer so formed specifies the value of the desired
+    character or wide character.
+7   Each octal or hexadecimal escape sequence is the longest sequence of characters that can
+    constitute the escape sequence.
+8   In addition, characters not in the basic character set are representable by universal
+    character names and certain nongraphic characters are representable by escape sequences
+    consisting of the backslash \ followed by a lowercase letter: \a, \b, \f, \n, \r, \t,
+    and \v.<sup><a href="#note77"><b>77)</b></a></sup>
+
+[<a name="p68" href="#p68">page 68</a>] (<a href="#Contents">Contents</a>)
+
+<b>     Constraints</b>
+9    The value of an octal or hexadecimal escape sequence shall be in the range of
+     representable values for the corresponding type:
+            Prefix      Corresponding Type
+            none       unsigned char
+            L          the unsigned type corresponding to wchar_t
+            u          char16_t
+            U          char32_t
+<b>     Semantics</b>
+10   An integer character constant has type int. The value of an integer character constant
+     containing a single character that maps to a single-byte execution character is the
+     numerical value of the representation of the mapped character interpreted as an integer.
+     The value of an integer character constant containing more than one character (e.g.,
+     'ab'), or containing a character or escape sequence that does not map to a single-byte
+     execution character, is implementation-defined. If an integer character constant contains
+     a single character or escape sequence, its value is the one that results when an object with
+     type char whose value is that of the single character or escape sequence is converted to
+     type int.
+11   A wide character constant prefixed by the letter L has type wchar_t, an integer type
+     defined in the <a href="#7.19">&lt;stddef.h&gt;</a> header; a wide character constant prefixed by the letter u or
+     U has type char16_t or char32_t, respectively, unsigned integer types defined in the
+     <a href="#7.27">&lt;uchar.h&gt;</a> header. The value of a wide character constant containing a single
+     multibyte character that maps to a single member of the extended execution character set
+     is the wide character corresponding to that multibyte character, as defined by the
+     mbtowc, mbrtoc16, or mbrtoc32 function as appropriate for its type, with an
+     implementation-defined current locale. The value of a wide character constant containing
+     more than one multibyte character or a single multibyte character that maps to multiple
+     members of the extended execution character set, or containing a multibyte character or
+     escape sequence not represented in the extended execution character set, is
+     implementation-defined.
+12   EXAMPLE 1      The construction '\0' is commonly used to represent the null character.
+
+13   EXAMPLE 2 Consider implementations that use two's complement representation for integers and eight
+     bits for objects that have type char. In an implementation in which type char has the same range of
+     values as signed char, the integer character constant '\xFF' has the value -1; if type char has the
+     same range of values as unsigned char, the character constant '\xFF' has the value +255.
+
+
+
+
+     <sup><a name="note77" href="#note77"><b>77)</b></a></sup> The semantics of these characters were discussed in <a href="#5.2.2">5.2.2</a>. If any other character follows a backslash,
+         the result is not a token and a diagnostic is required. See ''future language directions'' (<a href="#6.11.4">6.11.4</a>).
+
+[<a name="p69" href="#p69">page 69</a>] (<a href="#Contents">Contents</a>)
+
+14   EXAMPLE 3 Even if eight bits are used for objects that have type char, the construction '\x123'
+     specifies an integer character constant containing only one character, since a hexadecimal escape sequence
+     is terminated only by a non-hexadecimal character. To specify an integer character constant containing the
+     two characters whose values are '\x12' and '3', the construction '\0223' may be used, since an octal
+     escape sequence is terminated after three octal digits. (The value of this two-character integer character
+     constant is implementation-defined.)
+
+15   EXAMPLE 4 Even if 12 or more bits are used for objects that have type wchar_t, the construction
+     L'\1234' specifies the implementation-defined value that results from the combination of the values
+     0123 and '4'.
+
+     Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), the mbtowc function
+     (<a href="#7.22.7.2">7.22.7.2</a>), Unicode utilities <a href="#7.27">&lt;uchar.h&gt;</a> (<a href="#7.27">7.27</a>).
+<a name="6.4.5" href="#6.4.5"><b>     6.4.5 String literals</b></a>
+<b>     Syntax</b>
+1             string-literal:
+                      encoding-prefixopt " s-char-sequenceopt "
+              encoding-prefix:
+                     u8
+                     u
+                     U
+                     L
+              s-char-sequence:
+                     s-char
+                     s-char-sequence s-char
+              s-char:
+                        any member of the source character set except
+                                     the double-quote ", backslash \, or new-line character
+                        escape-sequence
+<b>     Constraints</b>
+2    A sequence of adjacent string literal tokens shall not include both a wide string literal and
+     a UTF-8 string literal.
+<b>     Description</b>
+3    A character string literal is a sequence of zero or more multibyte characters enclosed in
+     double-quotes, as in "xyz". A UTF-8 string literal is the same, except prefixed by u8.
+     A wide string literal is the same, except prefixed by the letter L, u, or U.
+4    The same considerations apply to each element of the sequence in a string literal as if it
+     were in an integer character constant (for a character or UTF-8 string literal) or a wide
+     character constant (for a wide string literal), except that the single-quote ' is
+     representable either by itself or by the escape sequence \', but the double-quote " shall
+
+[<a name="p70" href="#p70">page 70</a>] (<a href="#Contents">Contents</a>)
+
+    be represented by the escape sequence \".
+<b>    Semantics</b>
+5   In translation phase 6, the multibyte character sequences specified by any sequence of
+    adjacent character and identically-prefixed string literal tokens are concatenated into a
+    single multibyte character sequence. If any of the tokens has an encoding prefix, the
+    resulting multibyte character sequence is treated as having the same prefix; otherwise, it
+    is treated as a character string literal. Whether differently-prefixed wide string literal
+    tokens can be concatenated and, if so, the treatment of the resulting multibyte character
+    sequence are implementation-defined.
+6   In translation phase 7, a byte or code of value zero is appended to each multibyte
+    character sequence that results from a string literal or literals.<sup><a href="#note78"><b>78)</b></a></sup> The multibyte character
+    sequence is then used to initialize an array of static storage duration and length just
+    sufficient to contain the sequence. For character string literals, the array elements have
+    type char, and are initialized with the individual bytes of the multibyte character
+    sequence. For UTF-8 string literals, the array elements have type char, and are
+    initialized with the characters of the multibyte character sequence, as encoded in UTF-8.
+    For wide string literals prefixed by the letter L, the array elements have type wchar_t
+    and are initialized with the sequence of wide characters corresponding to the multibyte
+    character sequence, as defined by the mbstowcs function with an implementation-
+    defined current locale. For wide string literals prefixed by the letter u or U, the array
+    elements have type char16_t or char32_t, respectively, and are initialized with the
+    sequence of wide characters corresponding to the multibyte character sequence, as
+    defined by successive calls to the mbrtoc16, or mbrtoc32 function as appropriate for
+    its type, with an implementation-defined current locale. The value of a string literal
+    containing a multibyte character or escape sequence not represented in the execution
+    character set is implementation-defined.
+7   It is unspecified whether these arrays are distinct provided their elements have the
+    appropriate values. If the program attempts to modify such an array, the behavior is
+    undefined.
+8   EXAMPLE 1      This pair of adjacent character string literals
+             "\x12" "3"
+    produces a single character string literal containing the two characters whose values are '\x12' and '3',
+    because escape sequences are converted into single members of the execution character set just prior to
+    adjacent string literal concatenation.
+
+9   EXAMPLE 2      Each of the sequences of adjacent string literal tokens
+
+
+
+    <sup><a name="note78" href="#note78"><b>78)</b></a></sup> A string literal need not be a string (see <a href="#7.1.1">7.1.1</a>), because a null character may be embedded in it by a
+        \0 escape sequence.
+
+[<a name="p71" href="#p71">page 71</a>] (<a href="#Contents">Contents</a>)
+
+             "a" "b" L"c"
+             "a" L"b" "c"
+             L"a" "b" L"c"
+             L"a" L"b" L"c"
+    is equivalent to the string literal
+             L"abc"
+    Likewise, each of the sequences
+             "a" "b" u"c"
+             "a" u"b" "c"
+             u"a" "b" u"c"
+             u"a" u"b" u"c"
+    is equivalent to
+             u"abc"
+
+    Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), the mbstowcs
+    function (<a href="#7.22.8.1">7.22.8.1</a>), Unicode utilities <a href="#7.27">&lt;uchar.h&gt;</a> (<a href="#7.27">7.27</a>).
+<a name="6.4.6" href="#6.4.6"><b>    6.4.6 Punctuators</b></a>
+<b>    Syntax</b>
+1            punctuator: one of
+                    [ ] ( ) { } . -&gt;
+                    ++ -- &amp; * + - ~ !
+                    / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                         ==    !=    ^    |   &amp;&amp;   ||
+                    ? : ; ...
+                    = *= /= %= += -= &lt;&lt;=                        &gt;&gt;=    &amp;=       ^=   |=
+                    , # ##
+                    &lt;: :&gt; &lt;% %&gt; %: %:%:
+<b>    Semantics</b>
+2   A punctuator is a symbol that has independent syntactic and semantic significance.
+    Depending on context, it may specify an operation to be performed (which in turn may
+    yield a value or a function designator, produce a side effect, or some combination thereof)
+    in which case it is known as an operator (other forms of operator also exist in some
+    contexts). An operand is an entity on which an operator acts.
+
+[<a name="p72" href="#p72">page 72</a>] (<a href="#Contents">Contents</a>)
+
+3   In all aspects of the language, the six tokens<sup><a href="#note79"><b>79)</b></a></sup>
+             &lt;:    :&gt;      &lt;%    %&gt;     %:     %:%:
+    behave, respectively, the same as the six tokens
+             [     ]       {     }      #      ##
+    except for their spelling.<sup><a href="#note80"><b>80)</b></a></sup>
+    Forward references: expressions (<a href="#6.5">6.5</a>), declarations (<a href="#6.7">6.7</a>), preprocessing directives
+    (<a href="#6.10">6.10</a>), statements (<a href="#6.8">6.8</a>).
+<a name="6.4.7" href="#6.4.7"><b>    6.4.7 Header names</b></a>
+<b>    Syntax</b>
+1            header-name:
+                    &lt; h-char-sequence &gt;
+                    " q-char-sequence "
+             h-char-sequence:
+                    h-char
+                    h-char-sequence h-char
+             h-char:
+                       any member of the source character set except
+                                    the new-line character and &gt;
+             q-char-sequence:
+                    q-char
+                    q-char-sequence q-char
+             q-char:
+                       any member of the source character set except
+                                    the new-line character and "
+<b>    Semantics</b>
+2   The sequences in both forms of header names are mapped in an implementation-defined
+    manner to headers or external source file names as specified in <a href="#6.10.2">6.10.2</a>.
+3   If the characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt; delimiters,
+    the behavior is undefined. Similarly, if the characters ', \, //, or /* occur in the
+
+
+
+
+    <sup><a name="note79" href="#note79"><b>79)</b></a></sup> These tokens are sometimes called ''digraphs''.
+    <sup><a name="note80" href="#note80"><b>80)</b></a></sup> Thus [ and &lt;: behave differently when ''stringized'' (see <a href="#6.10.3.2">6.10.3.2</a>), but can otherwise be freely
+        interchanged.
+
+[<a name="p73" href="#p73">page 73</a>] (<a href="#Contents">Contents</a>)
+
+    sequence between the " delimiters, the behavior is undefined.<sup><a href="#note81"><b>81)</b></a></sup> Header name
+    preprocessing tokens are recognized only within #include preprocessing directives and
+    in implementation-defined locations within #pragma directives.<sup><a href="#note82"><b>82)</b></a></sup>
+4   EXAMPLE       The following sequence of characters:
+             0x3&lt;1/a.h&gt;1e2
+             #include &lt;1/a.h&gt;
+             #define const.member@$
+    forms the following sequence of preprocessing tokens (with each individual preprocessing token delimited
+    by a { on the left and a } on the right).
+             {0x3}{&lt;}{1}{/}{a}{.}{h}{&gt;}{1e2}
+             {#}{include} {&lt;1/a.h&gt;}
+             {#}{define} {const}{.}{member}{@}{$}
+
+    Forward references: source file inclusion (<a href="#6.10.2">6.10.2</a>).
+<a name="6.4.8" href="#6.4.8"><b>    6.4.8 Preprocessing numbers</b></a>
+<b>    Syntax</b>
+1            pp-number:
+                   digit
+                   . digit
+                   pp-number       digit
+                   pp-number       identifier-nondigit
+                   pp-number       e sign
+                   pp-number       E sign
+                   pp-number       p sign
+                   pp-number       P sign
+                   pp-number       .
+<b>    Description</b>
+2   A preprocessing number begins with a digit optionally preceded by a period (.) and may
+    be followed by valid identifier characters and the character sequences e+, e-, E+, E-,
+    p+, p-, P+, or P-.
+3   Preprocessing number tokens lexically include all floating and integer constant tokens.
+<b>    Semantics</b>
+4   A preprocessing number does not have type or a value; it acquires both after a successful
+    conversion (as part of translation phase 7) to a floating constant token or an integer
+    constant token.
+
+
+    <sup><a name="note81" href="#note81"><b>81)</b></a></sup> Thus, sequences of characters that resemble escape sequences cause undefined behavior.
+    <sup><a name="note82" href="#note82"><b>82)</b></a></sup> For an example of a header name preprocessing token used in a #pragma directive, see <a href="#6.10.9">6.10.9</a>.
+
+[<a name="p74" href="#p74">page 74</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.4.9" href="#6.4.9"><b>    6.4.9 Comments</b></a>
+1   Except within a character constant, a string literal, or a comment, the characters /*
+    introduce a comment. The contents of such a comment are examined only to identify
+    multibyte characters and to find the characters */ that terminate it.<sup><a href="#note83"><b>83)</b></a></sup>
+2   Except within a character constant, a string literal, or a comment, the characters //
+    introduce a comment that includes all multibyte characters up to, but not including, the
+    next new-line character. The contents of such a comment are examined only to identify
+    multibyte characters and to find the terminating new-line character.
+3   EXAMPLE
+             "a//b"                             //   four-character string literal
+             #include "//e"                     //   undefined behavior
+             // */                              //   comment, not syntax error
+             f = g/**//h;                       //   equivalent to f = g / h;
+             //\
+             i();                               // part of a two-line comment
+             /\
+             / j();                             // part of a two-line comment
+             #define glue(x,y) x##y
+             glue(/,/) k();                     // syntax error, not comment
+             /*//*/ l();                        // equivalent to l();
+             m = n//**/o
+                + p;                            // equivalent to m = n + p;
+
+
+
+
+    <sup><a name="note83" href="#note83"><b>83)</b></a></sup> Thus, /* ... */ comments do not nest.
+
+[<a name="p75" href="#p75">page 75</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5" href="#6.5"><b>    6.5 Expressions</b></a>
+1   An expression is a sequence of operators and operands that specifies computation of a
+    value, or that designates an object or a function, or that generates side effects, or that
+    performs a combination thereof. The value computations of the operands of an operator
+    are sequenced before the value computation of the result of the operator.
+2   If a side effect on a scalar object is unsequenced relative to either a different side effect
+    on the same scalar object or a value computation using the value of the same scalar
+    object, the behavior is undefined. If there are multiple allowable orderings of the
+    subexpressions of an expression, the behavior is undefined if such an unsequenced side
+    effect occurs in any of the orderings.<sup><a href="#note84"><b>84)</b></a></sup>
+3   The grouping of operators and operands is indicated by the syntax.<sup><a href="#note85"><b>85)</b></a></sup> Except as specified
+    later, side effects and value computations of subexpressions are unsequenced.<sup><a href="#note86"><b>86)</b></a></sup>         *
+4   Some operators (the unary operator ~, and the binary operators &lt;&lt;, &gt;&gt;, &amp;, ^, and |,
+    collectively described as bitwise operators) are required to have operands that have
+    integer type. These operators yield values that depend on the internal representations of
+    integers, and have implementation-defined and undefined aspects for signed types.
+5   If an exceptional condition occurs during the evaluation of an expression (that is, if the
+    result is not mathematically defined or not in the range of representable values for its
+    type), the behavior is undefined.
+
+
+
+    <sup><a name="note84" href="#note84"><b>84)</b></a></sup> This paragraph renders undefined statement expressions such as
+                  i = ++i + 1;
+                  a[i++] = i;
+         while allowing
+                  i = i + 1;
+                  a[i] = i;
+
+    <sup><a name="note85" href="#note85"><b>85)</b></a></sup> The syntax specifies the precedence of operators in the evaluation of an expression, which is the same
+        as the order of the major subclauses of this subclause, highest precedence first. Thus, for example, the
+        expressions allowed as the operands of the binary + operator (<a href="#6.5.6">6.5.6</a>) are those expressions defined in
+        <a href="#6.5.1">6.5.1</a> through <a href="#6.5.6">6.5.6</a>. The exceptions are cast expressions (<a href="#6.5.4">6.5.4</a>) as operands of unary operators
+        (<a href="#6.5.3">6.5.3</a>), and an operand contained between any of the following pairs of operators: grouping
+        parentheses () (<a href="#6.5.1">6.5.1</a>), subscripting brackets [] (<a href="#6.5.2.1">6.5.2.1</a>), function-call parentheses () (<a href="#6.5.2.2">6.5.2.2</a>), and
+        the conditional operator ? : (<a href="#6.5.15">6.5.15</a>).
+         Within each major subclause, the operators have the same precedence. Left- or right-associativity is
+         indicated in each subclause by the syntax for the expressions discussed therein.
+    <sup><a name="note86" href="#note86"><b>86)</b></a></sup> In an expression that is evaluated more than once during the execution of a program, unsequenced and
+        indeterminately sequenced evaluations of its subexpressions need not be performed consistently in
+        different evaluations.
+
+[<a name="p76" href="#p76">page 76</a>] (<a href="#Contents">Contents</a>)
+
+6   The effective type of an object for an access to its stored value is the declared type of the
+    object, if any.<sup><a href="#note87"><b>87)</b></a></sup> If a value is stored into an object having no declared type through an
+    lvalue having a type that is not a character type, then the type of the lvalue becomes the
+    effective type of the object for that access and for subsequent accesses that do not modify
+    the stored value. If a value is copied into an object having no declared type using
+    memcpy or memmove, or is copied as an array of character type, then the effective type
+    of the modified object for that access and for subsequent accesses that do not modify the
+    value is the effective type of the object from which the value is copied, if it has one. For
+    all other accesses to an object having no declared type, the effective type of the object is
+    simply the type of the lvalue used for the access.
+7   An object shall have its stored value accessed only by an lvalue expression that has one of
+    the following types:<sup><a href="#note88"><b>88)</b></a></sup>
+    -- a type compatible with the effective type of the object,
+    -- a qualified version of a type compatible with the effective type of the object,
+    -- a type that is the signed or unsigned type corresponding to the effective type of the
+      object,
+    -- a type that is the signed or unsigned type corresponding to a qualified version of the
+      effective type of the object,
+    -- an aggregate or union type that includes one of the aforementioned types among its
+      members (including, recursively, a member of a subaggregate or contained union), or
+    -- a character type.
+8   A floating expression may be contracted, that is, evaluated as though it were a single
+    operation, thereby omitting rounding errors implied by the source code and the
+    expression evaluation method.<sup><a href="#note89"><b>89)</b></a></sup> The FP_CONTRACT pragma in <a href="#7.12">&lt;math.h&gt;</a> provides a
+    way to disallow contracted expressions. Otherwise, whether and how expressions are
+    contracted is implementation-defined.<sup><a href="#note90"><b>90)</b></a></sup>
+    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.23.2">7.23.2</a>).
+
+
+    <sup><a name="note87" href="#note87"><b>87)</b></a></sup> Allocated objects have no declared type.
+    <sup><a name="note88" href="#note88"><b>88)</b></a></sup> The intent of this list is to specify those circumstances in which an object may or may not be aliased.
+    <sup><a name="note89" href="#note89"><b>89)</b></a></sup> The intermediate operations in the contracted expression are evaluated as if to infinite precision and
+        range, while the final operation is rounded to the format determined by the expression evaluation
+        method. A contracted expression might also omit the raising of floating-point exceptions.
+    <sup><a name="note90" href="#note90"><b>90)</b></a></sup> This license is specifically intended to allow implementations to exploit fast machine instructions that
+        combine multiple C operators. As contractions potentially undermine predictability, and can even
+        decrease accuracy for containing expressions, their use needs to be well-defined and clearly
+        documented.
+
+[<a name="p77" href="#p77">page 77</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.1" href="#6.5.1"><b>    6.5.1 Primary expressions</b></a>
+<b>    Syntax</b>
+1            primary-expression:
+                    identifier
+                    constant
+                    string-literal
+                    ( expression )
+                    generic-selection
+<b>    Semantics</b>
+2   An identifier is a primary expression, provided it has been declared as designating an
+    object (in which case it is an lvalue) or a function (in which case it is a function
+    designator).<sup><a href="#note91"><b>91)</b></a></sup>
+3   A constant is a primary expression. Its type depends on its form and value, as detailed in
+    <a href="#6.4.4">6.4.4</a>.
+4   A string literal is a primary expression. It is an lvalue with type as detailed in <a href="#6.4.5">6.4.5</a>.
+5   A parenthesized expression is a primary expression. Its type and value are identical to
+    those of the unparenthesized expression. It is an lvalue, a function designator, or a void
+    expression if the unparenthesized expression is, respectively, an lvalue, a function
+    designator, or a void expression.
+    Forward references: declarations (<a href="#6.7">6.7</a>).
+<a name="6.5.1.1" href="#6.5.1.1"><b>    6.5.1.1 Generic selection</b></a>
+<b>    Syntax</b>
+1            generic-selection:
+                    _Generic ( assignment-expression , generic-assoc-list )
+             generic-assoc-list:
+                    generic-association
+                    generic-assoc-list , generic-association
+             generic-association:
+                    type-name : assignment-expression
+                    default : assignment-expression
+<b>    Constraints</b>
+2   A generic selection shall have no more than one default generic association. The type
+    name in a generic association shall specify a complete object type other than a variably
+
+    <sup><a name="note91" href="#note91"><b>91)</b></a></sup> Thus, an undeclared identifier is a violation of the syntax.
+
+[<a name="p78" href="#p78">page 78</a>] (<a href="#Contents">Contents</a>)
+
+    modified type. No two generic associations in the same generic selection shall specify
+    compatible types. The controlling expression of a generic selection shall have type
+    compatible with at most one of the types named in its generic association list. If a
+    generic selection has no default generic association, its controlling expression shall
+    have type compatible with exactly one of the types named in its generic association list.
+<b>    Semantics</b>
+3   The controlling expression of a generic selection is not evaluated. If a generic selection
+    has a generic association with a type name that is compatible with the type of the
+    controlling expression, then the result expression of the generic selection is the
+    expression in that generic association. Otherwise, the result expression of the generic
+    selection is the expression in the default generic association. None of the expressions
+    from any other generic association of the generic selection is evaluated.
+4   The type and value of a generic selection are identical to those of its result expression. It
+    is an lvalue, a function designator, or a void expression if its result expression is,
+    respectively, an lvalue, a function designator, or a void expression.
+5   EXAMPLE      The cbrt type-generic macro could be implemented as follows:
+             #define cbrt(X) _Generic((X),                                      \
+                                     long double: cbrtl,                        \
+                                     default: cbrt,                             \
+                                     float: cbrtf                               \
+                                     )(X)
+
+<a name="6.5.2" href="#6.5.2"><b>    6.5.2 Postfix operators</b></a>
+<b>    Syntax</b>
+1            postfix-expression:
+                    primary-expression
+                    postfix-expression [ expression ]
+                    postfix-expression ( argument-expression-listopt )
+                    postfix-expression . identifier
+                    postfix-expression -&gt; identifier
+                    postfix-expression ++
+                    postfix-expression --
+                    ( type-name ) { initializer-list }
+                    ( type-name ) { initializer-list , }
+             argument-expression-list:
+                   assignment-expression
+                   argument-expression-list , assignment-expression
+
+[<a name="p79" href="#p79">page 79</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.2.1" href="#6.5.2.1"><b>    6.5.2.1 Array subscripting</b></a>
+<b>    Constraints</b>
+1   One of the expressions shall have type ''pointer to complete object type'', the other
+    expression shall have integer type, and the result has type ''type''.
+<b>    Semantics</b>
+2   A postfix expression followed by an expression in square brackets [] is a subscripted
+    designation of an element of an array object. The definition of the subscript operator []
+    is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that
+    apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the
+    initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th
+    element of E1 (counting from zero).
+3   Successive subscript operators designate an element of a multidimensional array object.
+    If E is an n-dimensional array (n &gt;= 2) with dimensions i x j x . . . x k, then E (used as
+    other than an lvalue) is converted to a pointer to an (n - 1)-dimensional array with
+    dimensions j x . . . x k. If the unary * operator is applied to this pointer explicitly, or
+    implicitly as a result of subscripting, the result is the referenced (n - 1)-dimensional
+    array, which itself is converted into a pointer if used as other than an lvalue. It follows
+    from this that arrays are stored in row-major order (last subscript varies fastest).
+4   EXAMPLE        Consider the array object defined by the declaration
+             int x[3][5];
+    Here x is a 3 x 5 array of ints; more precisely, x is an array of three element objects, each of which is an
+    array of five ints. In the expression x[i], which is equivalent to (*((x)+(i))), x is first converted to
+    a pointer to the initial array of five ints. Then i is adjusted according to the type of x, which conceptually
+    entails multiplying i by the size of the object to which the pointer points, namely an array of five int
+    objects. The results are added and indirection is applied to yield an array of five ints. When used in the
+    expression x[i][j], that array is in turn converted to a pointer to the first of the ints, so x[i][j]
+    yields an int.
+
+    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), address and indirection operators
+    (<a href="#6.5.3.2">6.5.3.2</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
+<a name="6.5.2.2" href="#6.5.2.2"><b>    6.5.2.2 Function calls</b></a>
+<b>    Constraints</b>
+1   The expression that denotes the called function<sup><a href="#note92"><b>92)</b></a></sup> shall have type pointer to function
+    returning void or returning a complete object type other than an array type.
+2   If the expression that denotes the called function has a type that includes a prototype, the
+    number of arguments shall agree with the number of parameters. Each argument shall
+
+
+    <sup><a name="note92" href="#note92"><b>92)</b></a></sup> Most often, this is the result of converting an identifier that is a function designator.
+
+[<a name="p80" href="#p80">page 80</a>] (<a href="#Contents">Contents</a>)
+
+    have a type such that its value may be assigned to an object with the unqualified version
+    of the type of its corresponding parameter.
+<b>    Semantics</b>
+3   A postfix expression followed by parentheses () containing a possibly empty, comma-
+    separated list of expressions is a function call. The postfix expression denotes the called
+    function. The list of expressions specifies the arguments to the function.
+4   An argument may be an expression of any complete object type. In preparing for the call
+    to a function, the arguments are evaluated, and each parameter is assigned the value of the
+    corresponding argument.<sup><a href="#note93"><b>93)</b></a></sup>
+5   If the expression that denotes the called function has type pointer to function returning an
+    object type, the function call expression has the same type as that object type, and has the
+    value determined as specified in <a href="#6.8.6.4">6.8.6.4</a>. Otherwise, the function call has type void.         *
+6   If the expression that denotes the called function has a type that does not include a
+    prototype, the integer promotions are performed on each argument, and arguments that
+    have type float are promoted to double. These are called the default argument
+    promotions. If the number of arguments does not equal the number of parameters, the
+    behavior is undefined. If the function is defined with a type that includes a prototype, and
+    either the prototype ends with an ellipsis (, ...) or the types of the arguments after
+    promotion are not compatible with the types of the parameters, the behavior is undefined.
+    If the function is defined with a type that does not include a prototype, and the types of
+    the arguments after promotion are not compatible with those of the parameters after
+    promotion, the behavior is undefined, except for the following cases:
+    -- one promoted type is a signed integer type, the other promoted type is the
+      corresponding unsigned integer type, and the value is representable in both types;
+    -- both types are pointers to qualified or unqualified versions of a character type or
+      void.
+7   If the expression that denotes the called function has a type that does include a prototype,
+    the arguments are implicitly converted, as if by assignment, to the types of the
+    corresponding parameters, taking the type of each parameter to be the unqualified version
+    of its declared type. The ellipsis notation in a function prototype declarator causes
+    argument type conversion to stop after the last declared parameter. The default argument
+    promotions are performed on trailing arguments.
+
+
+
+    <sup><a name="note93" href="#note93"><b>93)</b></a></sup> A function may change the values of its parameters, but these changes cannot affect the values of the
+        arguments. On the other hand, it is possible to pass a pointer to an object, and the function may
+        change the value of the object pointed to. A parameter declared to have array or function type is
+        adjusted to have a pointer type as described in <a href="#6.9.1">6.9.1</a>.
+
+[<a name="p81" href="#p81">page 81</a>] (<a href="#Contents">Contents</a>)
+
+8    No other conversions are performed implicitly; in particular, the number and types of
+     arguments are not compared with those of the parameters in a function definition that
+     does not include a function prototype declarator.
+9    If the function is defined with a type that is not compatible with the type (of the
+     expression) pointed to by the expression that denotes the called function, the behavior is
+     undefined.
+10   There is a sequence point after the evaluations of the function designator and the actual
+     arguments but before the actual call. Every evaluation in the calling function (including
+     other function calls) that is not otherwise specifically sequenced before or after the
+     execution of the body of the called function is indeterminately sequenced with respect to
+     the execution of the called function.<sup><a href="#note94"><b>94)</b></a></sup>
+11   Recursive function calls shall be permitted, both directly and indirectly through any chain
+     of other functions.
+12   EXAMPLE        In the function call
+              (*pf[f1()]) (f2(), f3() + f4())
+     the functions f1, f2, f3, and f4 may be called in any order. All side effects have to be completed before
+     the function pointed to by pf[f1()] is called.
+
+     Forward references: function declarators (including prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), function
+     definitions (<a href="#6.9.1">6.9.1</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>).
+<a name="6.5.2.3" href="#6.5.2.3"><b>     6.5.2.3 Structure and union members</b></a>
+<b>     Constraints</b>
+1    The first operand of the . operator shall have an atomic, qualified, or unqualified
+     structure or union type, and the second operand shall name a member of that type.
+2    The first operand of the -&gt; operator shall have type ''pointer to atomic, qualified, or
+     unqualified structure'' or ''pointer to atomic, qualified, or unqualified union'', and the
+     second operand shall name a member of the type pointed to.
+<b>     Semantics</b>
+3    A postfix expression followed by the . operator and an identifier designates a member of
+     a structure or union object. The value is that of the named member,<sup><a href="#note95"><b>95)</b></a></sup> and is an lvalue if
+     the first expression is an lvalue. If the first expression has qualified type, the result has
+     the so-qualified version of the type of the designated member.
+
+     <sup><a name="note94" href="#note94"><b>94)</b></a></sup> In other words, function executions do not ''interleave'' with each other.
+     <sup><a name="note95" href="#note95"><b>95)</b></a></sup> If the member used to read the contents of a union object is not the same as the member last used to
+         store a value in the object, the appropriate part of the object representation of the value is reinterpreted
+         as an object representation in the new type as described in <a href="#6.2.6">6.2.6</a> (a process sometimes called ''type
+         punning''). This might be a trap representation.
+
+[<a name="p82" href="#p82">page 82</a>] (<a href="#Contents">Contents</a>)
+
+4   A postfix expression followed by the -&gt; operator and an identifier designates a member
+    of a structure or union object. The value is that of the named member of the object to
+    which the first expression points, and is an lvalue.<sup><a href="#note96"><b>96)</b></a></sup> If the first expression is a pointer to
+    a qualified type, the result has the so-qualified version of the type of the designated
+    member.
+5   Accessing a member of an atomic structure or union object results in undefined
+    behavior.<sup><a href="#note97"><b>97)</b></a></sup>
+6   One special guarantee is made in order to simplify the use of unions: if a union contains
+    several structures that share a common initial sequence (see below), and if the union
+    object currently contains one of these structures, it is permitted to inspect the common
+    initial part of any of them anywhere that a declaration of the completed type of the union
+    is visible. Two structures share a common initial sequence if corresponding members
+    have compatible types (and, for bit-fields, the same widths) for a sequence of one or more
+    initial members.
+7   EXAMPLE 1 If f is a function returning a structure or union, and x is a member of that structure or
+    union, f().x is a valid postfix expression but is not an lvalue.
+
+8   EXAMPLE 2       In:
+             struct s { int i; const int ci; };
+             struct s s;
+             const struct s cs;
+             volatile struct s vs;
+    the various members have the types:
+             s.i          int
+             s.ci         const int
+             cs.i         const int
+             cs.ci        const int
+             vs.i         volatile int
+             vs.ci        volatile const int
+
+
+
+
+    <sup><a name="note96" href="#note96"><b>96)</b></a></sup> If &amp;E is a valid pointer expression (where &amp; is the ''address-of '' operator, which generates a pointer to
+        its operand), the expression (&amp;E)-&gt;MOS is the same as E.MOS.
+    <sup><a name="note97" href="#note97"><b>97)</b></a></sup> For example, a data race would occur if access to the entire structure or union in one thread conflicts
+        with access to a member from another thread, where at least one access is a modification. Members
+        can be safely accessed using a non-atomic object which is assigned to or from the atomic object.
+
+[<a name="p83" href="#p83">page 83</a>] (<a href="#Contents">Contents</a>)
+
+9   EXAMPLE 3       The following is a valid fragment:
+             union {
+                     struct {
+                           int      alltypes;
+                     } n;
+                     struct {
+                           int      type;
+                           int      intnode;
+                     } ni;
+                     struct {
+                           int      type;
+                           double doublenode;
+                     } nf;
+             } u;
+             u.nf.type = 1;
+             u.nf.doublenode = <a href="#3.14">3.14</a>;
+             /* ... */
+             if (u.n.alltypes == 1)
+                     if (sin(u.nf.doublenode) == 0.0)
+                           /* ... */
+    The following is not a valid fragment (because the union type is not visible within function f):
+             struct t1 { int m; };
+             struct t2 { int m; };
+             int f(struct t1 *p1, struct t2 *p2)
+             {
+                   if (p1-&gt;m &lt; 0)
+                           p2-&gt;m = -p2-&gt;m;
+                   return p1-&gt;m;
+             }
+             int g()
+             {
+                   union {
+                           struct t1 s1;
+                           struct t2 s2;
+                   } u;
+                   /* ... */
+                   return f(&amp;u.s1, &amp;u.s2);
+             }
+
+    Forward references: address and indirection operators (<a href="#6.5.3.2">6.5.3.2</a>), structure and union
+    specifiers (<a href="#6.7.2.1">6.7.2.1</a>).
+
+[<a name="p84" href="#p84">page 84</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.2.4" href="#6.5.2.4"><b>    6.5.2.4 Postfix increment and decrement operators</b></a>
+<b>    Constraints</b>
+1   The operand of the postfix increment or decrement operator shall have atomic, qualified,
+    or unqualified real or pointer type, and shall be a modifiable lvalue.
+<b>    Semantics</b>
+2   The result of the postfix ++ operator is the value of the operand. As a side effect, the
+    value of the operand object is incremented (that is, the value 1 of the appropriate type is
+    added to it). See the discussions of additive operators and compound assignment for
+    information on constraints, types, and conversions and the effects of operations on
+    pointers. The value computation of the result is sequenced before the side effect of
+    updating the stored value of the operand. With respect to an indeterminately-sequenced
+    function call, the operation of postfix ++ is a single evaluation. Postfix ++ on an object
+    with atomic type is a read-modify-write operation with memory_order_seq_cst
+    memory order semantics.<sup><a href="#note98"><b>98)</b></a></sup>
+3   The postfix -- operator is analogous to the postfix ++ operator, except that the value of
+    the operand is decremented (that is, the value 1 of the appropriate type is subtracted from
+    it).
+    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+<a name="6.5.2.5" href="#6.5.2.5"><b>    6.5.2.5 Compound literals</b></a>
+<b>    Constraints</b>
+1   The type name shall specify a complete object type or an array of unknown size, but not a
+    variable length array type.
+2   All the constraints for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.
+<b>    Semantics</b>
+3   A postfix expression that consists of a parenthesized type name followed by a brace-
+    enclosed list of initializers is a compound literal. It provides an unnamed object whose
+    value is given by the initializer list.<sup><a href="#note99"><b>99)</b></a></sup>
+
+
+    <sup><a name="note98" href="#note98"><b>98)</b></a></sup> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
+        where T is the type of E:
+                 T tmp;
+                 T result = E;
+                 do {
+                        tmp = result + 1;
+                 } while (!atomic_compare_exchange_strong(&amp;E, &amp;result, tmp));
+         with result being the result of the operation.
+
+[<a name="p85" href="#p85">page 85</a>] (<a href="#Contents">Contents</a>)
+
+4    If the type name specifies an array of unknown size, the size is determined by the
+     initializer list as specified in <a href="#6.7.9">6.7.9</a>, and the type of the compound literal is that of the
+     completed array type. Otherwise (when the type name specifies an object type), the type
+     of the compound literal is that specified by the type name. In either case, the result is an
+     lvalue.
+5    The value of the compound literal is that of an unnamed object initialized by the
+     initializer list. If the compound literal occurs outside the body of a function, the object
+     has static storage duration; otherwise, it has automatic storage duration associated with
+     the enclosing block.
+6    All the semantic rules for initializer lists in <a href="#6.7.9">6.7.9</a> also apply to compound literals.<sup><a href="#note100"><b>100)</b></a></sup>
+7    String literals, and compound literals with const-qualified types, need not designate
+     distinct objects.<sup><a href="#note101"><b>101)</b></a></sup>
+8    EXAMPLE 1       The file scope definition
+              int *p = (int []){2, 4};
+     initializes p to point to the first element of an array of two ints, the first having the value two and the
+     second, four. The expressions in this compound literal are required to be constant. The unnamed object
+     has static storage duration.
+
+9    EXAMPLE 2       In contrast, in
+              void f(void)
+              {
+                    int *p;
+                    /*...*/
+                    p = (int [2]){*p};
+                    /*...*/
+              }
+     p is assigned the address of the first element of an array of two ints, the first having the value previously
+     pointed to by p and the second, zero. The expressions in this compound literal need not be constant. The
+     unnamed object has automatic storage duration.
+
+10   EXAMPLE 3 Initializers with designations can be combined with compound literals. Structure objects
+     created using compound literals can be passed to functions without depending on member order:
+              drawline((struct point){.x=1, .y=1},
+                    (struct point){.x=3, .y=4});
+     Or, if drawline instead expected pointers to struct point:
+
+
+
+     <sup><a name="note99" href="#note99"><b>99)</b></a></sup> Note that this differs from a cast expression. For example, a cast specifies a conversion to scalar types
+         or void only, and the result of a cast expression is not an lvalue.
+     <sup><a name="note100" href="#note100"><b>100)</b></a></sup> For example, subobjects without explicit initializers are initialized to zero.
+     <sup><a name="note101" href="#note101"><b>101)</b></a></sup> This allows implementations to share storage for string literals and constant compound literals with
+          the same or overlapping representations.
+
+[<a name="p86" href="#p86">page 86</a>] (<a href="#Contents">Contents</a>)
+
+              drawline(&amp;(struct point){.x=1, .y=1},
+                    &amp;(struct point){.x=3, .y=4});
+
+11   EXAMPLE 4        A read-only compound literal can be specified through constructions like:
+              (const float []){1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6}
+
+12   EXAMPLE 5        The following three expressions have different meanings:
+              "/tmp/fileXXXXXX"
+              (char []){"/tmp/fileXXXXXX"}
+              (const char []){"/tmp/fileXXXXXX"}
+     The first always has static storage duration and has type array of char, but need not be modifiable; the last
+     two have automatic storage duration when they occur within the body of a function, and the first of these
+     two is modifiable.
+
+13   EXAMPLE 6 Like string literals, const-qualified compound literals can be placed into read-only memory
+     and can even be shared. For example,
+              (const char []){"abc"} == "abc"
+     might yield 1 if the literals' storage is shared.
+
+14   EXAMPLE 7 Since compound literals are unnamed, a single compound literal cannot specify a circularly
+     linked object. For example, there is no way to write a self-referential compound literal that could be used
+     as the function argument in place of the named object endless_zeros below:
+              struct int_list { int car; struct int_list *cdr; };
+              struct int_list endless_zeros = {0, &amp;endless_zeros};
+              eval(endless_zeros);
+
+15   EXAMPLE 8        Each compound literal creates only a single object in a given scope:
+              struct s { int i; };
+              int f (void)
+              {
+                    struct s *p = 0, *q;
+                    int j = 0;
+              again:
+                        q = p, p = &amp;((struct s){ j++ });
+                        if (j &lt; 2) goto again;
+                        return p == q &amp;&amp; q-&gt;i == 1;
+              }
+     The function f() always returns the value 1.
+16   Note that if an iteration statement were used instead of an explicit goto and a labeled statement, the
+     lifetime of the unnamed object would be the body of the loop only, and on entry next time around p would
+     have an indeterminate value, which would result in undefined behavior.
+
+     Forward references: type names (<a href="#6.7.7">6.7.7</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+
+[<a name="p87" href="#p87">page 87</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.3" href="#6.5.3"><b>    6.5.3 Unary operators</b></a>
+<b>    Syntax</b>
+1            unary-expression:
+                    postfix-expression
+                    ++ unary-expression
+                    -- unary-expression
+                    unary-operator cast-expression
+                    sizeof unary-expression
+                    sizeof ( type-name )
+                    alignof ( type-name )
+             unary-operator: one of
+                    &amp; * + - ~             !
+<a name="6.5.3.1" href="#6.5.3.1"><b>    6.5.3.1 Prefix increment and decrement operators</b></a>
+<b>    Constraints</b>
+1   The operand of the prefix increment or decrement operator shall have atomic, qualified,
+    or unqualified real or pointer type, and shall be a modifiable lvalue.
+<b>    Semantics</b>
+2   The value of the operand of the prefix ++ operator is incremented. The result is the new
+    value of the operand after incrementation. The expression ++E is equivalent to (E+=1).
+    See the discussions of additive operators and compound assignment for information on
+    constraints, types, side effects, and conversions and the effects of operations on pointers.
+3   The prefix -- operator is analogous to the prefix ++ operator, except that the value of the
+    operand is decremented.
+    Forward references: additive operators (<a href="#6.5.6">6.5.6</a>), compound assignment (<a href="#6.5.16.2">6.5.16.2</a>).
+<a name="6.5.3.2" href="#6.5.3.2"><b>    6.5.3.2 Address and indirection operators</b></a>
+<b>    Constraints</b>
+1   The operand of the unary &amp; operator shall be either a function designator, the result of a
+    [] or unary * operator, or an lvalue that designates an object that is not a bit-field and is
+    not declared with the register storage-class specifier.
+2   The operand of the unary * operator shall have pointer type.
+<b>    Semantics</b>
+3   The unary &amp; operator yields the address of its operand. If the operand has type ''type'',
+    the result has type ''pointer to type''. If the operand is the result of a unary * operator,
+    neither that operator nor the &amp; operator is evaluated and the result is as if both were
+    omitted, except that the constraints on the operators still apply and the result is not an
+
+[<a name="p88" href="#p88">page 88</a>] (<a href="#Contents">Contents</a>)
+
+    lvalue. Similarly, if the operand is the result of a [] operator, neither the &amp; operator nor
+    the unary * that is implied by the [] is evaluated and the result is as if the &amp; operator
+    were removed and the [] operator were changed to a + operator. Otherwise, the result is
+    a pointer to the object or function designated by its operand.
+4   The unary * operator denotes indirection. If the operand points to a function, the result is
+    a function designator; if it points to an object, the result is an lvalue designating the
+    object. If the operand has type ''pointer to type'', the result has type ''type''. If an
+    invalid value has been assigned to the pointer, the behavior of the unary * operator is
+    undefined.<sup><a href="#note102"><b>102)</b></a></sup>
+    Forward references: storage-class specifiers (<a href="#6.7.1">6.7.1</a>), structure and union specifiers
+    (<a href="#6.7.2.1">6.7.2.1</a>).
+<a name="6.5.3.3" href="#6.5.3.3"><b>    6.5.3.3 Unary arithmetic operators</b></a>
+<b>    Constraints</b>
+1   The operand of the unary + or - operator shall have arithmetic type; of the ~ operator,
+    integer type; of the ! operator, scalar type.
+<b>    Semantics</b>
+2   The result of the unary + operator is the value of its (promoted) operand. The integer
+    promotions are performed on the operand, and the result has the promoted type.
+3   The result of the unary - operator is the negative of its (promoted) operand. The integer
+    promotions are performed on the operand, and the result has the promoted type.
+4   The result of the ~ operator is the bitwise complement of its (promoted) operand (that is,
+    each bit in the result is set if and only if the corresponding bit in the converted operand is
+    not set). The integer promotions are performed on the operand, and the result has the
+    promoted type. If the promoted type is an unsigned type, the expression ~E is equivalent
+    to the maximum value representable in that type minus E.
+5   The result of the logical negation operator ! is 0 if the value of its operand compares
+    unequal to 0, 1 if the value of its operand compares equal to 0. The result has type int.
+    The expression !E is equivalent to (0==E).
+
+
+
+    <sup><a name="note102" href="#note102"><b>102)</b></a></sup> Thus, &amp;*E is equivalent to E (even if E is a null pointer), and &amp;(E1[E2]) to ((E1)+(E2)). It is
+         always true that if E is a function designator or an lvalue that is a valid operand of the unary &amp;
+         operator, *&amp;E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of
+         an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
+         Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an
+         address inappropriately aligned for the type of object pointed to, and the address of an object after the
+         end of its lifetime.
+
+[<a name="p89" href="#p89">page 89</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.3.4" href="#6.5.3.4"><b>    6.5.3.4 The sizeof and alignof operators</b></a>
+<b>    Constraints</b>
+1   The sizeof operator shall not be applied to an expression that has function type or an
+    incomplete type, to the parenthesized name of such a type, or to an expression that
+    designates a bit-field member. The alignof operator shall not be applied to a function
+    type or an incomplete type.
+<b>    Semantics</b>
+2   The sizeof operator yields the size (in bytes) of its operand, which may be an
+    expression or the parenthesized name of a type. The size is determined from the type of
+    the operand. The result is an integer. If the type of the operand is a variable length array
+    type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an
+    integer constant.
+3   The alignof operator yields the alignment requirement of its operand type. The result
+    is an integer constant. When applied to an array type, the result is the alignment
+    requirement of the element type.
+4   When sizeof is applied to an operand that has type char, unsigned char, or
+    signed char, (or a qualified version thereof) the result is 1. When applied to an
+    operand that has array type, the result is the total number of bytes in the array.<sup><a href="#note103"><b>103)</b></a></sup> When
+    applied to an operand that has structure or union type, the result is the total number of
+    bytes in such an object, including internal and trailing padding.
+5   The value of the result of both operators is implementation-defined, and its type (an
+    unsigned integer type) is size_t, defined in <a href="#7.19">&lt;stddef.h&gt;</a> (and other headers).
+6   EXAMPLE 1 A principal use of the sizeof operator is in communication with routines such as storage
+    allocators and I/O systems. A storage-allocation function might accept a size (in bytes) of an object to
+    allocate and return a pointer to void. For example:
+            extern void *alloc(size_t);
+            double *dp = alloc(sizeof *dp);
+    The implementation of the alloc function should ensure that its return value is aligned suitably for
+    conversion to a pointer to double.
+
+7   EXAMPLE 2      Another use of the sizeof operator is to compute the number of elements in an array:
+            sizeof array / sizeof array[0]
+
+8   EXAMPLE 3      In this example, the size of a variable length array is computed and returned from a
+    function:
+            #include <a href="#7.19">&lt;stddef.h&gt;</a>
+
+
+
+    <sup><a name="note103" href="#note103"><b>103)</b></a></sup> When applied to a parameter declared to have array or function type, the sizeof operator yields the
+         size of the adjusted (pointer) type (see <a href="#6.9.1">6.9.1</a>).
+
+[<a name="p90" href="#p90">page 90</a>] (<a href="#Contents">Contents</a>)
+
+             size_t fsize3(int n)
+             {
+                   char b[n+3];                  // variable length array
+                   return sizeof b;              // execution time sizeof
+             }
+             int main()
+             {
+                   size_t size;
+                   size = fsize3(10); // fsize3 returns 13
+                   return 0;
+             }
+
+    Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>), declarations (<a href="#6.7">6.7</a>),
+    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), type names (<a href="#6.7.7">6.7.7</a>), array declarators (<a href="#6.7.6.2">6.7.6.2</a>).
+<a name="6.5.4" href="#6.5.4"><b>    6.5.4 Cast operators</b></a>
+<b>    Syntax</b>
+1            cast-expression:
+                    unary-expression
+                    ( type-name ) cast-expression
+<b>    Constraints</b>
+2   Unless the type name specifies a void type, the type name shall specify atomic, qualified,
+    or unqualified scalar type, and the operand shall have scalar type.
+3   Conversions that involve pointers, other than where permitted by the constraints of
+    <a href="#6.5.16.1">6.5.16.1</a>, shall be specified by means of an explicit cast.
+4   A pointer type shall not be converted to any floating type. A floating type shall not be
+    converted to any pointer type.
+<b>    Semantics</b>
+5   Preceding an expression by a parenthesized type name converts the value of the
+    expression to the named type. This construction is called a cast.<sup><a href="#note104"><b>104)</b></a></sup> A cast that specifies
+    no conversion has no effect on the type or value of an expression.
+6   If the value of the expression is represented with greater precision or range than required
+    by the type named by the cast (<a href="#6.3.1.8">6.3.1.8</a>), then the cast specifies a conversion even if the
+    type of the expression is the same as the named type and removes any extra range and
+    precision.
+    Forward references: equality operators (<a href="#6.5.9">6.5.9</a>), function declarators (including
+    prototypes) (<a href="#6.7.6.3">6.7.6.3</a>), simple assignment (<a href="#6.5.16.1">6.5.16.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
+
+    <sup><a name="note104" href="#note104"><b>104)</b></a></sup> A cast does not yield an lvalue. Thus, a cast to a qualified type has the same effect as a cast to the
+         unqualified version of the type.
+
+[<a name="p91" href="#p91">page 91</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.5" href="#6.5.5"><b>    6.5.5 Multiplicative operators</b></a>
+<b>    Syntax</b>
+1            multiplicative-expression:
+                     cast-expression
+                     multiplicative-expression * cast-expression
+                     multiplicative-expression / cast-expression
+                     multiplicative-expression % cast-expression
+<b>    Constraints</b>
+2   Each of the operands shall have arithmetic type. The operands of the % operator shall
+    have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the binary * operator is the product of the operands.
+5   The result of the / operator is the quotient from the division of the first operand by the
+    second; the result of the % operator is the remainder. In both operations, if the value of
+    the second operand is zero, the behavior is undefined.
+6   When integers are divided, the result of the / operator is the algebraic quotient with any
+    fractional part discarded.<sup><a href="#note105"><b>105)</b></a></sup> If the quotient a/b is representable, the expression
+    (a/b)*b + a%b shall equal a; otherwise, the behavior of both a/b and a%b is
+    undefined.
+<a name="6.5.6" href="#6.5.6"><b>    6.5.6 Additive operators</b></a>
+<b>    Syntax</b>
+1            additive-expression:
+                    multiplicative-expression
+                    additive-expression + multiplicative-expression
+                    additive-expression - multiplicative-expression
+<b>    Constraints</b>
+2   For addition, either both operands shall have arithmetic type, or one operand shall be a
+    pointer to a complete object type and the other shall have integer type. (Incrementing is
+    equivalent to adding 1.)
+3   For subtraction, one of the following shall hold:
+
+
+
+
+    <sup><a name="note105" href="#note105"><b>105)</b></a></sup> This is often called ''truncation toward zero''.
+
+[<a name="p92" href="#p92">page 92</a>] (<a href="#Contents">Contents</a>)
+
+    -- both operands have arithmetic type;
+    -- both operands are pointers to qualified or unqualified versions of compatible complete
+      object types; or
+    -- the left operand is a pointer to a complete object type and the right operand has
+      integer type.
+    (Decrementing is equivalent to subtracting 1.)
+<b>    Semantics</b>
+4   If both operands have arithmetic type, the usual arithmetic conversions are performed on
+    them.
+5   The result of the binary + operator is the sum of the operands.
+6   The result of the binary - operator is the difference resulting from the subtraction of the
+    second operand from the first.
+7   For the purposes of these operators, a pointer to an object that is not an element of an
+    array behaves the same as a pointer to the first element of an array of length one with the
+    type of the object as its element type.
+8   When an expression that has integer type is added to or subtracted from a pointer, the
+    result has the type of the pointer operand. If the pointer operand points to an element of
+    an array object, and the array is large enough, the result points to an element offset from
+    the original element such that the difference of the subscripts of the resulting and original
+    array elements equals the integer expression. In other words, if the expression P points to
+    the i-th element of an array object, the expressions (P)+N (equivalently, N+(P)) and
+    (P)-N (where N has the value n) point to, respectively, the i+n-th and i-n-th elements of
+    the array object, provided they exist. Moreover, if the expression P points to the last
+    element of an array object, the expression (P)+1 points one past the last element of the
+    array object, and if the expression Q points one past the last element of an array object,
+    the expression (Q)-1 points to the last element of the array object. If both the pointer
+    operand and the result point to elements of the same array object, or one past the last
+    element of the array object, the evaluation shall not produce an overflow; otherwise, the
+    behavior is undefined. If the result points one past the last element of the array object, it
+    shall not be used as the operand of a unary * operator that is evaluated.
+9   When two pointers are subtracted, both shall point to elements of the same array object,
+    or one past the last element of the array object; the result is the difference of the
+    subscripts of the two array elements. The size of the result is implementation-defined,
+    and its type (a signed integer type) is ptrdiff_t defined in the <a href="#7.19">&lt;stddef.h&gt;</a> header.
+    If the result is not representable in an object of that type, the behavior is undefined. In
+    other words, if the expressions P and Q point to, respectively, the i-th and j-th elements of
+    an array object, the expression (P)-(Q) has the value i-j provided the value fits in an
+
+[<a name="p93" href="#p93">page 93</a>] (<a href="#Contents">Contents</a>)
+
+     object of type ptrdiff_t. Moreover, if the expression P points either to an element of
+     an array object or one past the last element of an array object, and the expression Q points
+     to the last element of the same array object, the expression ((Q)+1)-(P) has the same
+     value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the
+     expression P points one past the last element of the array object, even though the
+     expression (Q)+1 does not point to an element of the array object.<sup><a href="#note106"><b>106)</b></a></sup>
+10   EXAMPLE        Pointer arithmetic is well defined with pointers to variable length array types.
+              {
+                       int n = 4, m = 3;
+                       int a[n][m];
+                       int (*p)[m] = a;            //   p == &amp;a[0]
+                       p += 1;                     //   p == &amp;a[1]
+                       (*p)[2] = 99;               //   a[1][2] == 99
+                       n = p - a;                  //   n == 1
+              }
+11   If array a in the above example were declared to be an array of known constant size, and pointer p were
+     declared to be a pointer to an array of the same known constant size (pointing to a), the results would be
+     the same.
+
+     Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), common definitions <a href="#7.19">&lt;stddef.h&gt;</a>
+     (<a href="#7.19">7.19</a>).
+<a name="6.5.7" href="#6.5.7"><b>     6.5.7 Bitwise shift operators</b></a>
+<b>     Syntax</b>
+1             shift-expression:
+                      additive-expression
+                      shift-expression &lt;&lt; additive-expression
+                      shift-expression &gt;&gt; additive-expression
+<b>     Constraints</b>
+2    Each of the operands shall have integer type.
+<b>     Semantics</b>
+3    The integer promotions are performed on each of the operands. The type of the result is
+     that of the promoted left operand. If the value of the right operand is negative or is
+
+     <sup><a name="note106" href="#note106"><b>106)</b></a></sup> Another way to approach pointer arithmetic is first to convert the pointer(s) to character pointer(s): In
+          this scheme the integer expression added to or subtracted from the converted pointer is first multiplied
+          by the size of the object originally pointed to, and the resulting pointer is converted back to the
+          original type. For pointer subtraction, the result of the difference between the character pointers is
+          similarly divided by the size of the object originally pointed to.
+          When viewed in this way, an implementation need only provide one extra byte (which may overlap
+          another object in the program) just after the end of the object in order to satisfy the ''one past the last
+          element'' requirements.
+
+[<a name="p94" href="#p94">page 94</a>] (<a href="#Contents">Contents</a>)
+
+    greater than or equal to the width of the promoted left operand, the behavior is undefined.
+4   The result of E1 &lt;&lt; E2 is E1 left-shifted E2 bit positions; vacated bits are filled with
+    zeros. If E1 has an unsigned type, the value of the result is E1 x 2E2 , reduced modulo
+    one more than the maximum value representable in the result type. If E1 has a signed
+    type and nonnegative value, and E1 x 2E2 is representable in the result type, then that is
+    the resulting value; otherwise, the behavior is undefined.
+5   The result of E1 &gt;&gt; E2 is E1 right-shifted E2 bit positions. If E1 has an unsigned type
+    or if E1 has a signed type and a nonnegative value, the value of the result is the integral
+    part of the quotient of E1 / 2E2 . If E1 has a signed type and a negative value, the
+    resulting value is implementation-defined.
+<a name="6.5.8" href="#6.5.8"><b>    6.5.8 Relational operators</b></a>
+<b>    Syntax</b>
+1            relational-expression:
+                     shift-expression
+                     relational-expression   &lt;    shift-expression
+                     relational-expression   &gt;    shift-expression
+                     relational-expression   &lt;=   shift-expression
+                     relational-expression   &gt;=   shift-expression
+<b>    Constraints</b>
+2   One of the following shall hold:
+    -- both operands have real type; or                                                            *
+    -- both operands are pointers to qualified or unqualified versions of compatible object
+      types.
+<b>    Semantics</b>
+3   If both of the operands have arithmetic type, the usual arithmetic conversions are
+    performed.
+4   For the purposes of these operators, a pointer to an object that is not an element of an
+    array behaves the same as a pointer to the first element of an array of length one with the
+    type of the object as its element type.
+5   When two pointers are compared, the result depends on the relative locations in the
+    address space of the objects pointed to. If two pointers to object types both point to the
+    same object, or both point one past the last element of the same array object, they
+    compare equal. If the objects pointed to are members of the same aggregate object,
+    pointers to structure members declared later compare greater than pointers to members
+    declared earlier in the structure, and pointers to array elements with larger subscript
+    values compare greater than pointers to elements of the same array with lower subscript
+
+[<a name="p95" href="#p95">page 95</a>] (<a href="#Contents">Contents</a>)
+
+    values. All pointers to members of the same union object compare equal. If the
+    expression P points to an element of an array object and the expression Q points to the
+    last element of the same array object, the pointer expression Q+1 compares greater than
+    P. In all other cases, the behavior is undefined.
+6   Each of the operators &lt; (less than), &gt; (greater than), &lt;= (less than or equal to), and &gt;=
+    (greater than or equal to) shall yield 1 if the specified relation is true and 0 if it is
+    false.<sup><a href="#note107"><b>107)</b></a></sup> The result has type int.
+<a name="6.5.9" href="#6.5.9"><b>    6.5.9 Equality operators</b></a>
+<b>    Syntax</b>
+1            equality-expression:
+                    relational-expression
+                    equality-expression == relational-expression
+                    equality-expression != relational-expression
+<b>    Constraints</b>
+2   One of the following shall hold:
+    -- both operands have arithmetic type;
+    -- both operands are pointers to qualified or unqualified versions of compatible types;
+    -- one operand is a pointer to an object type and the other is a pointer to a qualified or
+      unqualified version of void; or
+    -- one operand is a pointer and the other is a null pointer constant.
+<b>    Semantics</b>
+3   The == (equal to) and != (not equal to) operators are analogous to the relational
+    operators except for their lower precedence.<sup><a href="#note108"><b>108)</b></a></sup> Each of the operators yields 1 if the
+    specified relation is true and 0 if it is false. The result has type int. For any pair of
+    operands, exactly one of the relations is true.
+4   If both of the operands have arithmetic type, the usual arithmetic conversions are
+    performed. Values of complex types are equal if and only if both their real parts are equal
+    and also their imaginary parts are equal. Any two values of arithmetic types from
+    different type domains are equal if and only if the results of their conversions to the
+    (complex) result type determined by the usual arithmetic conversions are equal.
+
+
+
+    <sup><a name="note107" href="#note107"><b>107)</b></a></sup> The expression a&lt;b&lt;c is not interpreted as in ordinary mathematics. As the syntax indicates, it
+         means (a&lt;b)&lt;c; in other words, ''if a is less than b, compare 1 to c; otherwise, compare 0 to c''.
+    <sup><a name="note108" href="#note108"><b>108)</b></a></sup> Because of the precedences, a&lt;b == c&lt;d is 1 whenever a&lt;b and c&lt;d have the same truth-value.
+
+[<a name="p96" href="#p96">page 96</a>] (<a href="#Contents">Contents</a>)
+
+5   Otherwise, at least one operand is a pointer. If one operand is a pointer and the other is a
+    null pointer constant, the null pointer constant is converted to the type of the pointer. If
+    one operand is a pointer to an object type and the other is a pointer to a qualified or
+    unqualified version of void, the former is converted to the type of the latter.
+6   Two pointers compare equal if and only if both are null pointers, both are pointers to the
+    same object (including a pointer to an object and a subobject at its beginning) or function,
+    both are pointers to one past the last element of the same array object, or one is a pointer
+    to one past the end of one array object and the other is a pointer to the start of a different
+    array object that happens to immediately follow the first array object in the address
+    space.<sup><a href="#note109"><b>109)</b></a></sup>
+7   For the purposes of these operators, a pointer to an object that is not an element of an
+    array behaves the same as a pointer to the first element of an array of length one with the
+    type of the object as its element type.
+<a name="6.5.10" href="#6.5.10"><b>    6.5.10 Bitwise AND operator</b></a>
+<b>    Syntax</b>
+1            AND-expression:
+                   equality-expression
+                   AND-expression &amp; equality-expression
+<b>    Constraints</b>
+2   Each of the operands shall have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the binary &amp; operator is the bitwise AND of the operands (that is, each bit in
+    the result is set if and only if each of the corresponding bits in the converted operands is
+    set).
+
+
+
+
+    <sup><a name="note109" href="#note109"><b>109)</b></a></sup> Two objects may be adjacent in memory because they are adjacent elements of a larger array or
+         adjacent members of a structure with no padding between them, or because the implementation chose
+         to place them so, even though they are unrelated. If prior invalid pointer operations (such as accesses
+         outside array bounds) produced undefined behavior, subsequent comparisons also produce undefined
+         behavior.
+
+[<a name="p97" href="#p97">page 97</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.11" href="#6.5.11"><b>    6.5.11 Bitwise exclusive OR operator</b></a>
+<b>    Syntax</b>
+1            exclusive-OR-expression:
+                     AND-expression
+                     exclusive-OR-expression ^ AND-expression
+<b>    Constraints</b>
+2   Each of the operands shall have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the ^ operator is the bitwise exclusive OR of the operands (that is, each bit
+    in the result is set if and only if exactly one of the corresponding bits in the converted
+    operands is set).
+<a name="6.5.12" href="#6.5.12"><b>    6.5.12 Bitwise inclusive OR operator</b></a>
+<b>    Syntax</b>
+1            inclusive-OR-expression:
+                     exclusive-OR-expression
+                     inclusive-OR-expression | exclusive-OR-expression
+<b>    Constraints</b>
+2   Each of the operands shall have integer type.
+<b>    Semantics</b>
+3   The usual arithmetic conversions are performed on the operands.
+4   The result of the | operator is the bitwise inclusive OR of the operands (that is, each bit in
+    the result is set if and only if at least one of the corresponding bits in the converted
+    operands is set).
+
+[<a name="p98" href="#p98">page 98</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.13" href="#6.5.13"><b>    6.5.13 Logical AND operator</b></a>
+<b>    Syntax</b>
+1            logical-AND-expression:
+                     inclusive-OR-expression
+                     logical-AND-expression &amp;&amp; inclusive-OR-expression
+<b>    Constraints</b>
+2   Each of the operands shall have scalar type.
+<b>    Semantics</b>
+3   The &amp;&amp; operator shall yield 1 if both of its operands compare unequal to 0; otherwise, it
+    yields 0. The result has type int.
+4   Unlike the bitwise binary &amp; operator, the &amp;&amp; operator guarantees left-to-right evaluation;
+    if the second operand is evaluated, there is a sequence point between the evaluations of
+    the first and second operands. If the first operand compares equal to 0, the second
+    operand is not evaluated.
+<a name="6.5.14" href="#6.5.14"><b>    6.5.14 Logical OR operator</b></a>
+<b>    Syntax</b>
+1            logical-OR-expression:
+                     logical-AND-expression
+                     logical-OR-expression || logical-AND-expression
+<b>    Constraints</b>
+2   Each of the operands shall have scalar type.
+<b>    Semantics</b>
+3   The || operator shall yield 1 if either of its operands compare unequal to 0; otherwise, it
+    yields 0. The result has type int.
+4   Unlike the bitwise | operator, the || operator guarantees left-to-right evaluation; if the
+    second operand is evaluated, there is a sequence point between the evaluations of the first
+    and second operands. If the first operand compares unequal to 0, the second operand is
+    not evaluated.
+
+[<a name="p99" href="#p99">page 99</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.15" href="#6.5.15"><b>    6.5.15 Conditional operator</b></a>
+<b>    Syntax</b>
+1            conditional-expression:
+                    logical-OR-expression
+                    logical-OR-expression ? expression : conditional-expression
+<b>    Constraints</b>
+2   The first operand shall have scalar type.
+3   One of the following shall hold for the second and third operands:
+    -- both operands have arithmetic type;
+    -- both operands have the same structure or union type;
+    -- both operands have void type;
+    -- both operands are pointers to qualified or unqualified versions of compatible types;
+    -- one operand is a pointer and the other is a null pointer constant; or
+    -- one operand is a pointer to an object type and the other is a pointer to a qualified or
+      unqualified version of void.
+<b>    Semantics</b>
+4   The first operand is evaluated; there is a sequence point between its evaluation and the
+    evaluation of the second or third operand (whichever is evaluated). The second operand
+    is evaluated only if the first compares unequal to 0; the third operand is evaluated only if
+    the first compares equal to 0; the result is the value of the second or third operand
+    (whichever is evaluated), converted to the type described below.<sup><a href="#note110"><b>110)</b></a></sup>                        *
+5   If both the second and third operands have arithmetic type, the result type that would be
+    determined by the usual arithmetic conversions, were they applied to those two operands,
+    is the type of the result. If both the operands have structure or union type, the result has
+    that type. If both operands have void type, the result has void type.
+6   If both the second and third operands are pointers or one is a null pointer constant and the
+    other is a pointer, the result type is a pointer to a type qualified with all the type qualifiers
+    of the types referenced by both operands. Furthermore, if both operands are pointers to
+    compatible types or to differently qualified versions of compatible types, the result type is
+    a pointer to an appropriately qualified version of the composite type; if one operand is a
+    null pointer constant, the result has the type of the other operand; otherwise, one operand
+    is a pointer to void or a qualified version of void, in which case the result type is a
+    pointer to an appropriately qualified version of void.
+
+    <sup><a name="note110" href="#note110"><b>110)</b></a></sup> A conditional expression does not yield an lvalue.
+
+[<a name="p100" href="#p100">page 100</a>] (<a href="#Contents">Contents</a>)
+
+7   EXAMPLE The common type that results when the second and third operands are pointers is determined
+    in two independent stages. The appropriate qualifiers, for example, do not depend on whether the two
+    pointers have compatible types.
+8   Given the declarations
+              const void *c_vp;
+              void *vp;
+              const int *c_ip;
+              volatile int *v_ip;
+              int *ip;
+              const char *c_cp;
+    the third column in the following table is the common type that is the result of a conditional expression in
+    which the first two columns are the second and third operands (in either order):
+              c_vp    c_ip      const void *
+              v_ip    0         volatile int *
+              c_ip    v_ip      const volatile int *
+              vp      c_cp      const void *
+              ip      c_ip      const int *
+              vp      ip        void *
+
+<a name="6.5.16" href="#6.5.16"><b>    6.5.16 Assignment operators</b></a>
+<b>    Syntax</b>
+1            assignment-expression:
+                    conditional-expression
+                    unary-expression assignment-operator assignment-expression
+             assignment-operator: one of
+                    = *= /= %= +=                       -=     &lt;&lt;=      &gt;&gt;=      &amp;=     ^=     |=
+<b>    Constraints</b>
+2   An assignment operator shall have a modifiable lvalue as its left operand.
+<b>    Semantics</b>
+3   An assignment operator stores a value in the object designated by the left operand. An
+    assignment expression has the value of the left operand after the assignment,<sup><a href="#note111"><b>111)</b></a></sup> but is not
+    an lvalue. The type of an assignment expression is the type the left operand would have
+    after lvalue conversion. The side effect of updating the stored value of the left operand is
+    sequenced after the value computations of the left and right operands. The evaluations of
+    the operands are unsequenced.
+
+
+
+
+    <sup><a name="note111" href="#note111"><b>111)</b></a></sup> The implementation is permitted to read the object to determine the value but is not required to, even
+         when the object has volatile-qualified type.
+
+[<a name="p101" href="#p101">page 101</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.5.16.1" href="#6.5.16.1"><b>    6.5.16.1 Simple assignment</b></a>
+<b>    Constraints</b>
+1   One of the following shall hold:<sup><a href="#note112"><b>112)</b></a></sup>
+    -- the left operand has atomic, qualified, or unqualified arithmetic type, and the right has
+      arithmetic type;
+    -- the left operand has an atomic, qualified, or unqualified version of a structure or union
+      type compatible with the type of the right;
+    -- the left operand has atomic, qualified, or unqualified pointer type, and (considering
+      the type the left operand would have after lvalue conversion) both operands are
+      pointers to qualified or unqualified versions of compatible types, and the type pointed
+      to by the left has all the qualifiers of the type pointed to by the right;
+    -- the left operand has atomic, qualified, or unqualified pointer type, and (considering
+      the type the left operand would have after lvalue conversion) one operand is a pointer
+      to an object type, and the other is a pointer to a qualified or unqualified version of
+      void, and the type pointed to by the left has all the qualifiers of the type pointed to
+      by the right;
+    -- the left operand is an atomic, qualified, or unqualified pointer, and the right is a null
+      pointer constant; or
+    -- the left operand has type atomic, qualified, or unqualified _Bool, and the right is a
+      pointer.
+<b>    Semantics</b>
+2   In simple assignment (=), the value of the right operand is converted to the type of the
+    assignment expression and replaces the value stored in the object designated by the left
+    operand.
+3   If the value being stored in an object is read from another object that overlaps in any way
+    the storage of the first object, then the overlap shall be exact and the two objects shall
+    have qualified or unqualified versions of a compatible type; otherwise, the behavior is
+    undefined.
+4   EXAMPLE 1       In the program fragment
+
+
+
+
+    <sup><a name="note112" href="#note112"><b>112)</b></a></sup> The asymmetric appearance of these constraints with respect to type qualifiers is due to the conversion
+         (specified in <a href="#6.3.2.1">6.3.2.1</a>) that changes lvalues to ''the value of the expression'' and thus removes any type
+         qualifiers that were applied to the type category of the expression (for example, it removes const but
+         not volatile from the type int volatile * const).
+
+[<a name="p102" href="#p102">page 102</a>] (<a href="#Contents">Contents</a>)
+
+            int f(void);
+            char c;
+            /* ... */
+            if ((c = f()) == -1)
+                    /* ... */
+    the int value returned by the function may be truncated when stored in the char, and then converted back
+    to int width prior to the comparison. In an implementation in which ''plain'' char has the same range of
+    values as unsigned char (and char is narrower than int), the result of the conversion cannot be
+    negative, so the operands of the comparison can never compare equal. Therefore, for full portability, the
+    variable c should be declared as int.
+
+5   EXAMPLE 2       In the fragment:
+            char c;
+            int i;
+            long l;
+            l = (c = i);
+    the value of i is converted to the type of the assignment expression c = i, that is, char type. The value
+    of the expression enclosed in parentheses is then converted to the type of the outer assignment expression,
+    that is, long int type.
+
+6   EXAMPLE 3       Consider the fragment:
+            const char **cpp;
+            char *p;
+            const char c = 'A';
+            cpp = &amp;p;                  // constraint violation
+            *cpp = &amp;c;                 // valid
+            *p = 0;                    // valid
+    The first assignment is unsafe because it would allow the following valid code to attempt to change the
+    value of the const object c.
+
+<a name="6.5.16.2" href="#6.5.16.2"><b>    6.5.16.2 Compound assignment</b></a>
+<b>    Constraints</b>
+1   For the operators += and -= only, either the left operand shall be an atomic, qualified, or
+    unqualified pointer to a complete object type, and the right shall have integer type; or the
+    left operand shall have atomic, qualified, or unqualified arithmetic type, and the right
+    shall have arithmetic type.
+2   For the other operators, the left operand shall have atomic, qualified, or unqualified
+    arithmetic type, and (considering the type the left operand would have after lvalue
+    conversion) each operand shall have arithmetic type consistent with those allowed by the
+    corresponding binary operator.
+<b>    Semantics</b>
+3   A compound assignment of the form E1 op = E2 is equivalent to the simple assignment
+    expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once, and with
+    respect to an indeterminately-sequenced function call, the operation of a compound
+
+[<a name="p103" href="#p103">page 103</a>] (<a href="#Contents">Contents</a>)
+
+    assignment is a single evaluation. If E1 has an atomic type, compound assignment is a
+    read-modify-write operation with memory_order_seq_cst memory order
+    semantics.<sup><a href="#note113"><b>113)</b></a></sup>
+<a name="6.5.17" href="#6.5.17"><b>    6.5.17 Comma operator</b></a>
+<b>    Syntax</b>
+1            expression:
+                    assignment-expression
+                    expression , assignment-expression
+<b>    Semantics</b>
+2   The left operand of a comma operator is evaluated as a void expression; there is a
+    sequence point between its evaluation and that of the right operand. Then the right
+    operand is evaluated; the result has its type and value.<sup><a href="#note114"><b>114)</b></a></sup>                        *
+3   EXAMPLE As indicated by the syntax, the comma operator (as described in this subclause) cannot
+    appear in contexts where a comma is used to separate items in a list (such as arguments to functions or lists
+    of initializers). On the other hand, it can be used within a parenthesized expression or within the second
+    expression of a conditional operator in such contexts. In the function call
+             f(a, (t=3, t+2), c)
+    the function has three arguments, the second of which has the value 5.
+
+    Forward references: initialization (<a href="#6.7.9">6.7.9</a>).
+
+
+
+
+    <sup><a name="note113" href="#note113"><b>113)</b></a></sup> Where a pointer to an atomic object can be formed, this is equivalent to the following code sequence
+         where T is the type of E1:
+                  T tmp = E1;
+                  T result;
+                  do {
+                        result = tmp op (E2);
+                  } while (!atomic_compare_exchange_strong(&amp;E1, &amp;tmp, result));
+          with result being the result of the operation.
+    <sup><a name="note114" href="#note114"><b>114)</b></a></sup> A comma operator does not yield an lvalue.
+
+[<a name="p104" href="#p104">page 104</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.6" href="#6.6"><b>    6.6 Constant expressions</b></a>
+<b>    Syntax</b>
+1            constant-expression:
+                    conditional-expression
+<b>    Description</b>
+2   A constant expression can be evaluated during translation rather than runtime, and
+    accordingly may be used in any place that a constant may be.
+<b>    Constraints</b>
+3   Constant expressions shall not contain assignment, increment, decrement, function-call,
+    or comma operators, except when they are contained within a subexpression that is not
+    evaluated.<sup><a href="#note115"><b>115)</b></a></sup>
+4   Each constant expression shall evaluate to a constant that is in the range of representable
+    values for its type.
+<b>    Semantics</b>
+5   An expression that evaluates to a constant is required in several contexts. If a floating
+    expression is evaluated in the translation environment, the arithmetic precision and range
+    shall be at least as great as if the expression were being evaluated in the execution
+    environment.<sup><a href="#note116"><b>116)</b></a></sup>
+6   An integer constant expression<sup><a href="#note117"><b>117)</b></a></sup> shall have integer type and shall only have operands
+    that are integer constants, enumeration constants, character constants, sizeof
+    expressions whose results are integer constants, and floating constants that are the
+    immediate operands of casts. Cast operators in an integer constant expression shall only
+    convert arithmetic types to integer types, except as part of an operand to the sizeof
+    operator.
+7   More latitude is permitted for constant expressions in initializers. Such a constant
+    expression shall be, or evaluate to, one of the following:
+    -- an arithmetic constant expression,
+
+
+
+    <sup><a name="note115" href="#note115"><b>115)</b></a></sup> The operand of a sizeof operator is usually not evaluated (<a href="#6.5.3.4">6.5.3.4</a>).
+    <sup><a name="note116" href="#note116"><b>116)</b></a></sup> The use of evaluation formats as characterized by FLT_EVAL_METHOD also applies to evaluation in
+         the translation environment.
+    <sup><a name="note117" href="#note117"><b>117)</b></a></sup> An integer constant expression is required in a number of contexts such as the size of a bit-field
+         member of a structure, the value of an enumeration constant, and the size of a non-variable length
+         array. Further constraints that apply to the integer constant expressions used in conditional-inclusion
+         preprocessing directives are discussed in <a href="#6.10.1">6.10.1</a>.
+
+[<a name="p105" href="#p105">page 105</a>] (<a href="#Contents">Contents</a>)
+
+     -- a null pointer constant,
+     -- an address constant, or
+     -- an address constant for a complete object type plus or minus an integer constant
+       expression.
+8    An arithmetic constant expression shall have arithmetic type and shall only have
+     operands that are integer constants, floating constants, enumeration constants, character
+     constants, and sizeof expressions. Cast operators in an arithmetic constant expression
+     shall only convert arithmetic types to arithmetic types, except as part of an operand to a
+     sizeof operator whose result is an integer constant.
+9    An address constant is a null pointer, a pointer to an lvalue designating an object of static
+     storage duration, or a pointer to a function designator; it shall be created explicitly using
+     the unary &amp; operator or an integer constant cast to pointer type, or implicitly by the use of
+     an expression of array or function type. The array-subscript [] and member-access .
+     and -&gt; operators, the address &amp; and indirection * unary operators, and pointer casts may
+     be used in the creation of an address constant, but the value of an object shall not be
+     accessed by use of these operators.
+10   An implementation may accept other forms of constant expressions.
+11   The semantic rules for the evaluation of a constant expression are the same as for
+     nonconstant expressions.<sup><a href="#note118"><b>118)</b></a></sup>
+     Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), initialization (<a href="#6.7.9">6.7.9</a>).
+
+
+
+
+     <sup><a name="note118" href="#note118"><b>118)</b></a></sup> Thus, in the following initialization,
+                    static int i = 2 || 1 / 0;
+           the expression is a valid integer constant expression with value one.
+
+[<a name="p106" href="#p106">page 106</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7" href="#6.7"><b>    6.7 Declarations</b></a>
+<b>    Syntax</b>
+1            declaration:
+                    declaration-specifiers init-declarator-listopt ;
+                    static_assert-declaration
+             declaration-specifiers:
+                    storage-class-specifier declaration-specifiersopt
+                    type-specifier declaration-specifiersopt
+                    type-qualifier declaration-specifiersopt
+                    function-specifier declaration-specifiersopt
+                    alignment-specifier declaration-specifiersopt
+             init-declarator-list:
+                     init-declarator
+                     init-declarator-list , init-declarator
+             init-declarator:
+                     declarator
+                     declarator = initializer
+<b>    Constraints</b>
+2   A declaration other than a static_assert declaration shall declare at least a declarator
+    (other than the parameters of a function or the members of a structure or union), a tag, or
+    the members of an enumeration.
+3   If an identifier has no linkage, there shall be no more than one declaration of the identifier
+    (in a declarator or type specifier) with the same scope and in the same name space, except
+    that a typedef name can be redefined to denote the same type as it currently does and tags
+    may be redeclared as specified in <a href="#6.7.2.3">6.7.2.3</a>.
+4   All declarations in the same scope that refer to the same object or function shall specify
+    compatible types.
+<b>    Semantics</b>
+5   A declaration specifies the interpretation and attributes of a set of identifiers. A definition
+    of an identifier is a declaration for that identifier that:
+    -- for an object, causes storage to be reserved for that object;
+    -- for a function, includes the function body;<sup><a href="#note119"><b>119)</b></a></sup>
+
+
+
+    <sup><a name="note119" href="#note119"><b>119)</b></a></sup> Function definitions have a different syntax, described in <a href="#6.9.1">6.9.1</a>.
+
+[<a name="p107" href="#p107">page 107</a>] (<a href="#Contents">Contents</a>)
+
+    -- for an enumeration constant or typedef name, is the (only) declaration of the
+      identifier.
+6   The declaration specifiers consist of a sequence of specifiers that indicate the linkage,
+    storage duration, and part of the type of the entities that the declarators denote. The init-
+    declarator-list is a comma-separated sequence of declarators, each of which may have
+    additional type information, or an initializer, or both. The declarators contain the
+    identifiers (if any) being declared.
+7   If an identifier for an object is declared with no linkage, the type for the object shall be
+    complete by the end of its declarator, or by the end of its init-declarator if it has an
+    initializer; in the case of function parameters (including in prototypes), it is the adjusted
+    type (see <a href="#6.7.6.3">6.7.6.3</a>) that is required to be complete.
+    Forward references: declarators (<a href="#6.7.6">6.7.6</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>), initialization
+    (<a href="#6.7.9">6.7.9</a>), type names (<a href="#6.7.7">6.7.7</a>), type qualifiers (<a href="#6.7.3">6.7.3</a>).
+<a name="6.7.1" href="#6.7.1"><b>    6.7.1 Storage-class specifiers</b></a>
+<b>    Syntax</b>
+1            storage-class-specifier:
+                    typedef
+                    extern
+                    static
+                    _Thread_local
+                    auto
+                    register
+<b>    Constraints</b>
+2   At most, one storage-class specifier may be given in the declaration specifiers in a
+    declaration, except that _Thread_local may appear with static or extern.<sup><a href="#note120"><b>120)</b></a></sup>
+3   In the declaration of an object with block scope, if the declaration specifiers include
+    _Thread_local, they shall also include either static or extern. If
+    _Thread_local appears in any declaration of an object, it shall be present in every
+    declaration of that object.
+<b>    Semantics</b>
+4   The typedef specifier is called a ''storage-class specifier'' for syntactic convenience
+    only; it is discussed in <a href="#6.7.8">6.7.8</a>. The meanings of the various linkages and storage durations
+    were discussed in <a href="#6.2.2">6.2.2</a> and <a href="#6.2.4">6.2.4</a>.
+
+
+
+    <sup><a name="note120" href="#note120"><b>120)</b></a></sup> See ''future language directions'' (<a href="#6.11.5">6.11.5</a>).
+
+[<a name="p108" href="#p108">page 108</a>] (<a href="#Contents">Contents</a>)
+
+5   A declaration of an identifier for an object with storage-class specifier register
+    suggests that access to the object be as fast as possible. The extent to which such
+    suggestions are effective is implementation-defined.<sup><a href="#note121"><b>121)</b></a></sup>
+6   The declaration of an identifier for a function that has block scope shall have no explicit
+    storage-class specifier other than extern.
+7   If an aggregate or union object is declared with a storage-class specifier other than
+    typedef, the properties resulting from the storage-class specifier, except with respect to
+    linkage, also apply to the members of the object, and so on recursively for any aggregate
+    or union member objects.
+    Forward references: type definitions (<a href="#6.7.8">6.7.8</a>).
+<a name="6.7.2" href="#6.7.2"><b>    6.7.2 Type specifiers</b></a>
+<b>    Syntax</b>
+1            type-specifier:
+                    void
+                    char
+                    short
+                    int
+                    long
+                    float
+                    double
+                    signed
+                    unsigned
+                    _Bool
+                    _Complex
+                    atomic-type-specifier
+                    struct-or-union-specifier
+                    enum-specifier
+                    typedef-name
+<b>    Constraints</b>
+2   At least one type specifier shall be given in the declaration specifiers in each declaration,
+    and in the specifier-qualifier list in each struct declaration and type name. Each list of
+
+
+    <sup><a name="note121" href="#note121"><b>121)</b></a></sup> The implementation may treat any register declaration simply as an auto declaration. However,
+         whether or not addressable storage is actually used, the address of any part of an object declared with
+         storage-class specifier register cannot be computed, either explicitly (by use of the unary &amp;
+         operator as discussed in <a href="#6.5.3.2">6.5.3.2</a>) or implicitly (by converting an array name to a pointer as discussed in
+         <a href="#6.3.2.1">6.3.2.1</a>). Thus, the only operator that can be applied to an array declared with storage-class specifier
+         register is sizeof.
+
+[<a name="p109" href="#p109">page 109</a>] (<a href="#Contents">Contents</a>)
+
+    type specifiers shall be one of the following multisets (delimited by commas, when there
+    is more than one multiset per item); the type specifiers may occur in any order, possibly
+    intermixed with the other declaration specifiers.
+    -- void
+    -- char
+    -- signed char
+    -- unsigned char
+    -- short, signed short, short int, or signed short int
+    -- unsigned short, or unsigned short int
+    -- int, signed, or signed int
+    -- unsigned, or unsigned int
+    -- long, signed long, long int, or signed long int
+    -- unsigned long, or unsigned long int
+    -- long long, signed long long, long long int, or
+      signed long long int
+    -- unsigned long long, or unsigned long long int
+    -- float
+    -- double
+    -- long double
+    -- _Bool
+    -- float _Complex
+    -- double _Complex
+    -- long double _Complex
+    -- atomic type specifier
+    -- struct or union specifier
+    -- enum specifier
+    -- typedef name
+3   The type specifier _Complex shall not be used if the implementation does not support
+    complex types (see <a href="#6.10.8.3">6.10.8.3</a>).
+
+[<a name="p110" href="#p110">page 110</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Semantics</b>
+4   Specifiers for structures, unions, enumerations, and atomic types are discussed in <a href="#6.7.2.1">6.7.2.1</a>
+    through <a href="#6.7.2.4">6.7.2.4</a>. Declarations of typedef names are discussed in <a href="#6.7.8">6.7.8</a>. The
+    characteristics of the other types are discussed in <a href="#6.2.5">6.2.5</a>.
+5   Each of the comma-separated multisets designates the same type, except that for bit-
+    fields, it is implementation-defined whether the specifier int designates the same type as
+    signed int or the same type as unsigned int.
+    Forward references: atomic type specifiers (<a href="#6.7.2.4">6.7.2.4</a>), enumeration specifiers (<a href="#6.7.2.2">6.7.2.2</a>),
+    structure and union specifiers (<a href="#6.7.2.1">6.7.2.1</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+<a name="6.7.2.1" href="#6.7.2.1"><b>    6.7.2.1 Structure and union specifiers</b></a>
+<b>    Syntax</b>
+1            struct-or-union-specifier:
+                     struct-or-union identifieropt { struct-declaration-list }
+                     struct-or-union identifier
+             struct-or-union:
+                     struct
+                     union
+             struct-declaration-list:
+                     struct-declaration
+                     struct-declaration-list struct-declaration
+             struct-declaration:
+                     specifier-qualifier-list struct-declarator-listopt ;
+                     static_assert-declaration
+             specifier-qualifier-list:
+                    type-specifier specifier-qualifier-listopt
+                    type-qualifier specifier-qualifier-listopt
+             struct-declarator-list:
+                     struct-declarator
+                     struct-declarator-list , struct-declarator
+             struct-declarator:
+                     declarator
+                     declaratoropt : constant-expression
+<b>    Constraints</b>
+2   A struct-declaration that does not declare an anonymous structure or anonymous union
+    shall contain a struct-declarator-list.
+
+[<a name="p111" href="#p111">page 111</a>] (<a href="#Contents">Contents</a>)
+
+3    A structure or union shall not contain a member with incomplete or function type (hence,
+     a structure shall not contain an instance of itself, but may contain a pointer to an instance
+     of itself), except that the last member of a structure with more than one named member
+     may have incomplete array type; such a structure (and any union containing, possibly
+     recursively, a member that is such a structure) shall not be a member of a structure or an
+     element of an array.
+4    The expression that specifies the width of a bit-field shall be an integer constant
+     expression with a nonnegative value that does not exceed the width of an object of the
+     type that would be specified were the colon and expression omitted.<sup><a href="#note122"><b>122)</b></a></sup> If the value is
+     zero, the declaration shall have no declarator.
+5    A bit-field shall have a type that is a qualified or unqualified version of _Bool, signed
+     int, unsigned int, or some other implementation-defined type. It is
+     implementation-defined whether atomic types are permitted.
+<b>     Semantics</b>
+6    As discussed in <a href="#6.2.5">6.2.5</a>, a structure is a type consisting of a sequence of members, whose
+     storage is allocated in an ordered sequence, and a union is a type consisting of a sequence
+     of members whose storage overlap.
+7    Structure and union specifiers have the same form. The keywords struct and union
+     indicate that the type being specified is, respectively, a structure type or a union type.
+8    The presence of a struct-declaration-list in a struct-or-union-specifier declares a new type,
+     within a translation unit. The struct-declaration-list is a sequence of declarations for the
+     members of the structure or union. If the struct-declaration-list contains no named
+     members, no anonymous structures, and no anonymous unions, the behavior is undefined.
+     The type is incomplete until immediately after the } that terminates the list, and complete
+     thereafter.
+9    A member of a structure or union may have any complete object type other than a
+     variably modified type.<sup><a href="#note123"><b>123)</b></a></sup> In addition, a member may be declared to consist of a
+     specified number of bits (including a sign bit, if any). Such a member is called a
+     bit-field;<sup><a href="#note124"><b>124)</b></a></sup> its width is preceded by a colon.
+10   A bit-field is interpreted as having a signed or unsigned integer type consisting of the
+     specified number of bits.<sup><a href="#note125"><b>125)</b></a></sup> If the value 0 or 1 is stored into a nonzero-width bit-field of
+
+     <sup><a name="note122" href="#note122"><b>122)</b></a></sup> While the number of bits in a _Bool object is at least CHAR_BIT, the width (number of sign and
+          value bits) of a _Bool may be just 1 bit.
+     <sup><a name="note123" href="#note123"><b>123)</b></a></sup> A structure or union cannot contain a member with a variably modified type because member names
+          are not ordinary identifiers as defined in <a href="#6.2.3">6.2.3</a>.
+     <sup><a name="note124" href="#note124"><b>124)</b></a></sup> The unary &amp; (address-of) operator cannot be applied to a bit-field object; thus, there are no pointers to
+          or arrays of bit-field objects.
+
+[<a name="p112" href="#p112">page 112</a>] (<a href="#Contents">Contents</a>)
+
+     type _Bool, the value of the bit-field shall compare equal to the value stored; a _Bool
+     bit-field has the semantics of a _Bool.
+11   An implementation may allocate any addressable storage unit large enough to hold a bit-
+     field. If enough space remains, a bit-field that immediately follows another bit-field in a
+     structure shall be packed into adjacent bits of the same unit. If insufficient space remains,
+     whether a bit-field that does not fit is put into the next unit or overlaps adjacent units is
+     implementation-defined. The order of allocation of bit-fields within a unit (high-order to
+     low-order or low-order to high-order) is implementation-defined. The alignment of the
+     addressable storage unit is unspecified.
+12   A bit-field declaration with no declarator, but only a colon and a width, indicates an
+     unnamed bit-field.<sup><a href="#note126"><b>126)</b></a></sup> As a special case, a bit-field structure member with a width of 0
+     indicates that no further bit-field is to be packed into the unit in which the previous bit-
+     field, if any, was placed.
+13   An unnamed member of structure type with no tag is called an anonymous structure; an
+     unnamed member of union type with no tag is called an anonymous union. The members
+     of an anonymous structure or union are considered to be members of the containing
+     structure or union. This applies recursively if the containing structure or union is also
+     anonymous.
+14   Each non-bit-field member of a structure or union object is aligned in an implementation-
+     defined manner appropriate to its type.
+15   Within a structure object, the non-bit-field members and the units in which bit-fields
+     reside have addresses that increase in the order in which they are declared. A pointer to a
+     structure object, suitably converted, points to its initial member (or if that member is a
+     bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
+     padding within a structure object, but not at its beginning.
+16   The size of a union is sufficient to contain the largest of its members. The value of at
+     most one of the members can be stored in a union object at any time. A pointer to a
+     union object, suitably converted, points to each of its members (or if a member is a bit-
+     field, then to the unit in which it resides), and vice versa.
+17   There may be unnamed padding at the end of a structure or union.
+18   As a special case, the last element of a structure with more than one named member may
+     have an incomplete array type; this is called a flexible array member. In most situations,
+
+
+     <sup><a name="note125" href="#note125"><b>125)</b></a></sup> As specified in <a href="#6.7.2">6.7.2</a> above, if the actual type specifier used is int or a typedef-name defined as int,
+          then it is implementation-defined whether the bit-field is signed or unsigned.
+     <sup><a name="note126" href="#note126"><b>126)</b></a></sup> An unnamed bit-field structure member is useful for padding to conform to externally imposed
+          layouts.
+
+[<a name="p113" href="#p113">page 113</a>] (<a href="#Contents">Contents</a>)
+
+     the flexible array member is ignored. In particular, the size of the structure is as if the
+     flexible array member were omitted except that it may have more trailing padding than
+     the omission would imply. However, when a . (or -&gt;) operator has a left operand that is
+     (a pointer to) a structure with a flexible array member and the right operand names that
+     member, it behaves as if that member were replaced with the longest array (with the same
+     element type) that would not make the structure larger than the object being accessed; the
+     offset of the array shall remain that of the flexible array member, even if this would differ
+     from that of the replacement array. If this array would have no elements, it behaves as if
+     it had one element but the behavior is undefined if any attempt is made to access that
+     element or to generate a pointer one past it.
+19   EXAMPLE 1       The following illustrates anonymous structures and unions:
+              struct v {
+                    union {      // anonymous union
+                           struct { int i, j; };    // anonymous structure
+                           struct { long k, l; } w;
+                    };
+                    int m;
+              } v1;
+              v1.i = 2;   // valid
+              v1.k = 3;   // invalid: inner structure is not anonymous
+              v1.w.k = 5; // valid
+
+20   EXAMPLE 2       After the declaration:
+              struct s { int n; double d[]; };
+     the structure struct s has a flexible array member d. A typical way to use this is:
+              int m = /* some value */;
+              struct s *p = malloc(sizeof (struct s) + sizeof (double [m]));
+     and assuming that the call to malloc succeeds, the object pointed to by p behaves, for most purposes, as if
+     p had been declared as:
+              struct { int n; double d[m]; } *p;
+     (there are circumstances in which this equivalence is broken; in particular, the offsets of member d might
+     not be the same).
+21   Following the above declaration:
+              struct s t1 = { 0 };                         //   valid
+              struct s t2 = { 1, { <a href="#4.2">4.2</a> }};                 //   invalid
+              t1.n = 4;                                    //   valid
+              t1.d[0] = <a href="#4.2">4.2</a>;                               //   might be undefined behavior
+     The initialization of t2 is invalid (and violates a constraint) because struct s is treated as if it did not
+     contain member d. The assignment to t1.d[0] is probably undefined behavior, but it is possible that
+              sizeof (struct s) &gt;= offsetof(struct s, d) + sizeof (double)
+     in which case the assignment would be legitimate. Nevertheless, it cannot appear in strictly conforming
+     code.
+
+[<a name="p114" href="#p114">page 114</a>] (<a href="#Contents">Contents</a>)
+
+22   After the further declaration:
+              struct ss { int n; };
+     the expressions:
+              sizeof (struct s) &gt;= sizeof (struct ss)
+              sizeof (struct s) &gt;= offsetof(struct s, d)
+     are always equal to 1.
+23   If sizeof (double) is 8, then after the following code is executed:
+              struct s *s1;
+              struct s *s2;
+              s1 = malloc(sizeof (struct s) + 64);
+              s2 = malloc(sizeof (struct s) + 46);
+     and assuming that the calls to malloc succeed, the objects pointed to by s1 and s2 behave, for most
+     purposes, as if the identifiers had been declared as:
+              struct { int n; double d[8]; } *s1;
+              struct { int n; double d[5]; } *s2;
+24   Following the further successful assignments:
+              s1 = malloc(sizeof (struct s) + 10);
+              s2 = malloc(sizeof (struct s) + 6);
+     they then behave as if the declarations were:
+              struct { int n; double d[1]; } *s1, *s2;
+     and:
+              double *dp;
+              dp = &amp;(s1-&gt;d[0]);          //   valid
+              *dp = 42;                  //   valid
+              dp = &amp;(s2-&gt;d[0]);          //   valid
+              *dp = 42;                  //   undefined behavior
+25   The assignment:
+              *s1 = *s2;
+     only copies the member n; if any of the array elements are within the first sizeof (struct s) bytes
+     of the structure, they might be copied or simply overwritten with indeterminate values.
+
+     Forward references: declarators (<a href="#6.7.6">6.7.6</a>), tags (<a href="#6.7.2.3">6.7.2.3</a>).
+
+[<a name="p115" href="#p115">page 115</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.2.2" href="#6.7.2.2"><b>    6.7.2.2 Enumeration specifiers</b></a>
+<b>    Syntax</b>
+1            enum-specifier:
+                   enum identifieropt { enumerator-list }
+                   enum identifieropt { enumerator-list , }
+                   enum identifier
+             enumerator-list:
+                   enumerator
+                   enumerator-list , enumerator
+             enumerator:
+                   enumeration-constant
+                   enumeration-constant = constant-expression
+<b>    Constraints</b>
+2   The expression that defines the value of an enumeration constant shall be an integer
+    constant expression that has a value representable as an int.
+<b>    Semantics</b>
+3   The identifiers in an enumerator list are declared as constants that have type int and
+    may appear wherever such are permitted.<sup><a href="#note127"><b>127)</b></a></sup> An enumerator with = defines its
+    enumeration constant as the value of the constant expression. If the first enumerator has
+    no =, the value of its enumeration constant is 0. Each subsequent enumerator with no =
+    defines its enumeration constant as the value of the constant expression obtained by
+    adding 1 to the value of the previous enumeration constant. (The use of enumerators with
+    = may produce enumeration constants with values that duplicate other values in the same
+    enumeration.) The enumerators of an enumeration are also known as its members.
+4   Each enumerated type shall be compatible with char, a signed integer type, or an
+    unsigned integer type. The choice of type is implementation-defined,<sup><a href="#note128"><b>128)</b></a></sup> but shall be
+    capable of representing the values of all the members of the enumeration. The
+    enumerated type is incomplete until immediately after the } that terminates the list of
+    enumerator declarations, and complete thereafter.
+
+
+
+
+    <sup><a name="note127" href="#note127"><b>127)</b></a></sup> Thus, the identifiers of enumeration constants declared in the same scope shall all be distinct from
+         each other and from other identifiers declared in ordinary declarators.
+    <sup><a name="note128" href="#note128"><b>128)</b></a></sup> An implementation may delay the choice of which integer type until all enumeration constants have
+         been seen.
+
+[<a name="p116" href="#p116">page 116</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE       The following fragment:
+             enum hue { chartreuse, burgundy, claret=20, winedark };
+             enum hue col, *cp;
+             col = claret;
+             cp = &amp;col;
+             if (*cp != burgundy)
+                   /* ... */
+    makes hue the tag of an enumeration, and then declares col as an object that has that type and cp as a
+    pointer to an object that has that type. The enumerated values are in the set { 0, 1, 20, 21 }.
+
+    Forward references: tags (<a href="#6.7.2.3">6.7.2.3</a>).
+<a name="6.7.2.3" href="#6.7.2.3"><b>    6.7.2.3 Tags</b></a>
+<b>    Constraints</b>
+1   A specific type shall have its content defined at most once.
+2   Where two declarations that use the same tag declare the same type, they shall both use
+    the same choice of struct, union, or enum.
+3   A type specifier of the form
+            enum identifier
+    without an enumerator list shall only appear after the type it specifies is complete.
+<b>    Semantics</b>
+4   All declarations of structure, union, or enumerated types that have the same scope and
+    use the same tag declare the same type. Irrespective of whether there is a tag or what
+    other declarations of the type are in the same translation unit, the type is incomplete<sup><a href="#note129"><b>129)</b></a></sup>
+    until immediately after the closing brace of the list defining the content, and complete
+    thereafter.
+5   Two declarations of structure, union, or enumerated types which are in different scopes or
+    use different tags declare distinct types. Each declaration of a structure, union, or
+    enumerated type which does not include a tag declares a distinct type.
+6   A type specifier of the form
+
+
+
+
+    <sup><a name="note129" href="#note129"><b>129)</b></a></sup> An incomplete type may only by used when the size of an object of that type is not needed. It is not
+         needed, for example, when a typedef name is declared to be a specifier for a structure or union, or
+         when a pointer to or a function returning a structure or union is being declared. (See incomplete types
+         in <a href="#6.2.5">6.2.5</a>.) The specification has to be complete before such a function is called or defined.
+
+[<a name="p117" href="#p117">page 117</a>] (<a href="#Contents">Contents</a>)
+
+              struct-or-union identifieropt { struct-declaration-list }
+     or
+              enum identifieropt { enumerator-list }
+     or
+              enum identifieropt { enumerator-list , }
+     declares a structure, union, or enumerated type. The list defines the structure content,
+     union content, or enumeration content. If an identifier is provided,<sup><a href="#note130"><b>130)</b></a></sup> the type specifier
+     also declares the identifier to be the tag of that type.
+7    A declaration of the form
+              struct-or-union identifier ;
+     specifies a structure or union type and declares the identifier as a tag of that type.<sup><a href="#note131"><b>131)</b></a></sup>
+8    If a type specifier of the form
+              struct-or-union identifier
+     occurs other than as part of one of the above forms, and no other declaration of the
+     identifier as a tag is visible, then it declares an incomplete structure or union type, and
+     declares the identifier as the tag of that type.131)
+9    If a type specifier of the form
+              struct-or-union identifier
+     or
+              enum identifier
+     occurs other than as part of one of the above forms, and a declaration of the identifier as a
+     tag is visible, then it specifies the same type as that other declaration, and does not
+     redeclare the tag.
+10   EXAMPLE 1       This mechanism allows declaration of a self-referential structure.
+              struct tnode {
+                    int count;
+                    struct tnode *left, *right;
+              };
+     specifies a structure that contains an integer and two pointers to objects of the same type. Once this
+     declaration has been given, the declaration
+
+
+
+
+     <sup><a name="note130" href="#note130"><b>130)</b></a></sup> If there is no identifier, the type can, within the translation unit, only be referred to by the declaration
+          of which it is a part. Of course, when the declaration is of a typedef name, subsequent declarations
+          can make use of that typedef name to declare objects having the specified structure, union, or
+          enumerated type.
+     <sup><a name="note131" href="#note131"><b>131)</b></a></sup> A similar construction with enum does not exist.
+
+[<a name="p118" href="#p118">page 118</a>] (<a href="#Contents">Contents</a>)
+
+              struct tnode s, *sp;
+     declares s to be an object of the given type and sp to be a pointer to an object of the given type. With
+     these declarations, the expression sp-&gt;left refers to the left struct tnode pointer of the object to
+     which sp points; the expression s.right-&gt;count designates the count member of the right struct
+     tnode pointed to from s.
+11   The following alternative formulation uses the typedef mechanism:
+              typedef struct tnode TNODE;
+              struct tnode {
+                    int count;
+                    TNODE *left, *right;
+              };
+              TNODE s, *sp;
+
+12   EXAMPLE 2 To illustrate the use of prior declaration of a tag to specify a pair of mutually referential
+     structures, the declarations
+              struct s1 { struct s2 *s2p; /* ... */ }; // D1
+              struct s2 { struct s1 *s1p; /* ... */ }; // D2
+     specify a pair of structures that contain pointers to each other. Note, however, that if s2 were already
+     declared as a tag in an enclosing scope, the declaration D1 would refer to it, not to the tag s2 declared in
+     D2. To eliminate this context sensitivity, the declaration
+              struct s2;
+     may be inserted ahead of D1. This declares a new tag s2 in the inner scope; the declaration D2 then
+     completes the specification of the new type.
+
+     Forward references: declarators (<a href="#6.7.6">6.7.6</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+<a name="6.7.2.4" href="#6.7.2.4"><b>     6.7.2.4 Atomic type specifiers</b></a>
+<b>     Syntax</b>
+1             atomic-type-specifier:
+                     _Atomic ( type-name )
+<b>     Constraints</b>
+2    Atomic type specifiers shall not be used if the implementation does not support atomic
+     types (see <a href="#6.10.8.3">6.10.8.3</a>).
+3    The type name in an atomic type specifier shall not refer to an array type, a function type,
+     an atomic type, or a qualified type.
+<b>     Semantics</b>
+4    The properties associated with atomic types are meaningful only for expressions that are
+     lvalues. If the _Atomic keyword is immediately followed by a left parenthesis, it is
+     interpreted as a type specifier (with a type name), not as a type qualifier.
+
+[<a name="p119" href="#p119">page 119</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.3" href="#6.7.3"><b>    6.7.3 Type qualifiers</b></a>
+<b>    Syntax</b>
+1            type-qualifier:
+                    const
+                    restrict
+                    volatile
+                    _Atomic
+<b>    Constraints</b>
+2   Types other than pointer types whose referenced type is an object type shall not be
+    restrict-qualified.
+3   The type modified by the _Atomic qualifier shall not be an array type or a function
+    type.
+<b>    Semantics</b>
+4   The properties associated with qualified types are meaningful only for expressions that
+    are lvalues.<sup><a href="#note132"><b>132)</b></a></sup>
+5   If the same qualifier appears more than once in the same specifier-qualifier-list, either
+    directly or via one or more typedefs, the behavior is the same as if it appeared only
+    once. If other qualifiers appear along with the _Atomic qualifier in a specifier-qualifier-
+    list, the resulting type is the so-qualified atomic type.
+6   If an attempt is made to modify an object defined with a const-qualified type through use
+    of an lvalue with non-const-qualified type, the behavior is undefined. If an attempt is
+    made to refer to an object defined with a volatile-qualified type through use of an lvalue
+    with non-volatile-qualified type, the behavior is undefined.<sup><a href="#note133"><b>133)</b></a></sup>
+7   An object that has volatile-qualified type may be modified in ways unknown to the
+    implementation or have other unknown side effects. Therefore any expression referring
+    to such an object shall be evaluated strictly according to the rules of the abstract machine,
+    as described in <a href="#5.1.2.3">5.1.2.3</a>. Furthermore, at every sequence point the value last stored in the
+    object shall agree with that prescribed by the abstract machine, except as modified by the
+
+
+
+
+    <sup><a name="note132" href="#note132"><b>132)</b></a></sup> The implementation may place a const object that is not volatile in a read-only region of
+         storage. Moreover, the implementation need not allocate storage for such an object if its address is
+         never used.
+    <sup><a name="note133" href="#note133"><b>133)</b></a></sup> This applies to those objects that behave as if they were defined with qualified types, even if they are
+         never actually defined as objects in the program (such as an object at a memory-mapped input/output
+         address).
+
+[<a name="p120" href="#p120">page 120</a>] (<a href="#Contents">Contents</a>)
+
+     unknown factors mentioned previously.<sup><a href="#note134"><b>134)</b></a></sup> What constitutes an access to an object that
+     has volatile-qualified type is implementation-defined.
+8    An object that is accessed through a restrict-qualified pointer has a special association
+     with that pointer. This association, defined in <a href="#6.7.3.1">6.7.3.1</a> below, requires that all accesses to
+     that object use, directly or indirectly, the value of that particular pointer.<sup><a href="#note135"><b>135)</b></a></sup> The intended
+     use of the restrict qualifier (like the register storage class) is to promote
+     optimization, and deleting all instances of the qualifier from all preprocessing translation
+     units composing a conforming program does not change its meaning (i.e., observable
+     behavior).
+9    If the specification of an array type includes any type qualifiers, the element type is so-
+     qualified, not the array type. If the specification of a function type includes any type
+     qualifiers, the behavior is undefined.<sup><a href="#note136"><b>136)</b></a></sup>
+10   For two qualified types to be compatible, both shall have the identically qualified version
+     of a compatible type; the order of type qualifiers within a list of specifiers or qualifiers
+     does not affect the specified type.
+11   EXAMPLE 1      An object declared
+              extern const volatile int real_time_clock;
+     may be modifiable by hardware, but cannot be assigned to, incremented, or decremented.
+
+12   EXAMPLE 2 The following declarations and expressions illustrate the behavior when type qualifiers
+     modify an aggregate type:
+              const struct s { int mem; } cs = { 1 };
+              struct s ncs; // the object ncs is modifiable
+              typedef int A[2][3];
+              const A a = {{4, 5, 6}, {7, 8, 9}}; // array of array of const int
+              int *pi;
+              const int *pci;
+              ncs = cs;            //    valid
+              cs = ncs;            //    violates modifiable lvalue constraint for =
+              pi = &amp;ncs.mem;       //    valid
+              pi = &amp;cs.mem;        //    violates type constraints for =
+              pci = &amp;cs.mem;       //    valid
+              pi = a[0];           //    invalid: a[0] has type ''const int *''
+
+
+
+     <sup><a name="note134" href="#note134"><b>134)</b></a></sup> A volatile declaration may be used to describe an object corresponding to a memory-mapped
+          input/output port or an object accessed by an asynchronously interrupting function. Actions on
+          objects so declared shall not be ''optimized out'' by an implementation or reordered except as
+          permitted by the rules for evaluating expressions.
+     <sup><a name="note135" href="#note135"><b>135)</b></a></sup> For example, a statement that assigns a value returned by malloc to a single pointer establishes this
+          association between the allocated object and the pointer.
+     <sup><a name="note136" href="#note136"><b>136)</b></a></sup> Both of these can occur through the use of typedefs.
+
+[<a name="p121" href="#p121">page 121</a>] (<a href="#Contents">Contents</a>)
+
+13   EXAMPLE 3       The declaration
+              _Atomic volatile int *p;
+     specifies that p has the type ''pointer to volatile atomic int'', a pointer to a volatile-qualified atomic type.
+
+<a name="6.7.3.1" href="#6.7.3.1"><b>     6.7.3.1 Formal definition of restrict</b></a>
+1    Let D be a declaration of an ordinary identifier that provides a means of designating an
+     object P as a restrict-qualified pointer to type T.
+2    If D appears inside a block and does not have storage class extern, let B denote the
+     block. If D appears in the list of parameter declarations of a function definition, let B
+     denote the associated block. Otherwise, let B denote the block of main (or the block of
+     whatever function is called at program startup in a freestanding environment).
+3    In what follows, a pointer expression E is said to be based on object P if (at some
+     sequence point in the execution of B prior to the evaluation of E) modifying P to point to
+     a copy of the array object into which it formerly pointed would change the value of E.<sup><a href="#note137"><b>137)</b></a></sup>
+     Note that ''based'' is defined only for expressions with pointer types.
+4    During each execution of B, let L be any lvalue that has &amp;L based on P. If L is used to
+     access the value of the object X that it designates, and X is also modified (by any means),
+     then the following requirements apply: T shall not be const-qualified. Every other lvalue
+     used to access the value of X shall also have its address based on P. Every access that
+     modifies X shall be considered also to modify P, for the purposes of this subclause. If P
+     is assigned the value of a pointer expression E that is based on another restricted pointer
+     object P2, associated with block B2, then either the execution of B2 shall begin before
+     the execution of B, or the execution of B2 shall end prior to the assignment. If these
+     requirements are not met, then the behavior is undefined.
+5    Here an execution of B means that portion of the execution of the program that would
+     correspond to the lifetime of an object with scalar type and automatic storage duration
+     associated with B.
+6    A translator is free to ignore any or all aliasing implications of uses of restrict.
+7    EXAMPLE 1       The file scope declarations
+              int * restrict a;
+              int * restrict b;
+              extern int c[];
+     assert that if an object is accessed using one of a, b, or c, and that object is modified anywhere in the
+     program, then it is never accessed using either of the other two.
+
+
+     <sup><a name="note137" href="#note137"><b>137)</b></a></sup> In other words, E depends on the value of P itself rather than on the value of an object referenced
+          indirectly through P. For example, if identifier p has type (int **restrict), then the pointer
+          expressions p and p+1 are based on the restricted pointer object designated by p, but the pointer
+          expressions *p and p[1] are not.
+
+[<a name="p122" href="#p122">page 122</a>] (<a href="#Contents">Contents</a>)
+
+8    EXAMPLE 2       The function parameter declarations in the following example
+             void f(int n, int * restrict p, int * restrict q)
+             {
+                   while (n-- &gt; 0)
+                         *p++ = *q++;
+             }
+     assert that, during each execution of the function, if an object is accessed through one of the pointer
+     parameters, then it is not also accessed through the other.
+9    The benefit of the restrict qualifiers is that they enable a translator to make an effective dependence
+     analysis of function f without examining any of the calls of f in the program. The cost is that the
+     programmer has to examine all of those calls to ensure that none give undefined behavior. For example, the
+     second call of f in g has undefined behavior because each of d[1] through d[49] is accessed through
+     both p and q.
+              void g(void)
+              {
+                    extern int d[100];
+                    f(50, d + 50, d); // valid
+                    f(50, d + 1, d); // undefined behavior
+              }
+
+10   EXAMPLE 3       The function parameter declarations
+             void h(int n, int * restrict p, int * restrict q, int * restrict r)
+             {
+                   int i;
+                   for (i = 0; i &lt; n; i++)
+                          p[i] = q[i] + r[i];
+             }
+     illustrate how an unmodified object can be aliased through two restricted pointers. In particular, if a and b
+     are disjoint arrays, a call of the form h(100, a, b, b) has defined behavior, because array b is not
+     modified within function h.
+
+11   EXAMPLE 4 The rule limiting assignments between restricted pointers does not distinguish between a
+     function call and an equivalent nested block. With one exception, only ''outer-to-inner'' assignments
+     between restricted pointers declared in nested blocks have defined behavior.
+             {
+                      int * restrict p1;
+                      int * restrict q1;
+                      p1 = q1; // undefined behavior
+                      {
+                            int * restrict p2 = p1; // valid
+                            int * restrict q2 = q1; // valid
+                            p1 = q2;                // undefined behavior
+                            p2 = q2;                // undefined behavior
+                      }
+             }
+
+[<a name="p123" href="#p123">page 123</a>] (<a href="#Contents">Contents</a>)
+
+12   The one exception allows the value of a restricted pointer to be carried out of the block in which it (or, more
+     precisely, the ordinary identifier used to designate it) is declared when that block finishes execution. For
+     example, this permits new_vector to return a vector.
+              typedef struct { int n; float * restrict v; } vector;
+              vector new_vector(int n)
+              {
+                    vector t;
+                    t.n = n;
+                    t.v = malloc(n * sizeof (float));
+                    return t;
+              }
+
+<a name="6.7.4" href="#6.7.4"><b>     6.7.4 Function specifiers</b></a>
+<b>     Syntax</b>
+1             function-specifier:
+                     inline
+                     _Noreturn
+<b>     Constraints</b>
+2    Function specifiers shall be used only in the declaration of an identifier for a function.
+3    An inline definition of a function with external linkage shall not contain a definition of a
+     modifiable object with static or thread storage duration, and shall not contain a reference
+     to an identifier with internal linkage.
+4    In a hosted environment, no function specifier(s) shall appear in a declaration of main.
+<b>     Semantics</b>
+5    A function specifier may appear more than once; the behavior is the same as if it
+     appeared only once.
+6    A function declared with an inline function specifier is an inline function. Making a *
+     function an inline function suggests that calls to the function be as fast as possible.<sup><a href="#note138"><b>138)</b></a></sup>
+     The extent to which such suggestions are effective is implementation-defined.<sup><a href="#note139"><b>139)</b></a></sup>
+
+
+
+
+     <sup><a name="note138" href="#note138"><b>138)</b></a></sup> By using, for example, an alternative to the usual function call mechanism, such as ''inline
+          substitution''. Inline substitution is not textual substitution, nor does it create a new function.
+          Therefore, for example, the expansion of a macro used within the body of the function uses the
+          definition it had at the point the function body appears, and not where the function is called; and
+          identifiers refer to the declarations in scope where the body occurs. Likewise, the function has a
+          single address, regardless of the number of inline definitions that occur in addition to the external
+          definition.
+     <sup><a name="note139" href="#note139"><b>139)</b></a></sup> For example, an implementation might never perform inline substitution, or might only perform inline
+          substitutions to calls in the scope of an inline declaration.
+
+[<a name="p124" href="#p124">page 124</a>] (<a href="#Contents">Contents</a>)
+
+7    Any function with internal linkage can be an inline function. For a function with external
+     linkage, the following restrictions apply: If a function is declared with an inline
+     function specifier, then it shall also be defined in the same translation unit. If all of the
+     file scope declarations for a function in a translation unit include the inline function
+     specifier without extern, then the definition in that translation unit is an inline
+     definition. An inline definition does not provide an external definition for the function,
+     and does not forbid an external definition in another translation unit. An inline definition
+     provides an alternative to an external definition, which a translator may use to implement
+     any call to the function in the same translation unit. It is unspecified whether a call to the
+     function uses the inline definition or the external definition.<sup><a href="#note140"><b>140)</b></a></sup>
+8    A function declared with a _Noreturn function specifier shall not return to its caller.
+     Recommended practice
+9    The implementation should produce a diagnostic message for a function declared with a
+     _Noreturn function specifier that appears to be capable of returning to its caller.
+10   EXAMPLE 1 The declaration of an inline function with external linkage can result in either an external
+     definition, or a definition available for use only within the translation unit. A file scope declaration with
+     extern creates an external definition. The following example shows an entire translation unit.
+              inline double fahr(double t)
+              {
+                    return (9.0 * t) / 5.0 + 32.0;
+              }
+              inline double cels(double t)
+              {
+                    return (5.0 * (t - 32.0)) / 9.0;
+              }
+              extern double fahr(double);                  // creates an external definition
+              double convert(int is_fahr, double temp)
+              {
+                    /* A translator may perform inline substitutions */
+                    return is_fahr ? cels(temp) : fahr(temp);
+              }
+11   Note that the definition of fahr is an external definition because fahr is also declared with extern, but
+     the definition of cels is an inline definition. Because cels has external linkage and is referenced, an
+     external definition has to appear in another translation unit (see <a href="#6.9">6.9</a>); the inline definition and the external
+     definition are distinct and either may be used for the call.
+
+12   EXAMPLE 2
+
+
+
+
+     <sup><a name="note140" href="#note140"><b>140)</b></a></sup> Since an inline definition is distinct from the corresponding external definition and from any other
+          corresponding inline definitions in other translation units, all corresponding objects with static storage
+          duration are also distinct in each of the definitions.
+
+[<a name="p125" href="#p125">page 125</a>] (<a href="#Contents">Contents</a>)
+
+             _Noreturn void f () {
+                   abort(); // ok
+             }
+             _Noreturn void g (int i) { // causes undefined behavior if i &lt;= 0
+                   if (i &gt; 0) abort();
+             }
+
+    Forward references: function definitions (<a href="#6.9.1">6.9.1</a>).
+<a name="6.7.5" href="#6.7.5"><b>    6.7.5 Alignment specifier</b></a>
+<b>    Syntax</b>
+1            alignment-specifier:
+                   _Alignas ( type-name )
+                   _Alignas ( constant-expression )
+<b>    Constraints</b>
+2   An alignment attribute shall not be specified in a declaration of a typedef, or a bit-field, or
+    a function, or a parameter, or an object declared with the register storage-class
+    specifier.
+3   The constant expression shall be an integer constant expression. It shall evaluate to a
+    valid fundamental alignment, or to a valid extended alignment supported by the
+    implementation in the context in which it appears, or to zero.
+4   The combined effect of all alignment attributes in a declaration shall not specify an
+    alignment that is less strict than the alignment that would otherwise be required for the
+    type of the object or member being declared.
+<b>    Semantics</b>
+5   The first form is equivalent to _Alignas(alignof(type-name)).
+6   The alignment requirement of the declared object or member is taken to be the specified
+    alignment. An alignment specification of zero has no effect.<sup><a href="#note141"><b>141)</b></a></sup> When multiple
+    alignment specifiers occur in a declaration, the effective alignment requirement is the
+    strictest specified alignment.
+7   If the definition of an object has an alignment specifier, any other declaration of that
+    object shall either specify equivalent alignment or have no alignment specifier. If the
+    definition of an object does not have an alignment specifier, any other declaration of that
+    object shall also have no alignment specifier. If declarations of an object in different
+    translation units have different alignment specifiers, the behavior is undefined.
+
+
+
+    <sup><a name="note141" href="#note141"><b>141)</b></a></sup> An alignment specification of zero also does not affect other alignment specifications in the same
+         declaration.
+
+[<a name="p126" href="#p126">page 126</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.6" href="#6.7.6"><b>    6.7.6 Declarators</b></a>
+<b>    Syntax</b>
+1            declarator:
+                    pointeropt direct-declarator
+             direct-declarator:
+                     identifier
+                     ( declarator )
+                     direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+                     direct-declarator [ static type-qualifier-listopt assignment-expression ]
+                     direct-declarator [ type-qualifier-list static assignment-expression ]
+                     direct-declarator [ type-qualifier-listopt * ]
+                     direct-declarator ( parameter-type-list )
+                     direct-declarator ( identifier-listopt )
+             pointer:
+                    * type-qualifier-listopt
+                    * type-qualifier-listopt pointer
+             type-qualifier-list:
+                    type-qualifier
+                    type-qualifier-list type-qualifier
+             parameter-type-list:
+                   parameter-list
+                   parameter-list , ...
+             parameter-list:
+                   parameter-declaration
+                   parameter-list , parameter-declaration
+             parameter-declaration:
+                   declaration-specifiers declarator
+                   declaration-specifiers abstract-declaratoropt
+             identifier-list:
+                    identifier
+                    identifier-list , identifier
+<b>    Semantics</b>
+2   Each declarator declares one identifier, and asserts that when an operand of the same
+    form as the declarator appears in an expression, it designates a function or object with the
+    scope, storage duration, and type indicated by the declaration specifiers.
+3   A full declarator is a declarator that is not part of another declarator. The end of a full
+    declarator is a sequence point. If, in the nested sequence of declarators in a full
+
+[<a name="p127" href="#p127">page 127</a>] (<a href="#Contents">Contents</a>)
+
+    declarator, there is a declarator specifying a variable length array type, the type specified
+    by the full declarator is said to be variably modified. Furthermore, any type derived by
+    declarator type derivation from a variably modified type is itself variably modified.
+4   In the following subclauses, consider a declaration
+            T D1
+    where T contains the declaration specifiers that specify a type T (such as int) and D1 is
+    a declarator that contains an identifier ident. The type specified for the identifier ident in
+    the various forms of declarator is described inductively using this notation.
+5   If, in the declaration ''T D1'', D1 has the form
+            identifier
+    then the type specified for ident is T .
+6   If, in the declaration ''T D1'', D1 has the form
+            ( D )
+    then ident has the type specified by the declaration ''T D''. Thus, a declarator in
+    parentheses is identical to the unparenthesized declarator, but the binding of complicated
+    declarators may be altered by parentheses.
+    Implementation limits
+7   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, an implementation may limit the number of pointer, array, and
+    function declarators that modify an arithmetic, structure, union, or void type, either
+    directly or via one or more typedefs.
+    Forward references: array declarators (<a href="#6.7.6.2">6.7.6.2</a>), type definitions (<a href="#6.7.8">6.7.8</a>).
+<a name="6.7.6.1" href="#6.7.6.1"><b>    6.7.6.1 Pointer declarators</b></a>
+<b>    Semantics</b>
+1   If, in the declaration ''T D1'', D1 has the form
+            * type-qualifier-listopt D
+    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+    T '', then the type specified for ident is ''derived-declarator-type-list type-qualifier-list
+    pointer to T ''. For each type qualifier in the list, ident is a so-qualified pointer.
+2   For two pointer types to be compatible, both shall be identically qualified and both shall
+    be pointers to compatible types.
+3   EXAMPLE The following pair of declarations demonstrates the difference between a ''variable pointer
+    to a constant value'' and a ''constant pointer to a variable value''.
+
+[<a name="p128" href="#p128">page 128</a>] (<a href="#Contents">Contents</a>)
+
+             const int *ptr_to_constant;
+             int *const constant_ptr;
+    The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
+    but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
+    int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
+    same location.
+4   The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
+    type ''pointer to int''.
+             typedef int *int_ptr;
+             const int_ptr constant_ptr;
+    declares constant_ptr as an object that has type ''const-qualified pointer to int''.
+
+<a name="6.7.6.2" href="#6.7.6.2"><b>    6.7.6.2 Array declarators</b></a>
+<b>    Constraints</b>
+1   In addition to optional type qualifiers and the keyword static, the [ and ] may delimit
+    an expression or *. If they delimit an expression (which specifies the size of an array), the
+    expression shall have an integer type. If the expression is a constant expression, it shall
+    have a value greater than zero. The element type shall not be an incomplete or function
+    type. The optional type qualifiers and the keyword static shall appear only in a
+    declaration of a function parameter with an array type, and then only in the outermost
+    array type derivation.
+2   If an identifier is declared as having a variably modified type, it shall be an ordinary
+    identifier (as defined in <a href="#6.2.3">6.2.3</a>), have no linkage, and have either block scope or function
+    prototype scope. If an identifier is declared to be an object with static or thread storage
+    duration, it shall not have a variable length array type.
+<b>    Semantics</b>
+3   If, in the declaration ''T D1'', D1 has one of the forms:
+             D[ type-qualifier-listopt assignment-expressionopt ]
+             D[ static type-qualifier-listopt assignment-expression ]
+             D[ type-qualifier-list static assignment-expression ]
+             D[ type-qualifier-listopt * ]
+    and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+    T '', then the type specified for ident is ''derived-declarator-type-list array of T ''.<sup><a href="#note142"><b>142)</b></a></sup>
+    (See <a href="#6.7.6.3">6.7.6.3</a> for the meaning of the optional type qualifiers and the keyword static.)
+4   If the size is not present, the array type is an incomplete type. If the size is * instead of
+    being an expression, the array type is a variable length array type of unspecified size,
+    which can only be used in declarations or type names with function prototype scope;<sup><a href="#note143"><b>143)</b></a></sup>
+
+    <sup><a name="note142" href="#note142"><b>142)</b></a></sup> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
+
+[<a name="p129" href="#p129">page 129</a>] (<a href="#Contents">Contents</a>)
+
+    such arrays are nonetheless complete types. If the size is an integer constant expression
+    and the element type has a known constant size, the array type is not a variable length
+    array type; otherwise, the array type is a variable length array type. (Variable length
+    arrays are a conditional feature that implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.)
+5   If the size is an expression that is not an integer constant expression: if it occurs in a
+    declaration at function prototype scope, it is treated as if it were replaced by *; otherwise,
+    each time it is evaluated it shall have a value greater than zero. The size of each instance
+    of a variable length array type does not change during its lifetime. Where a size
+    expression is part of the operand of a sizeof operator and changing the value of the
+    size expression would not affect the result of the operator, it is unspecified whether or not
+    the size expression is evaluated.
+6   For two array types to be compatible, both shall have compatible element types, and if
+    both size specifiers are present, and are integer constant expressions, then both size
+    specifiers shall have the same constant value. If the two array types are used in a context
+    which requires them to be compatible, it is undefined behavior if the two size specifiers
+    evaluate to unequal values.
+7   EXAMPLE 1
+             float fa[11], *afp[17];
+    declares an array of float numbers and an array of pointers to float numbers.
+
+8   EXAMPLE 2       Note the distinction between the declarations
+             extern int *x;
+             extern int y[];
+    The first declares x to be a pointer to int; the second declares y to be an array of int of unspecified size
+    (an incomplete type), the storage for which is defined elsewhere.
+
+9   EXAMPLE 3       The following declarations demonstrate the compatibility rules for variably modified types.
+             extern int n;
+             extern int m;
+             void fcompat(void)
+             {
+                   int a[n][6][m];
+                   int (*p)[4][n+1];
+                   int c[n][n][6][m];
+                   int (*r)[n][n][n+1];
+                   p = a;       // invalid: not compatible because 4 != 6
+                   r = c;       // compatible, but defined behavior only if
+                                // n == 6 and m == n+1
+             }
+
+
+
+
+    <sup><a name="note143" href="#note143"><b>143)</b></a></sup> Thus, * can be used only in function declarations that are not definitions (see <a href="#6.7.6.3">6.7.6.3</a>).
+
+[<a name="p130" href="#p130">page 130</a>] (<a href="#Contents">Contents</a>)
+
+10   EXAMPLE 4 All declarations of variably modified (VM) types have to be at either block scope or
+     function prototype scope. Array objects declared with the _Thread_local, static, or extern
+     storage-class specifier cannot have a variable length array (VLA) type. However, an object declared with
+     the static storage-class specifier can have a VM type (that is, a pointer to a VLA type). Finally, all
+     identifiers declared with a VM type have to be ordinary identifiers and cannot, therefore, be members of
+     structures or unions.
+             extern int n;
+             int A[n];                                           // invalid: file scope VLA
+             extern int (*p2)[n];                                // invalid: file scope VM
+             int B[100];                                         // valid: file scope but not VM
+             void fvla(int m, int C[m][m]);                      // valid: VLA with prototype scope
+             void fvla(int m, int C[m][m])                       // valid: adjusted to auto pointer to VLA
+             {
+                   typedef int VLA[m][m];                        // valid: block scope typedef VLA
+                      struct tag {
+                            int (*y)[n];                         // invalid: y not ordinary identifier
+                            int z[n];                            // invalid: z not ordinary identifier
+                      };
+                      int D[m];                                  //   valid: auto VLA
+                      static int E[m];                           //   invalid: static block scope VLA
+                      extern int F[m];                           //   invalid: F has linkage and is VLA
+                      int (*s)[m];                               //   valid: auto pointer to VLA
+                      extern int (*r)[m];                        //   invalid: r has linkage and points to VLA
+                      static int (*q)[m] = &amp;B;                   //   valid: q is a static block pointer to VLA
+             }
+
+     Forward references:          function declarators (<a href="#6.7.6.3">6.7.6.3</a>), function definitions (<a href="#6.9.1">6.9.1</a>),
+     initialization (<a href="#6.7.9">6.7.9</a>).
+<a name="6.7.6.3" href="#6.7.6.3"><b>     6.7.6.3 Function declarators (including prototypes)</b></a>
+<b>     Constraints</b>
+1    A function declarator shall not specify a return type that is a function type or an array
+     type.
+2    The only storage-class specifier that shall occur in a parameter declaration is register.
+3    An identifier list in a function declarator that is not part of a definition of that function
+     shall be empty.
+4    After adjustment, the parameters in a parameter type list in a function declarator that is
+     part of a definition of that function shall not have incomplete type.
+<b>     Semantics</b>
+5    If, in the declaration ''T D1'', D1 has the form
+
+[<a name="p131" href="#p131">page 131</a>] (<a href="#Contents">Contents</a>)
+
+            D( parameter-type-list )
+     or
+            D( identifier-listopt )
+     and the type specified for ident in the declaration ''T D'' is ''derived-declarator-type-list
+     T '', then the type specified for ident is ''derived-declarator-type-list function returning
+     T ''.
+6    A parameter type list specifies the types of, and may declare identifiers for, the
+     parameters of the function.
+7    A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to
+     type'', where the type qualifiers (if any) are those specified within the [ and ] of the
+     array type derivation. If the keyword static also appears within the [ and ] of the
+     array type derivation, then for each call to the function, the value of the corresponding
+     actual argument shall provide access to the first element of an array with at least as many
+     elements as specified by the size expression.
+8    A declaration of a parameter as ''function returning type'' shall be adjusted to ''pointer to
+     function returning type'', as in <a href="#6.3.2.1">6.3.2.1</a>.
+9    If the list terminates with an ellipsis (, ...), no information about the number or types
+     of the parameters after the comma is supplied.<sup><a href="#note144"><b>144)</b></a></sup>
+10   The special case of an unnamed parameter of type void as the only item in the list
+     specifies that the function has no parameters.
+11   If, in a parameter declaration, an identifier can be treated either as a typedef name or as a
+     parameter name, it shall be taken as a typedef name.
+12   If the function declarator is not part of a definition of that function, parameters may have
+     incomplete type and may use the [*] notation in their sequences of declarator specifiers
+     to specify variable length array types.
+13   The storage-class specifier in the declaration specifiers for a parameter declaration, if
+     present, is ignored unless the declared parameter is one of the members of the parameter
+     type list for a function definition.
+14   An identifier list declares only the identifiers of the parameters of the function. An empty
+     list in a function declarator that is part of a definition of that function specifies that the
+     function has no parameters. The empty list in a function declarator that is not part of a
+     definition of that function specifies that no information about the number or types of the
+     parameters is supplied.<sup><a href="#note145"><b>145)</b></a></sup>
+
+
+
+     <sup><a name="note144" href="#note144"><b>144)</b></a></sup> The macros defined in the <a href="#7.16">&lt;stdarg.h&gt;</a> header (<a href="#7.16">7.16</a>) may be used to access arguments that
+          correspond to the ellipsis.
+
+[<a name="p132" href="#p132">page 132</a>] (<a href="#Contents">Contents</a>)
+
+15   For two function types to be compatible, both shall specify compatible return types.<sup><a href="#note146"><b>146)</b></a></sup>
+     Moreover, the parameter type lists, if both are present, shall agree in the number of
+     parameters and in use of the ellipsis terminator; corresponding parameters shall have
+     compatible types. If one type has a parameter type list and the other type is specified by a
+     function declarator that is not part of a function definition and that contains an empty
+     identifier list, the parameter list shall not have an ellipsis terminator and the type of each
+     parameter shall be compatible with the type that results from the application of the
+     default argument promotions. If one type has a parameter type list and the other type is
+     specified by a function definition that contains a (possibly empty) identifier list, both shall
+     agree in the number of parameters, and the type of each prototype parameter shall be
+     compatible with the type that results from the application of the default argument
+     promotions to the type of the corresponding identifier. (In the determination of type
+     compatibility and of a composite type, each parameter declared with function or array
+     type is taken as having the adjusted type and each parameter declared with qualified type
+     is taken as having the unqualified version of its declared type.)
+16   EXAMPLE 1       The declaration
+              int f(void), *fip(), (*pfi)();
+     declares a function f with no parameters returning an int, a function fip with no parameter specification
+     returning a pointer to an int, and a pointer pfi to a function with no parameter specification returning an
+     int. It is especially useful to compare the last two. The binding of *fip() is *(fip()), so that the
+     declaration suggests, and the same construction in an expression requires, the calling of a function fip,
+     and then using indirection through the pointer result to yield an int. In the declarator (*pfi)(), the
+     extra parentheses are necessary to indicate that indirection through a pointer to a function yields a function
+     designator, which is then used to call the function; it returns an int.
+17   If the declaration occurs outside of any function, the identifiers have file scope and external linkage. If the
+     declaration occurs inside a function, the identifiers of the functions f and fip have block scope and either
+     internal or external linkage (depending on what file scope declarations for these identifiers are visible), and
+     the identifier of the pointer pfi has block scope and no linkage.
+
+18   EXAMPLE 2       The declaration
+              int (*apfi[3])(int *x, int *y);
+     declares an array apfi of three pointers to functions returning int. Each of these functions has two
+     parameters that are pointers to int. The identifiers x and y are declared for descriptive purposes only and
+     go out of scope at the end of the declaration of apfi.
+
+19   EXAMPLE 3       The declaration
+              int (*fpfi(int (*)(long), int))(int, ...);
+     declares a function fpfi that returns a pointer to a function returning an int. The function fpfi has two
+     parameters: a pointer to a function returning an int (with one parameter of type long int), and an int.
+     The pointer returned by fpfi points to a function that has one int parameter and accepts zero or more
+
+
+     <sup><a name="note145" href="#note145"><b>145)</b></a></sup> See ''future language directions'' (<a href="#6.11.6">6.11.6</a>).
+     <sup><a name="note146" href="#note146"><b>146)</b></a></sup> If both function types are ''old style'', parameter types are not compared.
+
+[<a name="p133" href="#p133">page 133</a>] (<a href="#Contents">Contents</a>)
+
+     additional arguments of any type.
+
+20   EXAMPLE 4        The following prototype has a variably modified parameter.
+               void addscalar(int n, int m,
+                     double a[n][n*m+300], double x);
+               int main()
+               {
+                     double b[4][308];
+                     addscalar(4, 2, b, <a href="#2.17">2.17</a>);
+                     return 0;
+               }
+               void addscalar(int n, int m,
+                     double a[n][n*m+300], double x)
+               {
+                     for (int i = 0; i &lt; n; i++)
+                           for (int j = 0, k = n*m+300; j &lt; k; j++)
+                                 // a is a pointer to a VLA with n*m+300 elements
+                                 a[i][j] += x;
+               }
+
+21   EXAMPLE 5        The following are all compatible function prototype declarators.
+               double    maximum(int       n,   int   m,   double   a[n][m]);
+               double    maximum(int       n,   int   m,   double   a[*][*]);
+               double    maximum(int       n,   int   m,   double   a[ ][*]);
+               double    maximum(int       n,   int   m,   double   a[ ][m]);
+     as are:
+               void   f(double     (* restrict a)[5]);
+               void   f(double     a[restrict][5]);
+               void   f(double     a[restrict 3][5]);
+               void   f(double     a[restrict static 3][5]);
+     (Note that the last declaration also specifies that the argument corresponding to a in any call to f must be a
+     non-null pointer to the first of at least three arrays of 5 doubles, which the others do not.)
+
+     Forward references: function definitions (<a href="#6.9.1">6.9.1</a>), type names (<a href="#6.7.7">6.7.7</a>).
+
+[<a name="p134" href="#p134">page 134</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.7" href="#6.7.7"><b>    6.7.7 Type names</b></a>
+<b>    Syntax</b>
+1            type-name:
+                    specifier-qualifier-list abstract-declaratoropt
+             abstract-declarator:
+                    pointer
+                    pointeropt direct-abstract-declarator
+             direct-abstract-declarator:
+                     ( abstract-declarator )
+                     direct-abstract-declaratoropt [ type-qualifier-listopt
+                                    assignment-expressionopt ]
+                     direct-abstract-declaratoropt [ static type-qualifier-listopt
+                                    assignment-expression ]
+                     direct-abstract-declaratoropt [ type-qualifier-list static
+                                    assignment-expression ]
+                     direct-abstract-declaratoropt [ * ]
+                     direct-abstract-declaratoropt ( parameter-type-listopt )
+<b>    Semantics</b>
+2   In several contexts, it is necessary to specify a type. This is accomplished using a type
+    name, which is syntactically a declaration for a function or an object of that type that
+    omits the identifier.<sup><a href="#note147"><b>147)</b></a></sup>
+3   EXAMPLE        The constructions
+             (a)      int
+             (b)      int   *
+             (c)      int   *[3]
+             (d)      int   (*)[3]
+             (e)      int   (*)[*]
+             (f)      int   *()
+             (g)      int   (*)(void)
+             (h)      int   (*const [])(unsigned int, ...)
+    name respectively the types (a) int, (b) pointer to int, (c) array of three pointers to int, (d) pointer to an
+    array of three ints, (e) pointer to a variable length array of an unspecified number of ints, (f) function
+    with no parameter specification returning a pointer to int, (g) pointer to function with no parameters
+    returning an int, and (h) array of an unspecified number of constant pointers to functions, each with one
+    parameter that has type unsigned int and an unspecified number of other parameters, returning an
+    int.
+
+
+
+
+    <sup><a name="note147" href="#note147"><b>147)</b></a></sup> As indicated by the syntax, empty parentheses in a type name are interpreted as ''function with no
+         parameter specification'', rather than redundant parentheses around the omitted identifier.
+
+[<a name="p135" href="#p135">page 135</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.8" href="#6.7.8"><b>    6.7.8 Type definitions</b></a>
+<b>    Syntax</b>
+1            typedef-name:
+                    identifier
+<b>    Constraints</b>
+2   If a typedef name specifies a variably modified type then it shall have block scope.
+<b>    Semantics</b>
+3   In a declaration whose storage-class specifier is typedef, each declarator defines an
+    identifier to be a typedef name that denotes the type specified for the identifier in the way
+    described in <a href="#6.7.6">6.7.6</a>. Any array size expressions associated with variable length array
+    declarators are evaluated each time the declaration of the typedef name is reached in the
+    order of execution. A typedef declaration does not introduce a new type, only a
+    synonym for the type so specified. That is, in the following declarations:
+             typedef T type_ident;
+             type_ident D;
+    type_ident is defined as a typedef name with the type specified by the declaration
+    specifiers in T (known as T ), and the identifier in D has the type ''derived-declarator-
+    type-list T '' where the derived-declarator-type-list is specified by the declarators of D. A
+    typedef name shares the same name space as other identifiers declared in ordinary
+    declarators.
+4   EXAMPLE 1       After
+             typedef int MILES, KLICKSP();
+             typedef struct { double hi, lo; } range;
+    the constructions
+             MILES distance;
+             extern KLICKSP *metricp;
+             range x;
+             range z, *zp;
+    are all valid declarations. The type of distance is int, that of metricp is ''pointer to function with no
+    parameter specification returning int'', and that of x and z is the specified structure; zp is a pointer to
+    such a structure. The object distance has a type compatible with any other int object.
+
+5   EXAMPLE 2       After the declarations
+             typedef struct s1 { int x; } t1, *tp1;
+             typedef struct s2 { int x; } t2, *tp2;
+    type t1 and the type pointed to by tp1 are compatible. Type t1 is also compatible with type struct
+    s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
+
+[<a name="p136" href="#p136">page 136</a>] (<a href="#Contents">Contents</a>)
+
+6   EXAMPLE 3       The following obscure constructions
+             typedef signed int t;
+             typedef int plain;
+             struct tag {
+                   unsigned t:4;
+                   const t:5;
+                   plain r:5;
+             };
+    declare a typedef name t with type signed int, a typedef name plain with type int, and a structure
+    with three bit-field members, one named t that contains values in the range [0, 15], an unnamed const-
+    qualified bit-field which (if it could be accessed) would contain values in either the range [-15, +15] or
+    [-16, +15], and one named r that contains values in one of the ranges [0, 31], [-15, +15], or [-16, +15].
+    (The choice of range is implementation-defined.) The first two bit-field declarations differ in that
+    unsigned is a type specifier (which forces t to be the name of a structure member), while const is a
+    type qualifier (which modifies t which is still visible as a typedef name). If these declarations are followed
+    in an inner scope by
+             t f(t (t));
+             long t;
+    then a function f is declared with type ''function returning signed int with one unnamed parameter
+    with type pointer to function returning signed int with one unnamed parameter with type signed
+    int'', and an identifier t with type long int.
+
+7   EXAMPLE 4 On the other hand, typedef names can be used to improve code readability. All three of the
+    following declarations of the signal function specify exactly the same type, the first without making use
+    of any typedef names.
+             typedef void fv(int), (*pfv)(int);
+             void (*signal(int, void (*)(int)))(int);
+             fv *signal(int, fv *);
+             pfv signal(int, pfv);
+
+8   EXAMPLE 5 If a typedef name denotes a variable length array type, the length of the array is fixed at the
+    time the typedef name is defined, not each time it is used:
+             void copyt(int n)
+             {
+                   typedef int B[n];   //               B is n ints, n evaluated now
+                   n += 1;
+                   B a;                //               a is n ints, n without += 1
+                   int b[n];           //               a and b are different sizes
+                   for (int i = 1; i &lt; n;               i++)
+                         a[i-1] = b[i];
+             }
+
+[<a name="p137" href="#p137">page 137</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.9" href="#6.7.9"><b>    6.7.9 Initialization</b></a>
+<b>    Syntax</b>
+1            initializer:
+                      assignment-expression
+                      { initializer-list }
+                      { initializer-list , }
+             initializer-list:
+                      designationopt initializer
+                      initializer-list , designationopt initializer
+             designation:
+                    designator-list =
+             designator-list:
+                    designator
+                    designator-list designator
+             designator:
+                    [ constant-expression ]
+                    . identifier
+<b>    Constraints</b>
+2   No initializer shall attempt to provide a value for an object not contained within the entity
+    being initialized.
+3   The type of the entity to be initialized shall be an array of unknown size or a complete
+    object type that is not a variable length array type.
+4   All the expressions in an initializer for an object that has static or thread storage duration
+    shall be constant expressions or string literals.
+5   If the declaration of an identifier has block scope, and the identifier has external or
+    internal linkage, the declaration shall have no initializer for the identifier.
+6   If a designator has the form
+             [ constant-expression ]
+    then the current object (defined below) shall have array type and the expression shall be
+    an integer constant expression. If the array is of unknown size, any nonnegative value is
+    valid.
+7   If a designator has the form
+             . identifier
+    then the current object (defined below) shall have structure or union type and the
+    identifier shall be the name of a member of that type.
+
+[<a name="p138" href="#p138">page 138</a>] (<a href="#Contents">Contents</a>)
+
+<b>     Semantics</b>
+8    An initializer specifies the initial value stored in an object.
+9    Except where explicitly stated otherwise, for the purposes of this subclause unnamed
+     members of objects of structure and union type do not participate in initialization.
+     Unnamed members of structure objects have indeterminate value even after initialization.
+10   If an object that has automatic storage duration is not initialized explicitly, its value is
+     indeterminate. If an object that has static or thread storage duration is not initialized
+     explicitly, then:
+     -- if it has pointer type, it is initialized to a null pointer;
+     -- if it has arithmetic type, it is initialized to (positive or unsigned) zero;
+     -- if it is an aggregate, every member is initialized (recursively) according to these rules,
+       and any padding is initialized to zero bits;
+     -- if it is a union, the first named member is initialized (recursively) according to these
+       rules, and any padding is initialized to zero bits;
+11   The initializer for a scalar shall be a single expression, optionally enclosed in braces. The
+     initial value of the object is that of the expression (after conversion); the same type
+     constraints and conversions as for simple assignment apply, taking the type of the scalar
+     to be the unqualified version of its declared type.
+12   The rest of this subclause deals with initializers for objects that have aggregate or union
+     type.
+13   The initializer for a structure or union object that has automatic storage duration shall be
+     either an initializer list as described below, or a single expression that has compatible
+     structure or union type. In the latter case, the initial value of the object, including
+     unnamed members, is that of the expression.
+14   An array of character type may be initialized by a character string literal or UTF-8 string
+     literal, optionally enclosed in braces. Successive bytes of the string literal (including the
+     terminating null character if there is room or if the array is of unknown size) initialize the
+     elements of the array.
+15   An array with element type compatible with a qualified or unqualified version of
+     wchar_t may be initialized by a wide string literal, optionally enclosed in braces.
+     Successive wide characters of the wide string literal (including the terminating null wide
+     character if there is room or if the array is of unknown size) initialize the elements of the
+     array.
+16   Otherwise, the initializer for an object that has aggregate or union type shall be a brace-
+     enclosed list of initializers for the elements or named members.
+
+[<a name="p139" href="#p139">page 139</a>] (<a href="#Contents">Contents</a>)
+
+17   Each brace-enclosed initializer list has an associated current object. When no
+     designations are present, subobjects of the current object are initialized in order according
+     to the type of the current object: array elements in increasing subscript order, structure
+     members in declaration order, and the first named member of a union.<sup><a href="#note148"><b>148)</b></a></sup> In contrast, a
+     designation causes the following initializer to begin initialization of the subobject
+     described by the designator. Initialization then continues forward in order, beginning
+     with the next subobject after that described by the designator.<sup><a href="#note149"><b>149)</b></a></sup>
+18   Each designator list begins its description with the current object associated with the
+     closest surrounding brace pair. Each item in the designator list (in order) specifies a
+     particular member of its current object and changes the current object for the next
+     designator (if any) to be that member.<sup><a href="#note150"><b>150)</b></a></sup> The current object that results at the end of the
+     designator list is the subobject to be initialized by the following initializer.
+19   The initialization shall occur in initializer list order, each initializer provided for a
+     particular subobject overriding any previously listed initializer for the same subobject;<sup><a href="#note151"><b>151)</b></a></sup>
+     all subobjects that are not initialized explicitly shall be initialized implicitly the same as
+     objects that have static storage duration.
+20   If the aggregate or union contains elements or members that are aggregates or unions,
+     these rules apply recursively to the subaggregates or contained unions. If the initializer of
+     a subaggregate or contained union begins with a left brace, the initializers enclosed by
+     that brace and its matching right brace initialize the elements or members of the
+     subaggregate or the contained union. Otherwise, only enough initializers from the list are
+     taken to account for the elements or members of the subaggregate or the first member of
+     the contained union; any remaining initializers are left to initialize the next element or
+     member of the aggregate of which the current subaggregate or contained union is a part.
+21   If there are fewer initializers in a brace-enclosed list than there are elements or members
+     of an aggregate, or fewer characters in a string literal used to initialize an array of known
+     size than there are elements in the array, the remainder of the aggregate shall be
+     initialized implicitly the same as objects that have static storage duration.
+
+
+
+     <sup><a name="note148" href="#note148"><b>148)</b></a></sup> If the initializer list for a subaggregate or contained union does not begin with a left brace, its
+          subobjects are initialized as usual, but the subaggregate or contained union does not become the
+          current object: current objects are associated only with brace-enclosed initializer lists.
+     <sup><a name="note149" href="#note149"><b>149)</b></a></sup> After a union member is initialized, the next object is not the next member of the union; instead, it is
+          the next subobject of an object containing the union.
+     <sup><a name="note150" href="#note150"><b>150)</b></a></sup> Thus, a designator can only specify a strict subobject of the aggregate or union that is associated with
+          the surrounding brace pair. Note, too, that each separate designator list is independent.
+     <sup><a name="note151" href="#note151"><b>151)</b></a></sup> Any initializer for the subobject which is overridden and so not used to initialize that subobject might
+          not be evaluated at all.
+
+[<a name="p140" href="#p140">page 140</a>] (<a href="#Contents">Contents</a>)
+
+22   If an array of unknown size is initialized, its size is determined by the largest indexed
+     element with an explicit initializer. The array type is completed at the end of its
+     initializer list.
+23   The evaluations of the initialization list expressions are indeterminately sequenced with
+     respect to one another and thus the order in which any side effects occur is
+     unspecified.<sup><a href="#note152"><b>152)</b></a></sup>
+24   EXAMPLE 1       Provided that <a href="#7.3">&lt;complex.h&gt;</a> has been #included, the declarations
+              int i = <a href="#3.5">3.5</a>;
+              double complex c = 5 + 3 * I;
+     define and initialize i with the value 3 and c with the value 5.0 + i3.0.
+
+25   EXAMPLE 2       The declaration
+              int x[] = { 1, 3, 5 };
+     defines and initializes x as a one-dimensional array object that has three elements, as no size was specified
+     and there are three initializers.
+
+26   EXAMPLE 3       The declaration
+              int y[4][3] =         {
+                    { 1, 3,         5 },
+                    { 2, 4,         6 },
+                    { 3, 5,         7 },
+              };
+     is a definition with a fully bracketed initialization: 1, 3, and 5 initialize the first row of y (the array object
+     y[0]), namely y[0][0], y[0][1], and y[0][2]. Likewise the next two lines initialize y[1] and
+     y[2]. The initializer ends early, so y[3] is initialized with zeros. Precisely the same effect could have
+     been achieved by
+              int y[4][3] = {
+                    1, 3, 5, 2, 4, 6, 3, 5, 7
+              };
+     The initializer for y[0] does not begin with a left brace, so three items from the list are used. Likewise the
+     next three are taken successively for y[1] and y[2].
+
+27   EXAMPLE 4       The declaration
+              int z[4][3] = {
+                    { 1 }, { 2 }, { 3 }, { 4 }
+              };
+     initializes the first column of z as specified and initializes the rest with zeros.
+
+28   EXAMPLE 5       The declaration
+              struct { int a[3], b; } w[] = { { 1 }, 2 };
+     is a definition with an inconsistently bracketed initialization. It defines an array with two element
+
+
+
+     <sup><a name="note152" href="#note152"><b>152)</b></a></sup> In particular, the evaluation order need not be the same as the order of subobject initialization.
+
+[<a name="p141" href="#p141">page 141</a>] (<a href="#Contents">Contents</a>)
+
+     structures: w[0].a[0] is 1 and w[1].a[0] is 2; all the other elements are zero.
+
+29   EXAMPLE 6         The declaration
+               short q[4][3][2] = {
+                     { 1 },
+                     { 2, 3 },
+                     { 4, 5, 6 }
+               };
+     contains an incompletely but consistently bracketed initialization. It defines a three-dimensional array
+     object: q[0][0][0] is 1, q[1][0][0] is 2, q[1][0][1] is 3, and 4, 5, and 6 initialize
+     q[2][0][0], q[2][0][1], and q[2][1][0], respectively; all the rest are zero. The initializer for
+     q[0][0] does not begin with a left brace, so up to six items from the current list may be used. There is
+     only one, so the values for the remaining five elements are initialized with zero. Likewise, the initializers
+     for q[1][0] and q[2][0] do not begin with a left brace, so each uses up to six items, initializing their
+     respective two-dimensional subaggregates. If there had been more than six items in any of the lists, a
+     diagnostic message would have been issued. The same initialization result could have been achieved by:
+               short q[4][3][2] = {
+                     1, 0, 0, 0, 0, 0,
+                     2, 3, 0, 0, 0, 0,
+                     4, 5, 6
+               };
+     or by:
+               short q[4][3][2] = {
+                     {
+                           { 1 },
+                     },
+                     {
+                           { 2, 3 },
+                     },
+                     {
+                           { 4, 5 },
+                           { 6 },
+                     }
+               };
+     in a fully bracketed form.
+30   Note that the fully bracketed and minimally bracketed forms of initialization are, in general, less likely to
+     cause confusion.
+
+31   EXAMPLE 7         One form of initialization that completes array types involves typedef names. Given the
+     declaration
+               typedef int A[];          // OK - declared with block scope
+     the declaration
+               A a = { 1, 2 }, b = { 3, 4, 5 };
+     is identical to
+               int a[] = { 1, 2 }, b[] = { 3, 4, 5 };
+     due to the rules for incomplete types.
+
+[<a name="p142" href="#p142">page 142</a>] (<a href="#Contents">Contents</a>)
+
+32   EXAMPLE 8       The declaration
+              char s[] = "abc", t[3] = "abc";
+     defines ''plain'' char array objects s and t whose elements are initialized with character string literals.
+     This declaration is identical to
+              char s[] = { 'a', 'b', 'c', '\0' },
+                   t[] = { 'a', 'b', 'c' };
+     The contents of the arrays are modifiable. On the other hand, the declaration
+              char *p = "abc";
+     defines p with type ''pointer to char'' and initializes it to point to an object with type ''array of char''
+     with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to
+     modify the contents of the array, the behavior is undefined.
+
+33   EXAMPLE 9       Arrays can be initialized to correspond to the elements of an enumeration by using
+     designators:
+              enum { member_one,           member_two };
+              const char *nm[] =           {
+                    [member_two]           = "member two",
+                    [member_one]           = "member one",
+              };
+
+34   EXAMPLE 10       Structure members can be initialized to nonzero values without depending on their order:
+              div_t answer = { .quot = 2, .rem = -1 };
+
+35   EXAMPLE 11 Designators can be used to provide explicit initialization when unadorned initializer lists
+     might be misunderstood:
+              struct { int a[3], b; } w[] =
+                    { [0].a = {1}, [1].a[0] = 2 };
+
+36   EXAMPLE 12       Space can be ''allocated'' from both ends of an array by using a single designator:
+              int a[MAX] = {
+                    1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0
+              };
+37   In the above, if MAX is greater than ten, there will be some zero-valued elements in the middle; if it is less
+     than ten, some of the values provided by the first five initializers will be overridden by the second five.
+
+38   EXAMPLE 13       Any member of a union can be initialized:
+              union { /* ... */ } u = { .any_member = 42 };
+
+     Forward references: common definitions <a href="#7.19">&lt;stddef.h&gt;</a> (<a href="#7.19">7.19</a>).
+
+[<a name="p143" href="#p143">page 143</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.7.10" href="#6.7.10"><b>    6.7.10 Static assertions</b></a>
+<b>    Syntax</b>
+1            static_assert-declaration:
+                     _Static_assert ( constant-expression , string-literal ) ;
+<b>    Constraints</b>
+2   The constant expression shall compare unequal to 0.
+<b>    Semantics</b>
+3   The constant expression shall be an integer constant expression. If the value of the
+    constant expression compares unequal to 0, the declaration has no effect. Otherwise, the
+    constraint is violated and the implementation shall produce a diagnostic message that
+    includes the text of the string literal, except that characters not in the basic source
+    character set are not required to appear in the message.
+    Forward references: diagnostics (<a href="#7.2">7.2</a>).
+
+[<a name="p144" href="#p144">page 144</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.8" href="#6.8"><b>    6.8 Statements and blocks</b></a>
+<b>    Syntax</b>
+1            statement:
+                    labeled-statement
+                    compound-statement
+                    expression-statement
+                    selection-statement
+                    iteration-statement
+                    jump-statement
+<b>    Semantics</b>
+2   A statement specifies an action to be performed. Except as indicated, statements are
+    executed in sequence.
+3   A block allows a set of declarations and statements to be grouped into one syntactic unit.
+    The initializers of objects that have automatic storage duration, and the variable length
+    array declarators of ordinary identifiers with block scope, are evaluated and the values are
+    stored in the objects (including storing an indeterminate value in objects without an
+    initializer) each time the declaration is reached in the order of execution, as if it were a
+    statement, and within each declaration in the order that declarators appear.
+4   A full expression is an expression that is not part of another expression or of a declarator.
+    Each of the following is a full expression: an initializer that is not part of a compound
+    literal; the expression in an expression statement; the controlling expression of a selection
+    statement (if or switch); the controlling expression of a while or do statement; each
+    of the (optional) expressions of a for statement; the (optional) expression in a return
+    statement. There is a sequence point between the evaluation of a full expression and the
+    evaluation of the next full expression to be evaluated.
+    Forward references: expression and null statements (<a href="#6.8.3">6.8.3</a>), selection statements
+    (<a href="#6.8.4">6.8.4</a>), iteration statements (<a href="#6.8.5">6.8.5</a>), the return statement (<a href="#6.8.6.4">6.8.6.4</a>).
+<a name="6.8.1" href="#6.8.1"><b>    6.8.1 Labeled statements</b></a>
+<b>    Syntax</b>
+1            labeled-statement:
+                    identifier : statement
+                    case constant-expression : statement
+                    default : statement
+<b>    Constraints</b>
+2   A case or default label shall appear only in a switch statement. Further
+    constraints on such labels are discussed under the switch statement.
+
+[<a name="p145" href="#p145">page 145</a>] (<a href="#Contents">Contents</a>)
+
+3   Label names shall be unique within a function.
+<b>    Semantics</b>
+4   Any statement may be preceded by a prefix that declares an identifier as a label name.
+    Labels in themselves do not alter the flow of control, which continues unimpeded across
+    them.
+    Forward references: the goto statement (<a href="#6.8.6.1">6.8.6.1</a>), the switch statement (<a href="#6.8.4.2">6.8.4.2</a>).
+<a name="6.8.2" href="#6.8.2"><b>    6.8.2 Compound statement</b></a>
+<b>    Syntax</b>
+1            compound-statement:
+                   { block-item-listopt }
+             block-item-list:
+                     block-item
+                     block-item-list block-item
+             block-item:
+                     declaration
+                     statement
+<b>    Semantics</b>
+2   A compound statement is a block.
+<a name="6.8.3" href="#6.8.3"><b>    6.8.3 Expression and null statements</b></a>
+<b>    Syntax</b>
+1            expression-statement:
+                    expressionopt ;
+<b>    Semantics</b>
+2   The expression in an expression statement is evaluated as a void expression for its side
+    effects.<sup><a href="#note153"><b>153)</b></a></sup>
+3   A null statement (consisting of just a semicolon) performs no operations.
+4   EXAMPLE 1 If a function call is evaluated as an expression statement for its side effects only, the
+    discarding of its value may be made explicit by converting the expression to a void expression by means of
+    a cast:
+             int p(int);
+             /* ... */
+             (void)p(0);
+
+
+
+    <sup><a name="note153" href="#note153"><b>153)</b></a></sup> Such as assignments, and function calls which have side effects.
+
+[<a name="p146" href="#p146">page 146</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE 2       In the program fragment
+             char *s;
+             /* ... */
+             while (*s++ != '\0')
+                     ;
+    a null statement is used to supply an empty loop body to the iteration statement.
+
+6   EXAMPLE 3       A null statement may also be used to carry a label just before the closing } of a compound
+    statement.
+             while (loop1) {
+                   /* ... */
+                   while (loop2) {
+                           /* ... */
+                           if (want_out)
+                                   goto end_loop1;
+                           /* ... */
+                   }
+                   /* ... */
+             end_loop1: ;
+             }
+
+    Forward references: iteration statements (<a href="#6.8.5">6.8.5</a>).
+<a name="6.8.4" href="#6.8.4"><b>    6.8.4 Selection statements</b></a>
+<b>    Syntax</b>
+1            selection-statement:
+                     if ( expression ) statement
+                     if ( expression ) statement else statement
+                     switch ( expression ) statement
+<b>    Semantics</b>
+2   A selection statement selects among a set of statements depending on the value of a
+    controlling expression.
+3   A selection statement is a block whose scope is a strict subset of the scope of its
+    enclosing block. Each associated substatement is also a block whose scope is a strict
+    subset of the scope of the selection statement.
+<a name="6.8.4.1" href="#6.8.4.1"><b>    6.8.4.1 The if statement</b></a>
+<b>    Constraints</b>
+1   The controlling expression of an if statement shall have scalar type.
+<b>    Semantics</b>
+2   In both forms, the first substatement is executed if the expression compares unequal to 0.
+    In the else form, the second substatement is executed if the expression compares equal
+
+[<a name="p147" href="#p147">page 147</a>] (<a href="#Contents">Contents</a>)
+
+    to 0. If the first substatement is reached via a label, the second substatement is not
+    executed.
+3   An else is associated with the lexically nearest preceding if that is allowed by the
+    syntax.
+<a name="6.8.4.2" href="#6.8.4.2"><b>    6.8.4.2 The switch statement</b></a>
+<b>    Constraints</b>
+1   The controlling expression of a switch statement shall have integer type.
+2   If a switch statement has an associated case or default label within the scope of an
+    identifier with a variably modified type, the entire switch statement shall be within the
+    scope of that identifier.<sup><a href="#note154"><b>154)</b></a></sup>
+3   The expression of each case label shall be an integer constant expression and no two of
+    the case constant expressions in the same switch statement shall have the same value
+    after conversion. There may be at most one default label in a switch statement.
+    (Any enclosed switch statement may have a default label or case constant
+    expressions with values that duplicate case constant expressions in the enclosing
+    switch statement.)
+<b>    Semantics</b>
+4   A switch statement causes control to jump to, into, or past the statement that is the
+    switch body, depending on the value of a controlling expression, and on the presence of a
+    default label and the values of any case labels on or in the switch body. A case or
+    default label is accessible only within the closest enclosing switch statement.
+5   The integer promotions are performed on the controlling expression. The constant
+    expression in each case label is converted to the promoted type of the controlling
+    expression. If a converted value matches that of the promoted controlling expression,
+    control jumps to the statement following the matched case label. Otherwise, if there is
+    a default label, control jumps to the labeled statement. If no converted case constant
+    expression matches and there is no default label, no part of the switch body is
+    executed.
+    Implementation limits
+6   As discussed in <a href="#5.2.4.1">5.2.4.1</a>, the implementation may limit the number of case values in a
+    switch statement.
+
+
+
+
+    <sup><a name="note154" href="#note154"><b>154)</b></a></sup> That is, the declaration either precedes the switch statement, or it follows the last case or
+         default label associated with the switch that is in the block containing the declaration.
+
+[<a name="p148" href="#p148">page 148</a>] (<a href="#Contents">Contents</a>)
+
+7   EXAMPLE        In the artificial program fragment
+             switch (expr)
+             {
+                   int i = 4;
+                   f(i);
+             case 0:
+                   i = 17;
+                   /* falls through into default code */
+             default:
+                   printf("%d\n", i);
+             }
+    the object whose identifier is i exists with automatic storage duration (within the block) but is never
+    initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will
+    access an indeterminate value. Similarly, the call to the function f cannot be reached.
+
+<a name="6.8.5" href="#6.8.5"><b>    6.8.5 Iteration statements</b></a>
+<b>    Syntax</b>
+1            iteration-statement:
+                     while ( expression ) statement
+                     do statement while ( expression ) ;
+                     for ( expressionopt ; expressionopt ; expressionopt ) statement
+                     for ( declaration expressionopt ; expressionopt ) statement
+<b>    Constraints</b>
+2   The controlling expression of an iteration statement shall have scalar type.
+3   The declaration part of a for statement shall only declare identifiers for objects having
+    storage class auto or register.
+<b>    Semantics</b>
+4   An iteration statement causes a statement called the loop body to be executed repeatedly
+    until the controlling expression compares equal to 0. The repetition occurs regardless of
+    whether the loop body is entered from the iteration statement or by a jump.<sup><a href="#note155"><b>155)</b></a></sup>
+5   An iteration statement is a block whose scope is a strict subset of the scope of its
+    enclosing block. The loop body is also a block whose scope is a strict subset of the scope
+    of the iteration statement.
+6   An iteration statement whose controlling expression is not a constant expression,<sup><a href="#note156"><b>156)</b></a></sup> that
+    performs no input/output operations, does not access volatile objects, and performs no
+    synchronization or atomic operations in its body, controlling expression, or (in the case of
+
+    <sup><a name="note155" href="#note155"><b>155)</b></a></sup> Code jumped over is not executed. In particular, the controlling expression of a for or while
+         statement is not evaluated before entering the loop body, nor is clause-1 of a for statement.
+    <sup><a name="note156" href="#note156"><b>156)</b></a></sup> An omitted controlling expression is replaced by a nonzero constant, which is a constant expression.
+
+[<a name="p149" href="#p149">page 149</a>] (<a href="#Contents">Contents</a>)
+
+    a for statement) its expression-3, may be assumed by the implementation to
+    terminate.<sup><a href="#note157"><b>157)</b></a></sup>
+<a name="6.8.5.1" href="#6.8.5.1"><b>    6.8.5.1 The while statement</b></a>
+1   The evaluation of the controlling expression takes place before each execution of the loop
+    body.
+<a name="6.8.5.2" href="#6.8.5.2"><b>    6.8.5.2 The do statement</b></a>
+1   The evaluation of the controlling expression takes place after each execution of the loop
+    body.
+<a name="6.8.5.3" href="#6.8.5.3"><b>    6.8.5.3 The for statement</b></a>
+1   The statement
+             for ( clause-1 ; expression-2 ; expression-3 ) statement
+    behaves as follows: The expression expression-2 is the controlling expression that is
+    evaluated before each execution of the loop body. The expression expression-3 is
+    evaluated as a void expression after each execution of the loop body. If clause-1 is a
+    declaration, the scope of any identifiers it declares is the remainder of the declaration and
+    the entire loop, including the other two expressions; it is reached in the order of execution
+    before the first evaluation of the controlling expression. If clause-1 is an expression, it is
+    evaluated as a void expression before the first evaluation of the controlling expression.<sup><a href="#note158"><b>158)</b></a></sup>
+2   Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a
+    nonzero constant.
+<a name="6.8.6" href="#6.8.6"><b>    6.8.6 Jump statements</b></a>
+<b>    Syntax</b>
+1            jump-statement:
+                    goto identifier ;
+                    continue ;
+                    break ;
+                    return expressionopt ;
+
+
+
+
+    <sup><a name="note157" href="#note157"><b>157)</b></a></sup> This is intended to allow compiler transformations such as removal of empty loops even when
+         termination cannot be proven.
+    <sup><a name="note158" href="#note158"><b>158)</b></a></sup> Thus, clause-1 specifies initialization for the loop, possibly declaring one or more variables for use in
+         the loop; the controlling expression, expression-2, specifies an evaluation made before each iteration,
+         such that execution of the loop continues until the expression compares equal to 0; and expression-3
+         specifies an operation (such as incrementing) that is performed after each iteration.
+
+[<a name="p150" href="#p150">page 150</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Semantics</b>
+2   A jump statement causes an unconditional jump to another place.
+<a name="6.8.6.1" href="#6.8.6.1"><b>    6.8.6.1 The goto statement</b></a>
+<b>    Constraints</b>
+1   The identifier in a goto statement shall name a label located somewhere in the enclosing
+    function. A goto statement shall not jump from outside the scope of an identifier having
+    a variably modified type to inside the scope of that identifier.
+<b>    Semantics</b>
+2   A goto statement causes an unconditional jump to the statement prefixed by the named
+    label in the enclosing function.
+3   EXAMPLE 1 It is sometimes convenient to jump into the middle of a complicated set of statements. The
+    following outline presents one possible approach to a problem based on these three assumptions:
+      1.   The general initialization code accesses objects only visible to the current function.
+      2.   The general initialization code is too large to warrant duplication.
+      3. The code to determine the next operation is at the head of the loop. (To allow it to be reached by
+         continue statements, for example.)
+            /* ... */
+            goto first_time;
+            for (;;) {
+                    // determine next operation
+                    /* ... */
+                    if (need to reinitialize) {
+                            // reinitialize-only code
+                            /* ... */
+                    first_time:
+                            // general initialization code
+                            /* ... */
+                            continue;
+                    }
+                    // handle other operations
+                    /* ... */
+            }
+
+[<a name="p151" href="#p151">page 151</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE 2 A goto statement is not allowed to jump past any declarations of objects with variably
+    modified types. A jump within the scope, however, is permitted.
+            goto lab3;                         // invalid: going INTO scope of VLA.
+            {
+                  double a[n];
+                  a[j] = <a href="#4.4">4.4</a>;
+            lab3:
+                  a[j] = <a href="#3.3">3.3</a>;
+                  goto lab4;                   // valid: going WITHIN scope of VLA.
+                  a[j] = <a href="#5.5">5.5</a>;
+            lab4:
+                  a[j] = <a href="#6.6">6.6</a>;
+            }
+            goto lab4;                         // invalid: going INTO scope of VLA.
+
+<a name="6.8.6.2" href="#6.8.6.2"><b>    6.8.6.2 The continue statement</b></a>
+<b>    Constraints</b>
+1   A continue statement shall appear only in or as a loop body.
+<b>    Semantics</b>
+2   A continue statement causes a jump to the loop-continuation portion of the smallest
+    enclosing iteration statement; that is, to the end of the loop body. More precisely, in each
+    of the statements
+    while (/* ... */) {                  do {                                 for (/* ... */) {
+       /* ... */                            /* ... */                            /* ... */
+       continue;                            continue;                            continue;
+       /* ... */                            /* ... */                            /* ... */
+    contin: ;                            contin: ;                            contin: ;
+    }                                    } while (/* ... */);                 }
+    unless the continue statement shown is in an enclosed iteration statement (in which
+    case it is interpreted within that statement), it is equivalent to goto contin;.<sup><a href="#note159"><b>159)</b></a></sup>
+<a name="6.8.6.3" href="#6.8.6.3"><b>    6.8.6.3 The break statement</b></a>
+<b>    Constraints</b>
+1   A break statement shall appear only in or as a switch body or loop body.
+<b>    Semantics</b>
+2   A break statement terminates execution of the smallest enclosing switch or iteration
+    statement.
+
+
+
+    <sup><a name="note159" href="#note159"><b>159)</b></a></sup> Following the contin: label is a null statement.
+
+[<a name="p152" href="#p152">page 152</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.8.6.4" href="#6.8.6.4"><b>    6.8.6.4 The return statement</b></a>
+<b>    Constraints</b>
+1   A return statement with an expression shall not appear in a function whose return type
+    is void. A return statement without an expression shall only appear in a function
+    whose return type is void.
+<b>    Semantics</b>
+2   A return statement terminates execution of the current function and returns control to
+    its caller. A function may have any number of return statements.
+3   If a return statement with an expression is executed, the value of the expression is
+    returned to the caller as the value of the function call expression. If the expression has a
+    type different from the return type of the function in which it appears, the value is
+    converted as if by assignment to an object having the return type of the function.<sup><a href="#note160"><b>160)</b></a></sup>
+4   EXAMPLE       In:
+            struct s { double i; } f(void);
+            union {
+                  struct {
+                        int f1;
+                        struct s f2;
+                  } u1;
+                  struct {
+                        struct s f3;
+                        int f4;
+                  } u2;
+            } g;
+            struct s f(void)
+            {
+                  return g.u1.f2;
+            }
+            /* ... */
+            g.u2.f3 = f();
+    there is no undefined behavior, although there would be if the assignment were done directly (without using
+    a function call to fetch the value).
+
+
+
+
+    <sup><a name="note160" href="#note160"><b>160)</b></a></sup> The return statement is not an assignment. The overlap restriction of subclause <a href="#6.5.16.1">6.5.16.1</a> does not
+         apply to the case of function return. The representation of floating-point values may have wider range
+         or precision than implied by the type; a cast may be used to remove this extra range and precision.
+
+[<a name="p153" href="#p153">page 153</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.9" href="#6.9"><b>    6.9 External definitions</b></a>
+<b>    Syntax</b>
+1            translation-unit:
+                     external-declaration
+                     translation-unit external-declaration
+             external-declaration:
+                    function-definition
+                    declaration
+<b>    Constraints</b>
+2   The storage-class specifiers auto and register shall not appear in the declaration
+    specifiers in an external declaration.
+3   There shall be no more than one external definition for each identifier declared with
+    internal linkage in a translation unit. Moreover, if an identifier declared with internal
+    linkage is used in an expression (other than as a part of the operand of a sizeof
+    operator whose result is an integer constant), there shall be exactly one external definition
+    for the identifier in the translation unit.
+<b>    Semantics</b>
+4   As discussed in <a href="#5.1.1.1">5.1.1.1</a>, the unit of program text after preprocessing is a translation unit,
+    which consists of a sequence of external declarations. These are described as ''external''
+    because they appear outside any function (and hence have file scope). As discussed in
+    <a href="#6.7">6.7</a>, a declaration that also causes storage to be reserved for an object or a function named
+    by the identifier is a definition.
+5   An external definition is an external declaration that is also a definition of a function
+    (other than an inline definition) or an object. If an identifier declared with external
+    linkage is used in an expression (other than as part of the operand of a sizeof operator
+    whose result is an integer constant), somewhere in the entire program there shall be
+    exactly one external definition for the identifier; otherwise, there shall be no more than
+    one.<sup><a href="#note161"><b>161)</b></a></sup>
+
+
+
+
+    <sup><a name="note161" href="#note161"><b>161)</b></a></sup> Thus, if an identifier declared with external linkage is not used in an expression, there need be no
+         external definition for it.
+
+[<a name="p154" href="#p154">page 154</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.9.1" href="#6.9.1"><b>    6.9.1 Function definitions</b></a>
+<b>    Syntax</b>
+1            function-definition:
+                    declaration-specifiers declarator declaration-listopt compound-statement
+             declaration-list:
+                    declaration
+                    declaration-list declaration
+<b>    Constraints</b>
+2   The identifier declared in a function definition (which is the name of the function) shall
+    have a function type, as specified by the declarator portion of the function definition.<sup><a href="#note162"><b>162)</b></a></sup>
+3   The return type of a function shall be void or a complete object type other than array
+    type.
+4   The storage-class specifier, if any, in the declaration specifiers shall be either extern or
+    static.
+5   If the declarator includes a parameter type list, the declaration of each parameter shall
+    include an identifier, except for the special case of a parameter list consisting of a single
+    parameter of type void, in which case there shall not be an identifier. No declaration list
+    shall follow.
+6   If the declarator includes an identifier list, each declaration in the declaration list shall
+    have at least one declarator, those declarators shall declare only identifiers from the
+    identifier list, and every identifier in the identifier list shall be declared. An identifier
+    declared as a typedef name shall not be redeclared as a parameter. The declarations in the
+    declaration list shall contain no storage-class specifier other than register and no
+    initializations.
+
+
+
+    <sup><a name="note162" href="#note162"><b>162)</b></a></sup> The intent is that the type category in a function definition cannot be inherited from a typedef:
+                  typedef int F(void);                          //   type F is ''function with no parameters
+                                                                //                  returning int''
+                  F f, g;                                       //   f and g both have type compatible with F
+                  F f { /* ... */ }                             //   WRONG: syntax/constraint error
+                  F g() { /* ... */ }                           //   WRONG: declares that g returns a function
+                  int f(void) { /* ... */ }                     //   RIGHT: f has type compatible with F
+                  int g() { /* ... */ }                         //   RIGHT: g has type compatible with F
+                  F *e(void) { /* ... */ }                      //   e returns a pointer to a function
+                  F *((e))(void) { /* ... */ }                  //   same: parentheses irrelevant
+                  int (*fp)(void);                              //   fp points to a function that has type F
+                  F *Fp;                                        //   Fp points to a function that has type F
+
+[<a name="p155" href="#p155">page 155</a>] (<a href="#Contents">Contents</a>)
+
+<b>     Semantics</b>
+7    The declarator in a function definition specifies the name of the function being defined
+     and the identifiers of its parameters. If the declarator includes a parameter type list, the
+     list also specifies the types of all the parameters; such a declarator also serves as a
+     function prototype for later calls to the same function in the same translation unit. If the
+     declarator includes an identifier list,<sup><a href="#note163"><b>163)</b></a></sup> the types of the parameters shall be declared in a
+     following declaration list. In either case, the type of each parameter is adjusted as
+     described in <a href="#6.7.6.3">6.7.6.3</a> for a parameter type list; the resulting type shall be a complete object
+     type.
+8    If a function that accepts a variable number of arguments is defined without a parameter
+     type list that ends with the ellipsis notation, the behavior is undefined.
+9    Each parameter has automatic storage duration; its identifier is an lvalue.<sup><a href="#note164"><b>164)</b></a></sup> The layout
+     of the storage for parameters is unspecified.
+10   On entry to the function, the size expressions of each variably modified parameter are
+     evaluated and the value of each argument expression is converted to the type of the
+     corresponding parameter as if by assignment. (Array expressions and function
+     designators as arguments were converted to pointers before the call.)
+11   After all parameters have been assigned, the compound statement that constitutes the
+     body of the function definition is executed.
+12   If the } that terminates a function is reached, and the value of the function call is used by
+     the caller, the behavior is undefined.
+13   EXAMPLE 1       In the following:
+              extern int max(int a, int b)
+              {
+                    return a &gt; b ? a : b;
+              }
+     extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
+     function declarator; and
+              { return a &gt; b ? a : b; }
+     is the function body. The following similar definition uses the identifier-list form for the parameter
+     declarations:
+
+
+
+
+     <sup><a name="note163" href="#note163"><b>163)</b></a></sup> See ''future language directions'' (<a href="#6.11.7">6.11.7</a>).
+     <sup><a name="note164" href="#note164"><b>164)</b></a></sup> A parameter identifier cannot be redeclared in the function body except in an enclosed block.
+
+[<a name="p156" href="#p156">page 156</a>] (<a href="#Contents">Contents</a>)
+
+              extern int max(a, b)
+              int a, b;
+              {
+                    return a &gt; b ? a : b;
+              }
+     Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
+     that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
+     to the function, whereas the second form does not.
+
+14   EXAMPLE 2           To pass one function to another, one might say
+                          int f(void);
+                          /* ... */
+                          g(f);
+     Then the definition of g might read
+              void g(int (*funcp)(void))
+              {
+                    /* ... */
+                    (*funcp)(); /* or funcp(); ...                    */
+              }
+     or, equivalently,
+              void g(int func(void))
+              {
+                    /* ... */
+                    func(); /* or (*func)(); ...                   */
+              }
+
+<a name="6.9.2" href="#6.9.2"><b>     6.9.2 External object definitions</b></a>
+<b>     Semantics</b>
+1    If the declaration of an identifier for an object has file scope and an initializer, the
+     declaration is an external definition for the identifier.
+2    A declaration of an identifier for an object that has file scope without an initializer, and
+     without a storage-class specifier or with the storage-class specifier static, constitutes a
+     tentative definition. If a translation unit contains one or more tentative definitions for an
+     identifier, and the translation unit contains no external definition for that identifier, then
+     the behavior is exactly as if the translation unit contains a file scope declaration of that
+     identifier, with the composite type as of the end of the translation unit, with an initializer
+     equal to 0.
+3    If the declaration of an identifier for an object is a tentative definition and has internal
+     linkage, the declared type shall not be an incomplete type.
+
+[<a name="p157" href="#p157">page 157</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE 1
+             int i1 = 1;                    // definition, external linkage
+             static int i2 = 2;             // definition, internal linkage
+             extern int i3 = 3;             // definition, external linkage
+             int i4;                        // tentative definition, external linkage
+             static int i5;                 // tentative definition, internal linkage
+             int   i1;                      // valid tentative definition, refers to previous
+             int   i2;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+             int   i3;                      // valid tentative definition, refers to previous
+             int   i4;                      // valid tentative definition, refers to previous
+             int   i5;                      // <a href="#6.2.2">6.2.2</a> renders undefined, linkage disagreement
+             extern    int   i1;            // refers to previous, whose linkage is external
+             extern    int   i2;            // refers to previous, whose linkage is internal
+             extern    int   i3;            // refers to previous, whose linkage is external
+             extern    int   i4;            // refers to previous, whose linkage is external
+             extern    int   i5;            // refers to previous, whose linkage is internal
+
+5   EXAMPLE 2       If at the end of the translation unit containing
+             int i[];
+    the array i still has incomplete type, the implicit initializer causes it to have one element, which is set to
+    zero on program startup.
+
+[<a name="p158" href="#p158">page 158</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10" href="#6.10"><b>    6.10 Preprocessing directives</b></a>
+<b>    Syntax</b>
+1            preprocessing-file:
+                    groupopt
+             group:
+                      group-part
+                      group group-part
+             group-part:
+                    if-section
+                    control-line
+                    text-line
+                    # non-directive
+             if-section:
+                      if-group elif-groupsopt else-groupopt endif-line
+             if-group:
+                     # if     constant-expression new-line groupopt
+                     # ifdef identifier new-line groupopt
+                     # ifndef identifier new-line groupopt
+             elif-groups:
+                     elif-group
+                     elif-groups elif-group
+             elif-group:
+                     # elif       constant-expression new-line groupopt
+             else-group:
+                     # else       new-line groupopt
+             endif-line:
+                     # endif      new-line
+
+[<a name="p159" href="#p159">page 159</a>] (<a href="#Contents">Contents</a>)
+
+             control-line:
+                    # include pp-tokens new-line
+                    # define identifier replacement-list new-line
+                    # define identifier lparen identifier-listopt )
+                                                    replacement-list new-line
+                    # define identifier lparen ... ) replacement-list new-line
+                    # define identifier lparen identifier-list , ... )
+                                                    replacement-list new-line
+                    # undef   identifier new-line
+                    # line    pp-tokens new-line
+                    # error   pp-tokensopt new-line
+                    # pragma pp-tokensopt new-line
+                    #         new-line
+             text-line:
+                     pp-tokensopt new-line
+             non-directive:
+                    pp-tokens new-line
+             lparen:
+                       a ( character not immediately preceded by white-space
+             replacement-list:
+                    pp-tokensopt
+             pp-tokens:
+                    preprocessing-token
+                    pp-tokens preprocessing-token
+             new-line:
+                    the new-line character
+<b>    Description</b>
+2   A preprocessing directive consists of a sequence of preprocessing tokens that satisfies the
+    following constraints: The first token in the sequence is a # preprocessing token that (at
+    the start of translation phase 4) is either the first character in the source file (optionally
+    after white space containing no new-line characters) or that follows white space
+    containing at least one new-line character. The last token in the sequence is the first new-
+    line character that follows the first token in the sequence.<sup><a href="#note165"><b>165)</b></a></sup> A new-line character ends
+    the preprocessing directive even if it occurs within what would otherwise be an
+
+    <sup><a name="note165" href="#note165"><b>165)</b></a></sup> Thus, preprocessing directives are commonly called ''lines''. These ''lines'' have no other syntactic
+         significance, as all white space is equivalent except in certain situations during preprocessing (see the
+         # character string literal creation operator in <a href="#6.10.3.2">6.10.3.2</a>, for example).
+
+[<a name="p160" href="#p160">page 160</a>] (<a href="#Contents">Contents</a>)
+
+    invocation of a function-like macro.
+3   A text line shall not begin with a # preprocessing token. A non-directive shall not begin
+    with any of the directive names appearing in the syntax.
+4   When in a group that is skipped (<a href="#6.10.1">6.10.1</a>), the directive syntax is relaxed to allow any
+    sequence of preprocessing tokens to occur between the directive name and the following
+    new-line character.
+<b>    Constraints</b>
+5   The only white-space characters that shall appear between preprocessing tokens within a
+    preprocessing directive (from just after the introducing # preprocessing token through
+    just before the terminating new-line character) are space and horizontal-tab (including
+    spaces that have replaced comments or possibly other white-space characters in
+    translation phase 3).
+<b>    Semantics</b>
+6   The implementation can process and skip sections of source files conditionally, include
+    other source files, and replace macros. These capabilities are called preprocessing,
+    because conceptually they occur before translation of the resulting translation unit.
+7   The preprocessing tokens within a preprocessing directive are not subject to macro
+    expansion unless otherwise stated.
+8   EXAMPLE        In:
+              #define EMPTY
+              EMPTY # include &lt;file.h&gt;
+    the sequence of preprocessing tokens on the second line is not a preprocessing directive, because it does not
+    begin with a # at the start of translation phase 4, even though it will do so after the macro EMPTY has been
+    replaced.
+
+<a name="6.10.1" href="#6.10.1"><b>    6.10.1 Conditional inclusion</b></a>
+<b>    Constraints</b>
+1   The expression that controls conditional inclusion shall be an integer constant expression
+    except that: identifiers (including those lexically identical to keywords) are interpreted as *
+    described below;<sup><a href="#note166"><b>166)</b></a></sup> and it may contain unary operator expressions of the form
+         defined identifier
+    or
+         defined ( identifier )
+    which evaluate to 1 if the identifier is currently defined as a macro name (that is, if it is
+
+
+    <sup><a name="note166" href="#note166"><b>166)</b></a></sup> Because the controlling constant expression is evaluated during translation phase 4, all identifiers
+         either are or are not macro names -- there simply are no keywords, enumeration constants, etc.
+
+[<a name="p161" href="#p161">page 161</a>] (<a href="#Contents">Contents</a>)
+
+    predefined or if it has been the subject of a #define preprocessing directive without an
+    intervening #undef directive with the same subject identifier), 0 if it is not.
+2   Each preprocessing token that remains (in the list of preprocessing tokens that will
+    become the controlling expression) after all macro replacements have occurred shall be in
+    the lexical form of a token (<a href="#6.4">6.4</a>).
+<b>    Semantics</b>
+3   Preprocessing directives of the forms
+       # if   constant-expression new-line groupopt
+       # elif constant-expression new-line groupopt
+    check whether the controlling constant expression evaluates to nonzero.
+4   Prior to evaluation, macro invocations in the list of preprocessing tokens that will become
+    the controlling constant expression are replaced (except for those macro names modified
+    by the defined unary operator), just as in normal text. If the token defined is
+    generated as a result of this replacement process or use of the defined unary operator
+    does not match one of the two specified forms prior to macro replacement, the behavior is
+    undefined. After all replacements due to macro expansion and the defined unary
+    operator have been performed, all remaining identifiers (including those lexically
+    identical to keywords) are replaced with the pp-number 0, and then each preprocessing
+    token is converted into a token. The resulting tokens compose the controlling constant
+    expression which is evaluated according to the rules of <a href="#6.6">6.6</a>. For the purposes of this
+    token conversion and evaluation, all signed integer types and all unsigned integer types
+    act as if they have the same representation as, respectively, the types intmax_t and
+    uintmax_t defined in the header <a href="#7.20">&lt;stdint.h&gt;</a>.<sup><a href="#note167"><b>167)</b></a></sup> This includes interpreting
+    character constants, which may involve converting escape sequences into execution
+    character set members. Whether the numeric value for these character constants matches
+    the value obtained when an identical character constant occurs in an expression (other
+    than within a #if or #elif directive) is implementation-defined.<sup><a href="#note168"><b>168)</b></a></sup> Also, whether a
+    single-character character constant may have a negative value is implementation-defined.
+
+
+
+
+    <sup><a name="note167" href="#note167"><b>167)</b></a></sup> Thus, on an implementation where INT_MAX is 0x7FFF and UINT_MAX is 0xFFFF, the constant
+         0x8000 is signed and positive within a #if expression even though it would be unsigned in
+         translation phase 7.
+    <sup><a name="note168" href="#note168"><b>168)</b></a></sup> Thus, the constant expression in the following #if directive and if statement is not guaranteed to
+         evaluate to the same value in these two contexts.
+           #if 'z' - 'a' == 25
+           if ('z' - 'a' == 25)
+
+[<a name="p162" href="#p162">page 162</a>] (<a href="#Contents">Contents</a>)
+
+5   Preprocessing directives of the forms
+       # ifdef identifier new-line groupopt
+       # ifndef identifier new-line groupopt
+    check whether the identifier is or is not currently defined as a macro name. Their
+    conditions are equivalent to #if defined identifier and #if !defined identifier
+    respectively.
+6   Each directive's condition is checked in order. If it evaluates to false (zero), the group
+    that it controls is skipped: directives are processed only through the name that determines
+    the directive in order to keep track of the level of nested conditionals; the rest of the
+    directives' preprocessing tokens are ignored, as are the other preprocessing tokens in the
+    group. Only the first group whose control condition evaluates to true (nonzero) is
+    processed. If none of the conditions evaluates to true, and there is a #else directive, the
+    group controlled by the #else is processed; lacking a #else directive, all the groups
+    until the #endif are skipped.<sup><a href="#note169"><b>169)</b></a></sup>
+    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>), source file inclusion (<a href="#6.10.2">6.10.2</a>), largest
+    integer types (<a href="#7.20.1.5">7.20.1.5</a>).
+<a name="6.10.2" href="#6.10.2"><b>    6.10.2 Source file inclusion</b></a>
+<b>    Constraints</b>
+1   A #include directive shall identify a header or source file that can be processed by the
+    implementation.
+<b>    Semantics</b>
+2   A preprocessing directive of the form
+       # include &lt;h-char-sequence&gt; new-line
+    searches a sequence of implementation-defined places for a header identified uniquely by
+    the specified sequence between the &lt; and &gt; delimiters, and causes the replacement of that
+    directive by the entire contents of the header. How the places are specified or the header
+    identified is implementation-defined.
+3   A preprocessing directive of the form
+       # include "q-char-sequence" new-line
+    causes the replacement of that directive by the entire contents of the source file identified
+    by the specified sequence between the " delimiters. The named source file is searched
+
+
+    <sup><a name="note169" href="#note169"><b>169)</b></a></sup> As indicated by the syntax, a preprocessing token shall not follow a #else or #endif directive
+         before the terminating new-line character. However, comments may appear anywhere in a source file,
+         including within a preprocessing directive.
+
+[<a name="p163" href="#p163">page 163</a>] (<a href="#Contents">Contents</a>)
+
+    for in an implementation-defined manner. If this search is not supported, or if the search
+    fails, the directive is reprocessed as if it read
+       # include &lt;h-char-sequence&gt; new-line
+    with the identical contained sequence (including &gt; characters, if any) from the original
+    directive.
+4   A preprocessing directive of the form
+       # include pp-tokens new-line
+    (that does not match one of the two previous forms) is permitted. The preprocessing
+    tokens after include in the directive are processed just as in normal text. (Each
+    identifier currently defined as a macro name is replaced by its replacement list of
+    preprocessing tokens.) The directive resulting after all replacements shall match one of
+    the two previous forms.<sup><a href="#note170"><b>170)</b></a></sup> The method by which a sequence of preprocessing tokens
+    between a &lt; and a &gt; preprocessing token pair or a pair of " characters is combined into a
+    single header name preprocessing token is implementation-defined.
+5   The implementation shall provide unique mappings for sequences consisting of one or
+    more nondigits or digits (<a href="#6.4.2.1">6.4.2.1</a>) followed by a period (.) and a single nondigit. The
+    first character shall not be a digit. The implementation may ignore distinctions of
+    alphabetical case and restrict the mapping to eight significant characters before the
+    period.
+6   A #include preprocessing directive may appear in a source file that has been read
+    because of a #include directive in another file, up to an implementation-defined
+    nesting limit (see <a href="#5.2.4.1">5.2.4.1</a>).
+7   EXAMPLE 1       The most common uses of #include preprocessing directives are as in the following:
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             #include "myprog.h"
+
+
+
+
+    <sup><a name="note170" href="#note170"><b>170)</b></a></sup> Note that adjacent string literals are not concatenated into a single string literal (see the translation
+         phases in <a href="#5.1.1.2">5.1.1.2</a>); thus, an expansion that results in two string literals is an invalid directive.
+
+[<a name="p164" href="#p164">page 164</a>] (<a href="#Contents">Contents</a>)
+
+8   EXAMPLE 2      This illustrates macro-replaced #include directives:
+              #if VERSION == 1
+                    #define INCFILE          "vers1.h"
+              #elif VERSION == 2
+                    #define INCFILE          "vers2.h"        // and so on
+              #else
+                     #define INCFILE         "versN.h"
+              #endif
+              #include INCFILE
+
+    Forward references: macro replacement (<a href="#6.10.3">6.10.3</a>).
+<a name="6.10.3" href="#6.10.3"><b>    6.10.3 Macro replacement</b></a>
+<b>    Constraints</b>
+1   Two replacement lists are identical if and only if the preprocessing tokens in both have
+    the same number, ordering, spelling, and white-space separation, where all white-space
+    separations are considered identical.
+2   An identifier currently defined as an object-like macro shall not be redefined by another
+    #define preprocessing directive unless the second definition is an object-like macro
+    definition and the two replacement lists are identical. Likewise, an identifier currently
+    defined as a function-like macro shall not be redefined by another #define
+    preprocessing directive unless the second definition is a function-like macro definition
+    that has the same number and spelling of parameters, and the two replacement lists are
+    identical.
+3   There shall be white-space between the identifier and the replacement list in the definition
+    of an object-like macro.
+4   If the identifier-list in the macro definition does not end with an ellipsis, the number of
+    arguments (including those arguments consisting of no preprocessing tokens) in an
+    invocation of a function-like macro shall equal the number of parameters in the macro
+    definition. Otherwise, there shall be more arguments in the invocation than there are
+    parameters in the macro definition (excluding the ...). There shall exist a )
+    preprocessing token that terminates the invocation.
+5   The identifier __VA_ARGS__ shall occur only in the replacement-list of a function-like
+    macro that uses the ellipsis notation in the parameters.
+6   A parameter identifier in a function-like macro shall be uniquely declared within its
+    scope.
+<b>    Semantics</b>
+7   The identifier immediately following the define is called the macro name. There is one
+    name space for macro names. Any white-space characters preceding or following the
+    replacement list of preprocessing tokens are not considered part of the replacement list
+
+[<a name="p165" href="#p165">page 165</a>] (<a href="#Contents">Contents</a>)
+
+     for either form of macro.
+8    If a # preprocessing token, followed by an identifier, occurs lexically at the point at which
+     a preprocessing directive could begin, the identifier is not subject to macro replacement.
+9    A preprocessing directive of the form
+        # define identifier replacement-list new-line
+     defines an object-like macro that causes each subsequent instance of the macro name<sup><a href="#note171"><b>171)</b></a></sup>
+     to be replaced by the replacement list of preprocessing tokens that constitute the
+     remainder of the directive. The replacement list is then rescanned for more macro names
+     as specified below.
+10   A preprocessing directive of the form
+        # define identifier lparen identifier-listopt ) replacement-list new-line
+        # define identifier lparen ... ) replacement-list new-line
+        # define identifier lparen identifier-list , ... ) replacement-list new-line
+     defines a function-like macro with parameters, whose use is similar syntactically to a
+     function call. The parameters are specified by the optional list of identifiers, whose scope
+     extends from their declaration in the identifier list until the new-line character that
+     terminates the #define preprocessing directive. Each subsequent instance of the
+     function-like macro name followed by a ( as the next preprocessing token introduces the
+     sequence of preprocessing tokens that is replaced by the replacement list in the definition
+     (an invocation of the macro). The replaced sequence of preprocessing tokens is
+     terminated by the matching ) preprocessing token, skipping intervening matched pairs of
+     left and right parenthesis preprocessing tokens. Within the sequence of preprocessing
+     tokens making up an invocation of a function-like macro, new-line is considered a normal
+     white-space character.
+11   The sequence of preprocessing tokens bounded by the outside-most matching parentheses
+     forms the list of arguments for the function-like macro. The individual arguments within
+     the list are separated by comma preprocessing tokens, but comma preprocessing tokens
+     between matching inner parentheses do not separate arguments. If there are sequences of
+     preprocessing tokens within the list of arguments that would otherwise act as
+     preprocessing directives,<sup><a href="#note172"><b>172)</b></a></sup> the behavior is undefined.
+12   If there is a ... in the identifier-list in the macro definition, then the trailing arguments,
+     including any separating comma preprocessing tokens, are merged to form a single item:
+
+
+     <sup><a name="note171" href="#note171"><b>171)</b></a></sup> Since, by macro-replacement time, all character constants and string literals are preprocessing tokens,
+          not sequences possibly containing identifier-like subsequences (see <a href="#5.1.1.2">5.1.1.2</a>, translation phases), they
+          are never scanned for macro names or parameters.
+     <sup><a name="note172" href="#note172"><b>172)</b></a></sup> Despite the name, a non-directive is a preprocessing directive.
+
+[<a name="p166" href="#p166">page 166</a>] (<a href="#Contents">Contents</a>)
+
+    the variable arguments. The number of arguments so combined is such that, following
+    merger, the number of arguments is one more than the number of parameters in the macro
+    definition (excluding the ...).
+<a name="6.10.3.1" href="#6.10.3.1"><b>    6.10.3.1 Argument substitution</b></a>
+1   After the arguments for the invocation of a function-like macro have been identified,
+    argument substitution takes place. A parameter in the replacement list, unless preceded
+    by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is
+    replaced by the corresponding argument after all macros contained therein have been
+    expanded. Before being substituted, each argument's preprocessing tokens are
+    completely macro replaced as if they formed the rest of the preprocessing file; no other
+    preprocessing tokens are available.
+2   An identifier __VA_ARGS__ that occurs in the replacement list shall be treated as if it
+    were a parameter, and the variable arguments shall form the preprocessing tokens used to
+    replace it.
+<a name="6.10.3.2" href="#6.10.3.2"><b>    6.10.3.2 The # operator</b></a>
+<b>    Constraints</b>
+1   Each # preprocessing token in the replacement list for a function-like macro shall be
+    followed by a parameter as the next preprocessing token in the replacement list.
+<b>    Semantics</b>
+2   If, in the replacement list, a parameter is immediately preceded by a # preprocessing
+    token, both are replaced by a single character string literal preprocessing token that
+    contains the spelling of the preprocessing token sequence for the corresponding
+    argument. Each occurrence of white space between the argument's preprocessing tokens
+    becomes a single space character in the character string literal. White space before the
+    first preprocessing token and after the last preprocessing token composing the argument
+    is deleted. Otherwise, the original spelling of each preprocessing token in the argument
+    is retained in the character string literal, except for special handling for producing the
+    spelling of string literals and character constants: a \ character is inserted before each "
+    and \ character of a character constant or string literal (including the delimiting "
+    characters), except that it is implementation-defined whether a \ character is inserted
+    before the \ character beginning a universal character name. If the replacement that
+    results is not a valid character string literal, the behavior is undefined. The character
+    string literal corresponding to an empty argument is "". The order of evaluation of # and
+    ## operators is unspecified.
+
+[<a name="p167" href="#p167">page 167</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.3.3" href="#6.10.3.3"><b>    6.10.3.3 The ## operator</b></a>
+<b>    Constraints</b>
+1   A ## preprocessing token shall not occur at the beginning or at the end of a replacement
+    list for either form of macro definition.
+<b>    Semantics</b>
+2   If, in the replacement list of a function-like macro, a parameter is immediately preceded
+    or followed by a ## preprocessing token, the parameter is replaced by the corresponding
+    argument's preprocessing token sequence; however, if an argument consists of no
+    preprocessing tokens, the parameter is replaced by a placemarker preprocessing token
+    instead.<sup><a href="#note173"><b>173)</b></a></sup>
+3   For both object-like and function-like macro invocations, before the replacement list is
+    reexamined for more macro names to replace, each instance of a ## preprocessing token
+    in the replacement list (not from an argument) is deleted and the preceding preprocessing
+    token is concatenated with the following preprocessing token. Placemarker
+    preprocessing tokens are handled specially: concatenation of two placemarkers results in
+    a single placemarker preprocessing token, and concatenation of a placemarker with a
+    non-placemarker preprocessing token results in the non-placemarker preprocessing token.
+    If the result is not a valid preprocessing token, the behavior is undefined. The resulting
+    token is available for further macro replacement. The order of evaluation of ## operators
+    is unspecified.
+4   EXAMPLE       In the following fragment:
+            #define     hash_hash # ## #
+            #define     mkstr(a) # a
+            #define     in_between(a) mkstr(a)
+            #define     join(c, d) in_between(c hash_hash d)
+            char p[] = join(x, y); // equivalent to
+                                   // char p[] = "x ## y";
+    The expansion produces, at various stages:
+            join(x, y)
+            in_between(x hash_hash y)
+            in_between(x ## y)
+            mkstr(x ## y)
+            "x ## y"
+    In other words, expanding hash_hash produces a new token, consisting of two adjacent sharp signs, but
+    this new token is not the ## operator.
+
+
+    <sup><a name="note173" href="#note173"><b>173)</b></a></sup> Placemarker preprocessing tokens do not appear in the syntax because they are temporary entities that
+         exist only within translation phase 4.
+
+[<a name="p168" href="#p168">page 168</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.3.4" href="#6.10.3.4"><b>    6.10.3.4 Rescanning and further replacement</b></a>
+1   After all parameters in the replacement list have been substituted and # and ##
+    processing has taken place, all placemarker preprocessing tokens are removed. The
+    resulting preprocessing token sequence is then rescanned, along with all subsequent
+    preprocessing tokens of the source file, for more macro names to replace.
+2   If the name of the macro being replaced is found during this scan of the replacement list
+    (not including the rest of the source file's preprocessing tokens), it is not replaced.
+    Furthermore, if any nested replacements encounter the name of the macro being replaced,
+    it is not replaced. These nonreplaced macro name preprocessing tokens are no longer
+    available for further replacement even if they are later (re)examined in contexts in which
+    that macro name preprocessing token would otherwise have been replaced.
+3   The resulting completely macro-replaced preprocessing token sequence is not processed
+    as a preprocessing directive even if it resembles one, but all pragma unary operator
+    expressions within it are then processed as specified in <a href="#6.10.9">6.10.9</a> below.
+<a name="6.10.3.5" href="#6.10.3.5"><b>    6.10.3.5 Scope of macro definitions</b></a>
+1   A macro definition lasts (independent of block structure) until a corresponding #undef
+    directive is encountered or (if none is encountered) until the end of the preprocessing
+    translation unit. Macro definitions have no significance after translation phase 4.
+2   A preprocessing directive of the form
+       # undef identifier new-line
+    causes the specified identifier no longer to be defined as a macro name. It is ignored if
+    the specified identifier is not currently defined as a macro name.
+3   EXAMPLE 1      The simplest use of this facility is to define a ''manifest constant'', as in
+            #define TABSIZE 100
+            int table[TABSIZE];
+
+4   EXAMPLE 2 The following defines a function-like macro whose value is the maximum of its arguments.
+    It has the advantages of working for any compatible types of the arguments and of generating in-line code
+    without the overhead of function calling. It has the disadvantages of evaluating one or the other of its
+    arguments a second time (including side effects) and generating more code than a function if invoked
+    several times. It also cannot have its address taken, as it has none.
+            #define max(a, b) ((a) &gt; (b) ? (a) : (b))
+    The parentheses ensure that the arguments and the resulting expression are bound properly.
+
+[<a name="p169" href="#p169">page 169</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE 3     To illustrate the rules for redefinition and reexamination, the sequence
+             #define   x         3
+             #define   f(a)      f(x * (a))
+             #undef    x
+             #define   x         2
+             #define   g         f
+             #define   z         z[0]
+             #define   h         g(~
+             #define   m(a)      a(w)
+             #define   w         0,1
+             #define   t(a)      a
+             #define   p()       int
+             #define   q(x)      x
+             #define   r(x,y)    x ## y
+             #define   str(x)    # x
+             f(y+1) + f(f(z)) % t(t(g)(0) + t)(1);
+             g(x+(3,4)-w) | h 5) &amp; m
+                   (f)^m(m);
+             p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) };
+             char c[2][6] = { str(hello), str() };
+    results in
+             f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
+             f(2 * (2+(3,4)-0,1)) | f(2 * (~ 5)) &amp; f(2 * (0,1))^m(0,1);
+             int i[] = { 1, 23, 4, 5, };
+             char c[2][6] = { "hello", "" };
+
+6   EXAMPLE 4     To illustrate the rules for creating character string literals and concatenating tokens, the
+    sequence
+             #define str(s)      # s
+             #define xstr(s)     str(s)
+             #define debug(s, t) printf("x" # s "= %d, x" # t "= %s", \
+                                     x ## s, x ## t)
+             #define INCFILE(n) vers ## n
+             #define glue(a, b) a ## b
+             #define xglue(a, b) glue(a, b)
+             #define HIGHLOW     "hello"
+             #define LOW         LOW ", world"
+             debug(1, 2);
+             fputs(str(strncmp("abc\0d", "abc", '\4') // this goes away
+                   == 0) str(: @\n), s);
+             #include xstr(INCFILE(2).h)
+             glue(HIGH, LOW);
+             xglue(HIGH, LOW)
+    results in
+
+[<a name="p170" href="#p170">page 170</a>] (<a href="#Contents">Contents</a>)
+
+             printf("x" "1" "= %d, x" "2" "= %s", x1, x2);
+             fputs(
+               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0" ": @\n",
+               s);
+             #include "vers2.h"    (after macro replacement, before file access)
+             "hello";
+             "hello" ", world"
+    or, after concatenation of the character string literals,
+             printf("x1= %d, x2= %s", x1, x2);
+             fputs(
+               "strncmp(\"abc\\0d\", \"abc\", '\\4') == 0: @\n",
+               s);
+             #include "vers2.h"    (after macro replacement, before file access)
+             "hello";
+             "hello, world"
+    Space around the # and ## tokens in the macro definition is optional.
+
+7   EXAMPLE 5        To illustrate the rules for placemarker preprocessing tokens, the sequence
+             #define t(x,y,z) x ## y ## z
+             int j[] = { t(1,2,3), t(,4,5), t(6,,7), t(8,9,),
+                        t(10,,), t(,11,), t(,,12), t(,,) };
+    results in
+             int j[] = { 123, 45, 67, 89,
+                         10, 11, 12, };
+
+8   EXAMPLE 6        To demonstrate the redefinition rules, the following sequence is valid.
+             #define      OBJ_LIKE      (1-1)
+             #define      OBJ_LIKE      /* white space */ (1-1) /* other */
+             #define      FUNC_LIKE(a)   ( a )
+             #define      FUNC_LIKE( a )( /* note the white space */ \
+                                          a /* other stuff on this line
+                                              */ )
+    But the following redefinitions are invalid:
+             #define      OBJ_LIKE    (0)     // different token sequence
+             #define      OBJ_LIKE    (1 - 1) // different white space
+             #define      FUNC_LIKE(b) ( a ) // different parameter usage
+             #define      FUNC_LIKE(b) ( b ) // different parameter spelling
+
+9   EXAMPLE 7        Finally, to show the variable argument list macro facilities:
+             #define debug(...)       fprintf(stderr, __VA_ARGS__)
+             #define showlist(...)    puts(#__VA_ARGS__)
+             #define report(test, ...) ((test)?puts(#test):\
+                         printf(__VA_ARGS__))
+             debug("Flag");
+             debug("X = %d\n", x);
+             showlist(The first, second, and third items.);
+             report(x&gt;y, "x is %d but y is %d", x, y);
+
+[<a name="p171" href="#p171">page 171</a>] (<a href="#Contents">Contents</a>)
+
+    results in
+             fprintf(stderr, "Flag" );
+             fprintf(stderr, "X = %d\n", x );
+             puts( "The first, second, and third items." );
+             ((x&gt;y)?puts("x&gt;y"):
+                         printf("x is %d but y is %d", x, y));
+
+<a name="6.10.4" href="#6.10.4"><b>    6.10.4 Line control</b></a>
+<b>    Constraints</b>
+1   The string literal of a #line directive, if present, shall be a character string literal.
+<b>    Semantics</b>
+2   The line number of the current source line is one greater than the number of new-line
+    characters read or introduced in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>) while processing the source
+    file to the current token.
+3   A preprocessing directive of the form
+       # line digit-sequence new-line
+    causes the implementation to behave as if the following sequence of source lines begins
+    with a source line that has a line number as specified by the digit sequence (interpreted as
+    a decimal integer). The digit sequence shall not specify zero, nor a number greater than
+    2147483647.
+4   A preprocessing directive of the form
+       # line digit-sequence "s-char-sequenceopt" new-line
+    sets the presumed line number similarly and changes the presumed name of the source
+    file to be the contents of the character string literal.
+5   A preprocessing directive of the form
+       # line pp-tokens new-line
+    (that does not match one of the two previous forms) is permitted. The preprocessing
+    tokens after line on the directive are processed just as in normal text (each identifier
+    currently defined as a macro name is replaced by its replacement list of preprocessing
+    tokens). The directive resulting after all replacements shall match one of the two
+    previous forms and is then processed as appropriate.
+
+[<a name="p172" href="#p172">page 172</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.5" href="#6.10.5"><b>    6.10.5 Error directive</b></a>
+<b>    Semantics</b>
+1   A preprocessing directive of the form
+       # error pp-tokensopt new-line
+    causes the implementation to produce a diagnostic message that includes the specified
+    sequence of preprocessing tokens.
+<a name="6.10.6" href="#6.10.6"><b>    6.10.6 Pragma directive</b></a>
+<b>    Semantics</b>
+1   A preprocessing directive of the form
+       # pragma pp-tokensopt new-line
+    where the preprocessing token STDC does not immediately follow pragma in the
+    directive (prior to any macro replacement)<sup><a href="#note174"><b>174)</b></a></sup> causes the implementation to behave in an
+    implementation-defined manner. The behavior might cause translation to fail or cause the
+    translator or the resulting program to behave in a non-conforming manner. Any such
+    pragma that is not recognized by the implementation is ignored.
+2   If the preprocessing token STDC does immediately follow pragma in the directive (prior
+    to any macro replacement), then no macro replacement is performed on the directive, and
+    the directive shall have one of the following forms<sup><a href="#note175"><b>175)</b></a></sup> whose meanings are described
+    elsewhere:
+       #pragma STDC FP_CONTRACT on-off-switch
+       #pragma STDC FENV_ACCESS on-off-switch
+       #pragma STDC CX_LIMITED_RANGE on-off-switch
+       on-off-switch: one of
+                   ON     OFF           DEFAULT
+    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), the FENV_ACCESS pragma
+    (<a href="#7.6.1">7.6.1</a>), the CX_LIMITED_RANGE pragma (<a href="#7.3.4">7.3.4</a>).
+
+
+
+
+    <sup><a name="note174" href="#note174"><b>174)</b></a></sup> An implementation is not required to perform macro replacement in pragmas, but it is permitted
+         except for in standard pragmas (where STDC immediately follows pragma). If the result of macro
+         replacement in a non-standard pragma has the same form as a standard pragma, the behavior is still
+         implementation-defined; an implementation is permitted to behave as if it were the standard pragma,
+         but is not required to.
+    <sup><a name="note175" href="#note175"><b>175)</b></a></sup> See ''future language directions'' (<a href="#6.11.8">6.11.8</a>).
+
+[<a name="p173" href="#p173">page 173</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.7" href="#6.10.7"><b>    6.10.7 Null directive</b></a>
+<b>    Semantics</b>
+1   A preprocessing directive of the form
+       # new-line
+    has no effect.
+<a name="6.10.8" href="#6.10.8"><b>    6.10.8 Predefined macro names</b></a>
+1   The values of the predefined macros listed in the following subclauses<sup><a href="#note176"><b>176)</b></a></sup> (except for
+    __FILE__ and __LINE__) remain constant throughout the translation unit.
+2   None of these macro names, nor the identifier defined, shall be the subject of a
+    #define or a #undef preprocessing directive. Any other predefined macro names
+    shall begin with a leading underscore followed by an uppercase letter or a second
+    underscore.
+3   The implementation shall not predefine the macro __cplusplus, nor shall it define it
+    in any standard header.
+    Forward references: standard headers (<a href="#7.1.2">7.1.2</a>).
+<a name="6.10.8.1" href="#6.10.8.1"><b>    6.10.8.1 Mandatory macros</b></a>
+1   The following macro names shall be defined by the implementation:
+    __DATE__ The date of translation of the preprocessing translation unit: a character
+               string literal of the form "Mmm dd yyyy", where the names of the
+               months are the same as those generated by the asctime function, and the
+               first character of dd is a space character if the value is less than 10. If the
+               date of translation is not available, an implementation-defined valid date
+               shall be supplied.
+    __FILE__ The presumed name of the current source file (a character string literal).<sup><a href="#note177"><b>177)</b></a></sup>
+    __LINE__ The presumed line number (within the current source file) of the current
+               source line (an integer constant).177)
+    __STDC__ The integer constant 1, intended to indicate a conforming implementation.
+    __STDC_HOSTED__ The integer constant 1 if the implementation is a hosted
+              implementation or the integer constant 0 if it is not.
+
+
+
+
+    <sup><a name="note176" href="#note176"><b>176)</b></a></sup> See ''future language directions'' (<a href="#6.11.9">6.11.9</a>).
+    <sup><a name="note177" href="#note177"><b>177)</b></a></sup> The presumed source file name and line number can be changed by the #line directive.
+
+[<a name="p174" href="#p174">page 174</a>] (<a href="#Contents">Contents</a>)
+
+    __STDC_VERSION__ The integer constant 201ymmL.<sup><a href="#note178"><b>178)</b></a></sup>
+    __TIME__ The time of translation of the preprocessing translation unit: a character
+               string literal of the form "hh:mm:ss" as in the time generated by the
+               asctime function. If the time of translation is not available, an
+               implementation-defined valid time shall be supplied.
+    Forward references: the asctime function (<a href="#7.26.3.1">7.26.3.1</a>).
+<a name="6.10.8.2" href="#6.10.8.2"><b>    6.10.8.2 Environment macros</b></a>
+1   The following macro names are conditionally defined by the implementation:
+    __STDC_ISO_10646__ An integer constant of the form yyyymmL (for example,
+              199712L). If this symbol is defined, then every character in the Unicode
+              required set, when stored in an object of type wchar_t, has the same
+              value as the short identifier of that character. The Unicode required set
+              consists of all the characters that are defined by ISO/IEC 10646, along with
+              all amendments and technical corrigenda, as of the specified year and
+              month. If some other encoding is used, the macro shall not be defined and
+              the actual encoding used is implementation-defined.
+    __STDC_MB_MIGHT_NEQ_WC__ The integer constant 1, intended to indicate that, in
+              the encoding for wchar_t, a member of the basic character set need not
+              have a code value equal to its value when used as the lone character in an
+              integer character constant.
+    __STDC_UTF_16__ The integer constant 1, intended to indicate that values of type
+              char16_t are UTF-16 encoded. If some other encoding is used, the
+              macro shall not be defined and the actual encoding used is implementation-
+              defined.
+    __STDC_UTF_32__ The integer constant 1, intended to indicate that values of type
+              char32_t are UTF-32 encoded. If some other encoding is used, the
+              macro shall not be defined and the actual encoding used is implementation-
+              defined.
+    Forward references: common definitions (<a href="#7.19">7.19</a>), unicode utilities (<a href="#7.27">7.27</a>).
+
+
+
+
+    <sup><a name="note178" href="#note178"><b>178)</b></a></sup> This macro was not specified in ISO/IEC 9899:1990 and was specified as 199409L in
+         ISO/IEC 9899/AMD1:1995 and as 199901L in ISO/IEC 9899:1999. The intention is that this will
+         remain an integer constant of type long int that is increased with each revision of this International
+         Standard.
+
+[<a name="p175" href="#p175">page 175</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.10.8.3" href="#6.10.8.3"><b>    6.10.8.3 Conditional feature macros</b></a>
+1   The following macro names are conditionally defined by the implementation:
+    __STDC_ANALYZABLE__ The integer constant 1, intended to indicate conformance to
+              the specifications in <a href="#L">annex L</a> (Analyzability).
+    __STDC_IEC_559__ The integer constant 1, intended to indicate conformance to the
+              specifications in <a href="#F">annex F</a> (IEC 60559 floating-point arithmetic).
+    __STDC_IEC_559_COMPLEX__ The integer constant 1, intended to indicate
+              adherence to the specifications in <a href="#G">annex G</a> (IEC 60559 compatible complex
+              arithmetic).
+    __STDC_LIB_EXT1__ The integer constant 201ymmL, intended to indicate support
+              for the extensions defined in <a href="#K">annex K</a> (Bounds-checking interfaces).<sup><a href="#note179"><b>179)</b></a></sup>
+    __STDC_NO_COMPLEX__ The integer constant 1, intended to indicate that the
+              implementation does not support complex types or the <a href="#7.3">&lt;complex.h&gt;</a>
+              header.
+    __STDC_NO_THREADS__ The integer constant 1, intended to indicate that the
+              implementation does not support atomic types (including the _Atomic
+              type qualifier and the <a href="#7.17">&lt;stdatomic.h&gt;</a> header) or the <a href="#7.25">&lt;threads.h&gt;</a>
+              header.
+    __STDC_NO_VLA__ The integer constant 1, intended to indicate that the
+              implementation does not support variable length arrays or variably
+              modified types.
+2   An implementation that defines __STDC_NO_COMPLEX__ shall not define
+    __STDC_IEC_559_COMPLEX__.
+<a name="6.10.9" href="#6.10.9"><b>    6.10.9 Pragma operator</b></a>
+<b>    Semantics</b>
+1   A unary operator expression of the form:
+       _Pragma ( string-literal )
+    is processed as follows: The string literal is destringized by deleting the L prefix, if
+    present, deleting the leading and trailing double-quotes, replacing each escape sequence
+    \" by a double-quote, and replacing each escape sequence \\ by a single backslash. The
+    resulting sequence of characters is processed through translation phase 3 to produce
+    preprocessing tokens that are executed as if they were the pp-tokens in a pragma
+
+
+    <sup><a name="note179" href="#note179"><b>179)</b></a></sup> The intention is that this will remain an integer constant of type long int that is increased with
+         each revision of this International Standard.
+
+[<a name="p176" href="#p176">page 176</a>] (<a href="#Contents">Contents</a>)
+
+    directive. The original four preprocessing tokens in the unary operator expression are
+    removed.
+2   EXAMPLE       A directive of the form:
+              #pragma listing on "..\listing.dir"
+    can also be expressed as:
+              _Pragma ( "listing on \"..\\listing.dir\"" )
+    The latter form is processed in the same way whether it appears literally as shown, or results from macro
+    replacement, as in:
+              #define LISTING(x) PRAGMA(listing on #x)
+              #define PRAGMA(x) _Pragma(#x)
+              LISTING ( ..\listing.dir )
+
+[<a name="p177" href="#p177">page 177</a>] (<a href="#Contents">Contents</a>)
+
+<a name="6.11" href="#6.11"><b>    6.11 Future language directions</b></a>
+<a name="6.11.1" href="#6.11.1"><b>    6.11.1 Floating types</b></a>
+1   Future standardization may include additional floating-point types, including those with
+    greater range, precision, or both than long double.
+<a name="6.11.2" href="#6.11.2"><b>    6.11.2 Linkages of identifiers</b></a>
+1   Declaring an identifier with internal linkage at file scope without the static storage-
+    class specifier is an obsolescent feature.
+<a name="6.11.3" href="#6.11.3"><b>    6.11.3 External names</b></a>
+1   Restriction of the significance of an external name to fewer than 255 characters
+    (considering each universal character name or extended source character as a single
+    character) is an obsolescent feature that is a concession to existing implementations.
+<a name="6.11.4" href="#6.11.4"><b>    6.11.4 Character escape sequences</b></a>
+1   Lowercase letters as escape sequences are reserved for future standardization. Other
+    characters may be used in extensions.
+<a name="6.11.5" href="#6.11.5"><b>    6.11.5 Storage-class specifiers</b></a>
+1   The placement of a storage-class specifier other than at the beginning of the declaration
+    specifiers in a declaration is an obsolescent feature.
+<a name="6.11.6" href="#6.11.6"><b>    6.11.6 Function declarators</b></a>
+1   The use of function declarators with empty parentheses (not prototype-format parameter
+    type declarators) is an obsolescent feature.
+<a name="6.11.7" href="#6.11.7"><b>    6.11.7 Function definitions</b></a>
+1   The use of function definitions with separate parameter identifier and declaration lists
+    (not prototype-format parameter type and identifier declarators) is an obsolescent feature.
+<a name="6.11.8" href="#6.11.8"><b>    6.11.8 Pragma directives</b></a>
+1   Pragmas whose first preprocessing token is STDC are reserved for future standardization.
+<a name="6.11.9" href="#6.11.9"><b>    6.11.9 Predefined macro names</b></a>
+1   Macro names beginning with __STDC_ are reserved for future standardization.
+
+[<a name="p178" href="#p178">page 178</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="7" href="#7"><b>    7. Library</b></a>
+<a name="7.1" href="#7.1"><b>    7.1 Introduction</b></a>
+<a name="7.1.1" href="#7.1.1"><b>    7.1.1 Definitions of terms</b></a>
+1   A string is a contiguous sequence of characters terminated by and including the first null
+    character. The term multibyte string is sometimes used instead to emphasize special
+    processing given to multibyte characters contained in the string or to avoid confusion
+    with a wide string. A pointer to a string is a pointer to its initial (lowest addressed)
+    character. The length of a string is the number of bytes preceding the null character and
+    the value of a string is the sequence of the values of the contained characters, in order.
+2   The decimal-point character is the character used by functions that convert floating-point
+    numbers to or from character sequences to denote the beginning of the fractional part of
+    such character sequences.<sup><a href="#note180"><b>180)</b></a></sup> It is represented in the text and examples by a period, but
+    may be changed by the setlocale function.
+3   A null wide character is a wide character with code value zero.
+4   A wide string is a contiguous sequence of wide characters terminated by and including
+    the first null wide character. A pointer to a wide string is a pointer to its initial (lowest
+    addressed) wide character. The length of a wide string is the number of wide characters
+    preceding the null wide character and the value of a wide string is the sequence of code
+    values of the contained wide characters, in order.
+5   A shift sequence is a contiguous sequence of bytes within a multibyte string that
+    (potentially) causes a change in shift state (see <a href="#5.2.1.2">5.2.1.2</a>). A shift sequence shall not have a
+    corresponding wide character; it is instead taken to be an adjunct to an adjacent multibyte
+    character.<sup><a href="#note181"><b>181)</b></a></sup>
+    Forward references: character handling (<a href="#7.4">7.4</a>), the setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+
+
+
+
+    <sup><a name="note180" href="#note180"><b>180)</b></a></sup> The functions that make use of the decimal-point character are the numeric conversion functions
+         (<a href="#7.22.1">7.22.1</a>, <a href="#7.28.4.1">7.28.4.1</a>) and the formatted input/output functions (<a href="#7.21.6">7.21.6</a>, <a href="#7.28.2">7.28.2</a>).
+    <sup><a name="note181" href="#note181"><b>181)</b></a></sup> For state-dependent encodings, the values for MB_CUR_MAX and MB_LEN_MAX shall thus be large
+         enough to count all the bytes in any complete multibyte character plus at least one adjacent shift
+         sequence of maximum length. Whether these counts provide for more than one shift sequence is the
+         implementation's choice.
+
+[<a name="p179" href="#p179">page 179</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.1.2" href="#7.1.2"><b>    7.1.2 Standard headers</b></a>
+1   Each library function is declared, with a type that includes a prototype, in a header,<sup><a href="#note182"><b>182)</b></a></sup>
+    whose contents are made available by the #include preprocessing directive. The
+    header declares a set of related functions, plus any necessary types and additional macros
+    needed to facilitate their use. Declarations of types described in this clause shall not
+    include type qualifiers, unless explicitly stated otherwise.
+2   The standard headers are<sup><a href="#note183"><b>183)</b></a></sup>
+           <a href="#7.2">&lt;assert.h&gt;</a>             <a href="#7.9">&lt;iso646.h&gt;</a>              <a href="#7.16">&lt;stdarg.h&gt;</a>              <a href="#7.23">&lt;string.h&gt;</a>
+           <a href="#7.3">&lt;complex.h&gt;</a>            <a href="#7.10">&lt;limits.h&gt;</a>              <a href="#7.17">&lt;stdatomic.h&gt;</a>           <a href="#7.24">&lt;tgmath.h&gt;</a>
+           <a href="#7.4">&lt;ctype.h&gt;</a>              <a href="#7.11">&lt;locale.h&gt;</a>              <a href="#7.18">&lt;stdbool.h&gt;</a>             <a href="#7.25">&lt;threads.h&gt;</a>
+           <a href="#7.5">&lt;errno.h&gt;</a>              <a href="#7.12">&lt;math.h&gt;</a>                <a href="#7.19">&lt;stddef.h&gt;</a>              <a href="#7.26">&lt;time.h&gt;</a>
+           <a href="#7.6">&lt;fenv.h&gt;</a>               <a href="#7.13">&lt;setjmp.h&gt;</a>              <a href="#7.20">&lt;stdint.h&gt;</a>              <a href="#7.27">&lt;uchar.h&gt;</a>
+           <a href="#7.7">&lt;float.h&gt;</a>              <a href="#7.14">&lt;signal.h&gt;</a>              <a href="#7.21">&lt;stdio.h&gt;</a>               <a href="#7.28">&lt;wchar.h&gt;</a>
+           <a href="#7.8">&lt;inttypes.h&gt;</a>           <a href="#7.15">&lt;stdalign.h&gt;</a>            <a href="#7.22">&lt;stdlib.h&gt;</a>              <a href="#7.29">&lt;wctype.h&gt;</a>
+3   If a file with the same name as one of the above &lt; and &gt; delimited sequences, not
+    provided as part of the implementation, is placed in any of the standard places that are
+    searched for included source files, the behavior is undefined.
+4   Standard headers may be included in any order; each may be included more than once in
+    a given scope, with no effect different from being included only once, except that the
+    effect of including <a href="#7.2">&lt;assert.h&gt;</a> depends on the definition of NDEBUG (see <a href="#7.2">7.2</a>). If
+    used, a header shall be included outside of any external declaration or definition, and it
+    shall first be included before the first reference to any of the functions or objects it
+    declares, or to any of the types or macros it defines. However, if an identifier is declared
+    or defined in more than one header, the second and subsequent associated headers may be
+    included after the initial reference to the identifier. The program shall not have any
+    macros with names lexically identical to keywords currently defined prior to the
+    inclusion.
+5   Any definition of an object-like macro described in this clause shall expand to code that is
+    fully protected by parentheses where necessary, so that it groups in an arbitrary
+    expression as if it were a single identifier.
+6   Any declaration of a library function shall have external linkage.
+
+
+
+
+    <sup><a name="note182" href="#note182"><b>182)</b></a></sup> A header is not necessarily a source file, nor are the &lt; and &gt; delimited sequences in header names
+         necessarily valid source file names.
+    <sup><a name="note183" href="#note183"><b>183)</b></a></sup> The headers <a href="#7.3">&lt;complex.h&gt;</a>, <a href="#7.17">&lt;stdatomic.h&gt;</a>, and <a href="#7.25">&lt;threads.h&gt;</a> are conditional features that
+         implementations need not support; see <a href="#6.10.8.3">6.10.8.3</a>.
+
+[<a name="p180" href="#p180">page 180</a>] (<a href="#Contents">Contents</a>)
+
+7   A summary of the contents of the standard headers is given in <a href="#B">annex B</a>.
+    Forward references: diagnostics (<a href="#7.2">7.2</a>).
+<a name="7.1.3" href="#7.1.3"><b>    7.1.3 Reserved identifiers</b></a>
+1   Each header declares or defines all identifiers listed in its associated subclause, and
+    optionally declares or defines identifiers listed in its associated future library directions
+    subclause and identifiers which are always reserved either for any use or for use as file
+    scope identifiers.
+    -- All identifiers that begin with an underscore and either an uppercase letter or another
+      underscore are always reserved for any use.
+    -- All identifiers that begin with an underscore are always reserved for use as identifiers
+      with file scope in both the ordinary and tag name spaces.
+    -- Each macro name in any of the following subclauses (including the future library
+      directions) is reserved for use as specified if any of its associated headers is included;
+      unless explicitly stated otherwise (see <a href="#7.1.4">7.1.4</a>).
+    -- All identifiers with external linkage in any of the following subclauses (including the
+      future library directions) and errno are always reserved for use as identifiers with
+      external linkage.<sup><a href="#note184"><b>184)</b></a></sup>
+    -- Each identifier with file scope listed in any of the following subclauses (including the
+      future library directions) is reserved for use as a macro name and as an identifier with
+      file scope in the same name space if any of its associated headers is included.
+2   No other identifiers are reserved. If the program declares or defines an identifier in a
+    context in which it is reserved (other than as allowed by <a href="#7.1.4">7.1.4</a>), or defines a reserved
+    identifier as a macro name, the behavior is undefined.
+3   If the program removes (with #undef) any macro definition of an identifier in the first
+    group listed above, the behavior is undefined.
+
+
+
+
+    <sup><a name="note184" href="#note184"><b>184)</b></a></sup> The list of reserved identifiers with external linkage includes math_errhandling, setjmp,
+         va_copy, and va_end.
+
+[<a name="p181" href="#p181">page 181</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.1.4" href="#7.1.4"><b>    7.1.4 Use of library functions</b></a>
+1   Each of the following statements applies unless explicitly stated otherwise in the detailed
+    descriptions that follow: If an argument to a function has an invalid value (such as a value
+    outside the domain of the function, or a pointer outside the address space of the program,
+    or a null pointer, or a pointer to non-modifiable storage when the corresponding
+    parameter is not const-qualified) or a type (after promotion) not expected by a function
+    with variable number of arguments, the behavior is undefined. If a function argument is
+    described as being an array, the pointer actually passed to the function shall have a value
+    such that all address computations and accesses to objects (that would be valid if the
+    pointer did point to the first element of such an array) are in fact valid. Any function
+    declared in a header may be additionally implemented as a function-like macro defined in
+    the header, so if a library function is declared explicitly when its header is included, one
+    of the techniques shown below can be used to ensure the declaration is not affected by
+    such a macro. Any macro definition of a function can be suppressed locally by enclosing
+    the name of the function in parentheses, because the name is then not followed by the left
+    parenthesis that indicates expansion of a macro function name. For the same syntactic
+    reason, it is permitted to take the address of a library function even if it is also defined as
+    a macro.<sup><a href="#note185"><b>185)</b></a></sup> The use of #undef to remove any macro definition will also ensure that an
+    actual function is referred to. Any invocation of a library function that is implemented as
+    a macro shall expand to code that evaluates each of its arguments exactly once, fully
+    protected by parentheses where necessary, so it is generally safe to use arbitrary
+    expressions as arguments.<sup><a href="#note186"><b>186)</b></a></sup> Likewise, those function-like macros described in the
+    following subclauses may be invoked in an expression anywhere a function with a
+    compatible return type could be called.<sup><a href="#note187"><b>187)</b></a></sup> All object-like macros listed as expanding to
+
+
+    <sup><a name="note185" href="#note185"><b>185)</b></a></sup> This means that an implementation shall provide an actual function for each library function, even if it
+         also provides a macro for that function.
+    <sup><a name="note186" href="#note186"><b>186)</b></a></sup> Such macros might not contain the sequence points that the corresponding function calls do.
+    <sup><a name="note187" href="#note187"><b>187)</b></a></sup> Because external identifiers and some macro names beginning with an underscore are reserved,
+         implementations may provide special semantics for such names. For example, the identifier
+         _BUILTIN_abs could be used to indicate generation of in-line code for the abs function. Thus, the
+         appropriate header could specify
+                   #define abs(x) _BUILTIN_abs(x)
+          for a compiler whose code generator will accept it.
+          In this manner, a user desiring to guarantee that a given library function such as abs will be a genuine
+          function may write
+                   #undef abs
+          whether the implementation's header provides a macro implementation of abs or a built-in
+          implementation. The prototype for the function, which precedes and is hidden by any macro
+          definition, is thereby revealed also.
+
+[<a name="p182" href="#p182">page 182</a>] (<a href="#Contents">Contents</a>)
+
+    integer constant expressions shall additionally be suitable for use in #if preprocessing
+    directives.
+2   Provided that a library function can be declared without reference to any type defined in a
+    header, it is also permissible to declare the function and use it without including its
+    associated header.
+3   There is a sequence point immediately before a library function returns.
+4   The functions in the standard library are not guaranteed to be reentrant and may modify
+    objects with static or thread storage duration.<sup><a href="#note188"><b>188)</b></a></sup>
+5   Unless explicitly stated otherwise in the detailed descriptions that follow, library
+    functions shall prevent data races as follows: A library function shall not directly or
+    indirectly access objects accessible by threads other than the current thread unless the
+    objects are accessed directly or indirectly via the function's arguments. A library
+    function shall not directly or indirectly modify objects accessible by threads other than
+    the current thread unless the objects are accessed directly or indirectly via the function's
+    non-const arguments.<sup><a href="#note189"><b>189)</b></a></sup> Implementations may share their own internal objects between
+    threads if the objects are not visible to users and are protected against data races.
+6   Unless otherwise specified, library functions shall perform all operations solely within the
+    current thread if those operations have effects that are visible to users.<sup><a href="#note190"><b>190)</b></a></sup>
+7   EXAMPLE        The function atoi may be used in any of several ways:
+    -- by use of its associated header (possibly generating a macro expansion)
+                 #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+                 const char *str;
+                 /* ... */
+                 i = atoi(str);
+    -- by use of its associated header (assuredly generating a true function reference)
+
+
+
+
+    <sup><a name="note188" href="#note188"><b>188)</b></a></sup> Thus, a signal handler cannot, in general, call standard library functions.
+    <sup><a name="note189" href="#note189"><b>189)</b></a></sup> This means, for example, that an implementation is not permitted to use a static object for internal
+         purposes without synchronization because it could cause a data race even in programs that do not
+         explicitly share objects between threads.
+    <sup><a name="note190" href="#note190"><b>190)</b></a></sup> This allows implementations to parallelize operations if there are no visible side effects.
+
+[<a name="p183" href="#p183">page 183</a>] (<a href="#Contents">Contents</a>)
+
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            #undef atoi
+            const char *str;
+            /* ... */
+            i = atoi(str);
+   or
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            const char *str;
+            /* ... */
+            i = (atoi)(str);
+-- by explicit declaration
+            extern int atoi(const char *);
+            const char *str;
+            /* ... */
+            i = atoi(str);
+
+[<a name="p184" href="#p184">page 184</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.2" href="#7.2"><b>    7.2 Diagnostics &lt;assert.h&gt;</b></a>
+1   The header <a href="#7.2">&lt;assert.h&gt;</a> defines the assert and static_assert macros and
+    refers to another macro,
+            NDEBUG
+    which is not defined by <a href="#7.2">&lt;assert.h&gt;</a>. If NDEBUG is defined as a macro name at the
+    point in the source file where <a href="#7.2">&lt;assert.h&gt;</a> is included, the assert macro is defined
+    simply as
+            #define assert(ignore) ((void)0)
+    The assert macro is redefined according to the current state of NDEBUG each time that
+    <a href="#7.2">&lt;assert.h&gt;</a> is included.
+2   The assert macro shall be implemented as a macro, not as an actual function. If the
+    macro definition is suppressed in order to access an actual function, the behavior is
+    undefined.
+3   The macro
+            static_assert
+    expands to _Static_assert.
+<a name="7.2.1" href="#7.2.1"><b>    7.2.1 Program diagnostics</b></a>
+<a name="7.2.1.1" href="#7.2.1.1"><b>    7.2.1.1 The assert macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.2">&lt;assert.h&gt;</a>
+            void assert(scalar expression);
+<b>    Description</b>
+2   The assert macro puts diagnostic tests into programs; it expands to a void expression.
+    When it is executed, if expression (which shall have a scalar type) is false (that is,
+    compares equal to 0), the assert macro writes information about the particular call that
+    failed (including the text of the argument, the name of the source file, the source line
+    number, and the name of the enclosing function -- the latter are respectively the values of
+    the preprocessing macros __FILE__ and __LINE__ and of the identifier
+    __func__) on the standard error stream in an implementation-defined format.<sup><a href="#note191"><b>191)</b></a></sup> It
+    then calls the abort function.
+
+
+
+    <sup><a name="note191" href="#note191"><b>191)</b></a></sup> The message written might be of the form:
+         Assertion failed: expression, function abc, file xyz, line nnn.
+
+[<a name="p185" href="#p185">page 185</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The assert macro returns no value.
+    Forward references: the abort function (<a href="#7.22.4.1">7.22.4.1</a>).
+
+[<a name="p186" href="#p186">page 186</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3" href="#7.3"><b>    7.3 Complex arithmetic &lt;complex.h&gt;</b></a>
+<a name="7.3.1" href="#7.3.1"><b>    7.3.1 Introduction</b></a>
+1   The header <a href="#7.3">&lt;complex.h&gt;</a> defines macros and declares functions that support complex
+    arithmetic.<sup><a href="#note192"><b>192)</b></a></sup>
+2   Implementations that define the macro __STDC_NO_COMPLEX__ need not provide
+    this header nor support any of its facilities.
+3   Each synopsis specifies a family of functions consisting of a principal function with one
+    or more double complex parameters and a double complex or double return
+    value; and other functions with the same name but with f and l suffixes which are
+    corresponding functions with float and long double parameters and return values.
+4   The macro
+             complex
+    expands to _Complex; the macro
+             _Complex_I
+    expands to a constant expression of type const float _Complex, with the value of
+    the imaginary unit.<sup><a href="#note193"><b>193)</b></a></sup>
+5   The macros
+             imaginary
+    and
+             _Imaginary_I
+    are defined if and only if the implementation supports imaginary types;<sup><a href="#note194"><b>194)</b></a></sup> if defined,
+    they expand to _Imaginary and a constant expression of type const float
+    _Imaginary with the value of the imaginary unit.
+6   The macro
+             I
+    expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is not
+    defined, I shall expand to _Complex_I.
+7   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+    redefine the macros complex, imaginary, and I.
+
+    <sup><a name="note192" href="#note192"><b>192)</b></a></sup> See ''future library directions'' (<a href="#7.30.1">7.30.1</a>).
+    <sup><a name="note193" href="#note193"><b>193)</b></a></sup> The imaginary unit is a number i such that i 2 = -1.
+    <sup><a name="note194" href="#note194"><b>194)</b></a></sup> A specification for imaginary types is in informative <a href="#G">annex G</a>.
+
+[<a name="p187" href="#p187">page 187</a>] (<a href="#Contents">Contents</a>)
+
+    Forward references: IEC 60559-compatible complex arithmetic (<a href="#G">annex G</a>).
+<a name="7.3.2" href="#7.3.2"><b>    7.3.2 Conventions</b></a>
+1   Values are interpreted as radians, not degrees. An implementation may set errno but is
+    not required to.
+<a name="7.3.3" href="#7.3.3"><b>    7.3.3 Branch cuts</b></a>
+1   Some of the functions below have branch cuts, across which the function is
+    discontinuous. For implementations with a signed zero (including all IEC 60559
+    implementations) that follow the specifications of <a href="#G">annex G</a>, the sign of zero distinguishes
+    one side of a cut from another so the function is continuous (except for format
+    limitations) as the cut is approached from either side. For example, for the square root
+    function, which has a branch cut along the negative real axis, the top of the cut, with
+    imaginary part +0, maps to the positive imaginary axis, and the bottom of the cut, with
+    imaginary part -0, maps to the negative imaginary axis.
+2   Implementations that do not support a signed zero (see <a href="#F">annex F</a>) cannot distinguish the
+    sides of branch cuts. These implementations shall map a cut so the function is continuous
+    as the cut is approached coming around the finite endpoint of the cut in a counter
+    clockwise direction. (Branch cuts for the functions specified here have just one finite
+    endpoint.) For example, for the square root function, coming counter clockwise around
+    the finite endpoint of the cut along the negative real axis approaches the cut from above,
+    so the cut maps to the positive imaginary axis.
+<a name="7.3.4" href="#7.3.4"><b>    7.3.4 The CX_LIMITED_RANGE pragma</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           #pragma STDC CX_LIMITED_RANGE on-off-switch
+<b>    Description</b>
+2   The usual mathematical formulas for complex multiply, divide, and absolute value are
+    problematic because of their treatment of infinities and because of undue overflow and
+    underflow. The CX_LIMITED_RANGE pragma can be used to inform the
+    implementation that (where the state is ''on'') the usual mathematical formulas are
+    acceptable.<sup><a href="#note195"><b>195)</b></a></sup> The pragma can occur either outside external declarations or preceding all
+    explicit declarations and statements inside a compound statement. When outside external
+    declarations, the pragma takes effect from its occurrence until another
+    CX_LIMITED_RANGE pragma is encountered, or until the end of the translation unit.
+    When inside a compound statement, the pragma takes effect from its occurrence until
+    another CX_LIMITED_RANGE pragma is encountered (including within a nested
+    compound statement), or until the end of the compound statement; at the end of a
+    compound statement the state for the pragma is restored to its condition just before the
+
+[<a name="p188" href="#p188">page 188</a>] (<a href="#Contents">Contents</a>)
+
+    compound statement. If this pragma is used in any other context, the behavior is
+    undefined. The default state for the pragma is ''off''.
+<a name="7.3.5" href="#7.3.5"><b>    7.3.5 Trigonometric functions</b></a>
+<a name="7.3.5.1" href="#7.3.5.1"><b>    7.3.5.1 The cacos functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex cacos(double complex z);
+            float complex cacosf(float complex z);
+            long double complex cacosl(long double complex z);
+<b>    Description</b>
+2   The cacos functions compute the complex arc cosine of z, with branch cuts outside the
+    interval [-1, +1] along the real axis.
+<b>    Returns</b>
+3   The cacos functions return the complex arc cosine value, in the range of a strip
+    mathematically unbounded along the imaginary axis and in the interval [0, pi ] along the
+    real axis.
+<a name="7.3.5.2" href="#7.3.5.2"><b>    7.3.5.2 The casin functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex casin(double complex z);
+            float complex casinf(float complex z);
+            long double complex casinl(long double complex z);
+<b>    Description</b>
+2   The casin functions compute the complex arc sine of z, with branch cuts outside the
+    interval [-1, +1] along the real axis.
+<b>    Returns</b>
+3   The casin functions return the complex arc sine value, in the range of a strip
+    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+
+    <sup><a name="note195" href="#note195"><b>195)</b></a></sup> The purpose of the pragma is to allow the implementation to use the formulas:
+            (x + iy) x (u + iv) = (xu - yv) + i(yu + xv)
+            (x + iy) / (u + iv) = [(xu + yv) + i(yu - xv)]/(u2 + v 2 )
+            | x + iy | = (sqrt) x 2 + y 2
+                         -----
+         where the programmer can determine they are safe.
+
+[<a name="p189" href="#p189">page 189</a>] (<a href="#Contents">Contents</a>)
+
+    along the real axis.
+<a name="7.3.5.3" href="#7.3.5.3"><b>    7.3.5.3 The catan functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex catan(double complex z);
+           float complex catanf(float complex z);
+           long double complex catanl(long double complex z);
+<b>    Description</b>
+2   The catan functions compute the complex arc tangent of z, with branch cuts outside the
+    interval [-i, +i] along the imaginary axis.
+<b>    Returns</b>
+3   The catan functions return the complex arc tangent value, in the range of a strip
+    mathematically unbounded along the imaginary axis and in the interval [-pi /2, +pi /2]
+    along the real axis.
+<a name="7.3.5.4" href="#7.3.5.4"><b>    7.3.5.4 The ccos functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex ccos(double complex z);
+           float complex ccosf(float complex z);
+           long double complex ccosl(long double complex z);
+<b>    Description</b>
+2   The ccos functions compute the complex cosine of z.
+<b>    Returns</b>
+3   The ccos functions return the complex cosine value.
+<a name="7.3.5.5" href="#7.3.5.5"><b>    7.3.5.5 The csin functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex csin(double complex z);
+           float complex csinf(float complex z);
+           long double complex csinl(long double complex z);
+<b>    Description</b>
+2   The csin functions compute the complex sine of z.
+
+[<a name="p190" href="#p190">page 190</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The csin functions return the complex sine value.
+<a name="7.3.5.6" href="#7.3.5.6"><b>    7.3.5.6 The ctan functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex ctan(double complex z);
+            float complex ctanf(float complex z);
+            long double complex ctanl(long double complex z);
+<b>    Description</b>
+2   The ctan functions compute the complex tangent of z.
+<b>    Returns</b>
+3   The ctan functions return the complex tangent value.
+<a name="7.3.6" href="#7.3.6"><b>    7.3.6 Hyperbolic functions</b></a>
+<a name="7.3.6.1" href="#7.3.6.1"><b>    7.3.6.1 The cacosh functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex cacosh(double complex z);
+            float complex cacoshf(float complex z);
+            long double complex cacoshl(long double complex z);
+<b>    Description</b>
+2   The cacosh functions compute the complex arc hyperbolic cosine of z, with a branch
+    cut at values less than 1 along the real axis.
+<b>    Returns</b>
+3   The cacosh functions return the complex arc hyperbolic cosine value, in the range of a
+    half-strip of nonnegative values along the real axis and in the interval [-ipi , +ipi ] along the
+    imaginary axis.
+<a name="7.3.6.2" href="#7.3.6.2"><b>    7.3.6.2 The casinh functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex casinh(double complex z);
+            float complex casinhf(float complex z);
+            long double complex casinhl(long double complex z);
+
+[<a name="p191" href="#p191">page 191</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
+    outside the interval [-i, +i] along the imaginary axis.
+<b>    Returns</b>
+3   The casinh functions return the complex arc hyperbolic sine value, in the range of a
+    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+    along the imaginary axis.
+<a name="7.3.6.3" href="#7.3.6.3"><b>    7.3.6.3 The catanh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex catanh(double complex z);
+           float complex catanhf(float complex z);
+           long double complex catanhl(long double complex z);
+<b>    Description</b>
+2   The catanh functions compute the complex arc hyperbolic tangent of z, with branch
+    cuts outside the interval [-1, +1] along the real axis.
+<b>    Returns</b>
+3   The catanh functions return the complex arc hyperbolic tangent value, in the range of a
+    strip mathematically unbounded along the real axis and in the interval [-ipi /2, +ipi /2]
+    along the imaginary axis.
+<a name="7.3.6.4" href="#7.3.6.4"><b>    7.3.6.4 The ccosh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex ccosh(double complex z);
+           float complex ccoshf(float complex z);
+           long double complex ccoshl(long double complex z);
+<b>    Description</b>
+2   The ccosh functions compute the complex hyperbolic cosine of z.
+<b>    Returns</b>
+3   The ccosh functions return the complex hyperbolic cosine value.
+
+[<a name="p192" href="#p192">page 192</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.6.5" href="#7.3.6.5"><b>    7.3.6.5 The csinh functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex csinh(double complex z);
+            float complex csinhf(float complex z);
+            long double complex csinhl(long double complex z);
+<b>    Description</b>
+2   The csinh functions compute the complex hyperbolic sine of z.
+<b>    Returns</b>
+3   The csinh functions return the complex hyperbolic sine value.
+<a name="7.3.6.6" href="#7.3.6.6"><b>    7.3.6.6 The ctanh functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex ctanh(double complex z);
+            float complex ctanhf(float complex z);
+            long double complex ctanhl(long double complex z);
+<b>    Description</b>
+2   The ctanh functions compute the complex hyperbolic tangent of z.
+<b>    Returns</b>
+3   The ctanh functions return the complex hyperbolic tangent value.
+<a name="7.3.7" href="#7.3.7"><b>    7.3.7 Exponential and logarithmic functions</b></a>
+<a name="7.3.7.1" href="#7.3.7.1"><b>    7.3.7.1 The cexp functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex cexp(double complex z);
+            float complex cexpf(float complex z);
+            long double complex cexpl(long double complex z);
+<b>    Description</b>
+2   The cexp functions compute the complex base-e exponential of z.
+<b>    Returns</b>
+3   The cexp functions return the complex base-e exponential value.
+
+[<a name="p193" href="#p193">page 193</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.7.2" href="#7.3.7.2"><b>    7.3.7.2 The clog functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex clog(double complex z);
+           float complex clogf(float complex z);
+           long double complex clogl(long double complex z);
+<b>    Description</b>
+2   The clog functions compute the complex natural (base-e) logarithm of z, with a branch
+    cut along the negative real axis.
+<b>    Returns</b>
+3   The clog functions return the complex natural logarithm value, in the range of a strip
+    mathematically unbounded along the real axis and in the interval [-ipi , +ipi ] along the
+    imaginary axis.
+<a name="7.3.8" href="#7.3.8"><b>    7.3.8 Power and absolute-value functions</b></a>
+<a name="7.3.8.1" href="#7.3.8.1"><b>    7.3.8.1 The cabs functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double cabs(double complex z);
+           float cabsf(float complex z);
+           long double cabsl(long double complex z);
+<b>    Description</b>
+2   The cabs functions compute the complex absolute value (also called norm, modulus, or
+    magnitude) of z.
+<b>    Returns</b>
+3   The cabs functions return the complex absolute value.
+<a name="7.3.8.2" href="#7.3.8.2"><b>    7.3.8.2 The cpow functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex cpow(double complex x, double complex y);
+           float complex cpowf(float complex x, float complex y);
+           long double complex cpowl(long double complex x,
+                long double complex y);
+
+[<a name="p194" href="#p194">page 194</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The cpow functions compute the complex power function xy , with a branch cut for the
+    first parameter along the negative real axis.
+<b>    Returns</b>
+3   The cpow functions return the complex power function value.
+<a name="7.3.8.3" href="#7.3.8.3"><b>    7.3.8.3 The csqrt functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex csqrt(double complex z);
+            float complex csqrtf(float complex z);
+            long double complex csqrtl(long double complex z);
+<b>    Description</b>
+2   The csqrt functions compute the complex square root of z, with a branch cut along the
+    negative real axis.
+<b>    Returns</b>
+3   The csqrt functions return the complex square root value, in the range of the right half-
+    plane (including the imaginary axis).
+<a name="7.3.9" href="#7.3.9"><b>    7.3.9 Manipulation functions</b></a>
+<a name="7.3.9.1" href="#7.3.9.1"><b>    7.3.9.1 The carg functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double carg(double complex z);
+            float cargf(float complex z);
+            long double cargl(long double complex z);
+<b>    Description</b>
+2   The carg functions compute the argument (also called phase angle) of z, with a branch
+    cut along the negative real axis.
+<b>    Returns</b>
+3   The carg functions return the value of the argument in the interval [-pi , +pi ].
+
+[<a name="p195" href="#p195">page 195</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.9.2" href="#7.3.9.2"><b>    7.3.9.2 The cimag functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double cimag(double complex z);
+           float cimagf(float complex z);
+           long double cimagl(long double complex z);
+<b>    Description</b>
+2   The cimag functions compute the imaginary part of z.<sup><a href="#note196"><b>196)</b></a></sup>
+<b>    Returns</b>
+3   The cimag functions return the imaginary part value (as a real).
+<a name="7.3.9.3" href="#7.3.9.3"><b>    7.3.9.3 The CMPLX macros</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.3">&lt;complex.h&gt;</a>
+           double complex CMPLX(double x, double y);
+           float complex CMPLXF(float x, float y);
+           long double complex CMPLXL(long double x, long double y);
+<b>    Description</b>
+2   The CMPLX macros expand to an expression of the specified complex type, with the real
+    part having the (converted) value of x and the imaginary part having the (converted)
+    value of y.
+    Recommended practice
+3   The resulting expression should be suitable for use as an initializer for an object with
+    static or thread storage duration, provided both arguments are likewise suitable.
+<b>    Returns</b>
+4   The CMPLX macros return the complex value x + i y.
+5   NOTE    These macros act as if the implementation supported imaginary types and the definitions were:
+          #define CMPLX(x, y)  ((double complex)((double)(x) + \
+                                        _Imaginary_I * (double)(y)))
+          #define CMPLXF(x, y) ((float complex)((float)(x) + \
+                                        _Imaginary_I * (float)(y)))
+          #define CMPLXL(x, y) ((long double complex)((long double)(x) + \
+                                        _Imaginary_I * (long double)(y)))
+
+
+
+
+    <sup><a name="note196" href="#note196"><b>196)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+[<a name="p196" href="#p196">page 196</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.3.9.4" href="#7.3.9.4"><b>    7.3.9.4 The conj functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex conj(double complex z);
+            float complex conjf(float complex z);
+            long double complex conjl(long double complex z);
+<b>    Description</b>
+2   The conj functions compute the complex conjugate of z, by reversing the sign of its
+    imaginary part.
+<b>    Returns</b>
+3   The conj functions return the complex conjugate value.
+<a name="7.3.9.5" href="#7.3.9.5"><b>    7.3.9.5 The cproj functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double complex cproj(double complex z);
+            float complex cprojf(float complex z);
+            long double complex cprojl(long double complex z);
+<b>    Description</b>
+2   The cproj functions compute a projection of z onto the Riemann sphere: z projects to
+    z except that all complex infinities (even those with one infinite part and one NaN part)
+    project to positive infinity on the real axis. If z has an infinite part, then cproj(z) is
+    equivalent to
+            INFINITY + I * copysign(0.0, cimag(z))
+<b>    Returns</b>
+3   The cproj functions return the value of the projection onto the Riemann sphere.
+<a name="7.3.9.6" href="#7.3.9.6"><b>    7.3.9.6 The creal functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.3">&lt;complex.h&gt;</a>
+            double creal(double complex z);
+            float crealf(float complex z);
+            long double creall(long double complex z);
+<b>    Description</b>
+2   The creal functions compute the real part of z.<sup><a href="#note197"><b>197)</b></a></sup>
+
+[<a name="p197" href="#p197">page 197</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The creal functions return the real part value.
+
+
+
+
+    <sup><a name="note197" href="#note197"><b>197)</b></a></sup> For a variable z of complex type, z == creal(z) + cimag(z)*I.
+
+[<a name="p198" href="#p198">page 198</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.4" href="#7.4"><b>    7.4 Character handling &lt;ctype.h&gt;</b></a>
+1   The header <a href="#7.4">&lt;ctype.h&gt;</a> declares several functions useful for classifying and mapping
+    characters.<sup><a href="#note198"><b>198)</b></a></sup> In all cases the argument is an int, the value of which shall be
+    representable as an unsigned char or shall equal the value of the macro EOF. If the
+    argument has any other value, the behavior is undefined.
+2   The behavior of these functions is affected by the current locale. Those functions that
+    have locale-specific aspects only when not in the "C" locale are noted below.
+3   The term printing character refers to a member of a locale-specific set of characters, each
+    of which occupies one printing position on a display device; the term control character
+    refers to a member of a locale-specific set of characters that are not printing
+    characters.<sup><a href="#note199"><b>199)</b></a></sup> All letters and digits are printing characters.
+    Forward references: EOF (<a href="#7.21.1">7.21.1</a>), localization (<a href="#7.11">7.11</a>).
+<a name="7.4.1" href="#7.4.1"><b>    7.4.1 Character classification functions</b></a>
+1   The functions in this subclause return nonzero (true) if and only if the value of the
+    argument c conforms to that in the description of the function.
+<a name="7.4.1.1" href="#7.4.1.1"><b>    7.4.1.1 The isalnum function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
+             int isalnum(int c);
+<b>    Description</b>
+2   The isalnum function tests for any character for which isalpha or isdigit is true.
+<a name="7.4.1.2" href="#7.4.1.2"><b>    7.4.1.2 The isalpha function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.4">&lt;ctype.h&gt;</a>
+             int isalpha(int c);
+<b>    Description</b>
+2   The isalpha function tests for any character for which isupper or islower is true,
+    or any character that is one of a locale-specific set of alphabetic characters for which
+
+
+
+    <sup><a name="note198" href="#note198"><b>198)</b></a></sup> See ''future library directions'' (<a href="#7.30.2">7.30.2</a>).
+    <sup><a name="note199" href="#note199"><b>199)</b></a></sup> In an implementation that uses the seven-bit US ASCII character set, the printing characters are those
+         whose values lie from 0x20 (space) through 0x7E (tilde); the control characters are those whose
+         values lie from 0 (NUL) through 0x1F (US), and the character 0x7F (DEL).
+
+[<a name="p199" href="#p199">page 199</a>] (<a href="#Contents">Contents</a>)
+
+    none of iscntrl, isdigit, ispunct, or isspace is true.<sup><a href="#note200"><b>200)</b></a></sup> In the "C" locale,
+    isalpha returns true only for the characters for which isupper or islower is true.
+<a name="7.4.1.3" href="#7.4.1.3"><b>    7.4.1.3 The isblank function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isblank(int c);
+<b>    Description</b>
+2   The isblank function tests for any character that is a standard blank character or is one
+    of a locale-specific set of characters for which isspace is true and that is used to
+    separate words within a line of text. The standard blank characters are the following:
+    space (' '), and horizontal tab ('\t'). In the "C" locale, isblank returns true only
+    for the standard blank characters.
+<a name="7.4.1.4" href="#7.4.1.4"><b>    7.4.1.4 The iscntrl function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int iscntrl(int c);
+<b>    Description</b>
+2   The iscntrl function tests for any control character.
+<a name="7.4.1.5" href="#7.4.1.5"><b>    7.4.1.5 The isdigit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isdigit(int c);
+<b>    Description</b>
+2   The isdigit function tests for any decimal-digit character (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.4.1.6" href="#7.4.1.6"><b>    7.4.1.6 The isgraph function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isgraph(int c);
+
+
+
+
+    <sup><a name="note200" href="#note200"><b>200)</b></a></sup> The functions islower and isupper test true or false separately for each of these additional
+         characters; all four combinations are possible.
+
+[<a name="p200" href="#p200">page 200</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The isgraph function tests for any printing character except space (' ').
+<a name="7.4.1.7" href="#7.4.1.7"><b>    7.4.1.7 The islower function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int islower(int c);
+<b>    Description</b>
+2   The islower function tests for any character that is a lowercase letter or is one of a
+    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+    isspace is true. In the "C" locale, islower returns true only for the lowercase
+    letters (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.4.1.8" href="#7.4.1.8"><b>    7.4.1.8 The isprint function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isprint(int c);
+<b>    Description</b>
+2   The isprint function tests for any printing character including space (' ').
+<a name="7.4.1.9" href="#7.4.1.9"><b>    7.4.1.9 The ispunct function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int ispunct(int c);
+<b>    Description</b>
+2   The ispunct function tests for any printing character that is one of a locale-specific set
+    of punctuation characters for which neither isspace nor isalnum is true. In the "C"
+    locale, ispunct returns true for every printing character for which neither isspace
+    nor isalnum is true.
+<a name="7.4.1.10" href="#7.4.1.10"><b>    7.4.1.10 The isspace function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int isspace(int c);
+<b>    Description</b>
+2   The isspace function tests for any character that is a standard white-space character or
+    is one of a locale-specific set of characters for which isalnum is false. The standard
+
+[<a name="p201" href="#p201">page 201</a>] (<a href="#Contents">Contents</a>)
+
+    white-space characters are the following: space (' '), form feed ('\f'), new-line
+    ('\n'), carriage return ('\r'), horizontal tab ('\t'), and vertical tab ('\v'). In the
+    "C" locale, isspace returns true only for the standard white-space characters.
+<a name="7.4.1.11" href="#7.4.1.11"><b>    7.4.1.11 The isupper function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int isupper(int c);
+<b>    Description</b>
+2   The isupper function tests for any character that is an uppercase letter or is one of a
+    locale-specific set of characters for which none of iscntrl, isdigit, ispunct, or
+    isspace is true. In the "C" locale, isupper returns true only for the uppercase
+    letters (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.4.1.12" href="#7.4.1.12"><b>    7.4.1.12 The isxdigit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int isxdigit(int c);
+<b>    Description</b>
+2   The isxdigit function tests for any hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+<a name="7.4.2" href="#7.4.2"><b>    7.4.2 Character case mapping functions</b></a>
+<a name="7.4.2.1" href="#7.4.2.1"><b>    7.4.2.1 The tolower function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.4">&lt;ctype.h&gt;</a>
+           int tolower(int c);
+<b>    Description</b>
+2   The tolower function converts an uppercase letter to a corresponding lowercase letter.
+<b>    Returns</b>
+3   If the argument is a character for which isupper is true and there are one or more
+    corresponding characters, as specified by the current locale, for which islower is true,
+    the tolower function returns one of the corresponding characters (always the same one
+    for any given locale); otherwise, the argument is returned unchanged.
+
+[<a name="p202" href="#p202">page 202</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.4.2.2" href="#7.4.2.2"><b>    7.4.2.2 The toupper function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.4">&lt;ctype.h&gt;</a>
+            int toupper(int c);
+<b>    Description</b>
+2   The toupper function converts a lowercase letter to a corresponding uppercase letter.
+<b>    Returns</b>
+3   If the argument is a character for which islower is true and there are one or more
+    corresponding characters, as specified by the current locale, for which isupper is true,
+    the toupper function returns one of the corresponding characters (always the same one
+    for any given locale); otherwise, the argument is returned unchanged.
+
+[<a name="p203" href="#p203">page 203</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.5" href="#7.5"><b>    7.5 Errors &lt;errno.h&gt;</b></a>
+1   The header <a href="#7.5">&lt;errno.h&gt;</a> defines several macros, all relating to the reporting of error
+    conditions.
+2   The macros are
+             EDOM
+             EILSEQ
+             ERANGE
+    which expand to integer constant expressions with type int, distinct positive values, and
+    which are suitable for use in #if preprocessing directives; and
+             errno
+    which expands to a modifiable lvalue<sup><a href="#note201"><b>201)</b></a></sup> that has type int and thread local storage
+    duration, the value of which is set to a positive error number by several library functions.
+    If a macro definition is suppressed in order to access an actual object, or a program
+    defines an identifier with the name errno, the behavior is undefined.
+3   The value of errno in the initial thread is zero at program startup (the initial value of
+    errno in other threads is an indeterminate value), but is never set to zero by any library
+    function.<sup><a href="#note202"><b>202)</b></a></sup> The value of errno may be set to nonzero by a library function call
+    whether or not there is an error, provided the use of errno is not documented in the
+    description of the function in this International Standard.
+4   Additional macro definitions, beginning with E and a digit or E and an uppercase
+    letter,<sup><a href="#note203"><b>203)</b></a></sup> may also be specified by the implementation.
+
+
+
+
+    <sup><a name="note201" href="#note201"><b>201)</b></a></sup> The macro errno need not be the identifier of an object. It might expand to a modifiable lvalue
+         resulting from a function call (for example, *errno()).
+    <sup><a name="note202" href="#note202"><b>202)</b></a></sup> Thus, a program that uses errno for error checking should set it to zero before a library function call,
+         then inspect it before a subsequent library function call. Of course, a library function can save the
+         value of errno on entry and then set it to zero, as long as the original value is restored if errno's
+         value is still zero just before the return.
+    <sup><a name="note203" href="#note203"><b>203)</b></a></sup> See ''future library directions'' (<a href="#7.30.3">7.30.3</a>).
+
+[<a name="p204" href="#p204">page 204</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.6" href="#7.6"><b>    7.6 Floating-point environment &lt;fenv.h&gt;</b></a>
+1   The header <a href="#7.6">&lt;fenv.h&gt;</a> defines several macros, and declares types and functions that
+    provide access to the floating-point environment. The floating-point environment refers
+    collectively to any floating-point status flags and control modes supported by the
+    implementation.<sup><a href="#note204"><b>204)</b></a></sup> A floating-point status flag is a system variable whose value is set
+    (but never cleared) when a floating-point exception is raised, which occurs as a side effect
+    of exceptional floating-point arithmetic to provide auxiliary information.<sup><a href="#note205"><b>205)</b></a></sup> A floating-
+    point control mode is a system variable whose value may be set by the user to affect the
+    subsequent behavior of floating-point arithmetic.
+2   The floating-point environment has thread storage duration. The initial state for a
+    thread's floating-point environment is the current state of the floating-point environment
+    of the thread that creates it at the time of creation.
+3   Certain programming conventions support the intended model of use for the floating-
+    point environment:<sup><a href="#note206"><b>206)</b></a></sup>
+    -- a function call does not alter its caller's floating-point control modes, clear its caller's
+      floating-point status flags, nor depend on the state of its caller's floating-point status
+      flags unless the function is so documented;
+    -- a function call is assumed to require default floating-point control modes, unless its
+      documentation promises otherwise;
+    -- a function call is assumed to have the potential for raising floating-point exceptions,
+      unless its documentation promises otherwise.
+4   The type
+            fenv_t
+    represents the entire floating-point environment.
+5   The type
+            fexcept_t
+    represents the floating-point status flags collectively, including any status the
+    implementation associates with the flags.
+
+
+    <sup><a name="note204" href="#note204"><b>204)</b></a></sup> This header is designed to support the floating-point exception status flags and directed-rounding
+         control modes required by IEC 60559, and other similar floating-point state information. It is also
+         designed to facilitate code portability among all systems.
+    <sup><a name="note205" href="#note205"><b>205)</b></a></sup> A floating-point status flag is not an object and can be set more than once within an expression.
+    <sup><a name="note206" href="#note206"><b>206)</b></a></sup> With these conventions, a programmer can safely assume default floating-point control modes (or be
+         unaware of them). The responsibilities associated with accessing the floating-point environment fall
+         on the programmer or program that does so explicitly.
+
+[<a name="p205" href="#p205">page 205</a>] (<a href="#Contents">Contents</a>)
+
+6   Each of the macros
+             FE_DIVBYZERO
+             FE_INEXACT
+             FE_INVALID
+             FE_OVERFLOW
+             FE_UNDERFLOW
+    is defined if and only if the implementation supports the floating-point exception by
+    means of the functions in 7.6.2.<sup><a href="#note207"><b>207)</b></a></sup> Additional implementation-defined floating-point
+    exceptions, with macro definitions beginning with FE_ and an uppercase letter, may also
+    be specified by the implementation. The defined macros expand to integer constant
+    expressions with values such that bitwise ORs of all combinations of the macros result in
+    distinct values, and furthermore, bitwise ANDs of all combinations of the macros result in
+    zero.<sup><a href="#note208"><b>208)</b></a></sup>
+7   The macro
+             FE_ALL_EXCEPT
+    is simply the bitwise OR of all floating-point exception macros defined by the
+    implementation. If no such macros are defined, FE_ALL_EXCEPT shall be defined as 0.
+8   Each of the macros
+             FE_DOWNWARD
+             FE_TONEAREST
+             FE_TOWARDZERO
+             FE_UPWARD
+    is defined if and only if the implementation supports getting and setting the represented
+    rounding direction by means of the fegetround and fesetround functions.
+    Additional implementation-defined rounding directions, with macro definitions beginning
+    with FE_ and an uppercase letter, may also be specified by the implementation. The
+    defined macros expand to integer constant expressions whose values are distinct
+    nonnegative values.<sup><a href="#note209"><b>209)</b></a></sup>
+9   The macro
+
+
+
+    <sup><a name="note207" href="#note207"><b>207)</b></a></sup> The implementation supports a floating-point exception if there are circumstances where a call to at
+         least one of the functions in <a href="#7.6.2">7.6.2</a>, using the macro as the appropriate argument, will succeed. It is not
+         necessary for all the functions to succeed all the time.
+    <sup><a name="note208" href="#note208"><b>208)</b></a></sup> The macros should be distinct powers of two.
+    <sup><a name="note209" href="#note209"><b>209)</b></a></sup> Even though the rounding direction macros may expand to constants corresponding to the values of
+         FLT_ROUNDS, they are not required to do so.
+
+[<a name="p206" href="#p206">page 206</a>] (<a href="#Contents">Contents</a>)
+
+              FE_DFL_ENV
+     represents the default floating-point environment -- the one installed at program startup
+     -- and has type ''pointer to const-qualified fenv_t''. It can be used as an argument to
+     <a href="#7.6">&lt;fenv.h&gt;</a> functions that manage the floating-point environment.
+10   Additional implementation-defined environments, with macro definitions beginning with
+     FE_ and an uppercase letter, and having type ''pointer to const-qualified fenv_t'', may
+     also be specified by the implementation.
+<a name="7.6.1" href="#7.6.1"><b>     7.6.1 The FENV_ACCESS pragma</b></a>
+<b>     Synopsis</b>
+1             #include <a href="#7.6">&lt;fenv.h&gt;</a>
+              #pragma STDC FENV_ACCESS on-off-switch
+<b>     Description</b>
+2    The FENV_ACCESS pragma provides a means to inform the implementation when a
+     program might access the floating-point environment to test floating-point status flags or
+     run under non-default floating-point control modes.<sup><a href="#note210"><b>210)</b></a></sup> The pragma shall occur either
+     outside external declarations or preceding all explicit declarations and statements inside a
+     compound statement. When outside external declarations, the pragma takes effect from
+     its occurrence until another FENV_ACCESS pragma is encountered, or until the end of
+     the translation unit. When inside a compound statement, the pragma takes effect from its
+     occurrence until another FENV_ACCESS pragma is encountered (including within a
+     nested compound statement), or until the end of the compound statement; at the end of a
+     compound statement the state for the pragma is restored to its condition just before the
+     compound statement. If this pragma is used in any other context, the behavior is
+     undefined. If part of a program tests floating-point status flags, sets floating-point control
+     modes, or runs under non-default mode settings, but was translated with the state for the
+     FENV_ACCESS pragma ''off'', the behavior is undefined. The default state (''on'' or
+     ''off'') for the pragma is implementation-defined. (When execution passes from a part of
+     the program translated with FENV_ACCESS ''off'' to a part translated with
+     FENV_ACCESS ''on'', the state of the floating-point status flags is unspecified and the
+     floating-point control modes have their default settings.)
+
+
+
+
+     <sup><a name="note210" href="#note210"><b>210)</b></a></sup> The purpose of the FENV_ACCESS pragma is to allow certain optimizations that could subvert flag
+          tests and mode changes (e.g., global common subexpression elimination, code motion, and constant
+          folding). In general, if the state of FENV_ACCESS is ''off'', the translator can assume that default
+          modes are in effect and the flags are not tested.
+
+[<a name="p207" href="#p207">page 207</a>] (<a href="#Contents">Contents</a>)
+
+3   EXAMPLE
+            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            void f(double x)
+            {
+                  #pragma STDC FENV_ACCESS ON
+                  void g(double);
+                  void h(double);
+                  /* ... */
+                  g(x + 1);
+                  h(x + 1);
+                  /* ... */
+            }
+4   If the function g might depend on status flags set as a side effect of the first x + 1, or if the second
+    x + 1 might depend on control modes set as a side effect of the call to function g, then the program shall
+    contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note211"><b>211)</b></a></sup>
+
+<a name="7.6.2" href="#7.6.2"><b>    7.6.2 Floating-point exceptions</b></a>
+1   The following functions provide access to the floating-point status flags.<sup><a href="#note212"><b>212)</b></a></sup> The int
+    input argument for the functions represents a subset of floating-point exceptions, and can
+    be zero or the bitwise OR of one or more floating-point exception macros, for example
+    FE_OVERFLOW | FE_INEXACT. For other argument values the behavior of these
+    functions is undefined.
+<a name="7.6.2.1" href="#7.6.2.1"><b>    7.6.2.1 The feclearexcept function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int feclearexcept(int excepts);
+<b>    Description</b>
+2   The feclearexcept function attempts to clear the supported floating-point exceptions
+    represented by its argument.
+<b>    Returns</b>
+3   The feclearexcept function returns zero if the excepts argument is zero or if all
+    the specified exceptions were successfully cleared. Otherwise, it returns a nonzero value.
+
+
+    <sup><a name="note211" href="#note211"><b>211)</b></a></sup> The side effects impose a temporal ordering that requires two evaluations of x + 1. On the other
+         hand, without the #pragma STDC FENV_ACCESS ON pragma, and assuming the default state is
+         ''off'', just one evaluation of x + 1 would suffice.
+    <sup><a name="note212" href="#note212"><b>212)</b></a></sup> The functions fetestexcept, feraiseexcept, and feclearexcept support the basic
+         abstraction of flags that are either set or clear. An implementation may endow floating-point status
+         flags with more information -- for example, the address of the code which first raised the floating-
+         point exception; the functions fegetexceptflag and fesetexceptflag deal with the full
+         content of flags.
+
+[<a name="p208" href="#p208">page 208</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.6.2.2" href="#7.6.2.2"><b>    7.6.2.2 The fegetexceptflag function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             int fegetexceptflag(fexcept_t *flagp,
+                  int excepts);
+<b>    Description</b>
+2   The fegetexceptflag function attempts to store an implementation-defined
+    representation of the states of the floating-point status flags indicated by the argument
+    excepts in the object pointed to by the argument flagp.
+<b>    Returns</b>
+3   The fegetexceptflag function returns zero if the representation was successfully
+    stored. Otherwise, it returns a nonzero value.
+<a name="7.6.2.3" href="#7.6.2.3"><b>    7.6.2.3 The feraiseexcept function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             int feraiseexcept(int excepts);
+<b>    Description</b>
+2   The feraiseexcept function attempts to raise the supported floating-point exceptions
+    represented by its argument.<sup><a href="#note213"><b>213)</b></a></sup> The order in which these floating-point exceptions are
+    raised is unspecified, except as stated in <a href="#F.8.6">F.8.6</a>. Whether the feraiseexcept function
+    additionally raises the ''inexact'' floating-point exception whenever it raises the
+    ''overflow'' or ''underflow'' floating-point exception is implementation-defined.
+<b>    Returns</b>
+3   The feraiseexcept function returns zero if the excepts argument is zero or if all
+    the specified exceptions were successfully raised. Otherwise, it returns a nonzero value.
+
+
+
+
+    <sup><a name="note213" href="#note213"><b>213)</b></a></sup> The effect is intended to be similar to that of floating-point exceptions raised by arithmetic operations.
+         Hence, enabled traps for floating-point exceptions raised by this function are taken. The specification
+         in <a href="#F.8.6">F.8.6</a> is in the same spirit.
+
+[<a name="p209" href="#p209">page 209</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.6.2.4" href="#7.6.2.4"><b>    7.6.2.4 The fesetexceptflag function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fesetexceptflag(const fexcept_t *flagp,
+                 int excepts);
+<b>    Description</b>
+2   The fesetexceptflag function attempts to set the floating-point status flags
+    indicated by the argument excepts to the states stored in the object pointed to by
+    flagp. The value of *flagp shall have been set by a previous call to
+    fegetexceptflag whose second argument represented at least those floating-point
+    exceptions represented by the argument excepts. This function does not raise floating-
+    point exceptions, but only sets the state of the flags.
+<b>    Returns</b>
+3   The fesetexceptflag function returns zero if the excepts argument is zero or if
+    all the specified flags were successfully set to the appropriate state. Otherwise, it returns
+    a nonzero value.
+<a name="7.6.2.5" href="#7.6.2.5"><b>    7.6.2.5 The fetestexcept function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fetestexcept(int excepts);
+<b>    Description</b>
+2   The fetestexcept function determines which of a specified subset of the floating-
+    point exception flags are currently set. The excepts argument specifies the floating-
+    point status flags to be queried.<sup><a href="#note214"><b>214)</b></a></sup>
+<b>    Returns</b>
+3   The fetestexcept function returns the value of the bitwise OR of the floating-point
+    exception macros corresponding to the currently set floating-point exceptions included in
+    excepts.
+4   EXAMPLE       Call f if ''invalid'' is set, then g if ''overflow'' is set:
+
+
+
+
+    <sup><a name="note214" href="#note214"><b>214)</b></a></sup> This mechanism allows testing several floating-point exceptions with just one function call.
+
+[<a name="p210" href="#p210">page 210</a>] (<a href="#Contents">Contents</a>)
+
+            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            /* ... */
+            {
+                    #pragma STDC FENV_ACCESS ON
+                    int set_excepts;
+                    feclearexcept(FE_INVALID | FE_OVERFLOW);
+                    // maybe raise exceptions
+                    set_excepts = fetestexcept(FE_INVALID | FE_OVERFLOW);
+                    if (set_excepts &amp; FE_INVALID) f();
+                    if (set_excepts &amp; FE_OVERFLOW) g();
+                    /* ... */
+            }
+
+<a name="7.6.3" href="#7.6.3"><b>    7.6.3 Rounding</b></a>
+1   The fegetround and fesetround functions provide control of rounding direction
+    modes.
+<a name="7.6.3.1" href="#7.6.3.1"><b>    7.6.3.1 The fegetround function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fegetround(void);
+<b>    Description</b>
+2   The fegetround function gets the current rounding direction.
+<b>    Returns</b>
+3   The fegetround function returns the value of the rounding direction macro
+    representing the current rounding direction or a negative value if there is no such
+    rounding direction macro or the current rounding direction is not determinable.
+<a name="7.6.3.2" href="#7.6.3.2"><b>    7.6.3.2 The fesetround function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fesetround(int round);
+<b>    Description</b>
+2   The fesetround function establishes the rounding direction represented by its
+    argument round. If the argument is not equal to the value of a rounding direction macro,
+    the rounding direction is not changed.
+<b>    Returns</b>
+3   The fesetround function returns zero if and only if the requested rounding direction
+    was established.
+
+[<a name="p211" href="#p211">page 211</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE Save, set, and restore the rounding direction. Report an error and abort if setting the
+    rounding direction fails.
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           #include <a href="#7.2">&lt;assert.h&gt;</a>
+           void f(int round_dir)
+           {
+                 #pragma STDC FENV_ACCESS ON
+                 int save_round;
+                 int setround_ok;
+                 save_round = fegetround();
+                 setround_ok = fesetround(round_dir);
+                 assert(setround_ok == 0);
+                 /* ... */
+                 fesetround(save_round);
+                 /* ... */
+           }
+
+<a name="7.6.4" href="#7.6.4"><b>    7.6.4 Environment</b></a>
+1   The functions in this section manage the floating-point environment -- status flags and
+    control modes -- as one entity.
+<a name="7.6.4.1" href="#7.6.4.1"><b>    7.6.4.1 The fegetenv function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           int fegetenv(fenv_t *envp);
+<b>    Description</b>
+2   The fegetenv function attempts to store the current floating-point environment in the
+    object pointed to by envp.
+<b>    Returns</b>
+3   The fegetenv function returns zero if the environment was successfully stored.
+    Otherwise, it returns a nonzero value.
+<a name="7.6.4.2" href="#7.6.4.2"><b>    7.6.4.2 The feholdexcept function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           int feholdexcept(fenv_t *envp);
+<b>    Description</b>
+2   The feholdexcept function saves the current floating-point environment in the object
+    pointed to by envp, clears the floating-point status flags, and then installs a non-stop
+    (continue on floating-point exceptions) mode, if available, for all floating-point
+    exceptions.<sup><a href="#note215"><b>215)</b></a></sup>
+
+[<a name="p212" href="#p212">page 212</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The feholdexcept function returns zero if and only if non-stop floating-point
+    exception handling was successfully installed.
+<a name="7.6.4.3" href="#7.6.4.3"><b>    7.6.4.3 The fesetenv function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int fesetenv(const fenv_t *envp);
+<b>    Description</b>
+2   The fesetenv function attempts to establish the floating-point environment represented
+    by the object pointed to by envp. The argument envp shall point to an object set by a
+    call to fegetenv or feholdexcept, or equal a floating-point environment macro.
+    Note that fesetenv merely installs the state of the floating-point status flags
+    represented through its argument, and does not raise these floating-point exceptions.
+<b>    Returns</b>
+3   The fesetenv function returns zero if the environment was successfully established.
+    Otherwise, it returns a nonzero value.
+<a name="7.6.4.4" href="#7.6.4.4"><b>    7.6.4.4 The feupdateenv function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            int feupdateenv(const fenv_t *envp);
+<b>    Description</b>
+2   The feupdateenv function attempts to save the currently raised floating-point
+    exceptions in its automatic storage, install the floating-point environment represented by
+    the object pointed to by envp, and then raise the saved floating-point exceptions. The
+    argument envp shall point to an object set by a call to feholdexcept or fegetenv,
+    or equal a floating-point environment macro.
+<b>    Returns</b>
+3   The feupdateenv function returns zero if all the actions were successfully carried out.
+    Otherwise, it returns a nonzero value.
+
+
+
+
+    <sup><a name="note215" href="#note215"><b>215)</b></a></sup> IEC 60559 systems have a default non-stop mode, and typically at least one other mode for trap
+         handling or aborting; if the system provides only the non-stop mode then installing it is trivial. For
+         such systems, the feholdexcept function can be used in conjunction with the feupdateenv
+         function to write routines that hide spurious floating-point exceptions from their callers.
+
+[<a name="p213" href="#p213">page 213</a>] (<a href="#Contents">Contents</a>)
+
+4   EXAMPLE   Hide spurious underflow floating-point exceptions:
+          #include <a href="#7.6">&lt;fenv.h&gt;</a>
+          double f(double x)
+          {
+                #pragma STDC FENV_ACCESS ON
+                double result;
+                fenv_t save_env;
+                if (feholdexcept(&amp;save_env))
+                      return /* indication of an environmental problem */;
+                // compute result
+                if (/* test spurious underflow */)
+                      if (feclearexcept(FE_UNDERFLOW))
+                               return /* indication of an environmental problem */;
+                if (feupdateenv(&amp;save_env))
+                      return /* indication of an environmental problem */;
+                return result;
+          }
+
+[<a name="p214" href="#p214">page 214</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.7" href="#7.7"><b>    7.7 Characteristics of floating types &lt;float.h&gt;</b></a>
+1   The header <a href="#7.7">&lt;float.h&gt;</a> defines several macros that expand to various limits and
+    parameters of the standard floating-point types.
+2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
+    in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+
+[<a name="p215" href="#p215">page 215</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.8" href="#7.8"><b>    7.8 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
+1   The header <a href="#7.8">&lt;inttypes.h&gt;</a> includes the header <a href="#7.20">&lt;stdint.h&gt;</a> and extends it with
+    additional facilities provided by hosted implementations.
+2   It declares functions for manipulating greatest-width integers and converting numeric
+    character strings to greatest-width integers, and it declares the type
+             imaxdiv_t
+    which is a structure type that is the type of the value returned by the imaxdiv function.
+    For each type declared in <a href="#7.20">&lt;stdint.h&gt;</a>, it defines corresponding macros for conversion
+    specifiers for use with the formatted input/output functions.<sup><a href="#note216"><b>216)</b></a></sup>
+    Forward references: integer types <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#7.20">7.20</a>), formatted input/output
+    functions (<a href="#7.21.6">7.21.6</a>), formatted wide character input/output functions (<a href="#7.28.2">7.28.2</a>).
+<a name="7.8.1" href="#7.8.1"><b>    7.8.1 Macros for format specifiers</b></a>
+1   Each of the following object-like macros expands to a character string literal containing a *
+    conversion specifier, possibly modified by a length modifier, suitable for use within the
+    format argument of a formatted input/output function when converting the corresponding
+    integer type. These macro names have the general form of PRI (character string literals
+    for the fprintf and fwprintf family) or SCN (character string literals for the
+    fscanf and fwscanf family),<sup><a href="#note217"><b>217)</b></a></sup> followed by the conversion specifier, followed by a
+    name corresponding to a similar type name in <a href="#7.20.1">7.20.1</a>. In these names, N represents the
+    width of the type as described in <a href="#7.20.1">7.20.1</a>. For example, PRIdFAST32 can be used in a
+    format string to print the value of an integer of type int_fast32_t.
+2   The fprintf macros for signed integers are:
+           PRIdN             PRIdLEASTN                PRIdFASTN          PRIdMAX             PRIdPTR
+           PRIiN             PRIiLEASTN                PRIiFASTN          PRIiMAX             PRIiPTR
+3   The fprintf macros for unsigned integers are:
+           PRIoN             PRIoLEASTN                PRIoFASTN          PRIoMAX             PRIoPTR
+           PRIuN             PRIuLEASTN                PRIuFASTN          PRIuMAX             PRIuPTR
+           PRIxN             PRIxLEASTN                PRIxFASTN          PRIxMAX             PRIxPTR
+           PRIXN             PRIXLEASTN                PRIXFASTN          PRIXMAX             PRIXPTR
+4   The fscanf macros for signed integers are:
+
+
+
+    <sup><a name="note216" href="#note216"><b>216)</b></a></sup> See ''future library directions'' (<a href="#7.30.4">7.30.4</a>).
+    <sup><a name="note217" href="#note217"><b>217)</b></a></sup> Separate macros are given for use with fprintf and fscanf functions because, in the general case,
+         different format specifiers may be required for fprintf and fscanf, even when the type is the
+         same.
+
+[<a name="p216" href="#p216">page 216</a>] (<a href="#Contents">Contents</a>)
+
+           SCNdN           SCNdLEASTN               SCNdFASTN              SCNdMAX             SCNdPTR
+           SCNiN           SCNiLEASTN               SCNiFASTN              SCNiMAX             SCNiPTR
+5   The fscanf macros for unsigned integers are:
+           SCNoN           SCNoLEASTN               SCNoFASTN              SCNoMAX             SCNoPTR
+           SCNuN           SCNuLEASTN               SCNuFASTN              SCNuMAX             SCNuPTR
+           SCNxN           SCNxLEASTN               SCNxFASTN              SCNxMAX             SCNxPTR
+6   For each type that the implementation provides in <a href="#7.20">&lt;stdint.h&gt;</a>, the corresponding
+    fprintf macros shall be defined and the corresponding fscanf macros shall be
+    defined unless the implementation does not have a suitable fscanf length modifier for
+    the type.
+7   EXAMPLE
+            #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int main(void)
+            {
+                  uintmax_t i = UINTMAX_MAX;    // this type always exists
+                  wprintf(L"The largest integer value is %020"
+                        PRIxMAX "\n", i);
+                  return 0;
+            }
+
+<a name="7.8.2" href="#7.8.2"><b>    7.8.2 Functions for greatest-width integer types</b></a>
+<a name="7.8.2.1" href="#7.8.2.1"><b>    7.8.2.1 The imaxabs function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+            intmax_t imaxabs(intmax_t j);
+<b>    Description</b>
+2   The imaxabs function computes the absolute value of an integer j. If the result cannot
+    be represented, the behavior is undefined.<sup><a href="#note218"><b>218)</b></a></sup>
+<b>    Returns</b>
+3   The imaxabs function returns the absolute value.
+
+
+
+
+    <sup><a name="note218" href="#note218"><b>218)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
+
+[<a name="p217" href="#p217">page 217</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.8.2.2" href="#7.8.2.2"><b>    7.8.2.2 The imaxdiv function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+           imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+<b>    Description</b>
+2   The imaxdiv function computes numer / denom and numer % denom in a single
+    operation.
+<b>    Returns</b>
+3   The imaxdiv function returns a structure of type imaxdiv_t comprising both the
+    quotient and the remainder. The structure shall contain (in either order) the members
+    quot (the quotient) and rem (the remainder), each of which has type intmax_t. If
+    either part of the result cannot be represented, the behavior is undefined.
+<a name="7.8.2.3" href="#7.8.2.3"><b>    7.8.2.3 The strtoimax and strtoumax functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+           intmax_t strtoimax(const char * restrict nptr,
+                char ** restrict endptr, int base);
+           uintmax_t strtoumax(const char * restrict nptr,
+                char ** restrict endptr, int base);
+<b>    Description</b>
+2   The strtoimax and strtoumax functions are equivalent to the strtol, strtoll,
+    strtoul, and strtoull functions, except that the initial portion of the string is
+    converted to intmax_t and uintmax_t representation, respectively.
+<b>    Returns</b>
+3   The strtoimax and strtoumax functions return the converted value, if any. If no
+    conversion could be performed, zero is returned. If the correct value is outside the range
+    of representable values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned
+    (according to the return type and sign of the value, if any), and the value of the macro
+    ERANGE is stored in errno.
+    Forward references: the strtol, strtoll, strtoul, and strtoull functions
+    (<a href="#7.22.1.4">7.22.1.4</a>).
+
+[<a name="p218" href="#p218">page 218</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.8.2.4" href="#7.8.2.4"><b>    7.8.2.4 The wcstoimax and wcstoumax functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.19">&lt;stddef.h&gt;</a>           // for wchar_t
+            #include <a href="#7.8">&lt;inttypes.h&gt;</a>
+            intmax_t wcstoimax(const wchar_t * restrict nptr,
+                 wchar_t ** restrict endptr, int base);
+            uintmax_t wcstoumax(const wchar_t * restrict nptr,
+                 wchar_t ** restrict endptr, int base);
+<b>    Description</b>
+2   The wcstoimax and wcstoumax functions are equivalent to the wcstol, wcstoll,
+    wcstoul, and wcstoull functions except that the initial portion of the wide string is
+    converted to intmax_t and uintmax_t representation, respectively.
+<b>    Returns</b>
+3   The wcstoimax function returns the converted value, if any. If no conversion could be
+    performed, zero is returned. If the correct value is outside the range of representable
+    values, INTMAX_MAX, INTMAX_MIN, or UINTMAX_MAX is returned (according to the
+    return type and sign of the value, if any), and the value of the macro ERANGE is stored in
+    errno.
+    Forward references: the wcstol, wcstoll, wcstoul, and wcstoull functions
+    (<a href="#7.28.4.1.2">7.28.4.1.2</a>).
+
+[<a name="p219" href="#p219">page 219</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.9" href="#7.9"><b>    7.9 Alternative spellings &lt;iso646.h&gt;</b></a>
+1   The header <a href="#7.9">&lt;iso646.h&gt;</a> defines the following eleven macros (on the left) that expand
+    to the corresponding tokens (on the right):
+          and           &amp;&amp;
+          and_eq        &amp;=
+          bitand        &amp;
+          bitor         |
+          compl         ~
+          not           !
+          not_eq        !=
+          or            ||
+          or_eq         |=
+          xor           ^
+          xor_eq        ^=
+
+[<a name="p220" href="#p220">page 220</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.10" href="#7.10"><b>    7.10 Sizes of integer types &lt;limits.h&gt;</b></a>
+1   The header <a href="#7.10">&lt;limits.h&gt;</a> defines several macros that expand to various limits and
+    parameters of the standard integer types.
+2   The macros, their meanings, and the constraints (or restrictions) on their values are listed
+    in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+
+[<a name="p221" href="#p221">page 221</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.11" href="#7.11"><b>    7.11 Localization &lt;locale.h&gt;</b></a>
+1   The header <a href="#7.11">&lt;locale.h&gt;</a> declares two functions, one type, and defines several macros.
+2   The type is
+           struct lconv
+    which contains members related to the formatting of numeric values. The structure shall
+    contain at least the following members, in any order. The semantics of the members and
+    their normal ranges are explained in <a href="#7.11.2.1">7.11.2.1</a>. In the "C" locale, the members shall have
+    the values specified in the comments.
+           char   *decimal_point;                 //   "."
+           char   *thousands_sep;                 //   ""
+           char   *grouping;                      //   ""
+           char   *mon_decimal_point;             //   ""
+           char   *mon_thousands_sep;             //   ""
+           char   *mon_grouping;                  //   ""
+           char   *positive_sign;                 //   ""
+           char   *negative_sign;                 //   ""
+           char   *currency_symbol;               //   ""
+           char   frac_digits;                    //   CHAR_MAX
+           char   p_cs_precedes;                  //   CHAR_MAX
+           char   n_cs_precedes;                  //   CHAR_MAX
+           char   p_sep_by_space;                 //   CHAR_MAX
+           char   n_sep_by_space;                 //   CHAR_MAX
+           char   p_sign_posn;                    //   CHAR_MAX
+           char   n_sign_posn;                    //   CHAR_MAX
+           char   *int_curr_symbol;               //   ""
+           char   int_frac_digits;                //   CHAR_MAX
+           char   int_p_cs_precedes;              //   CHAR_MAX
+           char   int_n_cs_precedes;              //   CHAR_MAX
+           char   int_p_sep_by_space;             //   CHAR_MAX
+           char   int_n_sep_by_space;             //   CHAR_MAX
+           char   int_p_sign_posn;                //   CHAR_MAX
+           char   int_n_sign_posn;                //   CHAR_MAX
+
+[<a name="p222" href="#p222">page 222</a>] (<a href="#Contents">Contents</a>)
+
+3   The macros defined are NULL (described in <a href="#7.19">7.19</a>); and
+             LC_ALL
+             LC_COLLATE
+             LC_CTYPE
+             LC_MONETARY
+             LC_NUMERIC
+             LC_TIME
+    which expand to integer constant expressions with distinct values, suitable for use as the
+    first argument to the setlocale function.<sup><a href="#note219"><b>219)</b></a></sup> Additional macro definitions, beginning
+    with the characters LC_ and an uppercase letter,<sup><a href="#note220"><b>220)</b></a></sup> may also be specified by the
+    implementation.
+<a name="7.11.1" href="#7.11.1"><b>    7.11.1 Locale control</b></a>
+<a name="7.11.1.1" href="#7.11.1.1"><b>    7.11.1.1 The setlocale function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.11">&lt;locale.h&gt;</a>
+             char *setlocale(int category, const char *locale);
+<b>    Description</b>
+2   The setlocale function selects the appropriate portion of the program's locale as
+    specified by the category and locale arguments. The setlocale function may be
+    used to change or query the program's entire current locale or portions thereof. The value
+    LC_ALL for category names the program's entire locale; the other values for
+    category name only a portion of the program's locale. LC_COLLATE affects the
+    behavior of the strcoll and strxfrm functions. LC_CTYPE affects the behavior of
+    the character handling functions<sup><a href="#note221"><b>221)</b></a></sup> and the multibyte and wide character functions.
+    LC_MONETARY affects the monetary formatting information returned by the
+    localeconv function. LC_NUMERIC affects the decimal-point character for the
+    formatted input/output functions and the string conversion functions, as well as the
+    nonmonetary formatting information returned by the localeconv function. LC_TIME
+    affects the behavior of the strftime and wcsftime functions.
+3   A value of "C" for locale specifies the minimal environment for C translation; a value
+    of "" for locale specifies the locale-specific native environment. Other
+    implementation-defined strings may be passed as the second argument to setlocale.
+
+    <sup><a name="note219" href="#note219"><b>219)</b></a></sup> ISO/IEC 9945-2 specifies locale and charmap formats that may be used to specify locales for C.
+    <sup><a name="note220" href="#note220"><b>220)</b></a></sup> See ''future library directions'' (<a href="#7.30.5">7.30.5</a>).
+    <sup><a name="note221" href="#note221"><b>221)</b></a></sup> The only functions in <a href="#7.4">7.4</a> whose behavior is not affected by the current locale are isdigit and
+         isxdigit.
+
+[<a name="p223" href="#p223">page 223</a>] (<a href="#Contents">Contents</a>)
+
+4   At program startup, the equivalent of
+            setlocale(LC_ALL, "C");
+    is executed.
+5   A call to the setlocale function may introduce a data race with other calls to the
+    setlocale function or with calls to functions that are affected by the current locale.
+    The implementation shall behave as if no library function calls the setlocale function.
+<b>    Returns</b>
+6   If a pointer to a string is given for locale and the selection can be honored, the
+    setlocale function returns a pointer to the string associated with the specified
+    category for the new locale. If the selection cannot be honored, the setlocale
+    function returns a null pointer and the program's locale is not changed.
+7   A null pointer for locale causes the setlocale function to return a pointer to the
+    string associated with the category for the program's current locale; the program's
+    locale is not changed.<sup><a href="#note222"><b>222)</b></a></sup>
+8   The pointer to string returned by the setlocale function is such that a subsequent call
+    with that string value and its associated category will restore that part of the program's
+    locale. The string pointed to shall not be modified by the program, but may be
+    overwritten by a subsequent call to the setlocale function.
+    Forward references: formatted input/output functions (<a href="#7.21.6">7.21.6</a>), multibyte/wide
+    character conversion functions (<a href="#7.22.7">7.22.7</a>), multibyte/wide string conversion functions
+    (<a href="#7.22.8">7.22.8</a>), numeric conversion functions (<a href="#7.22.1">7.22.1</a>), the strcoll function (<a href="#7.23.4.3">7.23.4.3</a>), the
+    strftime function (<a href="#7.26.3.5">7.26.3.5</a>), the strxfrm function (<a href="#7.23.4.5">7.23.4.5</a>).
+<a name="7.11.2" href="#7.11.2"><b>    7.11.2 Numeric formatting convention inquiry</b></a>
+<a name="7.11.2.1" href="#7.11.2.1"><b>    7.11.2.1 The localeconv function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.11">&lt;locale.h&gt;</a>
+            struct lconv *localeconv(void);
+<b>    Description</b>
+2   The localeconv function sets the components of an object with type struct lconv
+    with values appropriate for the formatting of numeric quantities (monetary and otherwise)
+    according to the rules of the current locale.
+
+
+
+    <sup><a name="note222" href="#note222"><b>222)</b></a></sup> The implementation shall arrange to encode in a string the various categories due to a heterogeneous
+         locale when category has the value LC_ALL.
+
+[<a name="p224" href="#p224">page 224</a>] (<a href="#Contents">Contents</a>)
+
+3   The members of the structure with type char * are pointers to strings, any of which
+    (except decimal_point) can point to "", to indicate that the value is not available in
+    the current locale or is of zero length. Apart from grouping and mon_grouping, the
+    strings shall start and end in the initial shift state. The members with type char are
+    nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not
+    available in the current locale. The members include the following:
+    char *decimal_point
+              The decimal-point character used to format nonmonetary quantities.
+    char *thousands_sep
+              The character used to separate groups of digits before the decimal-point
+              character in formatted nonmonetary quantities.
+    char *grouping
+              A string whose elements indicate the size of each group of digits in
+              formatted nonmonetary quantities.
+    char *mon_decimal_point
+              The decimal-point used to format monetary quantities.
+    char *mon_thousands_sep
+              The separator for groups of digits before the decimal-point in formatted
+              monetary quantities.
+    char *mon_grouping
+              A string whose elements indicate the size of each group of digits in
+              formatted monetary quantities.
+    char *positive_sign
+              The string used to indicate a nonnegative-valued formatted monetary
+              quantity.
+    char *negative_sign
+              The string used to indicate a negative-valued formatted monetary quantity.
+    char *currency_symbol
+              The local currency symbol applicable to the current locale.
+    char frac_digits
+              The number of fractional digits (those after the decimal-point) to be
+              displayed in a locally formatted monetary quantity.
+    char p_cs_precedes
+              Set to 1 or 0 if the currency_symbol respectively precedes or
+              succeeds the value for a nonnegative locally formatted monetary quantity.
+
+[<a name="p225" href="#p225">page 225</a>] (<a href="#Contents">Contents</a>)
+
+char n_cs_precedes
+          Set to 1 or 0 if the currency_symbol respectively precedes or
+          succeeds the value for a negative locally formatted monetary quantity.
+char p_sep_by_space
+          Set to a value indicating the separation of the currency_symbol, the
+          sign string, and the value for a nonnegative locally formatted monetary
+          quantity.
+char n_sep_by_space
+          Set to a value indicating the separation of the currency_symbol, the
+          sign string, and the value for a negative locally formatted monetary
+          quantity.
+char p_sign_posn
+          Set to a value indicating the positioning of the positive_sign for a
+          nonnegative locally formatted monetary quantity.
+char n_sign_posn
+          Set to a value indicating the positioning of the negative_sign for a
+          negative locally formatted monetary quantity.
+char *int_curr_symbol
+          The international currency symbol applicable to the current locale. The
+          first three characters contain the alphabetic international currency symbol
+          in accordance with those specified in ISO 4217. The fourth character
+          (immediately preceding the null character) is the character used to separate
+          the international currency symbol from the monetary quantity.
+char int_frac_digits
+          The number of fractional digits (those after the decimal-point) to be
+          displayed in an internationally formatted monetary quantity.
+char int_p_cs_precedes
+          Set to 1 or 0 if the int_curr_symbol respectively precedes or
+          succeeds the value for a nonnegative internationally formatted monetary
+          quantity.
+char int_n_cs_precedes
+          Set to 1 or 0 if the int_curr_symbol respectively precedes or
+          succeeds the value for a negative internationally formatted monetary
+          quantity.
+char int_p_sep_by_space
+          Set to a value indicating the separation of the int_curr_symbol, the
+          sign string, and the value for a nonnegative internationally formatted
+          monetary quantity.
+
+[<a name="p226" href="#p226">page 226</a>] (<a href="#Contents">Contents</a>)
+
+    char int_n_sep_by_space
+              Set to a value indicating the separation of the int_curr_symbol, the
+              sign string, and the value for a negative internationally formatted monetary
+              quantity.
+    char int_p_sign_posn
+              Set to a value indicating the positioning of the positive_sign for a
+              nonnegative internationally formatted monetary quantity.
+    char int_n_sign_posn
+              Set to a value indicating the positioning of the negative_sign for a
+              negative internationally formatted monetary quantity.
+4   The elements of grouping and mon_grouping are interpreted according to the
+    following:
+    CHAR_MAX      No further grouping is to be performed.
+    0             The previous element is to be repeatedly used for the remainder of the
+                  digits.
+    other         The integer value is the number of digits that compose the current group.
+                  The next element is examined to determine the size of the next group of
+                  digits before the current group.
+5   The values of p_sep_by_space, n_sep_by_space, int_p_sep_by_space,
+    and int_n_sep_by_space are interpreted according to the following:
+    0   No space separates the currency symbol and value.
+    1   If the currency symbol and sign string are adjacent, a space separates them from the
+        value; otherwise, a space separates the currency symbol from the value.
+    2   If the currency symbol and sign string are adjacent, a space separates them;
+        otherwise, a space separates the sign string from the value.
+    For int_p_sep_by_space and int_n_sep_by_space, the fourth character of
+    int_curr_symbol is used instead of a space.
+6   The values of p_sign_posn, n_sign_posn, int_p_sign_posn,                            and
+    int_n_sign_posn are interpreted according to the following:
+    0   Parentheses surround the quantity and currency symbol.
+    1   The sign string precedes the quantity and currency symbol.
+    2   The sign string succeeds the quantity and currency symbol.
+    3   The sign string immediately precedes the currency symbol.
+    4   The sign string immediately succeeds the currency symbol.
+
+[<a name="p227" href="#p227">page 227</a>] (<a href="#Contents">Contents</a>)
+
+7    The implementation shall behave as if no library function calls the localeconv
+     function.
+<b>     Returns</b>
+8    The localeconv function returns a pointer to the filled-in object. The structure
+     pointed to by the return value shall not be modified by the program, but may be
+     overwritten by a subsequent call to the localeconv function. In addition, calls to the
+     setlocale function with categories LC_ALL, LC_MONETARY, or LC_NUMERIC may
+     overwrite the contents of the structure.
+9    EXAMPLE 1 The following table illustrates rules which may well be used by four countries to format
+     monetary quantities.
+                                   Local format                                     International format
+
+     Country            Positive                  Negative                    Positive               Negative
+
+     Country1     1.234,56 mk             -1.234,56 mk                  FIM   1.234,56         FIM -1.234,56
+     Country2     L.1.234                 -L.1.234                      ITL   1.234            -ITL 1.234
+     Country3     fl. 1.234,56              fl. -1.234,56                   NLG   1.234,56         NLG -1.234,56
+     Country4     SFrs.1,234.56           SFrs.1,234.56C                CHF   1,234.56         CHF 1,234.56C
+10   For these four countries, the respective values for the monetary members of the structure returned by
+     localeconv could be:
+                                       Country1              Country2              Country3            Country4
+
+     mon_decimal_point                 ","                   ""                   ","                 "."
+     mon_thousands_sep                 "."                   "."                  "."                 ","
+     mon_grouping                      "\3"                  "\3"                 "\3"                "\3"
+     positive_sign                     ""                    ""                   ""                  ""
+     negative_sign                     "-"                   "-"                  "-"                 "C"
+     currency_symbol                   "mk"                  "L."                 "\u0192"            "SFrs."
+     frac_digits                       2                     0                    2                   2
+     p_cs_precedes                     0                     1                    1                   1
+     n_cs_precedes                     0                     1                    1                   1
+     p_sep_by_space                    1                     0                    1                   0
+     n_sep_by_space                    1                     0                    2                   0
+     p_sign_posn                       1                     1                    1                   1
+     n_sign_posn                       1                     1                    4                   2
+     int_curr_symbol                   "FIM "                "ITL "               "NLG "              "CHF "
+     int_frac_digits                   2                     0                    2                   2
+     int_p_cs_precedes                 1                     1                    1                   1
+     int_n_cs_precedes                 1                     1                    1                   1
+     int_p_sep_by_space                1                     1                    1                   1
+     int_n_sep_by_space                2                     1                    2                   1
+     int_p_sign_posn                   1                     1                    1                   1
+     int_n_sign_posn                   4                     1                    4                   2
+
+[<a name="p228" href="#p228">page 228</a>] (<a href="#Contents">Contents</a>)
+
+11   EXAMPLE 2 The following table illustrates how the cs_precedes, sep_by_space, and sign_posn members
+     affect the formatted value.
+                                                                   p_sep_by_space
+
+     p_cs_precedes           p_sign_posn                0                   1                  2
+
+                     0                    0         (<a href="#1.25">1.25</a>$)            (<a href="#1.25">1.25</a> $)            (<a href="#1.25">1.25</a>$)
+                                          1         +1.25$             +1.25 $             + <a href="#1.25">1.25</a>$
+                                          2         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
+                                          3         <a href="#1.25">1.25</a>+$             <a href="#1.25">1.25</a> +$             <a href="#1.25">1.25</a>+ $
+                                          4         <a href="#1.25">1.25</a>$+             <a href="#1.25">1.25</a> $+             <a href="#1.25">1.25</a>$ +
+
+                     1                    0         ($1.25)            ($ <a href="#1.25">1.25</a>)            ($1.25)
+                                          1         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                          2         $1.25+             $ <a href="#1.25">1.25</a>+             $1.25 +
+                                          3         +$1.25             +$ <a href="#1.25">1.25</a>             + $1.25
+                                          4         $+1.25             $+ <a href="#1.25">1.25</a>             $ +1.25
+
+[<a name="p229" href="#p229">page 229</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12" href="#7.12"><b>    7.12 Mathematics &lt;math.h&gt;</b></a>
+1   The header <a href="#7.12">&lt;math.h&gt;</a> declares two types and many mathematical functions and defines
+    several macros. Most synopses specify a family of functions consisting of a principal
+    function with one or more double parameters, a double return value, or both; and
+    other functions with the same name but with f and l suffixes, which are corresponding
+    functions with float and long double parameters, return values, or both.<sup><a href="#note223"><b>223)</b></a></sup>
+    Integer arithmetic functions and conversion functions are discussed later.
+2   The types
+            float_t
+            double_t
+    are floating types at least as wide as float and double, respectively, and such that
+    double_t is at least as wide as float_t. If FLT_EVAL_METHOD equals 0,
+    float_t and double_t are float and double, respectively; if
+    FLT_EVAL_METHOD equals 1, they are both double; if FLT_EVAL_METHOD equals
+    2, they are both long double; and for other values of FLT_EVAL_METHOD, they are
+    otherwise implementation-defined.<sup><a href="#note224"><b>224)</b></a></sup>
+3   The macro
+            HUGE_VAL
+    expands to a positive double constant expression, not necessarily representable as a
+    float. The macros
+            HUGE_VALF
+            HUGE_VALL
+    are respectively float and long double analogs of HUGE_VAL.<sup><a href="#note225"><b>225)</b></a></sup>
+4   The macro
+            INFINITY
+    expands to a constant expression of type float representing positive or unsigned
+    infinity, if available; else to a positive constant of type float that overflows at
+
+
+
+    <sup><a name="note223" href="#note223"><b>223)</b></a></sup> Particularly on systems with wide expression evaluation, a <a href="#7.12">&lt;math.h&gt;</a> function might pass arguments
+         and return values in wider format than the synopsis prototype indicates.
+    <sup><a name="note224" href="#note224"><b>224)</b></a></sup> The types float_t and double_t are intended to be the implementation's most efficient types at
+         least as wide as float and double, respectively. For FLT_EVAL_METHOD equal 0, 1, or 2, the
+         type float_t is the narrowest type used by the implementation to evaluate floating expressions.
+    <sup><a name="note225" href="#note225"><b>225)</b></a></sup> HUGE_VAL, HUGE_VALF, and HUGE_VALL can be positive infinities in an implementation that
+         supports infinities.
+
+[<a name="p230" href="#p230">page 230</a>] (<a href="#Contents">Contents</a>)
+
+    translation time.<sup><a href="#note226"><b>226)</b></a></sup>
+5   The macro
+             NAN
+    is defined if and only if the implementation supports quiet NaNs for the float type. It
+    expands to a constant expression of type float representing a quiet NaN.
+6   The number classification macros
+             FP_INFINITE
+             FP_NAN
+             FP_NORMAL
+             FP_SUBNORMAL
+             FP_ZERO
+    represent the mutually exclusive kinds of floating-point values. They expand to integer
+    constant expressions with distinct values. Additional implementation-defined floating-
+    point classifications, with macro definitions beginning with FP_ and an uppercase letter,
+    may also be specified by the implementation.
+7   The macro
+             FP_FAST_FMA
+    is optionally defined. If defined, it indicates that the fma function generally executes
+    about as fast as, or faster than, a multiply and an add of double operands.<sup><a href="#note227"><b>227)</b></a></sup> The
+    macros
+             FP_FAST_FMAF
+             FP_FAST_FMAL
+    are, respectively, float and long double analogs of FP_FAST_FMA. If defined,
+    these macros expand to the integer constant 1.
+8   The macros
+             FP_ILOGB0
+             FP_ILOGBNAN
+    expand to integer constant expressions whose values are returned by ilogb(x) if x is
+    zero or NaN, respectively. The value of FP_ILOGB0 shall be either INT_MIN or
+    -INT_MAX. The value of FP_ILOGBNAN shall be either INT_MAX or INT_MIN.
+
+
+    <sup><a name="note226" href="#note226"><b>226)</b></a></sup> In this case, using INFINITY will violate the constraint in <a href="#6.4.4">6.4.4</a> and thus require a diagnostic.
+    <sup><a name="note227" href="#note227"><b>227)</b></a></sup> Typically, the FP_FAST_FMA macro is defined if and only if the fma function is implemented
+         directly with a hardware multiply-add instruction. Software implementations are expected to be
+         substantially slower.
+
+[<a name="p231" href="#p231">page 231</a>] (<a href="#Contents">Contents</a>)
+
+9   The macros
+            MATH_ERRNO
+            MATH_ERREXCEPT
+    expand to the integer constants 1 and 2, respectively; the macro
+            math_errhandling
+    expands to an expression that has type int and the value MATH_ERRNO,
+    MATH_ERREXCEPT, or the bitwise OR of both. The value of math_errhandling is
+    constant for the duration of the program. It is unspecified whether
+    math_errhandling is a macro or an identifier with external linkage. If a macro
+    definition is suppressed or a program defines an identifier with the name
+    math_errhandling, the behavior is undefined.               If the expression
+    math_errhandling &amp; MATH_ERREXCEPT can be nonzero, the implementation
+    shall define the macros FE_DIVBYZERO, FE_INVALID, and FE_OVERFLOW in
+    <a href="#7.6">&lt;fenv.h&gt;</a>.
+<a name="7.12.1" href="#7.12.1"><b>    7.12.1 Treatment of error conditions</b></a>
+1   The behavior of each of the functions in <a href="#7.12">&lt;math.h&gt;</a> is specified for all representable
+    values of its input arguments, except where stated otherwise. Each function shall execute
+    as if it were a single operation without raising SIGFPE and without generating any of the
+    floating-point exceptions ''invalid'', ''divide-by-zero'', or ''overflow'' except to reflect
+    the result of the function.
+2   For all functions, a domain error occurs if an input argument is outside the domain over
+    which the mathematical function is defined. The description of each function lists any
+    required domain errors; an implementation may define additional domain errors, provided
+    that such errors are consistent with the mathematical definition of the function.<sup><a href="#note228"><b>228)</b></a></sup> On a
+    domain error, the function returns an implementation-defined value; if the integer
+    expression math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression
+    errno acquires the value EDOM; if the integer expression math_errhandling &amp;
+    MATH_ERREXCEPT is nonzero, the ''invalid'' floating-point exception is raised.
+3   Similarly, a pole error (also known as a singularity or infinitary) occurs if the
+    mathematical function has an exact infinite result as the finite input argument(s) are
+    approached in the limit (for example, log(0.0)). The description of each function lists
+    any required pole errors; an implementation may define additional pole errors, provided
+    that such errors are consistent with the mathematical definition of the function. On a pole
+    error, the function returns an implementation-defined value; if the integer expression
+
+
+    <sup><a name="note228" href="#note228"><b>228)</b></a></sup> In an implementation that supports infinities, this allows an infinity as an argument to be a domain
+         error if the mathematical domain of the function does not include the infinity.
+
+[<a name="p232" href="#p232">page 232</a>] (<a href="#Contents">Contents</a>)
+
+    math_errhandling &amp; MATH_ERRNO is nonzero, the integer expression errno
+    acquires the value ERANGE; if the integer expression math_errhandling &amp;
+    MATH_ERREXCEPT is nonzero, the ''divide-by-zero'' floating-point exception is raised.
+4   Likewise, a range error occurs if the mathematical result of the function cannot be
+    represented in an object of the specified type, due to extreme magnitude.
+5   A floating result overflows if the magnitude of the mathematical result is finite but so
+    large that the mathematical result cannot be represented without extraordinary roundoff
+    error in an object of the specified type. If a floating result overflows and default rounding
+    is in effect, then the function returns the value of the macro HUGE_VAL, HUGE_VALF, or *
+    HUGE_VALL according to the return type, with the same sign as the correct value of the
+    function; if the integer expression math_errhandling &amp; MATH_ERRNO is nonzero,
+    the integer expression errno acquires the value ERANGE; if the integer expression
+    math_errhandling &amp; MATH_ERREXCEPT is nonzero, the ''overflow'' floating-
+    point exception is raised.
+6   The result underflows if the magnitude of the mathematical result is so small that the
+    mathematical result cannot be represented, without extraordinary roundoff error, in an
+    object of the specified type.<sup><a href="#note229"><b>229)</b></a></sup> If the result underflows, the function returns an
+    implementation-defined value whose magnitude is no greater than the smallest
+    normalized positive number in the specified type; if the integer expression
+    math_errhandling &amp; MATH_ERRNO is nonzero, whether errno acquires the
+    value    ERANGE       is    implementation-defined;     if   the  integer   expression
+    math_errhandling &amp; MATH_ERREXCEPT is nonzero, whether the ''underflow''
+    floating-point exception is raised is implementation-defined.
+7   If a domain, pole, or range error occurs and the integer expression
+    math_errhandling &amp; MATH_ERRNO is zero,<sup><a href="#note230"><b>230)</b></a></sup> then errno shall either be set to
+    the value corresponding to the error or left unmodified. If no such error occurs, errno
+    shall be left unmodified regardless of the setting of math_errhandling.
+
+
+
+
+    <sup><a name="note229" href="#note229"><b>229)</b></a></sup> The term underflow here is intended to encompass both ''gradual underflow'' as in IEC 60559 and
+         also ''flush-to-zero'' underflow.
+    <sup><a name="note230" href="#note230"><b>230)</b></a></sup> Math errors are being indicated by the floating-point exception flags rather than by errno.
+
+[<a name="p233" href="#p233">page 233</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.2" href="#7.12.2"><b>    7.12.2 The FP_CONTRACT pragma</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             #pragma STDC FP_CONTRACT on-off-switch
+<b>    Description</b>
+2   The FP_CONTRACT pragma can be used to allow (if the state is ''on'') or disallow (if the
+    state is ''off'') the implementation to contract expressions (<a href="#6.5">6.5</a>). Each pragma can occur
+    either outside external declarations or preceding all explicit declarations and statements
+    inside a compound statement. When outside external declarations, the pragma takes
+    effect from its occurrence until another FP_CONTRACT pragma is encountered, or until
+    the end of the translation unit. When inside a compound statement, the pragma takes
+    effect from its occurrence until another FP_CONTRACT pragma is encountered
+    (including within a nested compound statement), or until the end of the compound
+    statement; at the end of a compound statement the state for the pragma is restored to its
+    condition just before the compound statement. If this pragma is used in any other
+    context, the behavior is undefined. The default state (''on'' or ''off'') for the pragma is
+    implementation-defined.
+<a name="7.12.3" href="#7.12.3"><b>    7.12.3 Classification macros</b></a>
+1   In the synopses in this subclause, real-floating indicates that the argument shall be an
+    expression of real floating type.
+<a name="7.12.3.1" href="#7.12.3.1"><b>    7.12.3.1 The fpclassify macro</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             int fpclassify(real-floating x);
+<b>    Description</b>
+2   The fpclassify macro classifies its argument value as NaN, infinite, normal,
+    subnormal, zero, or into another implementation-defined category. First, an argument
+    represented in a format wider than its semantic type is converted to its semantic type.
+    Then classification is based on the type of the argument.<sup><a href="#note231"><b>231)</b></a></sup>
+<b>    Returns</b>
+3   The fpclassify macro returns the value of the number classification macro
+    appropriate to the value of its argument.                                *
+
+
+    <sup><a name="note231" href="#note231"><b>231)</b></a></sup> Since an expression can be evaluated with more range and precision than its type has, it is important to
+         know the type that classification is based on. For example, a normal long double value might
+         become subnormal when converted to double, and zero when converted to float.
+
+[<a name="p234" href="#p234">page 234</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.3.2" href="#7.12.3.2"><b>    7.12.3.2 The isfinite macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isfinite(real-floating x);
+<b>    Description</b>
+2   The isfinite macro determines whether its argument has a finite value (zero,
+    subnormal, or normal, and not infinite or NaN). First, an argument represented in a
+    format wider than its semantic type is converted to its semantic type. Then determination
+    is based on the type of the argument.
+<b>    Returns</b>
+3   The isfinite macro returns a nonzero value if and only if its argument has a finite
+    value.
+<a name="7.12.3.3" href="#7.12.3.3"><b>    7.12.3.3 The isinf macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isinf(real-floating x);
+<b>    Description</b>
+2   The isinf macro determines whether its argument value is an infinity (positive or
+    negative). First, an argument represented in a format wider than its semantic type is
+    converted to its semantic type. Then determination is based on the type of the argument.
+<b>    Returns</b>
+3   The isinf macro returns a nonzero value if and only if its argument has an infinite
+    value.
+<a name="7.12.3.4" href="#7.12.3.4"><b>    7.12.3.4 The isnan macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isnan(real-floating x);
+<b>    Description</b>
+2   The isnan macro determines whether its argument value is a NaN. First, an argument
+    represented in a format wider than its semantic type is converted to its semantic type.
+    Then determination is based on the type of the argument.<sup><a href="#note232"><b>232)</b></a></sup>
+
+
+    <sup><a name="note232" href="#note232"><b>232)</b></a></sup> For the isnan macro, the type for determination does not matter unless the implementation supports
+         NaNs in the evaluation type but not in the semantic type.
+
+[<a name="p235" href="#p235">page 235</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The isnan macro returns a nonzero value if and only if its argument has a NaN value.
+<a name="7.12.3.5" href="#7.12.3.5"><b>    7.12.3.5 The isnormal macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isnormal(real-floating x);
+<b>    Description</b>
+2   The isnormal macro determines whether its argument value is normal (neither zero,
+    subnormal, infinite, nor NaN). First, an argument represented in a format wider than its
+    semantic type is converted to its semantic type. Then determination is based on the type
+    of the argument.
+<b>    Returns</b>
+3   The isnormal macro returns a nonzero value if and only if its argument has a normal
+    value.
+<a name="7.12.3.6" href="#7.12.3.6"><b>    7.12.3.6 The signbit macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int signbit(real-floating x);
+<b>    Description</b>
+2   The signbit macro determines whether the sign of its argument value is negative.<sup><a href="#note233"><b>233)</b></a></sup>
+<b>    Returns</b>
+3   The signbit macro returns a nonzero value if and only if the sign of its argument value
+    is negative.
+
+
+
+
+    <sup><a name="note233" href="#note233"><b>233)</b></a></sup> The signbit macro reports the sign of all values, including infinities, zeros, and NaNs. If zero is
+         unsigned, it is treated as positive.
+
+[<a name="p236" href="#p236">page 236</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.4" href="#7.12.4"><b>    7.12.4 Trigonometric functions</b></a>
+<a name="7.12.4.1" href="#7.12.4.1"><b>    7.12.4.1 The acos functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double acos(double x);
+            float acosf(float x);
+            long double acosl(long double x);
+<b>    Description</b>
+2   The acos functions compute the principal value of the arc cosine of x. A domain error
+    occurs for arguments not in the interval [-1, +1].
+<b>    Returns</b>
+3   The acos functions return arccos x in the interval [0, pi ] radians.
+<a name="7.12.4.2" href="#7.12.4.2"><b>    7.12.4.2 The asin functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double asin(double x);
+            float asinf(float x);
+            long double asinl(long double x);
+<b>    Description</b>
+2   The asin functions compute the principal value of the arc sine of x. A domain error
+    occurs for arguments not in the interval [-1, +1].
+<b>    Returns</b>
+3   The asin functions return arcsin x in the interval [-pi /2, +pi /2] radians.
+<a name="7.12.4.3" href="#7.12.4.3"><b>    7.12.4.3 The atan functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double atan(double x);
+            float atanf(float x);
+            long double atanl(long double x);
+<b>    Description</b>
+2   The atan functions compute the principal value of the arc tangent of x.
+
+[<a name="p237" href="#p237">page 237</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The atan functions return arctan x in the interval [-pi /2, +pi /2] radians.
+<a name="7.12.4.4" href="#7.12.4.4"><b>    7.12.4.4 The atan2 functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double atan2(double y, double x);
+           float atan2f(float y, float x);
+           long double atan2l(long double y, long double x);
+<b>    Description</b>
+2   The atan2 functions compute the value of the arc tangent of y/x, using the signs of both
+    arguments to determine the quadrant of the return value. A domain error may occur if
+    both arguments are zero.
+<b>    Returns</b>
+3   The atan2 functions return arctan y/x in the interval [-pi , +pi ] radians.
+<a name="7.12.4.5" href="#7.12.4.5"><b>    7.12.4.5 The cos functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double cos(double x);
+           float cosf(float x);
+           long double cosl(long double x);
+<b>    Description</b>
+2   The cos functions compute the cosine of x (measured in radians).
+<b>    Returns</b>
+3   The cos functions return cos x.
+<a name="7.12.4.6" href="#7.12.4.6"><b>    7.12.4.6 The sin functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double sin(double x);
+           float sinf(float x);
+           long double sinl(long double x);
+<b>    Description</b>
+2   The sin functions compute the sine of x (measured in radians).
+
+[<a name="p238" href="#p238">page 238</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The sin functions return sin x.
+<a name="7.12.4.7" href="#7.12.4.7"><b>    7.12.4.7 The tan functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double tan(double x);
+            float tanf(float x);
+            long double tanl(long double x);
+<b>    Description</b>
+2   The tan functions return the tangent of x (measured in radians).
+<b>    Returns</b>
+3   The tan functions return tan x.
+<a name="7.12.5" href="#7.12.5"><b>    7.12.5 Hyperbolic functions</b></a>
+<a name="7.12.5.1" href="#7.12.5.1"><b>    7.12.5.1 The acosh functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double acosh(double x);
+            float acoshf(float x);
+            long double acoshl(long double x);
+<b>    Description</b>
+2   The acosh functions compute the (nonnegative) arc hyperbolic cosine of x. A domain
+    error occurs for arguments less than 1.
+<b>    Returns</b>
+3   The acosh functions return arcosh x in the interval [0, +(inf)].
+<a name="7.12.5.2" href="#7.12.5.2"><b>    7.12.5.2 The asinh functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double asinh(double x);
+            float asinhf(float x);
+            long double asinhl(long double x);
+<b>    Description</b>
+2   The asinh functions compute the arc hyperbolic sine of x.
+
+[<a name="p239" href="#p239">page 239</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The asinh functions return arsinh x.
+<a name="7.12.5.3" href="#7.12.5.3"><b>    7.12.5.3 The atanh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double atanh(double x);
+           float atanhf(float x);
+           long double atanhl(long double x);
+<b>    Description</b>
+2   The atanh functions compute the arc hyperbolic tangent of x. A domain error occurs
+    for arguments not in the interval [-1, +1]. A pole error may occur if the argument equals
+    -1 or +1.
+<b>    Returns</b>
+3   The atanh functions return artanh x.
+<a name="7.12.5.4" href="#7.12.5.4"><b>    7.12.5.4 The cosh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double cosh(double x);
+           float coshf(float x);
+           long double coshl(long double x);
+<b>    Description</b>
+2   The cosh functions compute the hyperbolic cosine of x. A range error occurs if the
+    magnitude of x is too large.
+<b>    Returns</b>
+3   The cosh functions return cosh x.
+<a name="7.12.5.5" href="#7.12.5.5"><b>    7.12.5.5 The sinh functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double sinh(double x);
+           float sinhf(float x);
+           long double sinhl(long double x);
+<b>    Description</b>
+2   The sinh functions compute the hyperbolic sine of x. A range error occurs if the
+    magnitude of x is too large.
+
+[<a name="p240" href="#p240">page 240</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The sinh functions return sinh x.
+<a name="7.12.5.6" href="#7.12.5.6"><b>    7.12.5.6 The tanh functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double tanh(double x);
+            float tanhf(float x);
+            long double tanhl(long double x);
+<b>    Description</b>
+2   The tanh functions compute the hyperbolic tangent of x.
+<b>    Returns</b>
+3   The tanh functions return tanh x.
+<a name="7.12.6" href="#7.12.6"><b>    7.12.6 Exponential and logarithmic functions</b></a>
+<a name="7.12.6.1" href="#7.12.6.1"><b>    7.12.6.1 The exp functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double exp(double x);
+            float expf(float x);
+            long double expl(long double x);
+<b>    Description</b>
+2   The exp functions compute the base-e exponential of x. A range error occurs if the
+    magnitude of x is too large.
+<b>    Returns</b>
+3   The exp functions return ex .
+<a name="7.12.6.2" href="#7.12.6.2"><b>    7.12.6.2 The exp2 functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double exp2(double x);
+            float exp2f(float x);
+            long double exp2l(long double x);
+<b>    Description</b>
+2   The exp2 functions compute the base-2 exponential of x. A range error occurs if the
+    magnitude of x is too large.
+
+[<a name="p241" href="#p241">page 241</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The exp2 functions return 2x .
+<a name="7.12.6.3" href="#7.12.6.3"><b>    7.12.6.3 The expm1 functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double expm1(double x);
+            float expm1f(float x);
+            long double expm1l(long double x);
+<b>    Description</b>
+2   The expm1 functions compute the base-e exponential of the argument, minus 1. A range
+    error occurs if x is too large.<sup><a href="#note234"><b>234)</b></a></sup>
+<b>    Returns</b>
+3   The expm1 functions return ex - 1.
+<a name="7.12.6.4" href="#7.12.6.4"><b>    7.12.6.4 The frexp functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double frexp(double value, int *exp);
+            float frexpf(float value, int *exp);
+            long double frexpl(long double value, int *exp);
+<b>    Description</b>
+2   The frexp functions break a floating-point number into a normalized fraction and an
+    integral power of 2. They store the integer in the int object pointed to by exp.
+<b>    Returns</b>
+3   If value is not a floating-point number or if the integral power of 2 is outside the range
+    of int, the results are unspecified. Otherwise, the frexp functions return the value x,
+    such that x has a magnitude in the interval [1/2, 1) or zero, and value equals x x 2*exp .
+    If value is zero, both parts of the result are zero.
+
+
+
+
+    <sup><a name="note234" href="#note234"><b>234)</b></a></sup> For small magnitude x, expm1(x) is expected to be more accurate than exp(x) - 1.
+
+[<a name="p242" href="#p242">page 242</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.6.5" href="#7.12.6.5"><b>    7.12.6.5 The ilogb functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int ilogb(double x);
+            int ilogbf(float x);
+            int ilogbl(long double x);
+<b>    Description</b>
+2   The ilogb functions extract the exponent of x as a signed int value. If x is zero they
+    compute the value FP_ILOGB0; if x is infinite they compute the value INT_MAX; if x is
+    a NaN they compute the value FP_ILOGBNAN; otherwise, they are equivalent to calling
+    the corresponding logb function and casting the returned value to type int. A domain
+    error or range error may occur if x is zero, infinite, or NaN. If the correct value is outside
+    the range of the return type, the numeric result is unspecified.
+<b>    Returns</b>
+3   The ilogb functions return the exponent of x as a signed int value.
+    Forward references: the logb functions (<a href="#7.12.6.11">7.12.6.11</a>).
+<a name="7.12.6.6" href="#7.12.6.6"><b>    7.12.6.6 The ldexp functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double ldexp(double x, int exp);
+            float ldexpf(float x, int exp);
+            long double ldexpl(long double x, int exp);
+<b>    Description</b>
+2   The ldexp functions multiply a floating-point number by an integral power of 2. A
+    range error may occur.
+<b>    Returns</b>
+3   The ldexp functions return x x 2exp .
+<a name="7.12.6.7" href="#7.12.6.7"><b>    7.12.6.7 The log functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double log(double x);
+            float logf(float x);
+            long double logl(long double x);
+
+[<a name="p243" href="#p243">page 243</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The log functions compute the base-e (natural) logarithm of x. A domain error occurs if
+    the argument is negative. A pole error may occur if the argument is zero.
+<b>    Returns</b>
+3   The log functions return loge x.
+<a name="7.12.6.8" href="#7.12.6.8"><b>    7.12.6.8 The log10 functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double log10(double x);
+            float log10f(float x);
+            long double log10l(long double x);
+<b>    Description</b>
+2   The log10 functions compute the base-10 (common) logarithm of x. A domain error
+    occurs if the argument is negative. A pole error may occur if the argument is zero.
+<b>    Returns</b>
+3   The log10 functions return log10 x.
+<a name="7.12.6.9" href="#7.12.6.9"><b>    7.12.6.9 The log1p functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double log1p(double x);
+            float log1pf(float x);
+            long double log1pl(long double x);
+<b>    Description</b>
+2   The log1p functions compute the base-e (natural) logarithm of 1 plus the argument.<sup><a href="#note235"><b>235)</b></a></sup>
+    A domain error occurs if the argument is less than -1. A pole error may occur if the
+    argument equals -1.
+<b>    Returns</b>
+3   The log1p functions return loge (1 + x).
+
+
+
+
+    <sup><a name="note235" href="#note235"><b>235)</b></a></sup> For small magnitude x, log1p(x) is expected to be more accurate than log(1 + x).
+
+[<a name="p244" href="#p244">page 244</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.6.10" href="#7.12.6.10"><b>    7.12.6.10 The log2 functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double log2(double x);
+            float log2f(float x);
+            long double log2l(long double x);
+<b>    Description</b>
+2   The log2 functions compute the base-2 logarithm of x. A domain error occurs if the
+    argument is less than zero. A pole error may occur if the argument is zero.
+<b>    Returns</b>
+3   The log2 functions return log2 x.
+<a name="7.12.6.11" href="#7.12.6.11"><b>    7.12.6.11 The logb functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double logb(double x);
+            float logbf(float x);
+            long double logbl(long double x);
+<b>    Description</b>
+2   The logb functions extract the exponent of x, as a signed integer value in floating-point
+    format. If x is subnormal it is treated as though it were normalized; thus, for positive
+    finite x,
+          1 &lt;= x x FLT_RADIX-logb(x) &lt; FLT_RADIX
+    A domain error or pole error may occur if the argument is zero.
+<b>    Returns</b>
+3   The logb functions return the signed exponent of x.
+<a name="7.12.6.12" href="#7.12.6.12"><b>    7.12.6.12 The modf functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double modf(double value, double *iptr);
+            float modff(float value, float *iptr);
+            long double modfl(long double value, long double *iptr);
+<b>    Description</b>
+2   The modf functions break the argument value into integral and fractional parts, each of
+    which has the same type and sign as the argument. They store the integral part (in
+
+[<a name="p245" href="#p245">page 245</a>] (<a href="#Contents">Contents</a>)
+
+    floating-point format) in the object pointed to by iptr.
+<b>    Returns</b>
+3   The modf functions return the signed fractional part of value.
+<a name="7.12.6.13" href="#7.12.6.13"><b>    7.12.6.13 The scalbn and scalbln functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double scalbn(double x, int n);
+           float scalbnf(float x, int n);
+           long double scalbnl(long double x, int n);
+           double scalbln(double x, long int n);
+           float scalblnf(float x, long int n);
+           long double scalblnl(long double x, long int n);
+<b>    Description</b>
+2   The scalbn and scalbln functions compute x x FLT_RADIXn efficiently, not
+    normally by computing FLT_RADIXn explicitly. A range error may occur.
+<b>    Returns</b>
+3   The scalbn and scalbln functions return x x FLT_RADIXn .
+<a name="7.12.7" href="#7.12.7"><b>    7.12.7 Power and absolute-value functions</b></a>
+<a name="7.12.7.1" href="#7.12.7.1"><b>    7.12.7.1 The cbrt functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double cbrt(double x);
+           float cbrtf(float x);
+           long double cbrtl(long double x);
+<b>    Description</b>
+2   The cbrt functions compute the real cube root of x.
+<b>    Returns</b>
+3   The cbrt functions return x1/3 .
+
+[<a name="p246" href="#p246">page 246</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.7.2" href="#7.12.7.2"><b>    7.12.7.2 The fabs functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fabs(double x);
+            float fabsf(float x);
+            long double fabsl(long double x);
+<b>    Description</b>
+2   The fabs functions compute the absolute value of a floating-point number x.
+<b>    Returns</b>
+3   The fabs functions return | x |.
+<a name="7.12.7.3" href="#7.12.7.3"><b>    7.12.7.3 The hypot functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double hypot(double x, double y);
+            float hypotf(float x, float y);
+            long double hypotl(long double x, long double y);
+<b>    Description</b>
+2   The hypot functions compute the square root of the sum of the squares of x and y,
+    without undue overflow or underflow. A range error may occur.
+3   Returns
+4   The hypot functions return (sqrt)x2 + y2 .
+                               -
+                               -----
+<a name="7.12.7.4" href="#7.12.7.4"><b>    7.12.7.4 The pow functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double pow(double x, double y);
+            float powf(float x, float y);
+            long double powl(long double x, long double y);
+<b>    Description</b>
+2   The pow functions compute x raised to the power y. A domain error occurs if x is finite
+    and negative and y is finite and not an integer value. A range error may occur. A domain
+    error may occur if x is zero and y is zero. A domain error or pole error may occur if x is
+    zero and y is less than zero.
+
+[<a name="p247" href="#p247">page 247</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The pow functions return xy .
+<a name="7.12.7.5" href="#7.12.7.5"><b>    7.12.7.5 The sqrt functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double sqrt(double x);
+           float sqrtf(float x);
+           long double sqrtl(long double x);
+<b>    Description</b>
+2   The sqrt functions compute the nonnegative square root of x. A domain error occurs if
+    the argument is less than zero.
+<b>    Returns</b>
+3   The sqrt functions return (sqrt)x.
+                              -
+                              -
+<a name="7.12.8" href="#7.12.8"><b>    7.12.8 Error and gamma functions</b></a>
+<a name="7.12.8.1" href="#7.12.8.1"><b>    7.12.8.1 The erf functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double erf(double x);
+           float erff(float x);
+           long double erfl(long double x);
+<b>    Description</b>
+2   The erf functions compute the error function of x.
+<b>    Returns</b>
+3                                      2        x
+                                            (integral)       e-t dt.
+                                                      2
+    The erf functions return erf x =
+                                       (sqrt)pi
+                                       -
+                                       -    0
+
+<a name="7.12.8.2" href="#7.12.8.2"><b>    7.12.8.2 The erfc functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double erfc(double x);
+           float erfcf(float x);
+           long double erfcl(long double x);
+<b>    Description</b>
+2   The erfc functions compute the complementary error function of x. A range error
+    occurs if x is too large.
+
+[<a name="p248" href="#p248">page 248</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3                                                       2       (inf)
+                                                            (integral)       e-t dt.
+                                                                      2
+    The erfc functions return erfc x = 1 - erf x =
+                                                     (sqrt)pi
+                                                     -
+                                                     -      x
+
+<a name="7.12.8.3" href="#7.12.8.3"><b>    7.12.8.3 The lgamma functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double lgamma(double x);
+            float lgammaf(float x);
+            long double lgammal(long double x);
+<b>    Description</b>
+2   The lgamma functions compute the natural logarithm of the absolute value of gamma of
+    x. A range error occurs if x is too large. A pole error may occur if x is a negative integer
+    or zero.
+<b>    Returns</b>
+3   The lgamma functions return loge | (Gamma)(x) |.
+<a name="7.12.8.4" href="#7.12.8.4"><b>    7.12.8.4 The tgamma functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double tgamma(double x);
+            float tgammaf(float x);
+            long double tgammal(long double x);
+<b>    Description</b>
+2   The tgamma functions compute the gamma function of x. A domain error or pole error
+    may occur if x is a negative integer or zero. A range error occurs if the magnitude of x is
+    too large and may occur if the magnitude of x is too small.
+<b>    Returns</b>
+3   The tgamma functions return (Gamma)(x).
+
+[<a name="p249" href="#p249">page 249</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.9" href="#7.12.9"><b>    7.12.9 Nearest integer functions</b></a>
+<a name="7.12.9.1" href="#7.12.9.1"><b>    7.12.9.1 The ceil functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double ceil(double x);
+           float ceilf(float x);
+           long double ceill(long double x);
+<b>    Description</b>
+2   The ceil functions compute the smallest integer value not less than x.
+<b>    Returns</b>
+3   The ceil functions return [^x^], expressed as a floating-point number.
+<a name="7.12.9.2" href="#7.12.9.2"><b>    7.12.9.2 The floor functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double floor(double x);
+           float floorf(float x);
+           long double floorl(long double x);
+<b>    Description</b>
+2   The floor functions compute the largest integer value not greater than x.
+<b>    Returns</b>
+3   The floor functions return [_x_], expressed as a floating-point number.
+<a name="7.12.9.3" href="#7.12.9.3"><b>    7.12.9.3 The nearbyint functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double nearbyint(double x);
+           float nearbyintf(float x);
+           long double nearbyintl(long double x);
+<b>    Description</b>
+2   The nearbyint functions round their argument to an integer value in floating-point
+    format, using the current rounding direction and without raising the ''inexact'' floating-
+    point exception.
+
+[<a name="p250" href="#p250">page 250</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The nearbyint functions return the rounded integer value.
+<a name="7.12.9.4" href="#7.12.9.4"><b>    7.12.9.4 The rint functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double rint(double x);
+            float rintf(float x);
+            long double rintl(long double x);
+<b>    Description</b>
+2   The rint functions differ from the nearbyint functions (<a href="#7.12.9.3">7.12.9.3</a>) only in that the
+    rint functions may raise the ''inexact'' floating-point exception if the result differs in
+    value from the argument.
+<b>    Returns</b>
+3   The rint functions return the rounded integer value.
+<a name="7.12.9.5" href="#7.12.9.5"><b>    7.12.9.5 The lrint and llrint functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            long int lrint(double x);
+            long int lrintf(float x);
+            long int lrintl(long double x);
+            long long int llrint(double x);
+            long long int llrintf(float x);
+            long long int llrintl(long double x);
+<b>    Description</b>
+2   The lrint and llrint functions round their argument to the nearest integer value,
+    rounding according to the current rounding direction. If the rounded value is outside the
+    range of the return type, the numeric result is unspecified and a domain error or range
+    error may occur.
+<b>    Returns</b>
+3   The lrint and llrint functions return the rounded integer value.
+
+[<a name="p251" href="#p251">page 251</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.9.6" href="#7.12.9.6"><b>    7.12.9.6 The round functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double round(double x);
+           float roundf(float x);
+           long double roundl(long double x);
+<b>    Description</b>
+2   The round functions round their argument to the nearest integer value in floating-point
+    format, rounding halfway cases away from zero, regardless of the current rounding
+    direction.
+<b>    Returns</b>
+3   The round functions return the rounded integer value.
+<a name="7.12.9.7" href="#7.12.9.7"><b>    7.12.9.7 The lround and llround functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           long int lround(double x);
+           long int lroundf(float x);
+           long int lroundl(long double x);
+           long long int llround(double x);
+           long long int llroundf(float x);
+           long long int llroundl(long double x);
+<b>    Description</b>
+2   The lround and llround functions round their argument to the nearest integer value,
+    rounding halfway cases away from zero, regardless of the current rounding direction. If
+    the rounded value is outside the range of the return type, the numeric result is unspecified
+    and a domain error or range error may occur.
+<b>    Returns</b>
+3   The lround and llround functions return the rounded integer value.
+<a name="7.12.9.8" href="#7.12.9.8"><b>    7.12.9.8 The trunc functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double trunc(double x);
+           float truncf(float x);
+           long double truncl(long double x);
+
+[<a name="p252" href="#p252">page 252</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The trunc functions round their argument to the integer value, in floating format,
+    nearest to but no larger in magnitude than the argument.
+<b>    Returns</b>
+3   The trunc functions return the truncated integer value.
+<a name="7.12.10" href="#7.12.10"><b>    7.12.10 Remainder functions</b></a>
+<a name="7.12.10.1" href="#7.12.10.1"><b>    7.12.10.1 The fmod functions</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             double fmod(double x, double y);
+             float fmodf(float x, float y);
+             long double fmodl(long double x, long double y);
+<b>    Description</b>
+2   The fmod functions compute the floating-point remainder of x/y.
+<b>    Returns</b>
+3   The fmod functions return the value x - ny, for some integer n such that, if y is nonzero,
+    the result has the same sign as x and magnitude less than the magnitude of y. If y is zero,
+    whether a domain error occurs or the fmod functions return zero is implementation-
+    defined.
+<a name="7.12.10.2" href="#7.12.10.2"><b>    7.12.10.2 The remainder functions</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             double remainder(double x, double y);
+             float remainderf(float x, float y);
+             long double remainderl(long double x, long double y);
+<b>    Description</b>
+2   The remainder functions compute the remainder x REM y required by IEC 60559.<sup><a href="#note236"><b>236)</b></a></sup>
+
+
+
+
+    <sup><a name="note236" href="#note236"><b>236)</b></a></sup> ''When y != 0, the remainder r = x REM y is defined regardless of the rounding mode by the
+         mathematical relation r = x - ny, where n is the integer nearest the exact value of x/y; whenever
+         | n - x/y | = 1/2, then n is even. If r = 0, its sign shall be that of x.'' This definition is applicable for *
+         all implementations.
+
+[<a name="p253" href="#p253">page 253</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The remainder functions return x REM y. If y is zero, whether a domain error occurs
+    or the functions return zero is implementation defined.
+<a name="7.12.10.3" href="#7.12.10.3"><b>    7.12.10.3 The remquo functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double remquo(double x, double y, int *quo);
+           float remquof(float x, float y, int *quo);
+           long double remquol(long double x, long double y,
+                int *quo);
+<b>    Description</b>
+2   The remquo functions compute the same remainder as the remainder functions. In
+    the object pointed to by quo they store a value whose sign is the sign of x/y and whose
+    magnitude is congruent modulo 2n to the magnitude of the integral quotient of x/y, where
+    n is an implementation-defined integer greater than or equal to 3.
+<b>    Returns</b>
+3   The remquo functions return x REM y. If y is zero, the value stored in the object
+    pointed to by quo is unspecified and whether a domain error occurs or the functions
+    return zero is implementation defined.
+<a name="7.12.11" href="#7.12.11"><b>    7.12.11 Manipulation functions</b></a>
+<a name="7.12.11.1" href="#7.12.11.1"><b>    7.12.11.1 The copysign functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           double copysign(double x, double y);
+           float copysignf(float x, float y);
+           long double copysignl(long double x, long double y);
+<b>    Description</b>
+2   The copysign functions produce a value with the magnitude of x and the sign of y.
+    They produce a NaN (with the sign of y) if x is a NaN. On implementations that
+    represent a signed zero but do not treat negative zero consistently in arithmetic
+    operations, the copysign functions regard the sign of zero as positive.
+<b>    Returns</b>
+3   The copysign functions return a value with the magnitude of x and the sign of y.
+
+[<a name="p254" href="#p254">page 254</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.11.2" href="#7.12.11.2"><b>    7.12.11.2 The nan functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double nan(const char *tagp);
+            float nanf(const char *tagp);
+            long double nanl(const char *tagp);
+<b>    Description</b>
+2   The call nan("n-char-sequence") is equivalent to strtod("NAN(n-char-
+    sequence)",     (char**)       NULL); the call nan("") is equivalent to
+    strtod("NAN()", (char**) NULL). If tagp does not point to an n-char
+    sequence or an empty string, the call is equivalent to strtod("NAN", (char**)
+    NULL). Calls to nanf and nanl are equivalent to the corresponding calls to strtof
+    and strtold.
+<b>    Returns</b>
+3   The nan functions return a quiet NaN, if available, with content indicated through tagp.
+    If the implementation does not support quiet NaNs, the functions return zero.
+    Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
+<a name="7.12.11.3" href="#7.12.11.3"><b>    7.12.11.3 The nextafter functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double nextafter(double x, double y);
+            float nextafterf(float x, float y);
+            long double nextafterl(long double x, long double y);
+<b>    Description</b>
+2   The nextafter functions determine the next representable value, in the type of the
+    function, after x in the direction of y, where x and y are first converted to the type of the
+    function.<sup><a href="#note237"><b>237)</b></a></sup> The nextafter functions return y if x equals y. A range error may occur
+    if the magnitude of x is the largest finite value representable in the type and the result is
+    infinite or not representable in the type.
+<b>    Returns</b>
+3   The nextafter functions return the next representable value in the specified format
+    after x in the direction of y.
+
+
+    <sup><a name="note237" href="#note237"><b>237)</b></a></sup> The argument values are converted to the type of the function, even by a macro implementation of the
+         function.
+
+[<a name="p255" href="#p255">page 255</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.11.4" href="#7.12.11.4"><b>    7.12.11.4 The nexttoward functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double nexttoward(double x, long double y);
+            float nexttowardf(float x, long double y);
+            long double nexttowardl(long double x, long double y);
+<b>    Description</b>
+2   The nexttoward functions are equivalent to the nextafter functions except that the
+    second parameter has type long double and the functions return y converted to the
+    type of the function if x equals y.<sup><a href="#note238"><b>238)</b></a></sup>
+<a name="7.12.12" href="#7.12.12"><b>    7.12.12 Maximum, minimum, and positive difference functions</b></a>
+<a name="7.12.12.1" href="#7.12.12.1"><b>    7.12.12.1 The fdim functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fdim(double x, double y);
+            float fdimf(float x, float y);
+            long double fdiml(long double x, long double y);
+<b>    Description</b>
+2   The fdim functions determine the positive difference between their arguments:
+          {x - y if x &gt; y
+          {
+          {+0     if x &lt;= y
+    A range error may occur.
+<b>    Returns</b>
+3   The fdim functions return the positive difference value.
+<a name="7.12.12.2" href="#7.12.12.2"><b>    7.12.12.2 The fmax functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fmax(double x, double y);
+            float fmaxf(float x, float y);
+            long double fmaxl(long double x, long double y);
+
+
+
+    <sup><a name="note238" href="#note238"><b>238)</b></a></sup> The result of the nexttoward functions is determined in the type of the function, without loss of
+         range or precision in a floating second argument.
+
+[<a name="p256" href="#p256">page 256</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The fmax functions determine the maximum numeric value of their arguments.<sup><a href="#note239"><b>239)</b></a></sup>
+<b>    Returns</b>
+3   The fmax functions return the maximum numeric value of their arguments.
+<a name="7.12.12.3" href="#7.12.12.3"><b>    7.12.12.3 The fmin functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fmin(double x, double y);
+            float fminf(float x, float y);
+            long double fminl(long double x, long double y);
+<b>    Description</b>
+2   The fmin functions determine the minimum numeric value of their arguments.<sup><a href="#note240"><b>240)</b></a></sup>
+<b>    Returns</b>
+3   The fmin functions return the minimum numeric value of their arguments.
+<a name="7.12.13" href="#7.12.13"><b>    7.12.13 Floating multiply-add</b></a>
+<a name="7.12.13.1" href="#7.12.13.1"><b>    7.12.13.1 The fma functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            double fma(double x, double y, double z);
+            float fmaf(float x, float y, float z);
+            long double fmal(long double x, long double y,
+                 long double z);
+<b>    Description</b>
+2   The fma functions compute (x x y) + z, rounded as one ternary operation: they compute
+    the value (as if) to infinite precision and round once to the result format, according to the
+    current rounding mode. A range error may occur.
+<b>    Returns</b>
+3   The fma functions return (x x y) + z, rounded as one ternary operation.
+
+
+
+
+    <sup><a name="note239" href="#note239"><b>239)</b></a></sup> NaN arguments are treated as missing data: if one argument is a NaN and the other numeric, then the
+         fmax functions choose the numeric value. See <a href="#F.10.9.2">F.10.9.2</a>.
+    <sup><a name="note240" href="#note240"><b>240)</b></a></sup> The fmin functions are analogous to the fmax functions in their treatment of NaNs.
+
+[<a name="p257" href="#p257">page 257</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.14" href="#7.12.14"><b>    7.12.14 Comparison macros</b></a>
+1   The relational and equality operators support the usual mathematical relationships
+    between numeric values. For any ordered pair of numeric values exactly one of the
+    relationships -- less, greater, and equal -- is true. Relational operators may raise the
+    ''invalid'' floating-point exception when argument values are NaNs. For a NaN and a
+    numeric value, or for two NaNs, just the unordered relationship is true.<sup><a href="#note241"><b>241)</b></a></sup> The following
+    subclauses provide macros that are quiet (non floating-point exception raising) versions
+    of the relational operators, and other comparison macros that facilitate writing efficient
+    code that accounts for NaNs without suffering the ''invalid'' floating-point exception. In
+    the synopses in this subclause, real-floating indicates that the argument shall be an
+    expression of real floating type<sup><a href="#note242"><b>242)</b></a></sup> (both arguments need not have the same type).<sup><a href="#note243"><b>243)</b></a></sup>
+<a name="7.12.14.1" href="#7.12.14.1"><b>    7.12.14.1 The isgreater macro</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             int isgreater(real-floating x, real-floating y);
+<b>    Description</b>
+2   The isgreater macro determines whether its first argument is greater than its second
+    argument. The value of isgreater(x, y) is always equal to (x) &gt; (y); however,
+    unlike (x) &gt; (y), isgreater(x, y) does not raise the ''invalid'' floating-point
+    exception when x and y are unordered.
+<b>    Returns</b>
+3   The isgreater macro returns the value of (x) &gt; (y).
+<a name="7.12.14.2" href="#7.12.14.2"><b>    7.12.14.2 The isgreaterequal macro</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.12">&lt;math.h&gt;</a>
+             int isgreaterequal(real-floating x, real-floating y);
+
+
+
+
+    <sup><a name="note241" href="#note241"><b>241)</b></a></sup> IEC 60559 requires that the built-in relational operators raise the ''invalid'' floating-point exception if
+         the operands compare unordered, as an error indicator for programs written without consideration of
+         NaNs; the result in these cases is false.
+    <sup><a name="note242" href="#note242"><b>242)</b></a></sup> If any argument is of integer type, or any other type that is not a real floating type, the behavior is
+         undefined.
+    <sup><a name="note243" href="#note243"><b>243)</b></a></sup> Whether an argument represented in a format wider than its semantic type is converted to the semantic
+         type is unspecified.
+
+[<a name="p258" href="#p258">page 258</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The isgreaterequal macro determines whether its first argument is greater than or
+    equal to its second argument. The value of isgreaterequal(x, y) is always equal
+    to (x) &gt;= (y); however, unlike (x) &gt;= (y), isgreaterequal(x, y) does
+    not raise the ''invalid'' floating-point exception when x and y are unordered.
+<b>    Returns</b>
+3   The isgreaterequal macro returns the value of (x) &gt;= (y).
+<a name="7.12.14.3" href="#7.12.14.3"><b>    7.12.14.3 The isless macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int isless(real-floating x, real-floating y);
+<b>    Description</b>
+2   The isless macro determines whether its first argument is less than its second
+    argument. The value of isless(x, y) is always equal to (x) &lt; (y); however,
+    unlike (x) &lt; (y), isless(x, y) does not raise the ''invalid'' floating-point
+    exception when x and y are unordered.
+<b>    Returns</b>
+3   The isless macro returns the value of (x) &lt; (y).
+<a name="7.12.14.4" href="#7.12.14.4"><b>    7.12.14.4 The islessequal macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.12">&lt;math.h&gt;</a>
+            int islessequal(real-floating x, real-floating y);
+<b>    Description</b>
+2   The islessequal macro determines whether its first argument is less than or equal to
+    its second argument. The value of islessequal(x, y) is always equal to
+    (x) &lt;= (y); however, unlike (x) &lt;= (y), islessequal(x, y) does not raise
+    the ''invalid'' floating-point exception when x and y are unordered.
+<b>    Returns</b>
+3   The islessequal macro returns the value of (x) &lt;= (y).
+
+[<a name="p259" href="#p259">page 259</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.12.14.5" href="#7.12.14.5"><b>    7.12.14.5 The islessgreater macro</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           int islessgreater(real-floating x, real-floating y);
+<b>    Description</b>
+2   The islessgreater macro determines whether its first argument is less than or
+    greater than its second argument. The islessgreater(x, y) macro is similar to
+    (x) &lt; (y) || (x) &gt; (y); however, islessgreater(x, y) does not raise
+    the ''invalid'' floating-point exception when x and y are unordered (nor does it evaluate x
+    and y twice).
+<b>    Returns</b>
+3   The islessgreater macro returns the value of (x) &lt; (y) || (x) &gt; (y).
+<a name="7.12.14.6" href="#7.12.14.6"><b>    7.12.14.6 The isunordered macro</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.12">&lt;math.h&gt;</a>
+           int isunordered(real-floating x, real-floating y);
+<b>    Description</b>
+2   The isunordered macro determines whether its arguments are unordered.
+<b>    Returns</b>
+3   The isunordered macro returns 1 if its arguments are unordered and 0 otherwise.
+
+[<a name="p260" href="#p260">page 260</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.13" href="#7.13"><b>    7.13 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
+1   The header <a href="#7.13">&lt;setjmp.h&gt;</a> defines the macro setjmp, and declares one function and
+    one type, for bypassing the normal function call and return discipline.<sup><a href="#note244"><b>244)</b></a></sup>
+2   The type declared is
+            jmp_buf
+    which is an array type suitable for holding the information needed to restore a calling
+    environment. The environment of a call to the setjmp macro consists of information
+    sufficient for a call to the longjmp function to return execution to the correct block and
+    invocation of that block, were it called recursively. It does not include the state of the
+    floating-point status flags, of open files, or of any other component of the abstract
+    machine.
+3   It is unspecified whether setjmp is a macro or an identifier declared with external
+    linkage. If a macro definition is suppressed in order to access an actual function, or a
+    program defines an external identifier with the name setjmp, the behavior is undefined.
+<a name="7.13.1" href="#7.13.1"><b>    7.13.1 Save calling environment</b></a>
+<a name="7.13.1.1" href="#7.13.1.1"><b>    7.13.1.1 The setjmp macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.13">&lt;setjmp.h&gt;</a>
+            int setjmp(jmp_buf env);
+<b>    Description</b>
+2   The setjmp macro saves its calling environment in its jmp_buf argument for later use
+    by the longjmp function.
+<b>    Returns</b>
+3   If the return is from a direct invocation, the setjmp macro returns the value zero. If the
+    return is from a call to the longjmp function, the setjmp macro returns a nonzero
+    value.
+    Environmental limits
+4   An invocation of the setjmp macro shall appear only in one of the following contexts:
+    -- the entire controlling expression of a selection or iteration statement;
+    -- one operand of a relational or equality operator with the other operand an integer
+      constant expression, with the resulting expression being the entire controlling
+
+
+    <sup><a name="note244" href="#note244"><b>244)</b></a></sup> These functions are useful for dealing with unusual conditions encountered in a low-level function of
+         a program.
+
+[<a name="p261" href="#p261">page 261</a>] (<a href="#Contents">Contents</a>)
+
+        expression of a selection or iteration statement;
+    -- the operand of a unary ! operator with the resulting expression being the entire
+      controlling expression of a selection or iteration statement; or
+    -- the entire expression of an expression statement (possibly cast to void).
+5   If the invocation appears in any other context, the behavior is undefined.
+<a name="7.13.2" href="#7.13.2"><b>    7.13.2 Restore calling environment</b></a>
+<a name="7.13.2.1" href="#7.13.2.1"><b>    7.13.2.1 The longjmp function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.13">&lt;setjmp.h&gt;</a>
+             _Noreturn void longjmp(jmp_buf env, int val);
+<b>    Description</b>
+2   The longjmp function restores the environment saved by the most recent invocation of
+    the setjmp macro in the same invocation of the program with the corresponding
+    jmp_buf argument. If there has been no such invocation, or if the function containing
+    the invocation of the setjmp macro has terminated execution<sup><a href="#note245"><b>245)</b></a></sup> in the interim, or if the
+    invocation of the setjmp macro was within the scope of an identifier with variably
+    modified type and execution has left that scope in the interim, the behavior is undefined.
+3   All accessible objects have values, and all other components of the abstract machine<sup><a href="#note246"><b>246)</b></a></sup>
+    have state, as of the time the longjmp function was called, except that the values of
+    objects of automatic storage duration that are local to the function containing the
+    invocation of the corresponding setjmp macro that do not have volatile-qualified type
+    and have been changed between the setjmp invocation and longjmp call are
+    indeterminate.
+<b>    Returns</b>
+4   After longjmp is completed, program execution continues as if the corresponding
+    invocation of the setjmp macro had just returned the value specified by val. The
+    longjmp function cannot cause the setjmp macro to return the value 0; if val is 0,
+    the setjmp macro returns the value 1.
+5   EXAMPLE The longjmp function that returns control back to the point of the setjmp invocation
+    might cause memory associated with a variable length array object to be squandered.
+
+
+
+
+    <sup><a name="note245" href="#note245"><b>245)</b></a></sup> For example, by executing a return statement or because another longjmp call has caused a
+         transfer to a setjmp invocation in a function earlier in the set of nested calls.
+    <sup><a name="note246" href="#note246"><b>246)</b></a></sup> This includes, but is not limited to, the floating-point status flags and the state of open files.
+
+[<a name="p262" href="#p262">page 262</a>] (<a href="#Contents">Contents</a>)
+
+        #include <a href="#7.13">&lt;setjmp.h&gt;</a>
+        jmp_buf buf;
+        void g(int n);
+        void h(int n);
+        int n = 6;
+        void f(void)
+        {
+              int x[n];          // valid: f is not terminated
+              setjmp(buf);
+              g(n);
+        }
+        void g(int n)
+        {
+              int a[n];          // a may remain allocated
+              h(n);
+        }
+        void h(int n)
+        {
+              int b[n];          // b may remain allocated
+              longjmp(buf, 2);   // might cause memory loss
+        }
+
+[<a name="p263" href="#p263">page 263</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.14" href="#7.14"><b>    7.14 Signal handling &lt;signal.h&gt;</b></a>
+1   The header <a href="#7.14">&lt;signal.h&gt;</a> declares a type and two functions and defines several macros,
+    for handling various signals (conditions that may be reported during program execution).
+2   The type defined is
+             sig_atomic_t
+    which is the (possibly volatile-qualified) integer type of an object that can be accessed as
+    an atomic entity, even in the presence of asynchronous interrupts.
+3   The macros defined are
+             SIG_DFL
+             SIG_ERR
+             SIG_IGN
+    which expand to constant expressions with distinct values that have type compatible with
+    the second argument to, and the return value of, the signal function, and whose values
+    compare unequal to the address of any declarable function; and the following, which
+    expand to positive integer constant expressions with type int and distinct values that are
+    the signal numbers, each corresponding to the specified condition:
+             SIGABRT abnormal termination, such as is initiated by the abort function
+             SIGFPE        an erroneous arithmetic operation, such as zero divide or an operation
+                           resulting in overflow
+             SIGILL        detection of an invalid function image, such as an invalid instruction
+             SIGINT        receipt of an interactive attention signal
+             SIGSEGV an invalid access to storage
+             SIGTERM a termination request sent to the program
+4   An implementation need not generate any of these signals, except as a result of explicit
+    calls to the raise function. Additional signals and pointers to undeclarable functions,
+    with macro definitions beginning, respectively, with the letters SIG and an uppercase
+    letter or with SIG_ and an uppercase letter,<sup><a href="#note247"><b>247)</b></a></sup> may also be specified by the
+    implementation. The complete set of signals, their semantics, and their default handling
+    is implementation-defined; all signal numbers shall be positive.
+
+
+
+
+    <sup><a name="note247" href="#note247"><b>247)</b></a></sup> See ''future library directions'' (<a href="#7.30.6">7.30.6</a>). The names of the signal numbers reflect the following terms
+         (respectively): abort, floating-point exception, illegal instruction, interrupt, segmentation violation,
+         and termination.
+
+[<a name="p264" href="#p264">page 264</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.14.1" href="#7.14.1"><b>    7.14.1 Specify signal handling</b></a>
+<a name="7.14.1.1" href="#7.14.1.1"><b>    7.14.1.1 The signal function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.14">&lt;signal.h&gt;</a>
+            void (*signal(int sig, void (*func)(int)))(int);
+<b>    Description</b>
+2   The signal function chooses one of three ways in which receipt of the signal number
+    sig is to be subsequently handled. If the value of func is SIG_DFL, default handling
+    for that signal will occur. If the value of func is SIG_IGN, the signal will be ignored.
+    Otherwise, func shall point to a function to be called when that signal occurs. An
+    invocation of such a function because of a signal, or (recursively) of any further functions
+    called by that invocation (other than functions in the standard library),<sup><a href="#note248"><b>248)</b></a></sup> is called a
+    signal handler.
+3   When a signal occurs and func points to a function, it is implementation-defined
+    whether the equivalent of signal(sig, SIG_DFL); is executed or the
+    implementation prevents some implementation-defined set of signals (at least including
+    sig) from occurring until the current signal handling has completed; in the case of
+    SIGILL, the implementation may alternatively define that no action is taken. Then the
+    equivalent of (*func)(sig); is executed. If and when the function returns, if the
+    value of sig is SIGFPE, SIGILL, SIGSEGV, or any other implementation-defined
+    value corresponding to a computational exception, the behavior is undefined; otherwise
+    the program will resume execution at the point it was interrupted.
+4   If the signal occurs as the result of calling the abort or raise function, the signal
+    handler shall not call the raise function.
+5   If the signal occurs other than as the result of calling the abort or raise function, the
+    behavior is undefined if the signal handler refers to any object with static or thread
+    storage duration that is not a lock-free atomic object other than by assigning a value to an
+    object declared as volatile sig_atomic_t, or the signal handler calls any function
+    in the standard library other than the abort function, the _Exit function, the
+    quick_exit function, or the signal function with the first argument equal to the
+    signal number corresponding to the signal that caused the invocation of the handler.
+    Furthermore, if such a call to the signal function results in a SIG_ERR return, the
+    value of errno is indeterminate.<sup><a href="#note249"><b>249)</b></a></sup>
+
+
+    <sup><a name="note248" href="#note248"><b>248)</b></a></sup> This includes functions called indirectly via standard library functions (e.g., a SIGABRT handler
+         called via the abort function).
+    <sup><a name="note249" href="#note249"><b>249)</b></a></sup> If any signal is generated by an asynchronous signal handler, the behavior is undefined.
+
+[<a name="p265" href="#p265">page 265</a>] (<a href="#Contents">Contents</a>)
+
+6   At program startup, the equivalent of
+           signal(sig, SIG_IGN);
+    may be executed for some signals selected in an implementation-defined manner; the
+    equivalent of
+           signal(sig, SIG_DFL);
+    is executed for all other signals defined by the implementation.
+7   The implementation shall behave as if no library function calls the signal function.
+<b>    Returns</b>
+8   If the request can be honored, the signal function returns the value of func for the
+    most recent successful call to signal for the specified signal sig. Otherwise, a value of
+    SIG_ERR is returned and a positive value is stored in errno.
+    Forward references: the abort function (<a href="#7.22.4.1">7.22.4.1</a>), the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the
+    _Exit function (<a href="#7.22.4.5">7.22.4.5</a>), the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
+<a name="7.14.2" href="#7.14.2"><b>    7.14.2 Send signal</b></a>
+<a name="7.14.2.1" href="#7.14.2.1"><b>    7.14.2.1 The raise function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.14">&lt;signal.h&gt;</a>
+           int raise(int sig);
+<b>    Description</b>
+2   The raise function carries out the actions described in <a href="#7.14.1.1">7.14.1.1</a> for the signal sig. If a
+    signal handler is called, the raise function shall not return until after the signal handler
+    does.
+<b>    Returns</b>
+3   The raise function returns zero if successful, nonzero if unsuccessful.
+
+[<a name="p266" href="#p266">page 266</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.15" href="#7.15"><b>    7.15 Alignment &lt;stdalign.h&gt;</b></a>
+1   The header <a href="#7.15">&lt;stdalign.h&gt;</a> defines two macros.
+2   The macro
+            alignas
+    expands to _Alignas.
+3   The remaining macro is suitable for use in #if preprocessing directives. It is
+            __alignas_is_defined
+    which expands to the integer constant 1.
+
+[<a name="p267" href="#p267">page 267</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.16" href="#7.16"><b>    7.16 Variable arguments &lt;stdarg.h&gt;</b></a>
+1   The header <a href="#7.16">&lt;stdarg.h&gt;</a> declares a type and defines four macros, for advancing
+    through a list of arguments whose number and types are not known to the called function
+    when it is translated.
+2   A function may be called with a variable number of arguments of varying types. As
+    described in <a href="#6.9.1">6.9.1</a>, its parameter list contains one or more parameters. The rightmost
+    parameter plays a special role in the access mechanism, and will be designated parmN in
+    this description.
+3   The type declared is
+            va_list
+    which is a complete object type suitable for holding information needed by the macros
+    va_start, va_arg, va_end, and va_copy. If access to the varying arguments is
+    desired, the called function shall declare an object (generally referred to as ap in this
+    subclause) having type va_list. The object ap may be passed as an argument to
+    another function; if that function invokes the va_arg macro with parameter ap, the
+    value of ap in the calling function is indeterminate and shall be passed to the va_end
+    macro prior to any further reference to ap.<sup><a href="#note250"><b>250)</b></a></sup>
+<a name="7.16.1" href="#7.16.1"><b>    7.16.1 Variable argument list access macros</b></a>
+1   The va_start and va_arg macros described in this subclause shall be implemented
+    as macros, not functions. It is unspecified whether va_copy and va_end are macros or
+    identifiers declared with external linkage. If a macro definition is suppressed in order to
+    access an actual function, or a program defines an external identifier with the same name,
+    the behavior is undefined. Each invocation of the va_start and va_copy macros
+    shall be matched by a corresponding invocation of the va_end macro in the same
+    function.
+<a name="7.16.1.1" href="#7.16.1.1"><b>    7.16.1.1 The va_arg macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            type va_arg(va_list ap, type);
+<b>    Description</b>
+2   The va_arg macro expands to an expression that has the specified type and the value of
+    the next argument in the call. The parameter ap shall have been initialized by the
+    va_start or va_copy macro (without an intervening invocation of the va_end
+
+    <sup><a name="note250" href="#note250"><b>250)</b></a></sup> It is permitted to create a pointer to a va_list and pass that pointer to another function, in which
+         case the original function may make further use of the original list after the other function returns.
+
+[<a name="p268" href="#p268">page 268</a>] (<a href="#Contents">Contents</a>)
+
+    macro for the same ap). Each invocation of the va_arg macro modifies ap so that the
+    values of successive arguments are returned in turn. The parameter type shall be a type
+    name specified such that the type of a pointer to an object that has the specified type can
+    be obtained simply by postfixing a * to type. If there is no actual next argument, or if
+    type is not compatible with the type of the actual next argument (as promoted according
+    to the default argument promotions), the behavior is undefined, except for the following
+    cases:
+    -- one type is a signed integer type, the other type is the corresponding unsigned integer
+      type, and the value is representable in both types;
+    -- one type is pointer to void and the other is a pointer to a character type.
+<b>    Returns</b>
+3   The first invocation of the va_arg macro after that of the va_start macro returns the
+    value of the argument after that specified by parmN . Successive invocations return the
+    values of the remaining arguments in succession.
+<a name="7.16.1.2" href="#7.16.1.2"><b>    7.16.1.2 The va_copy macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            void va_copy(va_list dest, va_list src);
+<b>    Description</b>
+2   The va_copy macro initializes dest as a copy of src, as if the va_start macro had
+    been applied to dest followed by the same sequence of uses of the va_arg macro as
+    had previously been used to reach the present state of src. Neither the va_copy nor
+    va_start macro shall be invoked to reinitialize dest without an intervening
+    invocation of the va_end macro for the same dest.
+<b>    Returns</b>
+3   The va_copy macro returns no value.
+<a name="7.16.1.3" href="#7.16.1.3"><b>    7.16.1.3 The va_end macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            void va_end(va_list ap);
+<b>    Description</b>
+2   The va_end macro facilitates a normal return from the function whose variable
+    argument list was referred to by the expansion of the va_start macro, or the function
+    containing the expansion of the va_copy macro, that initialized the va_list ap. The
+    va_end macro may modify ap so that it is no longer usable (without being reinitialized
+
+[<a name="p269" href="#p269">page 269</a>] (<a href="#Contents">Contents</a>)
+
+    by the va_start or va_copy macro). If there is no corresponding invocation of the
+    va_start or va_copy macro, or if the va_end macro is not invoked before the
+    return, the behavior is undefined.
+<b>    Returns</b>
+3   The va_end macro returns no value.
+<a name="7.16.1.4" href="#7.16.1.4"><b>    7.16.1.4 The va_start macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            void va_start(va_list ap, parmN);
+<b>    Description</b>
+2   The va_start macro shall be invoked before any access to the unnamed arguments.
+3   The va_start macro initializes ap for subsequent use by the va_arg and va_end
+    macros. Neither the va_start nor va_copy macro shall be invoked to reinitialize ap
+    without an intervening invocation of the va_end macro for the same ap.
+4   The parameter parmN is the identifier of the rightmost parameter in the variable
+    parameter list in the function definition (the one just before the , ...). If the parameter
+    parmN is declared with the register storage class, with a function or array type, or
+    with a type that is not compatible with the type that results after application of the default
+    argument promotions, the behavior is undefined.
+<b>    Returns</b>
+5   The va_start macro returns no value.
+6   EXAMPLE 1 The function f1 gathers into an array a list of arguments that are pointers to strings (but not
+    more than MAXARGS arguments), then passes the array as a single argument to function f2. The number of
+    pointers is specified by the first argument to f1.
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #define MAXARGS   31
+            void f1(int n_ptrs, ...)
+            {
+                  va_list ap;
+                  char *array[MAXARGS];
+                  int ptr_no = 0;
+
+[<a name="p270" href="#p270">page 270</a>] (<a href="#Contents">Contents</a>)
+
+                      if (n_ptrs &gt; MAXARGS)
+                            n_ptrs = MAXARGS;
+                      va_start(ap, n_ptrs);
+                      while (ptr_no &lt; n_ptrs)
+                            array[ptr_no++] = va_arg(ap, char *);
+                      va_end(ap);
+                      f2(n_ptrs, array);
+             }
+    Each call to f1 is required to have visible the definition of the function or a declaration such as
+             void f1(int, ...);
+
+7   EXAMPLE 2 The function f3 is similar, but saves the status of the variable argument list after the
+    indicated number of arguments; after f2 has been called once with the whole list, the trailing part of the list
+    is gathered again and passed to function f4.
+             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+             #define MAXARGS 31
+             void f3(int n_ptrs, int f4_after, ...)
+             {
+                   va_list ap, ap_save;
+                   char *array[MAXARGS];
+                   int ptr_no = 0;
+                   if (n_ptrs &gt; MAXARGS)
+                         n_ptrs = MAXARGS;
+                   va_start(ap, f4_after);
+                   while (ptr_no &lt; n_ptrs) {
+                         array[ptr_no++] = va_arg(ap, char *);
+                         if (ptr_no == f4_after)
+                               va_copy(ap_save, ap);
+                   }
+                   va_end(ap);
+                   f2(n_ptrs, array);
+                      // Now process the saved copy.
+                      n_ptrs -= f4_after;
+                      ptr_no = 0;
+                      while (ptr_no &lt; n_ptrs)
+                            array[ptr_no++] = va_arg(ap_save, char *);
+                      va_end(ap_save);
+                      f4(n_ptrs, array);
+             }
+
+[<a name="p271" href="#p271">page 271</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.17" href="#7.17"><b>    7.17 Atomics &lt;stdatomic.h&gt;</b></a>
+<a name="7.17.1" href="#7.17.1"><b>    7.17.1 Introduction</b></a>
+1   The header <a href="#7.17">&lt;stdatomic.h&gt;</a> defines several macros and declares several types and
+    functions for performing atomic operations on data shared between threads.
+2   Implementations that define the macro __STDC_NO_THREADS__ need not provide
+    this header nor support any of its facilities.
+3   The macros defined are the atomic lock-free macros
+           ATOMIC_CHAR_LOCK_FREE
+           ATOMIC_CHAR16_T_LOCK_FREE
+           ATOMIC_CHAR32_T_LOCK_FREE
+           ATOMIC_WCHAR_T_LOCK_FREE
+           ATOMIC_SHORT_LOCK_FREE
+           ATOMIC_INT_LOCK_FREE
+           ATOMIC_LONG_LOCK_FREE
+           ATOMIC_LLONG_LOCK_FREE
+           ATOMIC_ADDRESS_LOCK_FREE
+    which indicate the lock-free property of the corresponding atomic types (both signed and
+    unsigned); and
+           ATOMIC_FLAG_INIT
+    which expands to an initializer for an object of type atomic_flag.
+4   The types include
+           memory_order
+    which is an enumerated type whose enumerators identify memory ordering constraints;
+           atomic_flag
+    which is a structure type representing a lock-free, primitive atomic flag;
+           atomic_bool
+    which is a structure type representing the atomic analog of the type _Bool;
+           atomic_address
+    which is a structure type representing the atomic analog of a pointer type; and several
+    atomic analogs of integer types.
+5   In the following operation definitions:
+    -- An A refers to one of the atomic types.
+
+[<a name="p272" href="#p272">page 272</a>] (<a href="#Contents">Contents</a>)
+
+    -- A C refers to its corresponding non-atomic type. The atomic_address atomic
+      type corresponds to the void * non-atomic type.
+    -- An M refers to the type of the other argument for arithmetic operations. For atomic
+      integer types, M is C. For atomic address types, M is ptrdiff_t.
+    -- The functions not ending in _explicit have the same semantics as the
+      corresponding _explicit function with memory_order_seq_cst for the
+      memory_order argument.
+6   NOTE Many operations are volatile-qualified. The ''volatile as device register'' semantics have not
+    changed in the standard. This qualification means that volatility is preserved when applying these
+    operations to volatile objects.
+
+<a name="7.17.2" href="#7.17.2"><b>    7.17.2 Initialization</b></a>
+<a name="7.17.2.1" href="#7.17.2.1"><b>    7.17.2.1 The ATOMIC_VAR_INIT macro</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            #define ATOMIC_VAR_INIT(C value)
+<b>    Description</b>
+2   The ATOMIC_VAR_INIT macro expands to a token sequence suitable for initializing an
+    atomic object of a type that is initialization-compatible with value. An atomic object
+    with automatic storage duration that is not explicitly initialized using
+    ATOMIC_VAR_INIT is initially in an indeterminate state; however, the default (zero)
+    initialization for objects with static or thread-local storage duration is guaranteed to
+    produce a valid state.
+3   Concurrent access to the variable being initialized, even via an atomic operation,
+    constitutes a data race.
+4   EXAMPLE
+            atomic_int guide = ATOMIC_VAR_INIT(42);
+
+<a name="7.17.2.2" href="#7.17.2.2"><b>    7.17.2.2 The atomic_init generic function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            void atomic_init(volatile A *obj, C value);
+<b>    Description</b>
+2   The atomic_init generic function initializes the atomic object pointed to by obj to
+    the value value, while also initializing any additional state that the implementation
+    might need to carry for the atomic object.
+
+[<a name="p273" href="#p273">page 273</a>] (<a href="#Contents">Contents</a>)
+
+3   Although this function initializes an atomic object, it does not avoid data races;
+    concurrent access to the variable being initialized, even via an atomic operation,
+    constitutes a data race.
+<b>    Returns</b>
+4   The atomic_init generic function returns no value.
+5   EXAMPLE
+            atomic_int guide;
+            atomic_init(&amp;guide, 42);
+
+<a name="7.17.3" href="#7.17.3"><b>    7.17.3 Order and consistency</b></a>
+1   The enumerated type memory_order specifies the detailed regular (non-atomic)
+    memory synchronization operations as defined in <a href="#5.1.2.4">5.1.2.4</a> and may provide for operation
+    ordering. Its enumeration constants are as follows:
+            memory_order_relaxed
+            memory_order_consume
+            memory_order_acquire
+            memory_order_release
+            memory_order_acq_rel
+            memory_order_seq_cst
+2   For memory_order_relaxed, no operation orders memory.
+3   For       memory_order_release,       memory_order_acq_rel,             and
+    memory_order_seq_cst, a store operation performs a release operation on the
+    affected memory location.
+4   For       memory_order_acquire,       memory_order_acq_rel,             and
+    memory_order_seq_cst, a load operation performs an acquire operation on the
+    affected memory location.
+5   For memory_order_consume, a load operation performs a consume operation on the
+    affected memory location.
+6   For memory_order_seq_cst, there shall be a single total order S on all operations,
+    consistent with the ''happens before'' order and modification orders for all affected
+    locations, such that each memory_order_seq_cst operation that loads a value
+    observes either the last preceding modification according to this order S, or the result of
+    an operation that is not memory_order_seq_cst.
+7   NOTE 1 Although it is not explicitly required that S include lock operations, it can always be extended to
+    an order that does include lock and unlock operations, since the ordering between those is already included
+    in the ''happens before'' ordering.
+
+8   NOTE 2 Atomic operations specifying memory_order_relaxed are relaxed only with respect to
+    memory ordering. Implementations must still guarantee that any given atomic access to a particular atomic
+
+[<a name="p274" href="#p274">page 274</a>] (<a href="#Contents">Contents</a>)
+
+     object be indivisible with respect to all other atomic accesses to that object.
+
+9    For an atomic operation B that reads the value of an atomic object M, if there is a
+     memory_order_seq_cst fence X sequenced before B, then B observes either the
+     last memory_order_seq_cst modification of M preceding X in the total order S or
+     a later modification of M in its modification order.
+10   For atomic operations A and B on an atomic object M, where A modifies M and B takes
+     its value, if there is a memory_order_seq_cst fence X such that A is sequenced
+     before X and B follows X in S, then B observes either the effects of A or a later
+     modification of M in its modification order.
+11   For atomic operations A and B on an atomic object M, where A modifies M and B takes
+     its value, if there are memory_order_seq_cst fences X and Y such that A is
+     sequenced before X, Y is sequenced before B, and X precedes Y in S, then B observes
+     either the effects of A or a later modification of M in its modification order.
+12   Atomic read-modify-write operations shall always read the last value (in the modification
+     order) stored before the write associated with the read-modify-write operation.
+13   An atomic store shall only store a value that has been computed from constants and
+     program input values by a finite sequence of program evaluations, such that each
+     evaluation observes the values of variables as computed by the last prior assignment in
+     the sequence.<sup><a href="#note251"><b>251)</b></a></sup> The ordering of evaluations in this sequence shall be such that
+     -- If an evaluation B observes a value computed by A in a different thread, then B does
+       not happen before A.
+     -- If an evaluation A is included in the sequence, then all evaluations that assign to the
+       same variable and happen before A are also included.
+14   NOTE 3 The second requirement disallows ''out-of-thin-air'', or ''speculative'' stores of atomics when
+     relaxed atomics are used. Since unordered operations are involved, evaluations may appear in this
+     sequence out of thread order. For example, with x and y initially zero,
+              // Thread 1:
+              r1 = atomic_load_explicit(&amp;y, memory_order_relaxed);
+              atomic_store_explicit(&amp;x, r1, memory_order_relaxed);
+
+              // Thread 2:
+              r2 = atomic_load_explicit(&amp;x, memory_order_relaxed);
+              atomic_store_explicit(&amp;y, 42, memory_order_relaxed);
+     is allowed to produce r1 == 42 &amp;&amp; r2 == 42. The sequence of evaluations justifying this consists of:
+
+
+
+
+     <sup><a name="note251" href="#note251"><b>251)</b></a></sup> Among other implications, atomic variables shall not decay.
+
+[<a name="p275" href="#p275">page 275</a>] (<a href="#Contents">Contents</a>)
+
+             atomic_store_explicit(&amp;y, 42,               memory_order_relaxed);
+             r1 = atomic_load_explicit(&amp;y,               memory_order_relaxed);
+             atomic_store_explicit(&amp;x, r1,               memory_order_relaxed);
+             r2 = atomic_load_explicit(&amp;x,               memory_order_relaxed);
+     On the other hand,
+             // Thread 1:
+             r1 = atomic_load_explicit(&amp;y, memory_order_relaxed);
+             atomic_store_explicit(&amp;x, r1, memory_order_relaxed);
+
+             // Thread 2:
+             r2 = atomic_load_explicit(&amp;x, memory_order_relaxed);
+             atomic_store_explicit(&amp;y, r2, memory_order_relaxed);
+     is not allowed to produce r1 == 42 &amp;&amp; r2 = 42, since there is no sequence of evaluations that results
+     in the computation of 42. In the absence of ''relaxed'' operations and read-modify-write operations with
+     weaker than memory_order_acq_rel ordering, the second requirement has no impact.
+
+     Recommended practice
+15   The requirements do not forbid r1 == 42 &amp;&amp; r2 == 42 in the following example,
+     with x and y initially zero:
+             // Thread 1:
+             r1 = atomic_load_explicit(&amp;x, memory_order_relaxed);
+             if (r1 == 42)
+                  atomic_store_explicit(&amp;y, r1, memory_order_relaxed);
+
+             // Thread 2:
+             r2 = atomic_load_explicit(&amp;y, memory_order_relaxed);
+             if (r2 == 42)
+                  atomic_store_explicit(&amp;x, 42, memory_order_relaxed);
+     However, this is not useful behavior, and implementations should not allow it.
+16   Implementations should make atomic stores visible to atomic loads within a reasonable
+     amount of time.
+<a name="7.17.3.1" href="#7.17.3.1"><b>     7.17.3.1 The kill_dependency macro</b></a>
+<b>     Synopsis</b>
+1            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+             type kill_dependency(type y);
+<b>     Description</b>
+2    The kill_dependency macro terminates a dependency chain; the argument does not
+     carry a dependency to the return value.
+
+[<a name="p276" href="#p276">page 276</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The kill_dependency macro returns the value of y.
+<a name="7.17.4" href="#7.17.4"><b>    7.17.4 Fences</b></a>
+1   This subclause introduces synchronization primitives called fences. Fences can have
+    acquire semantics, release semantics, or both. A fence with acquire semantics is called
+    an acquire fence; a fence with release semantics is called a release fence.
+2   A release fence A synchronizes with an acquire fence B if there exist atomic operations
+    X and Y , both operating on some atomic object M, such that A is sequenced before X, X
+    modifies M, Y is sequenced before B, and Y reads the value written by X or a value
+    written by any side effect in the hypothetical release sequence X would head if it were a
+    release operation.
+3   A release fence A synchronizes with an atomic operation B that performs an acquire
+    operation on an atomic object M if there exists an atomic operation X such that A is
+    sequenced before X, X modifies M, and B reads the value written by X or a value written
+    by any side effect in the hypothetical release sequence X would head if it were a release
+    operation.
+4   An atomic operation A that is a release operation on an atomic object M synchronizes
+    with an acquire fence B if there exists some atomic operation X on M such that X is
+    sequenced before B and reads the value written by A or a value written by any side effect
+    in the release sequence headed by A.
+<a name="7.17.4.1" href="#7.17.4.1"><b>    7.17.4.1 The atomic_thread_fence function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            void atomic_thread_fence(memory_order order);
+<b>    Description</b>
+2   Depending on the value of order, this operation:
+    -- has no effects, if order == memory_order_relaxed;
+    -- is an acquire fence, if order == memory_order_acquire or order ==
+      memory_order_consume;
+    -- is a release fence, if order == memory_order_release;
+    -- is both an acquire fence              and   a    release   fence,    if   order     ==
+      memory_order_acq_rel;
+    -- is a sequentially consistent acquire and release fence, if order                    ==
+      memory_order_seq_cst.
+
+[<a name="p277" href="#p277">page 277</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The atomic_thread_fence function returns no value.
+<a name="7.17.4.2" href="#7.17.4.2"><b>    7.17.4.2 The atomic_signal_fence function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            void atomic_signal_fence(memory_order order);
+<b>    Description</b>
+2   Equivalent to atomic_thread_fence(order), except that ''synchronizes with''
+    relationships are established only between a thread and a signal handler executed in the
+    same thread.
+3   NOTE 1 The atomic_signal_fence function can be used to specify the order in which actions
+    performed by the thread become visible to the signal handler.
+
+4   NOTE 2 Compiler optimizations and reorderings of loads and stores are inhibited in the same way as with
+    atomic_thread_fence, but the hardware fence instructions that atomic_thread_fence would
+    have inserted are not emitted.
+
+<b>    Returns</b>
+5   The atomic_signal_fence function returns no value.
+<a name="7.17.5" href="#7.17.5"><b>    7.17.5 Lock-free property</b></a>
+1   The atomic lock-free macros indicate the lock-free property of integer and address atomic
+    types. A value of 0 indicates that the type is never lock-free; a value of 1 indicates that
+    the type is sometimes lock-free; a value of 2 indicates that the type is always lock-free.
+2   NOTE Operations that are lock-free should also be address-free. That is, atomic operations on the same
+    memory location via two different addresses will communicate atomically. The implementation should not
+    depend on any per-process state. This restriction enables communication via memory mapped into a
+    process more than once and memory shared between two processes.
+
+<a name="7.17.5.1" href="#7.17.5.1"><b>    7.17.5.1 The atomic_is_lock_free generic function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            _Bool atomic_is_lock_free(atomic_type const volatile *obj);
+<b>    Description</b>
+2   The atomic_is_lock_free generic function indicates whether or not the object
+    pointed to by obj is lock-free. atomic_type can be any atomic type.
+<b>    Returns</b>
+3   The atomic_is_lock_free generic function returns nonzero (true) if and only if the
+    object's operations are lock-free. The result of a lock-free query on one object cannot be
+
+[<a name="p278" href="#p278">page 278</a>] (<a href="#Contents">Contents</a>)
+
+    inferred from the result of a lock-free query on another object.
+<a name="7.17.6" href="#7.17.6"><b>    7.17.6 Atomic integer and address types</b></a>
+1   For each line in the following table, the atomic type name is declared as the
+    corresponding direct type.
+
+[<a name="p279" href="#p279">page 279</a>] (<a href="#Contents">Contents</a>)
+
+               Atomic type name                              Direct type
+           atomic_char                           _Atomic    char
+           atomic_schar                          _Atomic    signed char
+           atomic_uchar                          _Atomic    unsigned char
+           atomic_short                          _Atomic    short
+           atomic_ushort                         _Atomic    unsigned short
+           atomic_int                            _Atomic    int
+           atomic_uint                           _Atomic    unsigned int
+           atomic_long                           _Atomic    long
+           atomic_ulong                          _Atomic    unsigned long
+           atomic_llong                          _Atomic    long long
+           atomic_ullong                         _Atomic    unsigned long long
+           atomic_char16_t                       _Atomic    char16_t
+           atomic_char32_t                       _Atomic    char32_t
+           atomic_wchar_t                        _Atomic    wchar_t
+           atomic_int_least8_t                   _Atomic    int_least8_t
+           atomic_uint_least8_t                  _Atomic    uint_least8_t
+           atomic_int_least16_t                  _Atomic    int_least16_t
+           atomic_uint_least16_t                 _Atomic    uint_least16_t
+           atomic_int_least32_t                  _Atomic    int_least32_t
+           atomic_uint_least32_t                 _Atomic    uint_least32_t
+           atomic_int_least64_t                  _Atomic    int_least64_t
+           atomic_uint_least64_t                 _Atomic    uint_least64_t
+           atomic_int_fast8_t                    _Atomic    int_fast8_t
+           atomic_uint_fast8_t                   _Atomic    uint_fast8_t
+           atomic_int_fast16_t                   _Atomic    int_fast16_t
+           atomic_uint_fast16_t                  _Atomic    uint_fast16_t
+           atomic_int_fast32_t                   _Atomic    int_fast32_t
+           atomic_uint_fast32_t                  _Atomic    uint_fast32_t
+           atomic_int_fast64_t                   _Atomic    int_fast64_t
+           atomic_uint_fast64_t                  _Atomic    uint_fast64_t
+           atomic_intptr_t                       _Atomic    intptr_t
+           atomic_uintptr_t                      _Atomic    uintptr_t
+           atomic_size_t                         _Atomic    size_t
+           atomic_ptrdiff_t                      _Atomic    ptrdiff_t
+           atomic_intmax_t                       _Atomic    intmax_t
+           atomic_uintmax_t                      _Atomic    uintmax_t
+2   The semantics of the operations on these types are defined in <a href="#7.17.7">7.17.7</a>.
+3   The atomic_bool type provides an atomic boolean.
+
+[<a name="p280" href="#p280">page 280</a>] (<a href="#Contents">Contents</a>)
+
+4   The atomic_address type provides atomic void * operations. The unit of
+    addition/subtraction shall be one byte.
+5   NOTE The representation of atomic integer and address types need not have the same size as their
+    corresponding regular types. They should have the same size whenever possible, as it eases effort required
+    to port existing code.
+
+<a name="7.17.7" href="#7.17.7"><b>    7.17.7 Operations on atomic types</b></a>
+1   There are only a few kinds of operations on atomic types, though there are many
+    instances of those kinds. This subclause specifies each general kind.
+<a name="7.17.7.1" href="#7.17.7.1"><b>    7.17.7.1 The atomic_store generic functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            void atomic_store(volatile A *object, C desired);
+            void atomic_store_explicit(volatile A *object,
+                 C desired, memory_order order);
+<b>    Description</b>
+2   The      order      argument    shall    not    be    memory_order_acquire,
+    memory_order_consume, nor memory_order_acq_rel. Atomically replace the
+    value pointed to by object with the value of desired. Memory is affected according
+    to the value of order.
+<b>    Returns</b>
+3   The atomic_store generic functions return no value.
+<a name="7.17.7.2" href="#7.17.7.2"><b>    7.17.7.2 The atomic_load generic functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            C atomic_load(volatile A *object);
+            C atomic_load_explicit(volatile A *object,
+                 memory_order order);
+<b>    Description</b>
+2   The order argument shall not be memory_order_release nor
+    memory_order_acq_rel. Memory is affected according to the value of order.
+<b>    Returns</b>
+    Atomically returns the value pointed to by object.
+
+[<a name="p281" href="#p281">page 281</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.17.7.3" href="#7.17.7.3"><b>    7.17.7.3 The atomic_exchange generic functions</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+             C atomic_exchange(volatile A *object, C desired);
+             C atomic_exchange_explicit(volatile A *object,
+                  C desired, memory_order order);
+<b>    Description</b>
+2   Atomically replace the value pointed to by object with desired. Memory is affected
+    according to the value of order. These operations are read-modify-write operations
+    (<a href="#5.1.2.4">5.1.2.4</a>).
+<b>    Returns</b>
+3   Atomically returns the value pointed to by object immediately before the effects.
+<a name="7.17.7.4" href="#7.17.7.4"><b>    7.17.7.4 The atomic_compare_exchange generic functions</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+             _Bool atomic_compare_exchange_strong(volatile A *object,
+                  C *expected, C desired);
+             _Bool atomic_compare_exchange_strong_explicit(
+                  volatile A *object, C *expected, C desired,
+                  memory_order success, memory_order failure);
+             _Bool atomic_compare_exchange_weak(volatile A *object,
+                  C *expected, C desired);
+             _Bool atomic_compare_exchange_weak_explicit(
+                  volatile A *object, C *expected, C desired,
+                  memory_order success, memory_order failure);
+<b>    Description</b>
+2   The failure argument shall not be memory_order_release nor
+    memory_order_acq_rel. The failure argument shall be no stronger than the
+    success argument. Atomically, compares the value pointed to by object for equality
+    with that in expected, and if true, replaces the value pointed to by object with
+    desired, and if false, updates the value in expected with the value pointed to by
+    object. Further, if the comparison is true, memory is affected according to the value of
+    success, and if the comparison is false, memory is affected according to the value of
+    failure. These operations are atomic read-modify-write operations (<a href="#5.1.2.4">5.1.2.4</a>).
+3   NOTE 1    The effect of the compare-and-exchange operations is
+
+[<a name="p282" href="#p282">page 282</a>] (<a href="#Contents">Contents</a>)
+
+             if (*object == *expected)
+                   *object = desired;
+             else
+                   *expected = *object;
+
+4   The weak compare-and-exchange operations may fail spuriously, that is, return zero
+    while leaving the value pointed to by expected unchanged.
+5   NOTE 2 This spurious failure enables implementation of compare-and-exchange on a broader class of
+    machines, e.g. load-locked store-conditional machines.
+
+6   EXAMPLE         A consequence of spurious failure is that nearly all uses of weak compare-and-exchange will
+    be in a loop.
+             exp = atomic_load(&amp;cur);
+             do {
+                   des = function(exp);
+             } while (!atomic_compare_exchange_weak(&amp;cur, &amp;exp, des));
+    When a compare-and-exchange is in a loop, the weak version will yield better performance on some
+    platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
+    strong one is preferable.
+
+<b>    Returns</b>
+7   The result of the comparison.
+<a name="7.17.7.5" href="#7.17.7.5"><b>    7.17.7.5 The atomic_fetch and modify generic functions</b></a>
+1   The following operations perform arithmetic and bitwise computations. All of these
+    operations are applicable to an object of any atomic integer type. Only addition and
+    subtraction are applicable to atomic_address. None of these operations is applicable
+    to atomic_bool. The key, operator, and computation correspondence is:
+     key            op          computation
+     add            +       addition
+     sub            -       subtraction
+     or             |       bitwise inclusive or
+     xor            ^       bitwise exclusive or
+     and            &amp;       bitwise and
+<b>    Synopsis</b>
+2            #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+             C atomic_fetch_key(volatile A *object, M operand);
+             C atomic_fetch_key_explicit(volatile A *object,
+                  M operand, memory_order order);
+<b>    Description</b>
+3   Atomically replaces the value pointed to by object with the result of the computation
+    applied to the value pointed to by object and the given operand. Memory is affected
+    according to the value of order. These operations are atomic read-modify-write
+
+[<a name="p283" href="#p283">page 283</a>] (<a href="#Contents">Contents</a>)
+
+    operations (<a href="#5.1.2.4">5.1.2.4</a>). For signed integer types, arithmetic is defined to use two's
+    complement representation with silent wrap-around on overflow; there are no undefined
+    results. For address types, the result may be an undefined address, but the operations
+    otherwise have no undefined behavior.
+<b>    Returns</b>
+4   Atomically, the value pointed to by object immediately before the effects.
+5   NOTE The operation of the atomic_fetch and modify generic functions are nearly equivalent to the
+    operation of the corresponding op= compound assignment operators. The only differences are that the
+    compound assignment operators are not guaranteed to operate atomically, and the value yielded by a
+    compound assignment operator is the updated value of the object, whereas the value returned by the
+    atomic_fetch and modify generic functions is the previous value of the atomic object.
+
+<a name="7.17.8" href="#7.17.8"><b>    7.17.8 Atomic flag type and operations</b></a>
+1   The atomic_flag type provides the classic test-and-set functionality. It has two
+    states, set and clear.
+2   Operations on an object of type atomic_flag shall be lock free.
+3   NOTE Hence the operations should also be address-free. No other type requires lock-free operations, so
+    the atomic_flag type is the minimum hardware-implemented type needed to conform to this
+    International standard. The remaining types can be emulated with atomic_flag, though with less than
+    ideal properties.
+
+4   The macro ATOMIC_FLAG_INIT may be used to initialize an atomic_flag to the
+    clear state. An atomic_flag that is not explicitly initialized with
+    ATOMIC_FLAG_INIT is initially in an indeterminate state.
+5   EXAMPLE
+            atomic_flag guard = ATOMIC_FLAG_INIT;
+
+<a name="7.17.8.1" href="#7.17.8.1"><b>    7.17.8.1 The atomic_flag_test_and_set functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            bool atomic_flag_test_and_set(
+                 volatile atomic_flag *object);
+            bool atomic_flag_test_and_set_explicit(
+                 volatile atomic_flag *object, memory_order order);
+<b>    Description</b>
+2   Atomically sets the value pointed to by object to true. Memory is affected according
+    to the value of order. These operations are atomic read-modify-write operations
+    (<a href="#5.1.2.4">5.1.2.4</a>).
+
+[<a name="p284" href="#p284">page 284</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   Atomically, the value of the object immediately before the effects.
+<a name="7.17.8.2" href="#7.17.8.2"><b>    7.17.8.2 The atomic_flag_clear functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.17">&lt;stdatomic.h&gt;</a>
+            void atomic_flag_clear(volatile atomic_flag *object);
+            void atomic_flag_clear_explicit(
+                 volatile atomic_flag *object, memory_order order);
+<b>    Description</b>
+2   The order argument shall not be memory_order_acquire nor
+    memory_order_acq_rel. Atomically sets the value pointed to by object to false.
+    Memory is affected according to the value of order.
+<b>    Returns</b>
+3   The atomic_flag_clear functions return no value.
+
+[<a name="p285" href="#p285">page 285</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.18" href="#7.18"><b>    7.18 Boolean type and values &lt;stdbool.h&gt;</b></a>
+1   The header <a href="#7.18">&lt;stdbool.h&gt;</a> defines four macros.
+2   The macro
+             bool
+    expands to _Bool.
+3   The remaining three macros are suitable for use in #if preprocessing directives. They
+    are
+             true
+    which expands to the integer constant 1,
+             false
+    which expands to the integer constant 0, and
+             __bool_true_false_are_defined
+    which expands to the integer constant 1.
+4   Notwithstanding the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and perhaps then
+    redefine the macros bool, true, and false.<sup><a href="#note252"><b>252)</b></a></sup>
+
+
+
+
+    <sup><a name="note252" href="#note252"><b>252)</b></a></sup> See ''future library directions'' (<a href="#7.30.7">7.30.7</a>).
+
+[<a name="p286" href="#p286">page 286</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.19" href="#7.19"><b>    7.19 Common definitions &lt;stddef.h&gt;</b></a>
+1   The header <a href="#7.19">&lt;stddef.h&gt;</a> defines the following macros and declares the following types.
+    Some are also defined in other headers, as noted in their respective subclauses.
+2   The types are
+            ptrdiff_t
+    which is the signed integer type of the result of subtracting two pointers;
+            size_t
+    which is the unsigned integer type of the result of the sizeof operator;
+            max_align_t
+    which is an object type whose alignment is as great as is supported by the implementation
+    in all contexts; and
+            wchar_t
+    which is an integer type whose range of values can represent distinct codes for all
+    members of the largest extended character set specified among the supported locales; the
+    null character shall have the code value zero. Each member of the basic character set
+    shall have a code value equal to its value when used as the lone character in an integer
+    character      constant     if     an      implementation      does      not      define
+    __STDC_MB_MIGHT_NEQ_WC__.
+3   The macros are
+            NULL
+    which expands to an implementation-defined null pointer constant; and
+            offsetof(type, member-designator)
+    which expands to an integer constant expression that has type size_t, the value of
+    which is the offset in bytes, to the structure member (designated by member-designator),
+    from the beginning of its structure (designated by type). The type and member designator
+    shall be such that given
+            static type t;
+    then the expression &amp;(t.member-designator) evaluates to an address constant. (If the
+    specified member is a bit-field, the behavior is undefined.)
+    Recommended practice
+4   The types used for size_t and ptrdiff_t should not have an integer conversion rank
+    greater than that of signed long int unless the implementation supports objects
+    large enough to make this necessary.
+
+[<a name="p287" href="#p287">page 287</a>] (<a href="#Contents">Contents</a>)
+
+Forward references: localization (<a href="#7.11">7.11</a>).
+
+[<a name="p288" href="#p288">page 288</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20" href="#7.20"><b>    7.20 Integer types &lt;stdint.h&gt;</b></a>
+1   The header <a href="#7.20">&lt;stdint.h&gt;</a> declares sets of integer types having specified widths, and
+    defines corresponding sets of macros.<sup><a href="#note253"><b>253)</b></a></sup> It also defines macros that specify limits of
+    integer types corresponding to types defined in other standard headers.
+2   Types are defined in the following categories:
+    -- integer types having certain exact widths;
+    -- integer types having at least certain specified widths;
+    -- fastest integer types having at least certain specified widths;
+    -- integer types wide enough to hold pointers to objects;
+    -- integer types having greatest width.
+    (Some of these types may denote the same type.)
+3   Corresponding macros specify limits of the declared types and construct suitable
+    constants.
+4   For each type described herein that the implementation provides,<sup><a href="#note254"><b>254)</b></a></sup> <a href="#7.20">&lt;stdint.h&gt;</a> shall
+    declare that typedef name and define the associated macros. Conversely, for each type
+    described herein that the implementation does not provide, <a href="#7.20">&lt;stdint.h&gt;</a> shall not
+    declare that typedef name nor shall it define the associated macros. An implementation
+    shall provide those types described as ''required'', but need not provide any of the others
+    (described as ''optional'').
+<a name="7.20.1" href="#7.20.1"><b>    7.20.1 Integer types</b></a>
+1   When typedef names differing only in the absence or presence of the initial u are defined,
+    they shall denote corresponding signed and unsigned types as described in <a href="#6.2.5">6.2.5</a>; an
+    implementation providing one of these corresponding types shall also provide the other.
+2   In the following descriptions, the symbol N represents an unsigned decimal integer with
+    no leading zeros (e.g., 8 or 24, but not 04 or 048).
+
+
+
+
+    <sup><a name="note253" href="#note253"><b>253)</b></a></sup> See ''future library directions'' (<a href="#7.30.8">7.30.8</a>).
+    <sup><a name="note254" href="#note254"><b>254)</b></a></sup> Some of these types may denote implementation-defined extended integer types.
+
+[<a name="p289" href="#p289">page 289</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.1.1" href="#7.20.1.1"><b>    7.20.1.1 Exact-width integer types</b></a>
+1   The typedef name intN_t designates a signed integer type with width N , no padding
+    bits, and a two's complement representation. Thus, int8_t denotes such a signed
+    integer type with a width of exactly 8 bits.
+2   The typedef name uintN_t designates an unsigned integer type with width N and no
+    padding bits. Thus, uint24_t denotes such an unsigned integer type with a width of
+    exactly 24 bits.
+3   These types are optional. However, if an implementation provides integer types with
+    widths of 8, 16, 32, or 64 bits, no padding bits, and (for the signed types) that have a
+    two's complement representation, it shall define the corresponding typedef names.
+<a name="7.20.1.2" href="#7.20.1.2"><b>    7.20.1.2 Minimum-width integer types</b></a>
+1   The typedef name int_leastN_t designates a signed integer type with a width of at
+    least N , such that no signed integer type with lesser size has at least the specified width.
+    Thus, int_least32_t denotes a signed integer type with a width of at least 32 bits.
+2   The typedef name uint_leastN_t designates an unsigned integer type with a width
+    of at least N , such that no unsigned integer type with lesser size has at least the specified
+    width. Thus, uint_least16_t denotes an unsigned integer type with a width of at
+    least 16 bits.
+3   The following types are required:
+             int_least8_t                                      uint_least8_t
+             int_least16_t                                     uint_least16_t
+             int_least32_t                                     uint_least32_t
+             int_least64_t                                     uint_least64_t
+    All other types of this form are optional.
+<a name="7.20.1.3" href="#7.20.1.3"><b>    7.20.1.3 Fastest minimum-width integer types</b></a>
+1   Each of the following types designates an integer type that is usually fastest<sup><a href="#note255"><b>255)</b></a></sup> to operate
+    with among all integer types that have at least the specified width.
+2   The typedef name int_fastN_t designates the fastest signed integer type with a width
+    of at least N . The typedef name uint_fastN_t designates the fastest unsigned integer
+    type with a width of at least N .
+
+
+
+
+    <sup><a name="note255" href="#note255"><b>255)</b></a></sup> The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear
+         grounds for choosing one type over another, it will simply pick some integer type satisfying the
+         signedness and width requirements.
+
+[<a name="p290" href="#p290">page 290</a>] (<a href="#Contents">Contents</a>)
+
+3   The following types are required:
+            int_fast8_t                                    uint_fast8_t
+            int_fast16_t                                   uint_fast16_t
+            int_fast32_t                                   uint_fast32_t
+            int_fast64_t                                   uint_fast64_t
+    All other types of this form are optional.
+<a name="7.20.1.4" href="#7.20.1.4"><b>    7.20.1.4 Integer types capable of holding object pointers</b></a>
+1   The following type designates a signed integer type with the property that any valid
+    pointer to void can be converted to this type, then converted back to pointer to void,
+    and the result will compare equal to the original pointer:
+            intptr_t
+    The following type designates an unsigned integer type with the property that any valid
+    pointer to void can be converted to this type, then converted back to pointer to void,
+    and the result will compare equal to the original pointer:
+            uintptr_t
+    These types are optional.
+<a name="7.20.1.5" href="#7.20.1.5"><b>    7.20.1.5 Greatest-width integer types</b></a>
+1   The following type designates a signed integer type capable of representing any value of
+    any signed integer type:
+            intmax_t
+    The following type designates an unsigned integer type capable of representing any value
+    of any unsigned integer type:
+            uintmax_t
+    These types are required.
+<a name="7.20.2" href="#7.20.2"><b>    7.20.2 Limits of specified-width integer types</b></a>
+1   The following object-like macros specify the minimum and maximum limits of the types *
+    declared in <a href="#7.20">&lt;stdint.h&gt;</a>. Each macro name corresponds to a similar type name in
+    <a href="#7.20.1">7.20.1</a>.
+2   Each instance of any defined macro shall be replaced by a constant expression suitable
+    for use in #if preprocessing directives, and this expression shall have the same type as
+    would an expression that is an object of the corresponding type converted according to
+    the integer promotions. Its implementation-defined value shall be equal to or greater in
+    magnitude (absolute value) than the corresponding value given below, with the same sign,
+    except where stated to be exactly the given value.
+
+[<a name="p291" href="#p291">page 291</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.2.1" href="#7.20.2.1"><b>    7.20.2.1 Limits of exact-width integer types</b></a>
+1   -- minimum values of exact-width signed integer types
+          INTN_MIN                                  exactly -(2 N -1 )
+    -- maximum values of exact-width signed integer types
+          INTN_MAX                                  exactly 2 N -1 - 1
+    -- maximum values of exact-width unsigned integer types
+       UINTN_MAX                                    exactly 2 N - 1
+<a name="7.20.2.2" href="#7.20.2.2"><b>    7.20.2.2 Limits of minimum-width integer types</b></a>
+1   -- minimum values of minimum-width signed integer types
+          INT_LEASTN_MIN                                    -(2 N -1 - 1)
+    -- maximum values of minimum-width signed integer types
+          INT_LEASTN_MAX                                    2 N -1 - 1
+    -- maximum values of minimum-width unsigned integer types
+       UINT_LEASTN_MAX                                      2N - 1
+<a name="7.20.2.3" href="#7.20.2.3"><b>    7.20.2.3 Limits of fastest minimum-width integer types</b></a>
+1   -- minimum values of fastest minimum-width signed integer types
+          INT_FASTN_MIN                                     -(2 N -1 - 1)
+    -- maximum values of fastest minimum-width signed integer types
+       INT_FASTN_MAX                                        2 N -1 - 1
+    -- maximum values of fastest minimum-width unsigned integer types
+       UINT_FASTN_MAX                                       2N - 1
+<a name="7.20.2.4" href="#7.20.2.4"><b>    7.20.2.4 Limits of integer types capable of holding object pointers</b></a>
+1   -- minimum value of pointer-holding signed integer type
+          INTPTR_MIN                                        -(215 - 1)
+    -- maximum value of pointer-holding signed integer type
+       INTPTR_MAX                                           215 - 1
+    -- maximum value of pointer-holding unsigned integer type
+       UINTPTR_MAX                                          216 - 1
+
+[<a name="p292" href="#p292">page 292</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.2.5" href="#7.20.2.5"><b>    7.20.2.5 Limits of greatest-width integer types</b></a>
+1   -- minimum value of greatest-width signed integer type
+        INTMAX_MIN                                                    -(263 - 1)
+    -- maximum value of greatest-width signed integer type
+        INTMAX_MAX                                                    263 - 1
+    -- maximum value of greatest-width unsigned integer type
+        UINTMAX_MAX                                                   264 - 1
+<a name="7.20.3" href="#7.20.3"><b>    7.20.3 Limits of other integer types</b></a>
+1   The following object-like macros specify the minimum and maximum limits of integer *
+    types corresponding to types defined in other standard headers.
+2   Each instance of these macros shall be replaced by a constant expression suitable for use
+    in #if preprocessing directives, and this expression shall have the same type as would an
+    expression that is an object of the corresponding type converted according to the integer
+    promotions. Its implementation-defined value shall be equal to or greater in magnitude
+    (absolute value) than the corresponding value given below, with the same sign. An
+    implementation shall define only the macros corresponding to those typedef names it
+    actually provides.<sup><a href="#note256"><b>256)</b></a></sup>
+    -- limits of ptrdiff_t
+        PTRDIFF_MIN                                                 -65535
+        PTRDIFF_MAX                                                 +65535
+    -- limits of sig_atomic_t
+        SIG_ATOMIC_MIN                                              see below
+        SIG_ATOMIC_MAX                                              see below
+    -- limit of size_t
+        SIZE_MAX                                                      65535
+    -- limits of wchar_t
+        WCHAR_MIN                                                   see below
+        WCHAR_MAX                                                   see below
+    -- limits of wint_t
+
+
+
+
+    <sup><a name="note256" href="#note256"><b>256)</b></a></sup> A freestanding implementation need not provide all of these types.
+
+[<a name="p293" href="#p293">page 293</a>] (<a href="#Contents">Contents</a>)
+
+        WINT_MIN                                              see below
+        WINT_MAX                                              see below
+3   If sig_atomic_t (see <a href="#7.14">7.14</a>) is defined as a signed integer type, the value of
+    SIG_ATOMIC_MIN shall be no greater than -127 and the value of SIG_ATOMIC_MAX
+    shall be no less than 127; otherwise, sig_atomic_t is defined as an unsigned integer
+    type, and the value of SIG_ATOMIC_MIN shall be 0 and the value of
+    SIG_ATOMIC_MAX shall be no less than 255.
+4   If wchar_t (see <a href="#7.19">7.19</a>) is defined as a signed integer type, the value of WCHAR_MIN
+    shall be no greater than -127 and the value of WCHAR_MAX shall be no less than 127;
+    otherwise, wchar_t is defined as an unsigned integer type, and the value of
+    WCHAR_MIN shall be 0 and the value of WCHAR_MAX shall be no less than 255.<sup><a href="#note257"><b>257)</b></a></sup>
+5   If wint_t (see <a href="#7.28">7.28</a>) is defined as a signed integer type, the value of WINT_MIN shall
+    be no greater than -32767 and the value of WINT_MAX shall be no less than 32767;
+    otherwise, wint_t is defined as an unsigned integer type, and the value of WINT_MIN
+    shall be 0 and the value of WINT_MAX shall be no less than 65535.
+<a name="7.20.4" href="#7.20.4"><b>    7.20.4 Macros for integer constants</b></a>
+1   The following function-like macros expand to integer constants suitable for initializing *
+    objects that have integer types corresponding to types defined in <a href="#7.20">&lt;stdint.h&gt;</a>. Each
+    macro name corresponds to a similar type name in <a href="#7.20.1.2">7.20.1.2</a> or <a href="#7.20.1.5">7.20.1.5</a>.
+2   The argument in any instance of these macros shall be an unsuffixed integer constant (as
+    defined in <a href="#6.4.4.1">6.4.4.1</a>) with a value that does not exceed the limits for the corresponding type.
+3   Each invocation of one of these macros shall expand to an integer constant expression
+    suitable for use in #if preprocessing directives. The type of the expression shall have
+    the same type as would an expression of the corresponding type converted according to
+    the integer promotions. The value of the expression shall be that of the argument.
+<a name="7.20.4.1" href="#7.20.4.1"><b>    7.20.4.1 Macros for minimum-width integer constants</b></a>
+1   The macro INTN_C(value) shall expand to an integer constant expression
+    corresponding to the type int_leastN_t. The macro UINTN_C(value) shall expand
+    to an integer constant expression corresponding to the type uint_leastN_t. For
+    example, if uint_least64_t is a name for the type unsigned long long int,
+    then UINT64_C(0x123) might expand to the integer constant 0x123ULL.
+
+
+
+
+    <sup><a name="note257" href="#note257"><b>257)</b></a></sup> The values WCHAR_MIN and WCHAR_MAX do not necessarily correspond to members of the extended
+         character set.
+
+[<a name="p294" href="#p294">page 294</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.20.4.2" href="#7.20.4.2"><b>    7.20.4.2 Macros for greatest-width integer constants</b></a>
+1   The following macro expands to an integer constant expression having the value specified
+    by its argument and the type intmax_t:
+            INTMAX_C(value)
+    The following macro expands to an integer constant expression having the value specified
+    by its argument and the type uintmax_t:
+            UINTMAX_C(value)
+
+[<a name="p295" href="#p295">page 295</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21" href="#7.21"><b>    7.21 Input/output &lt;stdio.h&gt;</b></a>
+<a name="7.21.1" href="#7.21.1"><b>    7.21.1 Introduction</b></a>
+1   The header <a href="#7.21">&lt;stdio.h&gt;</a> defines several macros, and declares three types and many
+    functions for performing input and output.
+2   The types declared are size_t (described in <a href="#7.19">7.19</a>);
+           FILE
+    which is an object type capable of recording all the information needed to control a
+    stream, including its file position indicator, a pointer to its associated buffer (if any), an
+    error indicator that records whether a read/write error has occurred, and an end-of-file
+    indicator that records whether the end of the file has been reached; and
+           fpos_t
+    which is a complete object type other than an array type capable of recording all the
+    information needed to specify uniquely every position within a file.
+3   The macros are NULL (described in <a href="#7.19">7.19</a>);
+           _IOFBF
+           _IOLBF
+           _IONBF
+    which expand to integer constant expressions with distinct values, suitable for use as the
+    third argument to the setvbuf function;
+           BUFSIZ
+    which expands to an integer constant expression that is the size of the buffer used by the
+    setbuf function;
+           EOF
+    which expands to an integer constant expression, with type int and a negative value, that
+    is returned by several functions to indicate end-of-file, that is, no more input from a
+    stream;
+           FOPEN_MAX
+    which expands to an integer constant expression that is the minimum number of files that
+    the implementation guarantees can be open simultaneously;
+           FILENAME_MAX
+    which expands to an integer constant expression that is the size needed for an array of
+    char large enough to hold the longest file name string that the implementation
+
+[<a name="p296" href="#p296">page 296</a>] (<a href="#Contents">Contents</a>)
+
+    guarantees can be opened;<sup><a href="#note258"><b>258)</b></a></sup>
+            L_tmpnam
+    which expands to an integer constant expression that is the size needed for an array of
+    char large enough to hold a temporary file name string generated by the tmpnam
+    function;
+            SEEK_CUR
+            SEEK_END
+            SEEK_SET
+    which expand to integer constant expressions with distinct values, suitable for use as the
+    third argument to the fseek function;
+            TMP_MAX
+    which expands to an integer constant expression that is the minimum number of unique
+    file names that can be generated by the tmpnam function;
+            stderr
+            stdin
+            stdout
+    which are expressions of type ''pointer to FILE'' that point to the FILE objects
+    associated, respectively, with the standard error, input, and output streams.
+4   The header <a href="#7.28">&lt;wchar.h&gt;</a> declares a number of functions useful for wide character input
+    and output. The wide character input/output functions described in that subclause
+    provide operations analogous to most of those described here, except that the
+    fundamental units internal to the program are wide characters. The external
+    representation (in the file) is a sequence of ''generalized'' multibyte characters, as
+    described further in <a href="#7.21.3">7.21.3</a>.
+5   The input/output functions are given the following collective terms:
+    -- The wide character input functions -- those functions described in <a href="#7.28">7.28</a> that perform
+      input into wide characters and wide strings: fgetwc, fgetws, getwc, getwchar,
+      fwscanf, wscanf, vfwscanf, and vwscanf.
+    -- The wide character output functions -- those functions described in <a href="#7.28">7.28</a> that perform
+      output from wide characters and wide strings: fputwc, fputws, putwc,
+      putwchar, fwprintf, wprintf, vfwprintf, and vwprintf.
+
+
+    <sup><a name="note258" href="#note258"><b>258)</b></a></sup> If the implementation imposes no practical limit on the length of file name strings, the value of
+         FILENAME_MAX should instead be the recommended size of an array intended to hold a file name
+         string. Of course, file name string contents are subject to other system-specific constraints; therefore
+         all possible strings of length FILENAME_MAX cannot be expected to be opened successfully.
+
+[<a name="p297" href="#p297">page 297</a>] (<a href="#Contents">Contents</a>)
+
+    -- The wide character input/output functions -- the union of the ungetwc function, the
+      wide character input functions, and the wide character output functions.
+    -- The byte input/output functions -- those functions described in this subclause that
+      perform input/output: fgetc, fgets, fprintf, fputc, fputs, fread,
+      fscanf, fwrite, getc, getchar, printf, putc, putchar, puts, scanf, *
+      ungetc, vfprintf, vfscanf, vprintf, and vscanf.
+    Forward references: files (<a href="#7.21.3">7.21.3</a>), the fseek function (<a href="#7.21.9.2">7.21.9.2</a>), streams (<a href="#7.21.2">7.21.2</a>), the
+    tmpnam function (<a href="#7.21.4.4">7.21.4.4</a>), <a href="#7.28">&lt;wchar.h&gt;</a> (<a href="#7.28">7.28</a>).
+<a name="7.21.2" href="#7.21.2"><b>    7.21.2 Streams</b></a>
+1   Input and output, whether to or from physical devices such as terminals and tape drives,
+    or whether to or from files supported on structured storage devices, are mapped into
+    logical data streams, whose properties are more uniform than their various inputs and
+    outputs. Two forms of mapping are supported, for text streams and for binary
+    streams.<sup><a href="#note259"><b>259)</b></a></sup>
+2   A text stream is an ordered sequence of characters composed into lines, each line
+    consisting of zero or more characters plus a terminating new-line character. Whether the
+    last line requires a terminating new-line character is implementation-defined. Characters
+    may have to be added, altered, or deleted on input and output to conform to differing
+    conventions for representing text in the host environment. Thus, there need not be a one-
+    to-one correspondence between the characters in a stream and those in the external
+    representation. Data read in from a text stream will necessarily compare equal to the data
+    that were earlier written out to that stream only if: the data consist only of printing
+    characters and the control characters horizontal tab and new-line; no new-line character is
+    immediately preceded by space characters; and the last character is a new-line character.
+    Whether space characters that are written out immediately before a new-line character
+    appear when read in is implementation-defined.
+3   A binary stream is an ordered sequence of characters that can transparently record
+    internal data. Data read in from a binary stream shall compare equal to the data that were
+    earlier written out to that stream, under the same implementation. Such a stream may,
+    however, have an implementation-defined number of null characters appended to the end
+    of the stream.
+4   Each stream has an orientation. After a stream is associated with an external file, but
+    before any operations are performed on it, the stream is without orientation. Once a wide
+    character input/output function has been applied to a stream without orientation, the
+
+
+    <sup><a name="note259" href="#note259"><b>259)</b></a></sup> An implementation need not distinguish between text streams and binary streams. In such an
+         implementation, there need be no new-line characters in a text stream nor any limit to the length of a
+         line.
+
+[<a name="p298" href="#p298">page 298</a>] (<a href="#Contents">Contents</a>)
+
+    stream becomes a wide-oriented stream. Similarly, once a byte input/output function has
+    been applied to a stream without orientation, the stream becomes a byte-oriented stream.
+    Only a call to the freopen function or the fwide function can otherwise alter the
+    orientation of a stream. (A successful call to freopen removes any orientation.)<sup><a href="#note260"><b>260)</b></a></sup>
+5   Byte input/output functions shall not be applied to a wide-oriented stream and wide
+    character input/output functions shall not be applied to a byte-oriented stream. The
+    remaining stream operations do not affect, and are not affected by, a stream's orientation,
+    except for the following additional restrictions:
+    -- Binary wide-oriented streams have the file-positioning restrictions ascribed to both
+      text and binary streams.
+    -- For wide-oriented streams, after a successful call to a file-positioning function that
+      leaves the file position indicator prior to the end-of-file, a wide character output
+      function can overwrite a partial multibyte character; any file contents beyond the
+      byte(s) written are henceforth indeterminate.
+6   Each wide-oriented stream has an associated mbstate_t object that stores the current
+    parse state of the stream. A successful call to fgetpos stores a representation of the
+    value of this mbstate_t object as part of the value of the fpos_t object. A later
+    successful call to fsetpos using the same stored fpos_t value restores the value of
+    the associated mbstate_t object as well as the position within the controlled stream.
+    Environmental limits
+7   An implementation shall support text files with lines containing at least 254 characters,
+    including the terminating new-line character. The value of the macro BUFSIZ shall be at
+    least 256.
+    Forward references: the freopen function (<a href="#7.21.5.4">7.21.5.4</a>), the fwide function (<a href="#7.28.3.5">7.28.3.5</a>),
+    mbstate_t (<a href="#7.29.1">7.29.1</a>), the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>), the fsetpos function
+    (<a href="#7.21.9.3">7.21.9.3</a>).
+
+
+
+
+    <sup><a name="note260" href="#note260"><b>260)</b></a></sup> The three predefined streams stdin, stdout, and stderr are unoriented at program startup.
+
+[<a name="p299" href="#p299">page 299</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.3" href="#7.21.3"><b>    7.21.3 Files</b></a>
+1   A stream is associated with an external file (which may be a physical device) by opening
+    a file, which may involve creating a new file. Creating an existing file causes its former
+    contents to be discarded, if necessary. If a file can support positioning requests (such as a
+    disk file, as opposed to a terminal), then a file position indicator associated with the
+    stream is positioned at the start (character number zero) of the file, unless the file is
+    opened with append mode in which case it is implementation-defined whether the file
+    position indicator is initially positioned at the beginning or the end of the file. The file
+    position indicator is maintained by subsequent reads, writes, and positioning requests, to
+    facilitate an orderly progression through the file.
+2   Binary files are not truncated, except as defined in <a href="#7.21.5.3">7.21.5.3</a>. Whether a write on a text
+    stream causes the associated file to be truncated beyond that point is implementation-
+    defined.
+3   When a stream is unbuffered, characters are intended to appear from the source or at the
+    destination as soon as possible. Otherwise characters may be accumulated and
+    transmitted to or from the host environment as a block. When a stream is fully buffered,
+    characters are intended to be transmitted to or from the host environment as a block when
+    a buffer is filled. When a stream is line buffered, characters are intended to be
+    transmitted to or from the host environment as a block when a new-line character is
+    encountered. Furthermore, characters are intended to be transmitted as a block to the host
+    environment when a buffer is filled, when input is requested on an unbuffered stream, or
+    when input is requested on a line buffered stream that requires the transmission of
+    characters from the host environment. Support for these characteristics is
+    implementation-defined, and may be affected via the setbuf and setvbuf functions.
+4   A file may be disassociated from a controlling stream by closing the file. Output streams
+    are flushed (any unwritten buffer contents are transmitted to the host environment) before
+    the stream is disassociated from the file. The value of a pointer to a FILE object is
+    indeterminate after the associated file is closed (including the standard text streams).
+    Whether a file of zero length (on which no characters have been written by an output
+    stream) actually exists is implementation-defined.
+5   The file may be subsequently reopened, by the same or another program execution, and
+    its contents reclaimed or modified (if it can be repositioned at its start). If the main
+    function returns to its original caller, or if the exit function is called, all open files are
+    closed (hence all output streams are flushed) before program termination. Other paths to
+    program termination, such as calling the abort function, need not close all files
+    properly.
+6   The address of the FILE object used to control a stream may be significant; a copy of a
+    FILE object need not serve in place of the original.
+
+[<a name="p300" href="#p300">page 300</a>] (<a href="#Contents">Contents</a>)
+
+7    At program startup, three text streams are predefined and need not be opened explicitly
+     -- standard input (for reading conventional input), standard output (for writing
+     conventional output), and standard error (for writing diagnostic output). As initially
+     opened, the standard error stream is not fully buffered; the standard input and standard
+     output streams are fully buffered if and only if the stream can be determined not to refer
+     to an interactive device.
+8    Functions that open additional (nontemporary) files require a file name, which is a string.
+     The rules for composing valid file names are implementation-defined. Whether the same
+     file can be simultaneously open multiple times is also implementation-defined.
+9    Although both text and binary wide-oriented streams are conceptually sequences of wide
+     characters, the external file associated with a wide-oriented stream is a sequence of
+     multibyte characters, generalized as follows:
+     -- Multibyte encodings within files may contain embedded null bytes (unlike multibyte
+       encodings valid for use internal to the program).
+     -- A file need not begin nor end in the initial shift state.<sup><a href="#note261"><b>261)</b></a></sup>
+10   Moreover, the encodings used for multibyte characters may differ among files. Both the
+     nature and choice of such encodings are implementation-defined.
+11   The wide character input functions read multibyte characters from the stream and convert
+     them to wide characters as if they were read by successive calls to the fgetwc function.
+     Each conversion occurs as if by a call to the mbrtowc function, with the conversion state
+     described by the stream's own mbstate_t object. The byte input functions read
+     characters from the stream as if by successive calls to the fgetc function.
+12   The wide character output functions convert wide characters to multibyte characters and
+     write them to the stream as if they were written by successive calls to the fputwc
+     function. Each conversion occurs as if by a call to the wcrtomb function, with the
+     conversion state described by the stream's own mbstate_t object. The byte output
+     functions write characters to the stream as if by successive calls to the fputc function.
+13   In some cases, some of the byte input/output functions also perform conversions between
+     multibyte characters and wide characters. These conversions also occur as if by calls to
+     the mbrtowc and wcrtomb functions.
+14   An encoding error occurs if the character sequence presented to the underlying
+     mbrtowc function does not form a valid (generalized) multibyte character, or if the code
+     value passed to the underlying wcrtomb does not correspond to a valid (generalized)
+
+
+     <sup><a name="note261" href="#note261"><b>261)</b></a></sup> Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has
+          undefined behavior for a binary stream (because of possible trailing null characters) or for any stream
+          with state-dependent encoding that does not assuredly end in the initial shift state.
+
+[<a name="p301" href="#p301">page 301</a>] (<a href="#Contents">Contents</a>)
+
+     multibyte character. The wide character input/output functions and the byte input/output
+     functions store the value of the macro EILSEQ in errno if and only if an encoding error
+     occurs.
+     Environmental limits
+15   The value of FOPEN_MAX shall be at least eight, including the three standard text
+     streams.
+     Forward references: the exit function (<a href="#7.22.4.4">7.22.4.4</a>), the fgetc function (<a href="#7.21.7.1">7.21.7.1</a>), the
+     fopen function (<a href="#7.21.5.3">7.21.5.3</a>), the fputc function (<a href="#7.21.7.3">7.21.7.3</a>), the setbuf function
+     (<a href="#7.21.5.5">7.21.5.5</a>), the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>), the fgetwc function (<a href="#7.28.3.1">7.28.3.1</a>), the
+     fputwc function (<a href="#7.28.3.3">7.28.3.3</a>), conversion state (<a href="#7.28.6">7.28.6</a>), the mbrtowc function
+     (<a href="#7.28.6.3.2">7.28.6.3.2</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+<a name="7.21.4" href="#7.21.4"><b>     7.21.4 Operations on files</b></a>
+<a name="7.21.4.1" href="#7.21.4.1"><b>     7.21.4.1 The remove function</b></a>
+<b>     Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int remove(const char *filename);
+<b>     Description</b>
+2    The remove function causes the file whose name is the string pointed to by filename
+     to be no longer accessible by that name. A subsequent attempt to open that file using that
+     name will fail, unless it is created anew. If the file is open, the behavior of the remove
+     function is implementation-defined.
+<b>     Returns</b>
+3    The remove function returns zero if the operation succeeds, nonzero if it fails.
+<a name="7.21.4.2" href="#7.21.4.2"><b>     7.21.4.2 The rename function</b></a>
+<b>     Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int rename(const char *old, const char *new);
+<b>     Description</b>
+2    The rename function causes the file whose name is the string pointed to by old to be
+     henceforth known by the name given by the string pointed to by new. The file named
+     old is no longer accessible by that name. If a file named by the string pointed to by new
+     exists prior to the call to the rename function, the behavior is implementation-defined.
+
+[<a name="p302" href="#p302">page 302</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The rename function returns zero if the operation succeeds, nonzero if it fails,<sup><a href="#note262"><b>262)</b></a></sup> in
+    which case if the file existed previously it is still known by its original name.
+<a name="7.21.4.3" href="#7.21.4.3"><b>    7.21.4.3 The tmpfile function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            FILE *tmpfile(void);
+<b>    Description</b>
+2   The tmpfile function creates a temporary binary file that is different from any other
+    existing file and that will automatically be removed when it is closed or at program
+    termination. If the program terminates abnormally, whether an open temporary file is
+    removed is implementation-defined. The file is opened for update with "wb+" mode.
+    Recommended practice
+3   It should be possible to open at least TMP_MAX temporary files during the lifetime of the
+    program (this limit may be shared with tmpnam) and there should be no limit on the
+    number simultaneously open other than this limit and any limit on the number of open
+    files (FOPEN_MAX).
+<b>    Returns</b>
+4   The tmpfile function returns a pointer to the stream of the file that it created. If the file
+    cannot be created, the tmpfile function returns a null pointer.
+    Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+<a name="7.21.4.4" href="#7.21.4.4"><b>    7.21.4.4 The tmpnam function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            char *tmpnam(char *s);
+<b>    Description</b>
+2   The tmpnam function generates a string that is a valid file name and that is not the same
+    as the name of an existing file.<sup><a href="#note263"><b>263)</b></a></sup> The function is potentially capable of generating at
+
+
+    <sup><a name="note262" href="#note262"><b>262)</b></a></sup> Among the reasons the implementation may cause the rename function to fail are that the file is open
+         or that it is necessary to copy its contents to effectuate its renaming.
+    <sup><a name="note263" href="#note263"><b>263)</b></a></sup> Files created using strings generated by the tmpnam function are temporary only in the sense that
+         their names should not collide with those generated by conventional naming rules for the
+         implementation. It is still necessary to use the remove function to remove such files when their use
+         is ended, and before program termination.
+
+[<a name="p303" href="#p303">page 303</a>] (<a href="#Contents">Contents</a>)
+
+    least TMP_MAX different strings, but any or all of them may already be in use by existing
+    files and thus not be suitable return values.
+3   The tmpnam function generates a different string each time it is called.
+4   Calls to the tmpnam function with a null pointer argument may introduce data races with
+    each other. The implementation shall behave as if no library function calls the tmpnam
+    function.
+<b>    Returns</b>
+5   If no suitable string can be generated, the tmpnam function returns a null pointer.
+    Otherwise, if the argument is a null pointer, the tmpnam function leaves its result in an
+    internal static object and returns a pointer to that object (subsequent calls to the tmpnam
+    function may modify the same object). If the argument is not a null pointer, it is assumed
+    to point to an array of at least L_tmpnam chars; the tmpnam function writes its result
+    in that array and returns the argument as its value.
+    Environmental limits
+6   The value of the macro TMP_MAX shall be at least 25.
+<a name="7.21.5" href="#7.21.5"><b>    7.21.5 File access functions</b></a>
+<a name="7.21.5.1" href="#7.21.5.1"><b>    7.21.5.1 The fclose function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int fclose(FILE *stream);
+<b>    Description</b>
+2   A successful call to the fclose function causes the stream pointed to by stream to be
+    flushed and the associated file to be closed. Any unwritten buffered data for the stream
+    are delivered to the host environment to be written to the file; any unread buffered data
+    are discarded. Whether or not the call succeeds, the stream is disassociated from the file
+    and any buffer set by the setbuf or setvbuf function is disassociated from the stream
+    (and deallocated if it was automatically allocated).
+<b>    Returns</b>
+3   The fclose function returns zero if the stream was successfully closed, or EOF if any
+    errors were detected.
+
+[<a name="p304" href="#p304">page 304</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.5.2" href="#7.21.5.2"><b>    7.21.5.2 The fflush function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int fflush(FILE *stream);
+<b>    Description</b>
+2   If stream points to an output stream or an update stream in which the most recent
+    operation was not input, the fflush function causes any unwritten data for that stream
+    to be delivered to the host environment to be written to the file; otherwise, the behavior is
+    undefined.
+3   If stream is a null pointer, the fflush function performs this flushing action on all
+    streams for which the behavior is defined above.
+<b>    Returns</b>
+4   The fflush function sets the error indicator for the stream and returns EOF if a write
+    error occurs, otherwise it returns zero.
+    Forward references: the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+<a name="7.21.5.3" href="#7.21.5.3"><b>    7.21.5.3 The fopen function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            FILE *fopen(const char * restrict filename,
+                 const char * restrict mode);
+<b>    Description</b>
+2   The fopen function opens the file whose name is the string pointed to by filename,
+    and associates a stream with it.
+3   The argument mode points to a string. If the string is one of the following, the file is
+    open in the indicated mode. Otherwise, the behavior is undefined.<sup><a href="#note264"><b>264)</b></a></sup>
+    r                     open text file for reading
+    w                     truncate to zero length or create text file for writing
+    wx                    create text file for writing
+    a                     append; open or create text file for writing at end-of-file
+    rb                    open binary file for reading
+    wb                    truncate to zero length or create binary file for writing
+
+
+    <sup><a name="note264" href="#note264"><b>264)</b></a></sup> If the string begins with one of the above sequences, the implementation might choose to ignore the
+         remaining characters, or it might use them to select different kinds of a file (some of which might not
+         conform to the properties in <a href="#7.21.2">7.21.2</a>).
+
+[<a name="p305" href="#p305">page 305</a>] (<a href="#Contents">Contents</a>)
+
+    wbx               create binary file for writing
+    ab                append; open or create binary file for writing at end-of-file
+    r+                open text file for update (reading and writing)
+    w+                truncate to zero length or create text file for update
+    w+x               create text file for update
+    a+                append; open or create text file for update, writing at end-of-file
+    r+b or rb+        open binary file for update (reading and writing)
+    w+b or wb+        truncate to zero length or create binary file for update
+    w+bx or wb+x      create binary file for update
+    a+b or ab+        append; open or create binary file for update, writing at end-of-file
+4   Opening a file with read mode ('r' as the first character in the mode argument) fails if
+    the file does not exist or cannot be read.
+5   Opening a file with exclusive mode ('x' as the last character in the mode argument)
+    fails if the file already exists or cannot be created. Otherwise, the file is created with
+    exclusive (also known as non-shared) access to the extent that the underlying system
+    supports exclusive access.
+6   Opening a file with append mode ('a' as the first character in the mode argument)
+    causes all subsequent writes to the file to be forced to the then current end-of-file,
+    regardless of intervening calls to the fseek function. In some implementations, opening
+    a binary file with append mode ('b' as the second or third character in the above list of
+    mode argument values) may initially position the file position indicator for the stream
+    beyond the last data written, because of null character padding.
+7   When a file is opened with update mode ('+' as the second or third character in the
+    above list of mode argument values), both input and output may be performed on the
+    associated stream. However, output shall not be directly followed by input without an
+    intervening call to the fflush function or to a file positioning function (fseek,
+    fsetpos, or rewind), and input shall not be directly followed by output without an
+    intervening call to a file positioning function, unless the input operation encounters end-
+    of-file. Opening (or creating) a text file with update mode may instead open (or create) a
+    binary stream in some implementations.
+8   When opened, a stream is fully buffered if and only if it can be determined not to refer to
+    an interactive device. The error and end-of-file indicators for the stream are cleared.
+<b>    Returns</b>
+9   The fopen function returns a pointer to the object controlling the stream. If the open
+    operation fails, fopen returns a null pointer.
+    Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
+
+[<a name="p306" href="#p306">page 306</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.5.4" href="#7.21.5.4"><b>    7.21.5.4 The freopen function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            FILE *freopen(const char * restrict filename,
+                 const char * restrict mode,
+                 FILE * restrict stream);
+<b>    Description</b>
+2   The freopen function opens the file whose name is the string pointed to by filename
+    and associates the stream pointed to by stream with it. The mode argument is used just
+    as in the fopen function.<sup><a href="#note265"><b>265)</b></a></sup>
+3   If filename is a null pointer, the freopen function attempts to change the mode of
+    the stream to that specified by mode, as if the name of the file currently associated with
+    the stream had been used. It is implementation-defined which changes of mode are
+    permitted (if any), and under what circumstances.
+4   The freopen function first attempts to close any file that is associated with the specified
+    stream. Failure to close the file is ignored. The error and end-of-file indicators for the
+    stream are cleared.
+<b>    Returns</b>
+5   The freopen function returns a null pointer if the open operation fails. Otherwise,
+    freopen returns the value of stream.
+<a name="7.21.5.5" href="#7.21.5.5"><b>    7.21.5.5 The setbuf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            void setbuf(FILE * restrict stream,
+                 char * restrict buf);
+<b>    Description</b>
+2   Except that it returns no value, the setbuf function is equivalent to the setvbuf
+    function invoked with the values _IOFBF for mode and BUFSIZ for size, or (if buf
+    is a null pointer), with the value _IONBF for mode.
+
+
+
+
+    <sup><a name="note265" href="#note265"><b>265)</b></a></sup> The primary use of the freopen function is to change the file associated with a standard text stream
+         (stderr, stdin, or stdout), as those identifiers need not be modifiable lvalues to which the value
+         returned by the fopen function may be assigned.
+
+[<a name="p307" href="#p307">page 307</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The setbuf function returns no value.
+    Forward references: the setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
+<a name="7.21.5.6" href="#7.21.5.6"><b>    7.21.5.6 The setvbuf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int setvbuf(FILE * restrict stream,
+                 char * restrict buf,
+                 int mode, size_t size);
+<b>    Description</b>
+2   The setvbuf function may be used only after the stream pointed to by stream has
+    been associated with an open file and before any other operation (other than an
+    unsuccessful call to setvbuf) is performed on the stream. The argument mode
+    determines how stream will be buffered, as follows: _IOFBF causes input/output to be
+    fully buffered; _IOLBF causes input/output to be line buffered; _IONBF causes
+    input/output to be unbuffered. If buf is not a null pointer, the array it points to may be
+    used instead of a buffer allocated by the setvbuf function<sup><a href="#note266"><b>266)</b></a></sup> and the argument size
+    specifies the size of the array; otherwise, size may determine the size of a buffer
+    allocated by the setvbuf function. The contents of the array at any time are
+    indeterminate.
+<b>    Returns</b>
+3   The setvbuf function returns zero on success, or nonzero if an invalid value is given
+    for mode or if the request cannot be honored.
+
+
+
+
+    <sup><a name="note266" href="#note266"><b>266)</b></a></sup> The buffer has to have a lifetime at least as great as the open stream, so the stream should be closed
+         before a buffer that has automatic storage duration is deallocated upon block exit.
+
+[<a name="p308" href="#p308">page 308</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.6" href="#7.21.6"><b>    7.21.6 Formatted input/output functions</b></a>
+1   The formatted input/output functions shall behave as if there is a sequence point after the
+    actions associated with each specifier.<sup><a href="#note267"><b>267)</b></a></sup>
+<a name="7.21.6.1" href="#7.21.6.1"><b>    7.21.6.1 The fprintf function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int fprintf(FILE * restrict stream,
+                  const char * restrict format, ...);
+<b>    Description</b>
+2   The fprintf function writes output to the stream pointed to by stream, under control
+    of the string pointed to by format that specifies how subsequent arguments are
+    converted for output. If there are insufficient arguments for the format, the behavior is
+    undefined. If the format is exhausted while arguments remain, the excess arguments are
+    evaluated (as always) but are otherwise ignored. The fprintf function returns when
+    the end of the format string is encountered.
+3   The format shall be a multibyte character sequence, beginning and ending in its initial
+    shift state. The format is composed of zero or more directives: ordinary multibyte
+    characters (not %), which are copied unchanged to the output stream; and conversion
+    specifications, each of which results in fetching zero or more subsequent arguments,
+    converting them, if applicable, according to the corresponding conversion specifier, and
+    then writing the result to the output stream.
+4   Each conversion specification is introduced by the character %. After the %, the following
+    appear in sequence:
+    -- Zero or more flags (in any order) that modify the meaning of the conversion
+      specification.
+    -- An optional minimum field width. If the converted value has fewer characters than the
+      field width, it is padded with spaces (by default) on the left (or right, if the left
+      adjustment flag, described later, has been given) to the field width. The field width
+      takes the form of an asterisk * (described later) or a nonnegative decimal integer.<sup><a href="#note268"><b>268)</b></a></sup>
+    -- An optional precision that gives the minimum number of digits to appear for the d, i,
+      o, u, x, and X conversions, the number of digits to appear after the decimal-point
+      character for a, A, e, E, f, and F conversions, the maximum number of significant
+      digits for the g and G conversions, or the maximum number of bytes to be written for
+
+
+    <sup><a name="note267" href="#note267"><b>267)</b></a></sup> The fprintf functions perform writes to memory for the %n specifier.
+    <sup><a name="note268" href="#note268"><b>268)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
+
+[<a name="p309" href="#p309">page 309</a>] (<a href="#Contents">Contents</a>)
+
+        s conversions. The precision takes the form of a period (.) followed either by an
+        asterisk * (described later) or by an optional decimal integer; if only the period is
+        specified, the precision is taken as zero. If a precision appears with any other
+        conversion specifier, the behavior is undefined.
+    -- An optional length modifier that specifies the size of the argument.
+    -- A conversion specifier character that specifies the type of conversion to be applied.
+5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+    this case, an int argument supplies the field width or precision. The arguments
+    specifying field width, or precision, or both, shall appear (in that order) before the
+    argument (if any) to be converted. A negative field width argument is taken as a - flag
+    followed by a positive field width. A negative precision argument is taken as if the
+    precision were omitted.
+6   The flag characters and their meanings are:
+    -       The result of the conversion is left-justified within the field. (It is right-justified if
+            this flag is not specified.)
+    +       The result of a signed conversion always begins with a plus or minus sign. (It
+            begins with a sign only when a negative value is converted if this flag is not
+            specified.)<sup><a href="#note269"><b>269)</b></a></sup>
+    space If the first character of a signed conversion is not a sign, or if a signed conversion
+          results in no characters, a space is prefixed to the result. If the space and + flags
+          both appear, the space flag is ignored.
+    #       The result is converted to an ''alternative form''. For o conversion, it increases
+            the precision, if and only if necessary, to force the first digit of the result to be a
+            zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+            conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
+            and G conversions, the result of converting a floating-point number always
+            contains a decimal-point character, even if no digits follow it. (Normally, a
+            decimal-point character appears in the result of these conversions only if a digit
+            follows it.) For g and G conversions, trailing zeros are not removed from the
+            result. For other conversions, the behavior is undefined.
+    0       For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+            (following any indication of sign or base) are used to pad to the field width rather
+            than performing space padding, except when converting an infinity or NaN. If the
+            0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
+
+
+    <sup><a name="note269" href="#note269"><b>269)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+         include a minus sign.
+
+[<a name="p310" href="#p310">page 310</a>] (<a href="#Contents">Contents</a>)
+
+              conversions, if a precision is specified, the 0 flag is ignored. For other
+              conversions, the behavior is undefined.
+7   The length modifiers and their meanings are:
+    hh            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                  signed char or unsigned char argument (the argument will have
+                  been promoted according to the integer promotions, but its value shall be
+                  converted to signed char or unsigned char before printing); or that
+                  a following n conversion specifier applies to a pointer to a signed char
+                  argument.
+    h             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                  short int or unsigned short int argument (the argument will
+                  have been promoted according to the integer promotions, but its value shall
+                  be converted to short int or unsigned short int before printing);
+                  or that a following n conversion specifier applies to a pointer to a short
+                  int argument.
+    l (ell)       Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                  long int or unsigned long int argument; that a following n
+                  conversion specifier applies to a pointer to a long int argument; that a
+                  following c conversion specifier applies to a wint_t argument; that a
+                  following s conversion specifier applies to a pointer to a wchar_t
+                  argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+                  specifier.
+    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 long long int or unsigned long long int argument; or that a
+                 following n conversion specifier applies to a pointer to a long long int
+                 argument.
+    j             Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+                  an intmax_t or uintmax_t argument; or that a following n conversion
+                  specifier applies to a pointer to an intmax_t argument.
+    z             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                  size_t or the corresponding signed integer type argument; or that a
+                  following n conversion specifier applies to a pointer to a signed integer type
+                  corresponding to size_t argument.
+    t             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                  ptrdiff_t or the corresponding unsigned integer type argument; or that a
+                  following n conversion specifier applies to a pointer to a ptrdiff_t
+                  argument.
+
+[<a name="p311" href="#p311">page 311</a>] (<a href="#Contents">Contents</a>)
+
+    L              Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                   applies to a long double argument.
+    If a length modifier appears with any conversion specifier other than as specified above,
+    the behavior is undefined.
+8   The conversion specifiers and their meanings are:
+    d,i          The int argument is converted to signed decimal in the style [-]dddd. The
+                 precision specifies the minimum number of digits to appear; if the value
+                 being converted can be represented in fewer digits, it is expanded with
+                 leading zeros. The default precision is 1. The result of converting a zero
+                 value with a precision of zero is no characters.
+    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+            letters abcdef are used for x conversion and the letters ABCDEF for X
+            conversion. The precision specifies the minimum number of digits to appear;
+            if the value being converted can be represented in fewer digits, it is expanded
+            with leading zeros. The default precision is 1. The result of converting a
+            zero value with a precision of zero is no characters.
+    f,F          A double argument representing a floating-point number is converted to
+                 decimal notation in the style [-]ddd.ddd, where the number of digits after
+                 the decimal-point character is equal to the precision specification. If the
+                 precision is missing, it is taken as 6; if the precision is zero and the # flag is
+                 not specified, no decimal-point character appears. If a decimal-point
+                 character appears, at least one digit appears before it. The value is rounded to
+                 the appropriate number of digits.
+                 A double argument representing an infinity is converted in one of the styles
+                 [-]inf or [-]infinity -- which style is implementation-defined. A
+                 double argument representing a NaN is converted in one of the styles
+                 [-]nan or [-]nan(n-char-sequence) -- which style, and the meaning of
+                 any n-char-sequence, is implementation-defined. The F conversion specifier
+                 produces INF, INFINITY, or NAN instead of inf, infinity, or nan,
+                 respectively.<sup><a href="#note270"><b>270)</b></a></sup>
+    e,E          A double argument representing a floating-point number is converted in the
+                 style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+                 argument is nonzero) before the decimal-point character and the number of
+                 digits after it is equal to the precision; if the precision is missing, it is taken as
+
+
+    <sup><a name="note270" href="#note270"><b>270)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag characters have their usual meaning;
+         the # and 0 flag characters have no effect.
+
+[<a name="p312" href="#p312">page 312</a>] (<a href="#Contents">Contents</a>)
+
+              6; if the precision is zero and the # flag is not specified, no decimal-point
+              character appears. The value is rounded to the appropriate number of digits.
+              The E conversion specifier produces a number with E instead of e
+              introducing the exponent. The exponent always contains at least two digits,
+              and only as many more digits as necessary to represent the exponent. If the
+              value is zero, the exponent is zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.
+g,G           A double argument representing a floating-point number is converted in
+              style f or e (or in style F or E in the case of a G conversion specifier),
+              depending on the value converted and the precision. Let P equal the
+              precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+              Then, if a conversion with style E would have an exponent of X:
+              -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+                P - (X + 1).
+              -- otherwise, the conversion is with style e (or E) and precision P - 1.
+              Finally, unless the # flag is used, any trailing zeros are removed from the
+              fractional portion of the result and the decimal-point character is removed if
+              there is no fractional portion remaining.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.
+a,A           A double argument representing a floating-point number is converted in the
+              style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+              nonzero if the argument is a normalized floating-point number and is
+              otherwise unspecified) before the decimal-point character<sup><a href="#note271"><b>271)</b></a></sup> and the number
+              of hexadecimal digits after it is equal to the precision; if the precision is
+              missing and FLT_RADIX is a power of 2, then the precision is sufficient for
+              an exact representation of the value; if the precision is missing and
+              FLT_RADIX is not a power of 2, then the precision is sufficient to
+
+
+
+
+<sup><a name="note271" href="#note271"><b>271)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point character so
+     that subsequent digits align to nibble (4-bit) boundaries.
+
+[<a name="p313" href="#p313">page 313</a>] (<a href="#Contents">Contents</a>)
+
+              distinguish<sup><a href="#note272"><b>272)</b></a></sup> values of type double, except that trailing zeros may be
+              omitted; if the precision is zero and the # flag is not specified, no decimal-
+              point character appears. The letters abcdef are used for a conversion and
+              the letters ABCDEF for A conversion. The A conversion specifier produces a
+              number with X and P instead of x and p. The exponent always contains at
+              least one digit, and only as many more digits as necessary to represent the
+              decimal exponent of 2. If the value is zero, the exponent is zero.
+              A double argument representing an infinity or NaN is converted in the style
+              of an f or F conversion specifier.
+c             If no l length modifier is present, the int argument is converted to an
+              unsigned char, and the resulting character is written.
+              If an l length modifier is present, the wint_t argument is converted as if by
+              an ls conversion specification with no precision and an argument that points
+              to the initial element of a two-element array of wchar_t, the first element
+              containing the wint_t argument to the lc conversion specification and the
+              second a null wide character.
+s             If no l length modifier is present, the argument shall be a pointer to the initial
+              element of an array of character type.<sup><a href="#note273"><b>273)</b></a></sup> Characters from the array are
+              written up to (but not including) the terminating null character. If the
+              precision is specified, no more than that many bytes are written. If the
+              precision is not specified or is greater than the size of the array, the array shall
+              contain a null character.
+              If an l length modifier is present, the argument shall be a pointer to the initial
+              element of an array of wchar_t type. Wide characters from the array are
+              converted to multibyte characters (each as if by a call to the wcrtomb
+              function, with the conversion state described by an mbstate_t object
+              initialized to zero before the first wide character is converted) up to and
+              including a terminating null wide character. The resulting multibyte
+              characters are written up to (but not including) the terminating null character
+              (byte). If no precision is specified, the array shall contain a null wide
+              character. If a precision is specified, no more than that many bytes are
+              written (including shift sequences, if any), and the array shall contain a null
+              wide character if, to equal the multibyte character sequence length given by
+
+<sup><a name="note272" href="#note272"><b>272)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+     might suffice depending on the implementation's scheme for determining the digit to the left of the
+     decimal-point character.
+<sup><a name="note273" href="#note273"><b>273)</b></a></sup> No special provisions are made for multibyte characters.
+
+[<a name="p314" href="#p314">page 314</a>] (<a href="#Contents">Contents</a>)
+
+                    the precision, the function would need to access a wide character one past the
+                    end of the array. In no case is a partial multibyte character written.<sup><a href="#note274"><b>274)</b></a></sup>
+     p              The argument shall be a pointer to void. The value of the pointer is
+                    converted to a sequence of printing characters, in an implementation-defined
+                    manner.
+     n              The argument shall be a pointer to signed integer into which is written the
+                    number of characters written to the output stream so far by this call to
+                    fprintf. No argument is converted, but one is consumed. If the conversion
+                    specification includes any flags, a field width, or a precision, the behavior is
+                    undefined.
+     %              A % character is written. No argument is converted. The complete
+                    conversion specification shall be %%.
+9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note275"><b>275)</b></a></sup> If any argument is
+     not the correct type for the corresponding conversion specification, the behavior is
+     undefined.
+10   In no case does a nonexistent or small field width cause truncation of a field; if the result
+     of a conversion is wider than the field width, the field is expanded to contain the
+     conversion result.
+11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+     to a hexadecimal floating number with the given precision.
+     Recommended practice
+12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+     representable in the given precision, the result should be one of the two adjacent numbers
+     in hexadecimal floating style with the given precision, with the extra stipulation that the
+     error should have a correct sign for the current rounding direction.
+13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note276"><b>276)</b></a></sup> If the number of
+     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+     representable with DECIMAL_DIG digits, then the result should be an exact
+     representation with trailing zeros. Otherwise, the source value is bounded by two
+     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+
+
+     <sup><a name="note274" href="#note274"><b>274)</b></a></sup> Redundant shift sequences may result if multibyte characters have a state-dependent encoding.
+     <sup><a name="note275" href="#note275"><b>275)</b></a></sup> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+     <sup><a name="note276" href="#note276"><b>276)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+          given format specifier. The number of significant digits is determined by the format specifier, and in
+          the case of fixed-point conversion by the source value as well.
+
+[<a name="p315" href="#p315">page 315</a>] (<a href="#Contents">Contents</a>)
+
+     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+     the error should have a correct sign for the current rounding direction.
+<b>     Returns</b>
+14   The fprintf function returns the number of characters transmitted, or a negative value
+     if an output or encoding error occurred.
+     Environmental limits
+15   The number of characters that can be produced by any single conversion shall be at least
+     4095.
+16   EXAMPLE 1         To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+     places:
+              #include <a href="#7.12">&lt;math.h&gt;</a>
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              /* ... */
+              char *weekday, *month;      // pointers to strings
+              int day, hour, min;
+              fprintf(stdout, "%s, %s %d, %.2d:%.2d\n",
+                      weekday, month, day, hour, min);
+              fprintf(stdout, "pi = %.5f\n", 4 * atan(1.0));
+
+17   EXAMPLE 2 In this example, multibyte characters do not have a state-dependent encoding, and the
+     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+     the first of which is denoted here by a and the second by an uppercase letter.
+18   Given the following wide string with length seven,
+              static wchar_t wstr[] = L" X Yabc Z W";
+     the seven calls
+              fprintf(stdout,          "|1234567890123|\n");
+              fprintf(stdout,          "|%13ls|\n", wstr);
+              fprintf(stdout,          "|%-13.9ls|\n", wstr);
+              fprintf(stdout,          "|%13.10ls|\n", wstr);
+              fprintf(stdout,          "|%13.11ls|\n", wstr);
+              fprintf(stdout,          "|%13.15ls|\n", &amp;wstr[2]);
+              fprintf(stdout,          "|%13lc|\n", (wint_t) wstr[5]);
+     will print the following seven lines:
+              |1234567890123|
+              |   X Yabc Z W|
+              | X Yabc Z    |
+              |     X Yabc Z|
+              |   X Yabc Z W|
+              |      abc Z W|
+              |            Z|
+
+     Forward references: conversion state (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+
+[<a name="p316" href="#p316">page 316</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.6.2" href="#7.21.6.2"><b>    7.21.6.2 The fscanf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int fscanf(FILE * restrict stream,
+                 const char * restrict format, ...);
+<b>    Description</b>
+2   The fscanf function reads input from the stream pointed to by stream, under control
+    of the string pointed to by format that specifies the admissible input sequences and how
+    they are to be converted for assignment, using subsequent arguments as pointers to the
+    objects to receive the converted input. If there are insufficient arguments for the format,
+    the behavior is undefined. If the format is exhausted while arguments remain, the excess
+    arguments are evaluated (as always) but are otherwise ignored.
+3   The format shall be a multibyte character sequence, beginning and ending in its initial
+    shift state. The format is composed of zero or more directives: one or more white-space
+    characters, an ordinary multibyte character (neither % nor a white-space character), or a
+    conversion specification. Each conversion specification is introduced by the character %.
+    After the %, the following appear in sequence:
+    -- An optional assignment-suppressing character *.
+    -- An optional decimal integer greater than zero that specifies the maximum field width
+      (in characters).
+    -- An optional length modifier that specifies the size of the receiving object.
+    -- A conversion specifier character that specifies the type of conversion to be applied.
+4   The fscanf function executes each directive of the format in turn. When all directives
+    have been executed, or if a directive fails (as detailed below), the function returns.
+    Failures are described as input failures (due to the occurrence of an encoding error or the
+    unavailability of input characters), or matching failures (due to inappropriate input).
+5   A directive composed of white-space character(s) is executed by reading input up to the
+    first non-white-space character (which remains unread), or until no more characters can
+    be read.
+6   A directive that is an ordinary multibyte character is executed by reading the next
+    characters of the stream. If any of those characters differ from the ones composing the
+    directive, the directive fails and the differing and subsequent characters remain unread.
+    Similarly, if end-of-file, an encoding error, or a read error prevents a character from being
+    read, the directive fails.
+7   A directive that is a conversion specification defines a set of matching input sequences, as
+    described below for each specifier. A conversion specification is executed in the
+
+[<a name="p317" href="#p317">page 317</a>] (<a href="#Contents">Contents</a>)
+
+     following steps:
+8    Input white-space characters (as specified by the isspace function) are skipped, unless
+     the specification includes a [, c, or n specifier.<sup><a href="#note277"><b>277)</b></a></sup>
+9    An input item is read from the stream, unless the specification includes an n specifier. An
+     input item is defined as the longest sequence of input characters which does not exceed
+     any specified field width and which is, or is a prefix of, a matching input sequence.<sup><a href="#note278"><b>278)</b></a></sup>
+     The first character, if any, after the input item remains unread. If the length of the input
+     item is zero, the execution of the directive fails; this condition is a matching failure unless
+     end-of-file, an encoding error, or a read error prevented input from the stream, in which
+     case it is an input failure.
+10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+     count of input characters) is converted to a type appropriate to the conversion specifier. If
+     the input item is not a matching sequence, the execution of the directive fails: this
+     condition is a matching failure. Unless assignment suppression was indicated by a *, the
+     result of the conversion is placed in the object pointed to by the first argument following
+     the format argument that has not already received a conversion result. If this object
+     does not have an appropriate type, or if the result of the conversion cannot be represented
+     in the object, the behavior is undefined.
+11   The length modifiers and their meanings are:
+     hh             Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                    to an argument with type pointer to signed char or unsigned char.
+     h              Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                    to an argument with type pointer to short int or unsigned short
+                    int.
+     l (ell)        Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                    to an argument with type pointer to long int or unsigned long
+                    int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+                    an argument with type pointer to double; or that a following c, s, or [
+                    conversion specifier applies to an argument with type pointer to wchar_t.
+     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to long long int or unsigned
+                  long long int.
+
+
+
+     <sup><a name="note277" href="#note277"><b>277)</b></a></sup> These white-space characters are not counted against a specified field width.
+     <sup><a name="note278" href="#note278"><b>278)</b></a></sup> fscanf pushes back at most one input character onto the input stream. Therefore, some sequences
+          that are acceptable to strtod, strtol, etc., are unacceptable to fscanf.
+
+[<a name="p318" href="#p318">page 318</a>] (<a href="#Contents">Contents</a>)
+
+     j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to intmax_t or uintmax_t.
+     z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to size_t or the corresponding signed
+                  integer type.
+     t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to ptrdiff_t or the corresponding
+                  unsigned integer type.
+     L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                  applies to an argument with type pointer to long double.
+     If a length modifier appears with any conversion specifier other than as specified above,
+     the behavior is undefined.
+12   The conversion specifiers and their meanings are:
+     d           Matches an optionally signed decimal integer, whose format is the same as
+                 expected for the subject sequence of the strtol function with the value 10
+                 for the base argument. The corresponding argument shall be a pointer to
+                 signed integer.
+     i           Matches an optionally signed integer, whose format is the same as expected
+                 for the subject sequence of the strtol function with the value 0 for the
+                 base argument. The corresponding argument shall be a pointer to signed
+                 integer.
+     o           Matches an optionally signed octal integer, whose format is the same as
+                 expected for the subject sequence of the strtoul function with the value 8
+                 for the base argument. The corresponding argument shall be a pointer to
+                 unsigned integer.
+     u           Matches an optionally signed decimal integer, whose format is the same as
+                 expected for the subject sequence of the strtoul function with the value 10
+                 for the base argument. The corresponding argument shall be a pointer to
+                 unsigned integer.
+     x           Matches an optionally signed hexadecimal integer, whose format is the same
+                 as expected for the subject sequence of the strtoul function with the value
+                 16 for the base argument. The corresponding argument shall be a pointer to
+                 unsigned integer.
+     a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+             format is the same as expected for the subject sequence of the strtod
+             function. The corresponding argument shall be a pointer to floating.
+
+[<a name="p319" href="#p319">page 319</a>] (<a href="#Contents">Contents</a>)
+
+c             Matches a sequence of characters of exactly the number specified by the field
+              width (1 if no field width is present in the directive).<sup><a href="#note279"><b>279)</b></a></sup>
+              If no l length modifier is present, the corresponding argument shall be a
+              pointer to the initial element of a character array large enough to accept the
+              sequence. No null character is added.
+              If an l length modifier is present, the input shall be a sequence of multibyte
+              characters that begins in the initial shift state. Each multibyte character in the
+              sequence is converted to a wide character as if by a call to the mbrtowc
+              function, with the conversion state described by an mbstate_t object
+              initialized to zero before the first multibyte character is converted. The
+              corresponding argument shall be a pointer to the initial element of an array of
+              wchar_t large enough to accept the resulting sequence of wide characters.
+              No null wide character is added.
+s             Matches a sequence of non-white-space characters.279)
+              If no l length modifier is present, the corresponding argument shall be a
+              pointer to the initial element of a character array large enough to accept the
+              sequence and a terminating null character, which will be added automatically.
+              If an l length modifier is present, the input shall be a sequence of multibyte
+              characters that begins in the initial shift state. Each multibyte character is
+              converted to a wide character as if by a call to the mbrtowc function, with
+              the conversion state described by an mbstate_t object initialized to zero
+              before the first multibyte character is converted. The corresponding argument
+              shall be a pointer to the initial element of an array of wchar_t large enough
+              to accept the sequence and the terminating null wide character, which will be
+              added automatically.
+[             Matches a nonempty sequence of characters from a set of expected characters
+              (the scanset).279)
+              If no l length modifier is present, the corresponding argument shall be a
+              pointer to the initial element of a character array large enough to accept the
+              sequence and a terminating null character, which will be added automatically.
+              If an l length modifier is present, the input shall be a sequence of multibyte
+              characters that begins in the initial shift state. Each multibyte character is
+              converted to a wide character as if by a call to the mbrtowc function, with
+              the conversion state described by an mbstate_t object initialized to zero
+
+<sup><a name="note279" href="#note279"><b>279)</b></a></sup> No special provisions are made for multibyte characters in the matching rules used by the c, s, and [
+     conversion specifiers -- the extent of the input field is determined on a byte-by-byte basis. The
+     resulting field is nevertheless a sequence of multibyte characters that begins in the initial shift state.
+
+[<a name="p320" href="#p320">page 320</a>] (<a href="#Contents">Contents</a>)
+
+                    before the first multibyte character is converted. The corresponding argument
+                    shall be a pointer to the initial element of an array of wchar_t large enough
+                    to accept the sequence and the terminating null wide character, which will be
+                    added automatically.
+                    The conversion specifier includes all subsequent characters in the format
+                    string, up to and including the matching right bracket (]). The characters
+                    between the brackets (the scanlist) compose the scanset, unless the character
+                    after the left bracket is a circumflex (^), in which case the scanset contains all
+                    characters that do not appear in the scanlist between the circumflex and the
+                    right bracket. If the conversion specifier begins with [] or [^], the right
+                    bracket character is in the scanlist and the next following right bracket
+                    character is the matching right bracket that ends the specification; otherwise
+                    the first following right bracket character is the one that ends the
+                    specification. If a - character is in the scanlist and is not the first, nor the
+                    second where the first character is a ^, nor the last character, the behavior is
+                    implementation-defined.
+     p              Matches an implementation-defined set of sequences, which should be the
+                    same as the set of sequences that may be produced by the %p conversion of
+                    the fprintf function. The corresponding argument shall be a pointer to a
+                    pointer to void. The input item is converted to a pointer value in an
+                    implementation-defined manner. If the input item is a value converted earlier
+                    during the same program execution, the pointer that results shall compare
+                    equal to that value; otherwise the behavior of the %p conversion is undefined.
+     n              No input is consumed. The corresponding argument shall be a pointer to
+                    signed integer into which is to be written the number of characters read from
+                    the input stream so far by this call to the fscanf function. Execution of a
+                    %n directive does not increment the assignment count returned at the
+                    completion of execution of the fscanf function. No argument is converted,
+                    but one is consumed. If the conversion specification includes an assignment-
+                    suppressing character or a field width, the behavior is undefined.
+     %              Matches a single % character; no conversion or assignment occurs. The
+                    complete conversion specification shall be %%.
+13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note280"><b>280)</b></a></sup>
+14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+     respectively, a, e, f, g, and x.
+
+
+
+     <sup><a name="note280" href="#note280"><b>280)</b></a></sup> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+
+[<a name="p321" href="#p321">page 321</a>] (<a href="#Contents">Contents</a>)
+
+15   Trailing white space (including new-line characters) is left unread unless matched by a
+     directive. The success of literal matches and suppressed assignments is not directly
+     determinable other than via the %n directive.
+<b>     Returns</b>
+16   The fscanf function returns the value of the macro EOF if an input failure occurs
+     before the first conversion (if any) has completed. Otherwise, the function returns the
+     number of input items assigned, which can be fewer than provided for, or even zero, in
+     the event of an early matching failure.
+17   EXAMPLE 1        The call:
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              /* ... */
+              int n, i; float x; char name[50];
+              n = fscanf(stdin, "%d%f%s", &amp;i, &amp;x, name);
+     with the input line:
+              25 54.32E-1 thompson
+     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+     thompson\0.
+
+18   EXAMPLE 2        The call:
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              /* ... */
+              int i; float x; char name[50];
+              fscanf(stdin, "%2d%f%*d %[0123456789]", &amp;i, &amp;x, name);
+     with input:
+              56789 0123 56a72
+     will assign to i the value 56 and to x the value 789.0, will skip 0123, and will assign to name the
+     sequence 56\0. The next character read from the input stream will be a.
+
+19   EXAMPLE 3        To accept repeatedly from stdin a quantity, a unit of measure, and an item name:
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              /* ... */
+              int count; float quant; char units[21], item[21];
+              do {
+                      count = fscanf(stdin, "%f%20s of %20s", &amp;quant, units, item);
+                      fscanf(stdin,"%*[^\n]");
+              } while (!feof(stdin) &amp;&amp; !ferror(stdin));
+20   If the stdin stream contains the following lines:
+              2 quarts of oil
+              -12.8degrees Celsius
+              lots of luck
+              10.0LBS     of
+              dirt
+              100ergs of energy
+
+[<a name="p322" href="#p322">page 322</a>] (<a href="#Contents">Contents</a>)
+
+     the execution of the above example will be analogous to the following assignments:
+               quant     =   2; strcpy(units, "quarts"); strcpy(item, "oil");
+               count     =   3;
+               quant     =   -12.8; strcpy(units, "degrees");
+               count     =   2; // "C" fails to match "o"
+               count     =   0; // "l" fails to match "%f"
+               quant     =   10.0; strcpy(units, "LBS"); strcpy(item, "dirt");
+               count     =   3;
+               count     =   0; // "100e" fails to match "%f"
+               count     =   EOF;
+
+21   EXAMPLE 4         In:
+               #include <a href="#7.21">&lt;stdio.h&gt;</a>
+               /* ... */
+               int d1, d2, n1, n2, i;
+               i = sscanf("123", "%d%n%n%d", &amp;d1, &amp;n1, &amp;n2, &amp;d2);
+     the value 123 is assigned to d1 and the value 3 to n1. Because %n can never get an input failure the value
+     of 3 is also assigned to n2. The value of d2 is not affected. The value 1 is assigned to i.
+
+22   EXAMPLE 5 In these examples, multibyte characters do have a state-dependent encoding, and the
+     members of the extended character set that consist of more than one byte each consist of exactly two bytes,
+     the first of which is denoted here by a and the second by an uppercase letter, but are only recognized as
+     such when in the alternate shift state. The shift sequences are denoted by (uparrow) and (downarrow), in which the first causes
+     entry into the alternate shift state.
+23   After the call:
+               #include <a href="#7.21">&lt;stdio.h&gt;</a>
+               /* ... */
+               char str[50];
+               fscanf(stdin, "a%s", str);
+     with the input line:
+               a(uparrow) X Y(downarrow) bc
+     str will contain (uparrow) X Y(downarrow)\0 assuming that none of the bytes of the shift sequences (or of the multibyte
+     characters, in the more general case) appears to be a single-byte white-space character.
+24   In contrast, after the call:
+               #include <a href="#7.21">&lt;stdio.h&gt;</a>
+               #include <a href="#7.19">&lt;stddef.h&gt;</a>
+               /* ... */
+               wchar_t wstr[50];
+               fscanf(stdin, "a%ls", wstr);
+     with the same input line, wstr will contain the two wide characters that correspond to X and Y and a
+     terminating null wide character.
+25   However, the call:
+
+[<a name="p323" href="#p323">page 323</a>] (<a href="#Contents">Contents</a>)
+
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             #include <a href="#7.19">&lt;stddef.h&gt;</a>
+             /* ... */
+             wchar_t wstr[50];
+             fscanf(stdin, "a(uparrow) X(downarrow)%ls", wstr);
+     with the same input line will return zero due to a matching failure against the (downarrow) sequence in the format
+     string.
+26   Assuming that the first byte of the multibyte character X is the same as the first byte of the multibyte
+     character Y, after the call:
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             #include <a href="#7.19">&lt;stddef.h&gt;</a>
+             /* ... */
+             wchar_t wstr[50];
+             fscanf(stdin, "a(uparrow) Y(downarrow)%ls", wstr);
+     with the same input line, zero will again be returned, but stdin will be left with a partially consumed
+     multibyte character.
+
+     Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>), the
+     strtol, strtoll, strtoul, and strtoull functions (<a href="#7.22.1.4">7.22.1.4</a>), conversion state
+     (<a href="#7.28.6">7.28.6</a>), the wcrtomb function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+<a name="7.21.6.3" href="#7.21.6.3"><b>     7.21.6.3 The printf function</b></a>
+<b>     Synopsis</b>
+1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int printf(const char * restrict format, ...);
+<b>     Description</b>
+2    The printf function is equivalent to fprintf with the argument stdout interposed
+     before the arguments to printf.
+<b>     Returns</b>
+3    The printf function returns the number of characters transmitted, or a negative value if
+     an output or encoding error occurred.
+<a name="7.21.6.4" href="#7.21.6.4"><b>     7.21.6.4 The scanf function</b></a>
+<b>     Synopsis</b>
+1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int scanf(const char * restrict format, ...);
+<b>     Description</b>
+2    The scanf function is equivalent to fscanf with the argument stdin interposed
+     before the arguments to scanf.
+
+[<a name="p324" href="#p324">page 324</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The scanf function returns the value of the macro EOF if an input failure occurs before
+    the first conversion (if any) has completed. Otherwise, the scanf function returns the
+    number of input items assigned, which can be fewer than provided for, or even zero, in
+    the event of an early matching failure.
+<a name="7.21.6.5" href="#7.21.6.5"><b>    7.21.6.5 The snprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int snprintf(char * restrict s, size_t n,
+                 const char * restrict format, ...);
+<b>    Description</b>
+2   The snprintf function is equivalent to fprintf, except that the output is written into
+    an array (specified by argument s) rather than to a stream. If n is zero, nothing is written,
+    and s may be a null pointer. Otherwise, output characters beyond the n-1st are
+    discarded rather than being written to the array, and a null character is written at the end
+    of the characters actually written into the array. If copying takes place between objects
+    that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The snprintf function returns the number of characters that would have been written
+    had n been sufficiently large, not counting the terminating null character, or a negative
+    value if an encoding error occurred. Thus, the null-terminated output has been
+    completely written if and only if the returned value is nonnegative and less than n.
+<a name="7.21.6.6" href="#7.21.6.6"><b>    7.21.6.6 The sprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int sprintf(char * restrict s,
+                 const char * restrict format, ...);
+<b>    Description</b>
+2   The sprintf function is equivalent to fprintf, except that the output is written into
+    an array (specified by the argument s) rather than to a stream. A null character is written
+    at the end of the characters written; it is not counted as part of the returned value. If
+    copying takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The sprintf function returns the number of characters written in the array, not
+    counting the terminating null character, or a negative value if an encoding error occurred.
+
+[<a name="p325" href="#p325">page 325</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.6.7" href="#7.21.6.7"><b>    7.21.6.7 The sscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int sscanf(const char * restrict s,
+                const char * restrict format, ...);
+<b>    Description</b>
+2   The sscanf function is equivalent to fscanf, except that input is obtained from a
+    string (specified by the argument s) rather than from a stream. Reaching the end of the
+    string is equivalent to encountering end-of-file for the fscanf function. If copying
+    takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The sscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the sscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.21.6.8" href="#7.21.6.8"><b>    7.21.6.8 The vfprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int vfprintf(FILE * restrict stream,
+                const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vfprintf function is equivalent to fprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfprintf function does not invoke the
+    va_end macro.<sup><a href="#note281"><b>281)</b></a></sup>
+<b>    Returns</b>
+3   The vfprintf function returns the number of characters transmitted, or a negative
+    value if an output or encoding error occurred.
+4   EXAMPLE       The following shows the use of the vfprintf function in a general error-reporting routine.
+
+
+
+
+    <sup><a name="note281" href="#note281"><b>281)</b></a></sup> As the functions vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, and
+         vsscanf invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+[<a name="p326" href="#p326">page 326</a>] (<a href="#Contents">Contents</a>)
+
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            void error(char *function_name, char *format, ...)
+            {
+                  va_list args;
+                  va_start(args, format);
+                  // print out name of function causing error
+                  fprintf(stderr, "ERROR in %s: ", function_name);
+                  // print out remainder of message
+                  vfprintf(stderr, format, args);
+                  va_end(args);
+            }
+
+<a name="7.21.6.9" href="#7.21.6.9"><b>    7.21.6.9 The vfscanf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int vfscanf(FILE * restrict stream,
+                 const char * restrict format,
+                 va_list arg);
+<b>    Description</b>
+2   The vfscanf function is equivalent to fscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfscanf function does not invoke the
+    va_end macro.281)
+<b>    Returns</b>
+3   The vfscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the vfscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.21.6.10" href="#7.21.6.10"><b>    7.21.6.10 The vprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int vprintf(const char * restrict format,
+                 va_list arg);
+<b>    Description</b>
+2   The vprintf function is equivalent to printf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+
+[<a name="p327" href="#p327">page 327</a>] (<a href="#Contents">Contents</a>)
+
+    possibly subsequent va_arg calls). The vprintf function does not invoke the
+    va_end macro.281)
+<b>    Returns</b>
+3   The vprintf function returns the number of characters transmitted, or a negative value
+    if an output or encoding error occurred.
+<a name="7.21.6.11" href="#7.21.6.11"><b>    7.21.6.11 The vscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int vscanf(const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vscanf function is equivalent to scanf, with the variable argument list replaced
+    by arg, which shall have been initialized by the va_start macro (and possibly
+    subsequent va_arg calls). The vscanf function does not invoke the va_end
+    macro.281)
+<b>    Returns</b>
+3   The vscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the vscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.21.6.12" href="#7.21.6.12"><b>    7.21.6.12 The vsnprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int vsnprintf(char * restrict s, size_t n,
+                const char * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vsnprintf function is equivalent to snprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vsnprintf function does not invoke the
+    va_end macro.281) If copying takes place between objects that overlap, the behavior is
+    undefined.
+
+[<a name="p328" href="#p328">page 328</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The vsnprintf function returns the number of characters that would have been written
+    had n been sufficiently large, not counting the terminating null character, or a negative
+    value if an encoding error occurred. Thus, the null-terminated output has been
+    completely written if and only if the returned value is nonnegative and less than n.
+<a name="7.21.6.13" href="#7.21.6.13"><b>    7.21.6.13 The vsprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int vsprintf(char * restrict s,
+                 const char * restrict format,
+                 va_list arg);
+<b>    Description</b>
+2   The vsprintf function is equivalent to sprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vsprintf function does not invoke the
+    va_end macro.281) If copying takes place between objects that overlap, the behavior is
+    undefined.
+<b>    Returns</b>
+3   The vsprintf function returns the number of characters written in the array, not
+    counting the terminating null character, or a negative value if an encoding error occurred.
+<a name="7.21.6.14" href="#7.21.6.14"><b>    7.21.6.14 The vsscanf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int vsscanf(const char * restrict s,
+                 const char * restrict format,
+                 va_list arg);
+<b>    Description</b>
+2   The vsscanf function is equivalent to sscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vsscanf function does not invoke the
+    va_end macro.281)
+<b>    Returns</b>
+3   The vsscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the vsscanf function
+
+[<a name="p329" href="#p329">page 329</a>] (<a href="#Contents">Contents</a>)
+
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.21.7" href="#7.21.7"><b>    7.21.7 Character input/output functions</b></a>
+<a name="7.21.7.1" href="#7.21.7.1"><b>    7.21.7.1 The fgetc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int fgetc(FILE *stream);
+<b>    Description</b>
+2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
+    next character is present, the fgetc function obtains that character as an unsigned
+    char converted to an int and advances the associated file position indicator for the
+    stream (if defined).
+<b>    Returns</b>
+3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+    of-file indicator for the stream is set and the fgetc function returns EOF. Otherwise, the
+    fgetc function returns the next character from the input stream pointed to by stream.
+    If a read error occurs, the error indicator for the stream is set and the fgetc function
+    returns EOF.<sup><a href="#note282"><b>282)</b></a></sup>
+<a name="7.21.7.2" href="#7.21.7.2"><b>    7.21.7.2 The fgets function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            char *fgets(char * restrict s, int n,
+                 FILE * restrict stream);
+<b>    Description</b>
+2   The fgets function reads at most one less than the number of characters specified by n
+    from the stream pointed to by stream into the array pointed to by s. No additional
+    characters are read after a new-line character (which is retained) or after end-of-file. A
+    null character is written immediately after the last character read into the array.
+<b>    Returns</b>
+3   The fgets function returns s if successful. If end-of-file is encountered and no
+    characters have been read into the array, the contents of the array remain unchanged and a
+    null pointer is returned. If a read error occurs during the operation, the array contents are
+    indeterminate and a null pointer is returned.
+
+    <sup><a name="note282" href="#note282"><b>282)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+
+[<a name="p330" href="#p330">page 330</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.7.3" href="#7.21.7.3"><b>    7.21.7.3 The fputc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int fputc(int c, FILE *stream);
+<b>    Description</b>
+2   The fputc function writes the character specified by c (converted to an unsigned
+    char) to the output stream pointed to by stream, at the position indicated by the
+    associated file position indicator for the stream (if defined), and advances the indicator
+    appropriately. If the file cannot support positioning requests, or if the stream was opened
+    with append mode, the character is appended to the output stream.
+<b>    Returns</b>
+3   The fputc function returns the character written. If a write error occurs, the error
+    indicator for the stream is set and fputc returns EOF.
+<a name="7.21.7.4" href="#7.21.7.4"><b>    7.21.7.4 The fputs function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int fputs(const char * restrict s,
+                 FILE * restrict stream);
+<b>    Description</b>
+2   The fputs function writes the string pointed to by s to the stream pointed to by
+    stream. The terminating null character is not written.
+<b>    Returns</b>
+3   The fputs function returns EOF if a write error occurs; otherwise it returns a
+    nonnegative value.
+<a name="7.21.7.5" href="#7.21.7.5"><b>    7.21.7.5 The getc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int getc(FILE *stream);
+<b>    Description</b>
+2   The getc function is equivalent to fgetc, except that if it is implemented as a macro, it
+    may evaluate stream more than once, so the argument should never be an expression
+    with side effects.
+
+[<a name="p331" href="#p331">page 331</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The getc function returns the next character from the input stream pointed to by
+    stream. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+    getc returns EOF. If a read error occurs, the error indicator for the stream is set and
+    getc returns EOF.
+<a name="7.21.7.6" href="#7.21.7.6"><b>    7.21.7.6 The getchar function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int getchar(void);
+<b>    Description</b>
+2   The getchar function is equivalent to getc with the argument stdin.
+<b>    Returns</b>
+3   The getchar function returns the next character from the input stream pointed to by
+    stdin. If the stream is at end-of-file, the end-of-file indicator for the stream is set and
+    getchar returns EOF. If a read error occurs, the error indicator for the stream is set and
+    getchar returns EOF.                                                                       *
+<a name="7.21.7.7" href="#7.21.7.7"><b>    7.21.7.7 The putc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int putc(int c, FILE *stream);
+<b>    Description</b>
+2   The putc function is equivalent to fputc, except that if it is implemented as a macro, it
+    may evaluate stream more than once, so that argument should never be an expression
+    with side effects.
+<b>    Returns</b>
+3   The putc function returns the character written. If a write error occurs, the error
+    indicator for the stream is set and putc returns EOF.
+<a name="7.21.7.8" href="#7.21.7.8"><b>    7.21.7.8 The putchar function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int putchar(int c);
+<b>    Description</b>
+2   The putchar function is equivalent to putc with the second argument stdout.
+
+[<a name="p332" href="#p332">page 332</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The putchar function returns the character written. If a write error occurs, the error
+    indicator for the stream is set and putchar returns EOF.
+<a name="7.21.7.9" href="#7.21.7.9"><b>    7.21.7.9 The puts function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int puts(const char *s);
+<b>    Description</b>
+2   The puts function writes the string pointed to by s to the stream pointed to by stdout,
+    and appends a new-line character to the output. The terminating null character is not
+    written.
+<b>    Returns</b>
+3   The puts function returns EOF if a write error occurs; otherwise it returns a nonnegative
+    value.
+<a name="7.21.7.10" href="#7.21.7.10"><b>    7.21.7.10 The ungetc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int ungetc(int c, FILE *stream);
+<b>    Description</b>
+2   The ungetc function pushes the character specified by c (converted to an unsigned
+    char) back onto the input stream pointed to by stream. Pushed-back characters will be
+    returned by subsequent reads on that stream in the reverse order of their pushing. A
+    successful intervening call (with the stream pointed to by stream) to a file positioning
+    function (fseek, fsetpos, or rewind) discards any pushed-back characters for the
+    stream. The external storage corresponding to the stream is unchanged.
+3   One character of pushback is guaranteed. If the ungetc function is called too many
+    times on the same stream without an intervening read or file positioning operation on that
+    stream, the operation may fail.
+4   If the value of c equals that of the macro EOF, the operation fails and the input stream is
+    unchanged.
+5   A successful call to the ungetc function clears the end-of-file indicator for the stream.
+    The value of the file position indicator for the stream after reading or discarding all
+    pushed-back characters shall be the same as it was before the characters were pushed
+    back. For a text stream, the value of its file position indicator after a successful call to the
+    ungetc function is unspecified until all pushed-back characters are read or discarded.
+
+[<a name="p333" href="#p333">page 333</a>] (<a href="#Contents">Contents</a>)
+
+    For a binary stream, its file position indicator is decremented by each successful call to
+    the ungetc function; if its value was zero before a call, it is indeterminate after the
+    call.<sup><a href="#note283"><b>283)</b></a></sup>
+<b>    Returns</b>
+6   The ungetc function returns the character pushed back after conversion, or EOF if the
+    operation fails.
+    Forward references: file positioning functions (<a href="#7.21.9">7.21.9</a>).
+<a name="7.21.8" href="#7.21.8"><b>    7.21.8 Direct input/output functions</b></a>
+<a name="7.21.8.1" href="#7.21.8.1"><b>    7.21.8.1 The fread function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             size_t fread(void * restrict ptr,
+                  size_t size, size_t nmemb,
+                  FILE * restrict stream);
+<b>    Description</b>
+2   The fread function reads, into the array pointed to by ptr, up to nmemb elements
+    whose size is specified by size, from the stream pointed to by stream. For each
+    object, size calls are made to the fgetc function and the results stored, in the order
+    read, in an array of unsigned char exactly overlaying the object. The file position
+    indicator for the stream (if defined) is advanced by the number of characters successfully
+    read. If an error occurs, the resulting value of the file position indicator for the stream is
+    indeterminate. If a partial element is read, its value is indeterminate.
+<b>    Returns</b>
+3   The fread function returns the number of elements successfully read, which may be
+    less than nmemb if a read error or end-of-file is encountered. If size or nmemb is zero,
+    fread returns zero and the contents of the array and the state of the stream remain
+    unchanged.
+
+
+
+
+    <sup><a name="note283" href="#note283"><b>283)</b></a></sup> See ''future library directions'' (<a href="#7.30.9">7.30.9</a>).
+
+[<a name="p334" href="#p334">page 334</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.8.2" href="#7.21.8.2"><b>    7.21.8.2 The fwrite function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            size_t fwrite(const void * restrict ptr,
+                 size_t size, size_t nmemb,
+                 FILE * restrict stream);
+<b>    Description</b>
+2   The fwrite function writes, from the array pointed to by ptr, up to nmemb elements
+    whose size is specified by size, to the stream pointed to by stream. For each object,
+    size calls are made to the fputc function, taking the values (in order) from an array of
+    unsigned char exactly overlaying the object. The file position indicator for the
+    stream (if defined) is advanced by the number of characters successfully written. If an
+    error occurs, the resulting value of the file position indicator for the stream is
+    indeterminate.
+<b>    Returns</b>
+3   The fwrite function returns the number of elements successfully written, which will be
+    less than nmemb only if a write error is encountered. If size or nmemb is zero,
+    fwrite returns zero and the state of the stream remains unchanged.
+<a name="7.21.9" href="#7.21.9"><b>    7.21.9 File positioning functions</b></a>
+<a name="7.21.9.1" href="#7.21.9.1"><b>    7.21.9.1 The fgetpos function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int fgetpos(FILE * restrict stream,
+                 fpos_t * restrict pos);
+<b>    Description</b>
+2   The fgetpos function stores the current values of the parse state (if any) and file
+    position indicator for the stream pointed to by stream in the object pointed to by pos.
+    The values stored contain unspecified information usable by the fsetpos function for
+    repositioning the stream to its position at the time of the call to the fgetpos function.
+<b>    Returns</b>
+3   If successful, the fgetpos function returns zero; on failure, the fgetpos function
+    returns nonzero and stores an implementation-defined positive value in errno.
+    Forward references: the fsetpos function (<a href="#7.21.9.3">7.21.9.3</a>).
+
+[<a name="p335" href="#p335">page 335</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.9.2" href="#7.21.9.2"><b>    7.21.9.2 The fseek function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int fseek(FILE *stream, long int offset, int whence);
+<b>    Description</b>
+2   The fseek function sets the file position indicator for the stream pointed to by stream.
+    If a read or write error occurs, the error indicator for the stream is set and fseek fails.
+3   For a binary stream, the new position, measured in characters from the beginning of the
+    file, is obtained by adding offset to the position specified by whence. The specified
+    position is the beginning of the file if whence is SEEK_SET, the current value of the file
+    position indicator if SEEK_CUR, or end-of-file if SEEK_END. A binary stream need not
+    meaningfully support fseek calls with a whence value of SEEK_END.
+4   For a text stream, either offset shall be zero, or offset shall be a value returned by
+    an earlier successful call to the ftell function on a stream associated with the same file
+    and whence shall be SEEK_SET.
+5   After determining the new position, a successful call to the fseek function undoes any
+    effects of the ungetc function on the stream, clears the end-of-file indicator for the
+    stream, and then establishes the new position. After a successful fseek call, the next
+    operation on an update stream may be either input or output.
+<b>    Returns</b>
+6   The fseek function returns nonzero only for a request that cannot be satisfied.
+    Forward references: the ftell function (<a href="#7.21.9.4">7.21.9.4</a>).
+<a name="7.21.9.3" href="#7.21.9.3"><b>    7.21.9.3 The fsetpos function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int fsetpos(FILE *stream, const fpos_t *pos);
+<b>    Description</b>
+2   The fsetpos function sets the mbstate_t object (if any) and file position indicator
+    for the stream pointed to by stream according to the value of the object pointed to by
+    pos, which shall be a value obtained from an earlier successful call to the fgetpos
+    function on a stream associated with the same file. If a read or write error occurs, the
+    error indicator for the stream is set and fsetpos fails.
+3   A successful call to the fsetpos function undoes any effects of the ungetc function
+    on the stream, clears the end-of-file indicator for the stream, and then establishes the new
+    parse state and position. After a successful fsetpos call, the next operation on an
+
+[<a name="p336" href="#p336">page 336</a>] (<a href="#Contents">Contents</a>)
+
+    update stream may be either input or output.
+<b>    Returns</b>
+4   If successful, the fsetpos function returns zero; on failure, the fsetpos function
+    returns nonzero and stores an implementation-defined positive value in errno.
+<a name="7.21.9.4" href="#7.21.9.4"><b>    7.21.9.4 The ftell function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            long int ftell(FILE *stream);
+<b>    Description</b>
+2   The ftell function obtains the current value of the file position indicator for the stream
+    pointed to by stream. For a binary stream, the value is the number of characters from
+    the beginning of the file. For a text stream, its file position indicator contains unspecified
+    information, usable by the fseek function for returning the file position indicator for the
+    stream to its position at the time of the ftell call; the difference between two such
+    return values is not necessarily a meaningful measure of the number of characters written
+    or read.
+<b>    Returns</b>
+3   If successful, the ftell function returns the current value of the file position indicator
+    for the stream. On failure, the ftell function returns -1L and stores an
+    implementation-defined positive value in errno.
+<a name="7.21.9.5" href="#7.21.9.5"><b>    7.21.9.5 The rewind function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            void rewind(FILE *stream);
+<b>    Description</b>
+2   The rewind function sets the file position indicator for the stream pointed to by
+    stream to the beginning of the file. It is equivalent to
+            (void)fseek(stream, 0L, SEEK_SET)
+    except that the error indicator for the stream is also cleared.
+<b>    Returns</b>
+3   The rewind function returns no value.
+
+[<a name="p337" href="#p337">page 337</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.10" href="#7.21.10"><b>    7.21.10 Error-handling functions</b></a>
+<a name="7.21.10.1" href="#7.21.10.1"><b>    7.21.10.1 The clearerr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           void clearerr(FILE *stream);
+<b>    Description</b>
+2   The clearerr function clears the end-of-file and error indicators for the stream pointed
+    to by stream.
+<b>    Returns</b>
+3   The clearerr function returns no value.
+<a name="7.21.10.2" href="#7.21.10.2"><b>    7.21.10.2 The feof function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int feof(FILE *stream);
+<b>    Description</b>
+2   The feof function tests the end-of-file indicator for the stream pointed to by stream.
+<b>    Returns</b>
+3   The feof function returns nonzero if and only if the end-of-file indicator is set for
+    stream.
+<a name="7.21.10.3" href="#7.21.10.3"><b>    7.21.10.3 The ferror function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int ferror(FILE *stream);
+<b>    Description</b>
+2   The ferror function tests the error indicator for the stream pointed to by stream.
+<b>    Returns</b>
+3   The ferror function returns nonzero if and only if the error indicator is set for
+    stream.
+
+[<a name="p338" href="#p338">page 338</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.21.10.4" href="#7.21.10.4"><b>    7.21.10.4 The perror function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            void perror(const char *s);
+<b>    Description</b>
+2   The perror function maps the error number in the integer expression errno to an
+    error message. It writes a sequence of characters to the standard error stream thus: first
+    (if s is not a null pointer and the character pointed to by s is not the null character), the
+    string pointed to by s followed by a colon (:) and a space; then an appropriate error
+    message string followed by a new-line character. The contents of the error message
+    strings are the same as those returned by the strerror function with argument errno.
+<b>    Returns</b>
+3   The perror function returns no value.
+    Forward references: the strerror function (<a href="#7.23.6.2">7.23.6.2</a>).
+
+[<a name="p339" href="#p339">page 339</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22" href="#7.22"><b>    7.22 General utilities &lt;stdlib.h&gt;</b></a>
+1   The header <a href="#7.22">&lt;stdlib.h&gt;</a> declares five types and several functions of general utility, and
+    defines several macros.<sup><a href="#note284"><b>284)</b></a></sup>
+2   The types declared are size_t and wchar_t (both described in <a href="#7.19">7.19</a>),
+             div_t
+    which is a structure type that is the type of the value returned by the div function,
+             ldiv_t
+    which is a structure type that is the type of the value returned by the ldiv function, and
+             lldiv_t
+    which is a structure type that is the type of the value returned by the lldiv function.
+3   The macros defined are NULL (described in <a href="#7.19">7.19</a>);
+             EXIT_FAILURE
+    and
+             EXIT_SUCCESS
+    which expand to integer constant expressions that can be used as the argument to the
+    exit function to return unsuccessful or successful termination status, respectively, to the
+    host environment;
+             RAND_MAX
+    which expands to an integer constant expression that is the maximum value returned by
+    the rand function; and
+             MB_CUR_MAX
+    which expands to a positive integer expression with type size_t that is the maximum
+    number of bytes in a multibyte character for the extended character set specified by the
+    current locale (category LC_CTYPE), which is never greater than MB_LEN_MAX.
+
+
+
+
+    <sup><a name="note284" href="#note284"><b>284)</b></a></sup> See ''future library directions'' (<a href="#7.30.10">7.30.10</a>).
+
+[<a name="p340" href="#p340">page 340</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22.1" href="#7.22.1"><b>    7.22.1 Numeric conversion functions</b></a>
+1   The functions atof, atoi, atol, and atoll need not affect the value of the integer
+    expression errno on an error. If the value of the result cannot be represented, the
+    behavior is undefined.
+<a name="7.22.1.1" href="#7.22.1.1"><b>    7.22.1.1 The atof function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            double atof(const char *nptr);
+<b>    Description</b>
+2   The atof function converts the initial portion of the string pointed to by nptr to
+    double representation. Except for the behavior on error, it is equivalent to
+            strtod(nptr, (char **)NULL)
+<b>    Returns</b>
+3   The atof function returns the converted value.
+    Forward references: the strtod, strtof, and strtold functions (<a href="#7.22.1.3">7.22.1.3</a>).
+<a name="7.22.1.2" href="#7.22.1.2"><b>    7.22.1.2 The atoi, atol, and atoll functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            int atoi(const char *nptr);
+            long int atol(const char *nptr);
+            long long int atoll(const char *nptr);
+<b>    Description</b>
+2   The atoi, atol, and atoll functions convert the initial portion of the string pointed
+    to by nptr to int, long int, and long long int representation, respectively.
+    Except for the behavior on error, they are equivalent to
+            atoi: (int)strtol(nptr, (char **)NULL, 10)
+            atol: strtol(nptr, (char **)NULL, 10)
+            atoll: strtoll(nptr, (char **)NULL, 10)
+<b>    Returns</b>
+3   The atoi, atol, and atoll functions return the converted value.
+    Forward references: the strtol, strtoll, strtoul, and strtoull functions
+    (<a href="#7.22.1.4">7.22.1.4</a>).
+
+[<a name="p341" href="#p341">page 341</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22.1.3" href="#7.22.1.3"><b>    7.22.1.3 The strtod, strtof, and strtold functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+           double strtod(const char * restrict nptr,
+                char ** restrict endptr);
+           float strtof(const char * restrict nptr,
+                char ** restrict endptr);
+           long double strtold(const char * restrict nptr,
+                char ** restrict endptr);
+<b>    Description</b>
+2   The strtod, strtof, and strtold functions convert the initial portion of the string
+    pointed to by nptr to double, float, and long double representation,
+    respectively. First, they decompose the input string into three parts: an initial, possibly
+    empty, sequence of white-space characters (as specified by the isspace function), a
+    subject sequence resembling a floating-point constant or representing an infinity or NaN;
+    and a final string of one or more unrecognized characters, including the terminating null
+    character of the input string. Then, they attempt to convert the subject sequence to a
+    floating-point number, and return the result.
+3   The expected form of the subject sequence is an optional plus or minus sign, then one of
+    the following:
+    -- a nonempty sequence of decimal digits optionally containing a decimal-point
+      character, then an optional exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+      decimal-point character, then an optional binary exponent part as defined in <a href="#6.4.4.2">6.4.4.2</a>;
+    -- INF or INFINITY, ignoring case
+    -- NAN or NAN(n-char-sequenceopt), ignoring case in the NAN part, where:
+               n-char-sequence:
+                      digit
+                      nondigit
+                      n-char-sequence digit
+                      n-char-sequence nondigit
+    The subject sequence is defined as the longest initial subsequence of the input string,
+    starting with the first non-white-space character, that is of the expected form. The subject
+    sequence contains no characters if the input string is not of the expected form.
+4   If the subject sequence has the expected form for a floating-point number, the sequence of
+    characters starting with the first digit or the decimal-point character (whichever occurs
+    first) is interpreted as a floating constant according to the rules of <a href="#6.4.4.2">6.4.4.2</a>, except that the
+
+[<a name="p342" href="#p342">page 342</a>] (<a href="#Contents">Contents</a>)
+
+    decimal-point character is used in place of a period, and that if neither an exponent part
+    nor a decimal-point character appears in a decimal floating point number, or if a binary
+    exponent part does not appear in a hexadecimal floating point number, an exponent part
+    of the appropriate type with value zero is assumed to follow the last digit in the string. If
+    the subject sequence begins with a minus sign, the sequence is interpreted as negated.<sup><a href="#note285"><b>285)</b></a></sup>
+    A character sequence INF or INFINITY is interpreted as an infinity, if representable in
+    the return type, else like a floating constant that is too large for the range of the return
+    type. A character sequence NAN or NAN(n-char-sequenceopt), is interpreted as a quiet
+    NaN, if supported in the return type, else like a subject sequence part that does not have
+    the expected form; the meaning of the n-char sequences is implementation-defined.<sup><a href="#note286"><b>286)</b></a></sup> A
+    pointer to the final string is stored in the object pointed to by endptr, provided that
+    endptr is not a null pointer.
+5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+    value resulting from the conversion is correctly rounded.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+    Recommended practice
+8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+    the result is not exactly representable, the result should be one of the two numbers in the
+    appropriate internal format that are adjacent to the hexadecimal floating source value,
+    with the extra stipulation that the error should have a correct sign for the current rounding
+    direction.
+9   If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+    <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
+    sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+    consider the two bounding, adjacent decimal strings L and U, both having
+    DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+    The result should be one of the (equal or adjacent) values that would be obtained by
+    correctly rounding L and U according to the current rounding direction, with the extra
+
+    <sup><a name="note285" href="#note285"><b>285)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+         methods may yield different results if rounding is toward positive or negative infinity. In either case,
+         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+    <sup><a name="note286" href="#note286"><b>286)</b></a></sup> An implementation may use the n-char sequence to determine extra information to be represented in
+         the NaN's significand.
+
+[<a name="p343" href="#p343">page 343</a>] (<a href="#Contents">Contents</a>)
+
+     stipulation that the error with respect to D should have a correct sign for the current
+     rounding direction.<sup><a href="#note287"><b>287)</b></a></sup>
+<b>     Returns</b>
+10   The functions return the converted value, if any. If no conversion could be performed,
+     zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
+     plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
+     return type and sign of the value), and the value of the macro ERANGE is stored in
+     errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
+     no greater than the smallest normalized positive number in the return type; whether
+     errno acquires the value ERANGE is implementation-defined.
+<a name="7.22.1.4" href="#7.22.1.4"><b>     7.22.1.4 The strtol, strtoll, strtoul, and strtoull functions</b></a>
+<b>     Synopsis</b>
+1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             long int strtol(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+             long long int strtoll(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+             unsigned long int strtoul(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+             unsigned long long int strtoull(
+                  const char * restrict nptr,
+                  char ** restrict endptr,
+                  int base);
+<b>     Description</b>
+2    The strtol, strtoll, strtoul, and strtoull functions convert the initial
+     portion of the string pointed to by nptr to long int, long long int, unsigned
+     long int, and unsigned long long int representation, respectively. First,
+     they decompose the input string into three parts: an initial, possibly empty, sequence of
+     white-space characters (as specified by the isspace function), a subject sequence
+
+
+     <sup><a name="note287" href="#note287"><b>287)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
+          to the same internal floating value, but if not will round to adjacent values.
+
+[<a name="p344" href="#p344">page 344</a>] (<a href="#Contents">Contents</a>)
+
+    resembling an integer represented in some radix determined by the value of base, and a
+    final string of one or more unrecognized characters, including the terminating null
+    character of the input string. Then, they attempt to convert the subject sequence to an
+    integer, and return the result.
+3   If the value of base is zero, the expected form of the subject sequence is that of an
+    integer constant as described in <a href="#6.4.4.1">6.4.4.1</a>, optionally preceded by a plus or minus sign, but
+    not including an integer suffix. If the value of base is between 2 and 36 (inclusive), the
+    expected form of the subject sequence is a sequence of letters and digits representing an
+    integer with the radix specified by base, optionally preceded by a plus or minus sign,
+    but not including an integer suffix. The letters from a (or A) through z (or Z) are
+    ascribed the values 10 through 35; only letters and digits whose ascribed values are less
+    than that of base are permitted. If the value of base is 16, the characters 0x or 0X may
+    optionally precede the sequence of letters and digits, following the sign if present.
+4   The subject sequence is defined as the longest initial subsequence of the input string,
+    starting with the first non-white-space character, that is of the expected form. The subject
+    sequence contains no characters if the input string is empty or consists entirely of white
+    space, or if the first non-white-space character is other than a sign or a permissible letter
+    or digit.
+5   If the subject sequence has the expected form and the value of base is zero, the sequence
+    of characters starting with the first digit is interpreted as an integer constant according to
+    the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the value of base
+    is between 2 and 36, it is used as the base for conversion, ascribing to each letter its value
+    as given above. If the subject sequence begins with a minus sign, the value resulting from
+    the conversion is negated (in the return type). A pointer to the final string is stored in the
+    object pointed to by endptr, provided that endptr is not a null pointer.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+<b>    Returns</b>
+8   The strtol, strtoll, strtoul, and strtoull functions return the converted
+    value, if any. If no conversion could be performed, zero is returned. If the correct value
+    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+    and sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+
+[<a name="p345" href="#p345">page 345</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22.2" href="#7.22.2"><b>    7.22.2 Pseudo-random sequence generation functions</b></a>
+<a name="7.22.2.1" href="#7.22.2.1"><b>    7.22.2.1 The rand function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            int rand(void);
+<b>    Description</b>
+2   The rand function computes a sequence of pseudo-random integers in the range 0 to
+    RAND_MAX.<sup><a href="#note288"><b>288)</b></a></sup>
+3   The rand function is not required to avoid data races. The implementation shall behave
+    as if no library function calls the rand function.
+<b>    Returns</b>
+4   The rand function returns a pseudo-random integer.
+    Environmental limits
+5   The value of the RAND_MAX macro shall be at least 32767.
+<a name="7.22.2.2" href="#7.22.2.2"><b>    7.22.2.2 The srand function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void srand(unsigned int seed);
+<b>    Description</b>
+2   The srand function uses the argument as a seed for a new sequence of pseudo-random
+    numbers to be returned by subsequent calls to rand. If srand is then called with the
+    same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is
+    called before any calls to srand have been made, the same sequence shall be generated
+    as when srand is first called with a seed value of 1.
+3   The implementation shall behave as if no library function calls the srand function.
+<b>    Returns</b>
+4   The srand function returns no value.
+
+
+
+
+    <sup><a name="note288" href="#note288"><b>288)</b></a></sup> There are no guarantees as to the quality of the random sequence produced and some implementations
+         are known to produce sequences with distressingly non-random low-order bits. Applications with
+         particular requirements should use a generator that is known to be sufficient for their needs.
+
+[<a name="p346" href="#p346">page 346</a>] (<a href="#Contents">Contents</a>)
+
+5   EXAMPLE       The following functions define a portable implementation of rand and srand.
+            static unsigned long int next = 1;
+            int rand(void)   // RAND_MAX assumed to be 32767
+            {
+                  next = next * 1103515245 + 12345;
+                  return (unsigned int)(next/65536) % 32768;
+            }
+            void srand(unsigned int seed)
+            {
+                  next = seed;
+            }
+
+<a name="7.22.3" href="#7.22.3"><b>    7.22.3 Memory management functions</b></a>
+1   The order and contiguity of storage allocated by successive calls to the
+    aligned_alloc, calloc, malloc, and realloc functions is unspecified. The
+    pointer returned if the allocation succeeds is suitably aligned so that it may be assigned to
+    a pointer to any type of object with a fundamental alignment requirement and then used
+    to access such an object or an array of such objects in the space allocated (until the space
+    is explicitly deallocated). The lifetime of an allocated object extends from the allocation
+    until the deallocation. Each such allocation shall yield a pointer to an object disjoint from
+    any other object. The pointer returned points to the start (lowest byte address) of the
+    allocated space. If the space cannot be allocated, a null pointer is returned. If the size of
+    the space requested is zero, the behavior is implementation-defined: either a null pointer
+    is returned, or the behavior is as if the size were some nonzero value, except that the
+    returned pointer shall not be used to access an object.
+<a name="7.22.3.1" href="#7.22.3.1"><b>    7.22.3.1 The aligned_alloc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void *aligned_alloc(size_t alignment, size_t size);
+<b>    Description</b>
+2   The aligned_alloc function allocates space for an object whose alignment is
+    specified by alignment, whose size is specified by size, and whose value is
+    indeterminate. The value of alignment shall be a valid alignment supported by the
+    implementation and the value of size shall be an integral multiple of alignment.
+<b>    Returns</b>
+3   The aligned_alloc function returns either a null pointer or a pointer to the allocated
+    space.
+
+[<a name="p347" href="#p347">page 347</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22.3.2" href="#7.22.3.2"><b>    7.22.3.2 The calloc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void *calloc(size_t nmemb, size_t size);
+<b>    Description</b>
+2   The calloc function allocates space for an array of nmemb objects, each of whose size
+    is size. The space is initialized to all bits zero.<sup><a href="#note289"><b>289)</b></a></sup>
+<b>    Returns</b>
+3   The calloc function returns either a null pointer or a pointer to the allocated space.
+<a name="7.22.3.3" href="#7.22.3.3"><b>    7.22.3.3 The free function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void free(void *ptr);
+<b>    Description</b>
+2   The free function causes the space pointed to by ptr to be deallocated, that is, made
+    available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if
+    the argument does not match a pointer earlier returned by a memory management
+    function, or if the space has been deallocated by a call to free or realloc, the
+    behavior is undefined.
+<b>    Returns</b>
+3   The free function returns no value.
+<a name="7.22.3.4" href="#7.22.3.4"><b>    7.22.3.4 The malloc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void *malloc(size_t size);
+<b>    Description</b>
+2   The malloc function allocates space for an object whose size is specified by size and
+    whose value is indeterminate.
+
+
+
+
+    <sup><a name="note289" href="#note289"><b>289)</b></a></sup> Note that this need not be the same as the representation of floating-point zero or a null pointer
+         constant.
+
+[<a name="p348" href="#p348">page 348</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The malloc function returns either a null pointer or a pointer to the allocated space.
+<a name="7.22.3.5" href="#7.22.3.5"><b>    7.22.3.5 The realloc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void *realloc(void *ptr, size_t size);
+<b>    Description</b>
+2   The realloc function deallocates the old object pointed to by ptr and returns a
+    pointer to a new object that has the size specified by size. The contents of the new
+    object shall be the same as that of the old object prior to deallocation, up to the lesser of
+    the new and old sizes. Any bytes in the new object beyond the size of the old object have
+    indeterminate values.
+3   If ptr is a null pointer, the realloc function behaves like the malloc function for the
+    specified size. Otherwise, if ptr does not match a pointer earlier returned by a memory
+    management function, or if the space has been deallocated by a call to the free or
+    realloc function, the behavior is undefined. If memory for the new object cannot be
+    allocated, the old object is not deallocated and its value is unchanged.
+<b>    Returns</b>
+4   The realloc function returns a pointer to the new object (which may have the same
+    value as a pointer to the old object), or a null pointer if the new object could not be
+    allocated.
+<a name="7.22.4" href="#7.22.4"><b>    7.22.4 Communication with the environment</b></a>
+<a name="7.22.4.1" href="#7.22.4.1"><b>    7.22.4.1 The abort function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            _Noreturn void abort(void);
+<b>    Description</b>
+2   The abort function causes abnormal program termination to occur, unless the signal
+    SIGABRT is being caught and the signal handler does not return. Whether open streams
+    with unwritten buffered data are flushed, open streams are closed, or temporary files are
+    removed is implementation-defined. An implementation-defined form of the status
+    unsuccessful termination is returned to the host environment by means of the function
+    call raise(SIGABRT).
+
+[<a name="p349" href="#p349">page 349</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The abort function does not return to its caller.
+<a name="7.22.4.2" href="#7.22.4.2"><b>    7.22.4.2 The atexit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+           int atexit(void (*func)(void));
+<b>    Description</b>
+2   The atexit function registers the function pointed to by func, to be called without
+    arguments at normal program termination.<sup><a href="#note290"><b>290)</b></a></sup>
+    Environmental limits
+3   The implementation shall support the registration of at least 32 functions.
+<b>    Returns</b>
+4   The atexit function returns zero if the registration succeeds, nonzero if it fails.
+    Forward references: the at_quick_exit function (<a href="#7.22.4.3">7.22.4.3</a>), the exit function
+    (<a href="#7.22.4.4">7.22.4.4</a>).
+<a name="7.22.4.3" href="#7.22.4.3"><b>    7.22.4.3 The at_quick_exit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+           int at_quick_exit(void (*func)(void));
+<b>    Description</b>
+2   The at_quick_exit function registers the function pointed to by func, to be called
+    without arguments should quick_exit be called.<sup><a href="#note291"><b>291)</b></a></sup>
+    Environmental limits
+3   The implementation shall support the registration of at least 32 functions.
+<b>    Returns</b>
+4   The at_quick_exit function returns zero if the registration succeeds, nonzero if it
+    fails.
+    Forward references: the quick_exit function (<a href="#7.22.4.7">7.22.4.7</a>).
+
+
+    <sup><a name="note290" href="#note290"><b>290)</b></a></sup> The atexit function registrations are distinct from the at_quick_exit registrations, so
+         applications may need to call both registration functions with the same argument.
+    <sup><a name="note291" href="#note291"><b>291)</b></a></sup> The at_quick_exit function registrations are distinct from the atexit registrations, so
+         applications may need to call both registration functions with the same argument.
+
+[<a name="p350" href="#p350">page 350</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22.4.4" href="#7.22.4.4"><b>    7.22.4.4 The exit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            _Noreturn void exit(int status);
+<b>    Description</b>
+2   The exit function causes normal program termination to occur. No functions registered
+    by the at_quick_exit function are called. If a program calls the exit function
+    more than once, or calls the quick_exit function in addition to the exit function, the
+    behavior is undefined.
+3   First, all functions registered by the atexit function are called, in the reverse order of
+    their registration,<sup><a href="#note292"><b>292)</b></a></sup> except that a function is called after any previously registered
+    functions that had already been called at the time it was registered. If, during the call to
+    any such function, a call to the longjmp function is made that would terminate the call
+    to the registered function, the behavior is undefined.
+4   Next, all open streams with unwritten buffered data are flushed, all open streams are
+    closed, and all files created by the tmpfile function are removed.
+5   Finally, control is returned to the host environment. If the value of status is zero or
+    EXIT_SUCCESS, an implementation-defined form of the status successful termination is
+    returned. If the value of status is EXIT_FAILURE, an implementation-defined form
+    of the status unsuccessful termination is returned. Otherwise the status returned is
+    implementation-defined.
+<b>    Returns</b>
+6   The exit function cannot return to its caller.
+<a name="7.22.4.5" href="#7.22.4.5"><b>    7.22.4.5 The _Exit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            _Noreturn void _Exit(int status);
+<b>    Description</b>
+2   The _Exit function causes normal program termination to occur and control to be
+    returned to the host environment. No functions registered by the atexit function, the
+    at_quick_exit function, or signal handlers registered by the signal function are
+    called. The status returned to the host environment is determined in the same way as for
+
+
+    <sup><a name="note292" href="#note292"><b>292)</b></a></sup> Each function is called as many times as it was registered, and in the correct order with respect to
+         other registered functions.
+
+[<a name="p351" href="#p351">page 351</a>] (<a href="#Contents">Contents</a>)
+
+    the exit function (<a href="#7.22.4.4">7.22.4.4</a>). Whether open streams with unwritten buffered data are
+    flushed, open streams are closed, or temporary files are removed is implementation-
+    defined.
+<b>    Returns</b>
+3   The _Exit function cannot return to its caller.
+<a name="7.22.4.6" href="#7.22.4.6"><b>    7.22.4.6 The getenv function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            char *getenv(const char *name);
+<b>    Description</b>
+2   The getenv function searches an environment list, provided by the host environment,
+    for a string that matches the string pointed to by name. The set of environment names
+    and the method for altering the environment list are implementation-defined. The
+    getenv function need not avoid data races with other threads of execution that modify
+    the environment list.<sup><a href="#note293"><b>293)</b></a></sup>
+3   The implementation shall behave as if no library function calls the getenv function.
+<b>    Returns</b>
+4   The getenv function returns a pointer to a string associated with the matched list
+    member. The string pointed to shall not be modified by the program, but may be
+    overwritten by a subsequent call to the getenv function. If the specified name cannot
+    be found, a null pointer is returned.
+<a name="7.22.4.7" href="#7.22.4.7"><b>    7.22.4.7 The quick_exit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            _Noreturn void quick_exit(int status);
+<b>    Description</b>
+2   The quick_exit function causes normal program termination to occur. No functions
+    registered by the atexit function or signal handlers registered by the signal function
+    are called. If a program calls the quick_exit function more than once, or calls the
+    exit function in addition to the quick_exit function, the behavior is undefined.
+3   The quick_exit function first calls all functions registered by the at_quick_exit
+    function, in the reverse order of their registration,<sup><a href="#note294"><b>294)</b></a></sup> except that a function is called after
+
+
+    <sup><a name="note293" href="#note293"><b>293)</b></a></sup> Many implementations provide non-standard functions that modify the environment list.
+
+[<a name="p352" href="#p352">page 352</a>] (<a href="#Contents">Contents</a>)
+
+    any previously registered functions that had already been called at the time it was
+    registered. If, during the call to any such function, a call to the longjmp function is
+    made that would terminate the call to the registered function, the behavior is undefined.
+4   Then control is returned to the host environment by means of the function call
+    _Exit(status).
+<b>    Returns</b>
+5   The quick_exit function cannot return to its caller.
+<a name="7.22.4.8" href="#7.22.4.8"><b>    7.22.4.8 The system function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            int system(const char *string);
+<b>    Description</b>
+2   If string is a null pointer, the system function determines whether the host
+    environment has a command processor. If string is not a null pointer, the system
+    function passes the string pointed to by string to that command processor to be
+    executed in a manner which the implementation shall document; this might then cause the
+    program calling system to behave in a non-conforming manner or to terminate.
+<b>    Returns</b>
+3   If the argument is a null pointer, the system function returns nonzero only if a
+    command processor is available. If the argument is not a null pointer, and the system
+    function does return, it returns an implementation-defined value.
+<a name="7.22.5" href="#7.22.5"><b>    7.22.5 Searching and sorting utilities</b></a>
+1   These utilities make use of a comparison function to search or sort arrays of unspecified
+    type. Where an argument declared as size_t nmemb specifies the length of the array
+    for a function, nmemb can have the value zero on a call to that function; the comparison
+    function is not called, a search finds no matching element, and sorting performs no
+    rearrangement. Pointer arguments on such a call shall still have valid values, as described
+    in <a href="#7.1.4">7.1.4</a>.
+2   The implementation shall ensure that the second argument of the comparison function
+    (when called from bsearch), or both arguments (when called from qsort), are
+    pointers to elements of the array.<sup><a href="#note295"><b>295)</b></a></sup> The first argument when called from bsearch
+    shall equal key.
+
+
+
+    <sup><a name="note294" href="#note294"><b>294)</b></a></sup> Each function is called as many times as it was registered, and in the correct order with respect to
+         other registered functions.
+
+[<a name="p353" href="#p353">page 353</a>] (<a href="#Contents">Contents</a>)
+
+3   The comparison function shall not alter the contents of the array. The implementation
+    may reorder elements of the array between calls to the comparison function, but shall not
+    alter the contents of any individual element.
+4   When the same objects (consisting of size bytes, irrespective of their current positions
+    in the array) are passed more than once to the comparison function, the results shall be
+    consistent with one another. That is, for qsort they shall define a total ordering on the
+    array, and for bsearch the same object shall always compare the same way with the
+    key.
+5   A sequence point occurs immediately before and immediately after each call to the
+    comparison function, and also between any call to the comparison function and any
+    movement of the objects passed as arguments to that call.
+<a name="7.22.5.1" href="#7.22.5.1"><b>    7.22.5.1 The bsearch function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             void *bsearch(const void *key, const void *base,
+                  size_t nmemb, size_t size,
+                  int (*compar)(const void *, const void *));
+<b>    Description</b>
+2   The bsearch function searches an array of nmemb objects, the initial element of which
+    is pointed to by base, for an element that matches the object pointed to by key. The
+    size of each element of the array is specified by size.
+3   The comparison function pointed to by compar is called with two arguments that point
+    to the key object and to an array element, in that order. The function shall return an
+    integer less than, equal to, or greater than zero if the key object is considered,
+    respectively, to be less than, to match, or to be greater than the array element. The array
+    shall consist of: all the elements that compare less than, all the elements that compare
+    equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note296"><b>296)</b></a></sup>
+<b>    Returns</b>
+4   The bsearch function returns a pointer to a matching element of the array, or a null
+    pointer if no match is found. If two elements compare as equal, which element is
+
+
+    <sup><a name="note295" href="#note295"><b>295)</b></a></sup> That is, if the value passed is p, then the following expressions are always nonzero:
+                  ((char *)p - (char *)base) % size == 0
+                  (char *)p &gt;= (char *)base
+                  (char *)p &lt; (char *)base + nmemb * size
+
+    <sup><a name="note296" href="#note296"><b>296)</b></a></sup> In practice, the entire array is sorted according to the comparison function.
+
+[<a name="p354" href="#p354">page 354</a>] (<a href="#Contents">Contents</a>)
+
+    matched is unspecified.
+<a name="7.22.5.2" href="#7.22.5.2"><b>    7.22.5.2 The qsort function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void qsort(void *base, size_t nmemb, size_t size,
+                 int (*compar)(const void *, const void *));
+<b>    Description</b>
+2   The qsort function sorts an array of nmemb objects, the initial element of which is
+    pointed to by base. The size of each object is specified by size.
+3   The contents of the array are sorted into ascending order according to a comparison
+    function pointed to by compar, which is called with two arguments that point to the
+    objects being compared. The function shall return an integer less than, equal to, or
+    greater than zero if the first argument is considered to be respectively less than, equal to,
+    or greater than the second.
+4   If two elements compare as equal, their order in the resulting sorted array is unspecified.
+<b>    Returns</b>
+5   The qsort function returns no value.
+<a name="7.22.6" href="#7.22.6"><b>    7.22.6 Integer arithmetic functions</b></a>
+<a name="7.22.6.1" href="#7.22.6.1"><b>    7.22.6.1 The abs, labs and llabs functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            int abs(int j);
+            long int labs(long int j);
+            long long int llabs(long long int j);
+<b>    Description</b>
+2   The abs, labs, and llabs functions compute the absolute value of an integer j. If the
+    result cannot be represented, the behavior is undefined.<sup><a href="#note297"><b>297)</b></a></sup>
+<b>    Returns</b>
+3   The abs, labs, and llabs, functions return the absolute value.
+
+
+
+
+    <sup><a name="note297" href="#note297"><b>297)</b></a></sup> The absolute value of the most negative number cannot be represented in two's complement.
+
+[<a name="p355" href="#p355">page 355</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22.6.2" href="#7.22.6.2"><b>    7.22.6.2 The div, ldiv, and lldiv functions</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             div_t div(int numer, int denom);
+             ldiv_t ldiv(long int numer, long int denom);
+             lldiv_t lldiv(long long int numer, long long int denom);
+<b>    Description</b>
+2   The div, ldiv, and lldiv, functions compute numer / denom and numer %
+    denom in a single operation.
+<b>    Returns</b>
+3   The div, ldiv, and lldiv functions return a structure of type div_t, ldiv_t, and
+    lldiv_t, respectively, comprising both the quotient and the remainder. The structures
+    shall contain (in either order) the members quot (the quotient) and rem (the remainder),
+    each of which has the same type as the arguments numer and denom. If either part of
+    the result cannot be represented, the behavior is undefined.
+<a name="7.22.7" href="#7.22.7"><b>    7.22.7 Multibyte/wide character conversion functions</b></a>
+1   The behavior of the multibyte character functions is affected by the LC_CTYPE category
+    of the current locale. For a state-dependent encoding, each function is placed into its
+    initial conversion state at program startup and can be returned to that state by a call for
+    which its character pointer argument, s, is a null pointer. Subsequent calls with s as
+    other than a null pointer cause the internal conversion state of the function to be altered as
+    necessary. A call with s as a null pointer causes these functions to return a nonzero value
+    if encodings have state dependency, and zero otherwise.<sup><a href="#note298"><b>298)</b></a></sup> Changing the LC_CTYPE
+    category causes the conversion state of these functions to be indeterminate.
+<a name="7.22.7.1" href="#7.22.7.1"><b>    7.22.7.1 The mblen function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             int mblen(const char *s, size_t n);
+<b>    Description</b>
+2   If s is not a null pointer, the mblen function determines the number of bytes contained
+    in the multibyte character pointed to by s. Except that the conversion state of the
+    mbtowc function is not affected, it is equivalent to
+
+
+
+    <sup><a name="note298" href="#note298"><b>298)</b></a></sup> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+         character codes, but are grouped with an adjacent multibyte character.
+
+[<a name="p356" href="#p356">page 356</a>] (<a href="#Contents">Contents</a>)
+
+            mbtowc((wchar_t *)0, (const char *)0, 0);
+            mbtowc((wchar_t *)0, s, n);
+3   The implementation shall behave as if no library function calls the mblen function.
+<b>    Returns</b>
+4   If s is a null pointer, the mblen function returns a nonzero or zero value, if multibyte
+    character encodings, respectively, do or do not have state-dependent encodings. If s is
+    not a null pointer, the mblen function either returns 0 (if s points to the null character),
+    or returns the number of bytes that are contained in the multibyte character (if the next n
+    or fewer bytes form a valid multibyte character), or returns -1 (if they do not form a valid
+    multibyte character).
+    Forward references: the mbtowc function (<a href="#7.22.7.2">7.22.7.2</a>).
+<a name="7.22.7.2" href="#7.22.7.2"><b>    7.22.7.2 The mbtowc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            int mbtowc(wchar_t * restrict pwc,
+                 const char * restrict s,
+                 size_t n);
+<b>    Description</b>
+2   If s is not a null pointer, the mbtowc function inspects at most n bytes beginning with
+    the byte pointed to by s to determine the number of bytes needed to complete the next
+    multibyte character (including any shift sequences). If the function determines that the
+    next multibyte character is complete and valid, it determines the value of the
+    corresponding wide character and then, if pwc is not a null pointer, stores that value in
+    the object pointed to by pwc. If the corresponding wide character is the null wide
+    character, the function is left in the initial conversion state.
+3   The implementation shall behave as if no library function calls the mbtowc function.
+<b>    Returns</b>
+4   If s is a null pointer, the mbtowc function returns a nonzero or zero value, if multibyte
+    character encodings, respectively, do or do not have state-dependent encodings. If s is
+    not a null pointer, the mbtowc function either returns 0 (if s points to the null character),
+    or returns the number of bytes that are contained in the converted multibyte character (if
+    the next n or fewer bytes form a valid multibyte character), or returns -1 (if they do not
+    form a valid multibyte character).
+5   In no case will the value returned be greater than n or the value of the MB_CUR_MAX
+    macro.
+
+[<a name="p357" href="#p357">page 357</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.22.7.3" href="#7.22.7.3"><b>    7.22.7.3 The wctomb function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+           int wctomb(char *s, wchar_t wc);
+<b>    Description</b>
+2   The wctomb function determines the number of bytes needed to represent the multibyte
+    character corresponding to the wide character given by wc (including any shift
+    sequences), and stores the multibyte character representation in the array whose first
+    element is pointed to by s (if s is not a null pointer). At most MB_CUR_MAX characters
+    are stored. If wc is a null wide character, a null byte is stored, preceded by any shift
+    sequence needed to restore the initial shift state, and the function is left in the initial
+    conversion state.
+3   The implementation shall behave as if no library function calls the wctomb function.
+<b>    Returns</b>
+4   If s is a null pointer, the wctomb function returns a nonzero or zero value, if multibyte
+    character encodings, respectively, do or do not have state-dependent encodings. If s is
+    not a null pointer, the wctomb function returns -1 if the value of wc does not correspond
+    to a valid multibyte character, or returns the number of bytes that are contained in the
+    multibyte character corresponding to the value of wc.
+5   In no case will the value returned be greater than the value of the MB_CUR_MAX macro.
+<a name="7.22.8" href="#7.22.8"><b>    7.22.8 Multibyte/wide string conversion functions</b></a>
+1   The behavior of the multibyte string functions is affected by the LC_CTYPE category of
+    the current locale.
+<a name="7.22.8.1" href="#7.22.8.1"><b>    7.22.8.1 The mbstowcs function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+           size_t mbstowcs(wchar_t * restrict pwcs,
+                const char * restrict s,
+                size_t n);
+<b>    Description</b>
+2   The mbstowcs function converts a sequence of multibyte characters that begins in the
+    initial shift state from the array pointed to by s into a sequence of corresponding wide
+    characters and stores not more than n wide characters into the array pointed to by pwcs.
+    No multibyte characters that follow a null character (which is converted into a null wide
+    character) will be examined or converted. Each multibyte character is converted as if by
+    a call to the mbtowc function, except that the conversion state of the mbtowc function is
+
+[<a name="p358" href="#p358">page 358</a>] (<a href="#Contents">Contents</a>)
+
+    not affected.
+3   No more than n elements will be modified in the array pointed to by pwcs. If copying
+    takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+4   If an invalid multibyte character is encountered, the mbstowcs function returns
+    (size_t)(-1). Otherwise, the mbstowcs function returns the number of array
+    elements modified, not including a terminating null wide character, if any.<sup><a href="#note299"><b>299)</b></a></sup>
+<a name="7.22.8.2" href="#7.22.8.2"><b>    7.22.8.2 The wcstombs function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             size_t wcstombs(char * restrict s,
+                  const wchar_t * restrict pwcs,
+                  size_t n);
+<b>    Description</b>
+2   The wcstombs function converts a sequence of wide characters from the array pointed
+    to by pwcs into a sequence of corresponding multibyte characters that begins in the
+    initial shift state, and stores these multibyte characters into the array pointed to by s,
+    stopping if a multibyte character would exceed the limit of n total bytes or if a null
+    character is stored. Each wide character is converted as if by a call to the wctomb
+    function, except that the conversion state of the wctomb function is not affected.
+3   No more than n bytes will be modified in the array pointed to by s. If copying takes place
+    between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+4   If a wide character is encountered that does not correspond to a valid multibyte character,
+    the wcstombs function returns (size_t)(-1). Otherwise, the wcstombs function
+    returns the number of bytes modified, not including a terminating null character, if
+    any.299)
+
+
+
+
+    <sup><a name="note299" href="#note299"><b>299)</b></a></sup> The array will not be null-terminated if the value returned is n.
+
+[<a name="p359" href="#p359">page 359</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.23" href="#7.23"><b>    7.23 String handling &lt;string.h&gt;</b></a>
+<a name="7.23.1" href="#7.23.1"><b>    7.23.1 String function conventions</b></a>
+1   The header <a href="#7.23">&lt;string.h&gt;</a> declares one type and several functions, and defines one
+    macro useful for manipulating arrays of character type and other objects treated as arrays
+    of character type.<sup><a href="#note300"><b>300)</b></a></sup> The type is size_t and the macro is NULL (both described in
+<a name="7.19)" href="#7.19)"><b>    7.19). Various methods are used for determining the lengths of the arrays, but in all cases</b></a>
+    a char * or void * argument points to the initial (lowest addressed) character of the
+    array. If an array is accessed beyond the end of an object, the behavior is undefined.
+2   Where an argument declared as size_t n specifies the length of the array for a
+    function, n can have the value zero on a call to that function. Unless explicitly stated
+    otherwise in the description of a particular function in this subclause, pointer arguments
+    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+    function that locates a character finds no occurrence, a function that compares two
+    character sequences returns zero, and a function that copies characters copies zero
+    characters.
+3   For all functions in this subclause, each character shall be interpreted as if it had the type
+    unsigned char (and therefore every possible object representation is valid and has a
+    different value).
+<a name="7.23.2" href="#7.23.2"><b>    7.23.2 Copying functions</b></a>
+<a name="7.23.2.1" href="#7.23.2.1"><b>    7.23.2.1 The memcpy function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.23">&lt;string.h&gt;</a>
+             void *memcpy(void * restrict s1,
+                  const void * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The memcpy function copies n characters from the object pointed to by s2 into the
+    object pointed to by s1. If copying takes place between objects that overlap, the behavior
+    is undefined.
+<b>    Returns</b>
+3   The memcpy function returns the value of s1.
+
+
+
+
+    <sup><a name="note300" href="#note300"><b>300)</b></a></sup> See ''future library directions'' (<a href="#7.30.11">7.30.11</a>).
+
+[<a name="p360" href="#p360">page 360</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.23.2.2" href="#7.23.2.2"><b>    7.23.2.2 The memmove function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            void *memmove(void *s1, const void *s2, size_t n);
+<b>    Description</b>
+2   The memmove function copies n characters from the object pointed to by s2 into the
+    object pointed to by s1. Copying takes place as if the n characters from the object
+    pointed to by s2 are first copied into a temporary array of n characters that does not
+    overlap the objects pointed to by s1 and s2, and then the n characters from the
+    temporary array are copied into the object pointed to by s1.
+<b>    Returns</b>
+3   The memmove function returns the value of s1.
+<a name="7.23.2.3" href="#7.23.2.3"><b>    7.23.2.3 The strcpy function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            char *strcpy(char * restrict s1,
+                 const char * restrict s2);
+<b>    Description</b>
+2   The strcpy function copies the string pointed to by s2 (including the terminating null
+    character) into the array pointed to by s1. If copying takes place between objects that
+    overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The strcpy function returns the value of s1.
+<a name="7.23.2.4" href="#7.23.2.4"><b>    7.23.2.4 The strncpy function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            char *strncpy(char * restrict s1,
+                 const char * restrict s2,
+                 size_t n);
+<b>    Description</b>
+2   The strncpy function copies not more than n characters (characters that follow a null
+    character are not copied) from the array pointed to by s2 to the array pointed to by
+
+[<a name="p361" href="#p361">page 361</a>] (<a href="#Contents">Contents</a>)
+
+    s1.<sup><a href="#note301"><b>301)</b></a></sup> If copying takes place between objects that overlap, the behavior is undefined.
+3   If the array pointed to by s2 is a string that is shorter than n characters, null characters
+    are appended to the copy in the array pointed to by s1, until n characters in all have been
+    written.
+<b>    Returns</b>
+4   The strncpy function returns the value of s1.
+<a name="7.23.3" href="#7.23.3"><b>    7.23.3 Concatenation functions</b></a>
+<a name="7.23.3.1" href="#7.23.3.1"><b>    7.23.3.1 The strcat function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.23">&lt;string.h&gt;</a>
+             char *strcat(char * restrict s1,
+                  const char * restrict s2);
+<b>    Description</b>
+2   The strcat function appends a copy of the string pointed to by s2 (including the
+    terminating null character) to the end of the string pointed to by s1. The initial character
+    of s2 overwrites the null character at the end of s1. If copying takes place between
+    objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The strcat function returns the value of s1.
+<a name="7.23.3.2" href="#7.23.3.2"><b>    7.23.3.2 The strncat function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.23">&lt;string.h&gt;</a>
+             char *strncat(char * restrict s1,
+                  const char * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The strncat function appends not more than n characters (a null character and
+    characters that follow it are not appended) from the array pointed to by s2 to the end of
+    the string pointed to by s1. The initial character of s2 overwrites the null character at the
+    end of s1. A terminating null character is always appended to the result.<sup><a href="#note302"><b>302)</b></a></sup> If copying
+
+    <sup><a name="note301" href="#note301"><b>301)</b></a></sup> Thus, if there is no null character in the first n characters of the array pointed to by s2, the result will
+         not be null-terminated.
+    <sup><a name="note302" href="#note302"><b>302)</b></a></sup> Thus, the maximum number of characters that can end up in the array pointed to by s1 is
+         strlen(s1)+n+1.
+
+[<a name="p362" href="#p362">page 362</a>] (<a href="#Contents">Contents</a>)
+
+    takes place between objects that overlap, the behavior is undefined.
+<b>    Returns</b>
+3   The strncat function returns the value of s1.
+    Forward references: the strlen function (<a href="#7.23.6.3">7.23.6.3</a>).
+<a name="7.23.4" href="#7.23.4"><b>    7.23.4 Comparison functions</b></a>
+1   The sign of a nonzero value returned by the comparison functions memcmp, strcmp,
+    and strncmp is determined by the sign of the difference between the values of the first
+    pair of characters (both interpreted as unsigned char) that differ in the objects being
+    compared.
+<a name="7.23.4.1" href="#7.23.4.1"><b>    7.23.4.1 The memcmp function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            int memcmp(const void *s1, const void *s2, size_t n);
+<b>    Description</b>
+2   The memcmp function compares the first n characters of the object pointed to by s1 to
+    the first n characters of the object pointed to by s2.<sup><a href="#note303"><b>303)</b></a></sup>
+<b>    Returns</b>
+3   The memcmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+    pointed to by s2.
+<a name="7.23.4.2" href="#7.23.4.2"><b>    7.23.4.2 The strcmp function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            int strcmp(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strcmp function compares the string pointed to by s1 to the string pointed to by
+    s2.
+<b>    Returns</b>
+3   The strcmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+
+    <sup><a name="note303" href="#note303"><b>303)</b></a></sup> The contents of ''holes'' used as padding for purposes of alignment within structure objects are
+         indeterminate. Strings shorter than their allocated space and unions may also cause problems in
+         comparison.
+
+[<a name="p363" href="#p363">page 363</a>] (<a href="#Contents">Contents</a>)
+
+    pointed to by s2.
+<a name="7.23.4.3" href="#7.23.4.3"><b>    7.23.4.3 The strcoll function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;string.h&gt;</a>
+           int strcoll(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strcoll function compares the string pointed to by s1 to the string pointed to by
+    s2, both interpreted as appropriate to the LC_COLLATE category of the current locale.
+<b>    Returns</b>
+3   The strcoll function returns an integer greater than, equal to, or less than zero,
+    accordingly as the string pointed to by s1 is greater than, equal to, or less than the string
+    pointed to by s2 when both are interpreted as appropriate to the current locale.
+<a name="7.23.4.4" href="#7.23.4.4"><b>    7.23.4.4 The strncmp function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;string.h&gt;</a>
+           int strncmp(const char *s1, const char *s2, size_t n);
+<b>    Description</b>
+2   The strncmp function compares not more than n characters (characters that follow a
+    null character are not compared) from the array pointed to by s1 to the array pointed to
+    by s2.
+<b>    Returns</b>
+3   The strncmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+    to, or less than the possibly null-terminated array pointed to by s2.
+<a name="7.23.4.5" href="#7.23.4.5"><b>    7.23.4.5 The strxfrm function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;string.h&gt;</a>
+           size_t strxfrm(char * restrict s1,
+                const char * restrict s2,
+                size_t n);
+<b>    Description</b>
+2   The strxfrm function transforms the string pointed to by s2 and places the resulting
+    string into the array pointed to by s1. The transformation is such that if the strcmp
+    function is applied to two transformed strings, it returns a value greater than, equal to, or
+
+[<a name="p364" href="#p364">page 364</a>] (<a href="#Contents">Contents</a>)
+
+    less than zero, corresponding to the result of the strcoll function applied to the same
+    two original strings. No more than n characters are placed into the resulting array
+    pointed to by s1, including the terminating null character. If n is zero, s1 is permitted to
+    be a null pointer. If copying takes place between objects that overlap, the behavior is
+    undefined.
+<b>    Returns</b>
+3   The strxfrm function returns the length of the transformed string (not including the
+    terminating null character). If the value returned is n or more, the contents of the array
+    pointed to by s1 are indeterminate.
+4   EXAMPLE The value of the following expression is the size of the array needed to hold the
+    transformation of the string pointed to by s.
+            1 + strxfrm(NULL, s, 0)
+
+<a name="7.23.5" href="#7.23.5"><b>    7.23.5 Search functions</b></a>
+<a name="7.23.5.1" href="#7.23.5.1"><b>    7.23.5.1 The memchr function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            void *memchr(const void *s, int c, size_t n);
+<b>    Description</b>
+2   The memchr function locates the first occurrence of c (converted to an unsigned
+    char) in the initial n characters (each interpreted as unsigned char) of the object
+    pointed to by s. The implementation shall behave as if it reads the characters sequentially
+    and stops as soon as a matching character is found.
+<b>    Returns</b>
+3   The memchr function returns a pointer to the located character, or a null pointer if the
+    character does not occur in the object.
+<a name="7.23.5.2" href="#7.23.5.2"><b>    7.23.5.2 The strchr function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            char *strchr(const char *s, int c);
+<b>    Description</b>
+2   The strchr function locates the first occurrence of c (converted to a char) in the
+    string pointed to by s. The terminating null character is considered to be part of the
+    string.
+
+[<a name="p365" href="#p365">page 365</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The strchr function returns a pointer to the located character, or a null pointer if the
+    character does not occur in the string.
+<a name="7.23.5.3" href="#7.23.5.3"><b>    7.23.5.3 The strcspn function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;string.h&gt;</a>
+           size_t strcspn(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strcspn function computes the length of the maximum initial segment of the string
+    pointed to by s1 which consists entirely of characters not from the string pointed to by
+    s2.
+<b>    Returns</b>
+3   The strcspn function returns the length of the segment.
+<a name="7.23.5.4" href="#7.23.5.4"><b>    7.23.5.4 The strpbrk function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;string.h&gt;</a>
+           char *strpbrk(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strpbrk function locates the first occurrence in the string pointed to by s1 of any
+    character from the string pointed to by s2.
+<b>    Returns</b>
+3   The strpbrk function returns a pointer to the character, or a null pointer if no character
+    from s2 occurs in s1.
+<a name="7.23.5.5" href="#7.23.5.5"><b>    7.23.5.5 The strrchr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;string.h&gt;</a>
+           char *strrchr(const char *s, int c);
+<b>    Description</b>
+2   The strrchr function locates the last occurrence of c (converted to a char) in the
+    string pointed to by s. The terminating null character is considered to be part of the
+    string.
+
+[<a name="p366" href="#p366">page 366</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The strrchr function returns a pointer to the character, or a null pointer if c does not
+    occur in the string.
+<a name="7.23.5.6" href="#7.23.5.6"><b>    7.23.5.6 The strspn function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            size_t strspn(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strspn function computes the length of the maximum initial segment of the string
+    pointed to by s1 which consists entirely of characters from the string pointed to by s2.
+<b>    Returns</b>
+3   The strspn function returns the length of the segment.
+<a name="7.23.5.7" href="#7.23.5.7"><b>    7.23.5.7 The strstr function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            char *strstr(const char *s1, const char *s2);
+<b>    Description</b>
+2   The strstr function locates the first occurrence in the string pointed to by s1 of the
+    sequence of characters (excluding the terminating null character) in the string pointed to
+    by s2.
+<b>    Returns</b>
+3   The strstr function returns a pointer to the located string, or a null pointer if the string
+    is not found. If s2 points to a string with zero length, the function returns s1.
+<a name="7.23.5.8" href="#7.23.5.8"><b>    7.23.5.8 The strtok function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            char *strtok(char * restrict s1,
+                 const char * restrict s2);
+<b>    Description</b>
+2   A sequence of calls to the strtok function breaks the string pointed to by s1 into a
+    sequence of tokens, each of which is delimited by a character from the string pointed to
+    by s2. The first call in the sequence has a non-null first argument; subsequent calls in the
+    sequence have a null first argument. The separator string pointed to by s2 may be
+    different from call to call.
+
+[<a name="p367" href="#p367">page 367</a>] (<a href="#Contents">Contents</a>)
+
+3   The first call in the sequence searches the string pointed to by s1 for the first character
+    that is not contained in the current separator string pointed to by s2. If no such character
+    is found, then there are no tokens in the string pointed to by s1 and the strtok function
+    returns a null pointer. If such a character is found, it is the start of the first token.
+4   The strtok function then searches from there for a character that is contained in the
+    current separator string. If no such character is found, the current token extends to the
+    end of the string pointed to by s1, and subsequent searches for a token will return a null
+    pointer. If such a character is found, it is overwritten by a null character, which
+    terminates the current token. The strtok function saves a pointer to the following
+    character, from which the next search for a token will start.
+5   Each subsequent call, with a null pointer as the value of the first argument, starts
+    searching from the saved pointer and behaves as described above.
+6   The strtok function is not required to avoid data races. The implementation shall
+    behave as if no library function calls the strtok function.
+<b>    Returns</b>
+7   The strtok function returns a pointer to the first character of a token, or a null pointer
+    if there is no token.
+8   EXAMPLE
+           #include <a href="#7.23">&lt;string.h&gt;</a>
+           static char str[] = "?a???b,,,#c";
+           char *t;
+           t   =   strtok(str, "?");      //   t   points to the token "a"
+           t   =   strtok(NULL, ",");     //   t   points to the token "??b"
+           t   =   strtok(NULL, "#,");    //   t   points to the token "c"
+           t   =   strtok(NULL, "?");     //   t   is a null pointer
+
+<a name="7.23.6" href="#7.23.6"><b>    7.23.6 Miscellaneous functions</b></a>
+<a name="7.23.6.1" href="#7.23.6.1"><b>    7.23.6.1 The memset function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.23">&lt;string.h&gt;</a>
+           void *memset(void *s, int c, size_t n);
+<b>    Description</b>
+2   The memset function copies the value of c (converted to an unsigned char) into
+    each of the first n characters of the object pointed to by s.
+<b>    Returns</b>
+3   The memset function returns the value of s.
+
+[<a name="p368" href="#p368">page 368</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.23.6.2" href="#7.23.6.2"><b>    7.23.6.2 The strerror function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            char *strerror(int errnum);
+<b>    Description</b>
+2   The strerror function maps the number in errnum to a message string. Typically,
+    the values for errnum come from errno, but strerror shall map any value of type
+    int to a message.
+3   The strerror function is not required to avoid data races. The implementation shall
+    behave as if no library function calls the strerror function.
+<b>    Returns</b>
+4   The strerror function returns a pointer to the string, the contents of which are locale-
+    specific. The array pointed to shall not be modified by the program, but may be
+    overwritten by a subsequent call to the strerror function.
+<a name="7.23.6.3" href="#7.23.6.3"><b>    7.23.6.3 The strlen function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.23">&lt;string.h&gt;</a>
+            size_t strlen(const char *s);
+<b>    Description</b>
+2   The strlen function computes the length of the string pointed to by s.
+<b>    Returns</b>
+3   The strlen function returns the number of characters that precede the terminating null
+    character.
+
+[<a name="p369" href="#p369">page 369</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.24" href="#7.24"><b>    7.24 Type-generic math &lt;tgmath.h&gt;</b></a>
+1   The header <a href="#7.24">&lt;tgmath.h&gt;</a> includes the headers <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> and
+    defines several type-generic macros.
+2   Of the <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> functions without an f (float) or l (long
+    double) suffix, several have one or more parameters whose corresponding real type is
+    double. For each such function, except modf, there is a corresponding type-generic
+    macro.<sup><a href="#note304"><b>304)</b></a></sup> The parameters whose corresponding real type is double in the function
+    synopsis are generic parameters. Use of the macro invokes a function whose
+    corresponding real type and type domain are determined by the arguments for the generic
+    parameters.<sup><a href="#note305"><b>305)</b></a></sup>
+3   Use of the macro invokes a function whose generic parameters have the corresponding
+    real type determined as follows:
+    -- First, if any argument for generic parameters has type long double, the type
+      determined is long double.
+    -- Otherwise, if any argument for generic parameters has type double or is of integer
+      type, the type determined is double.
+    -- Otherwise, the type determined is float.
+4   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> for which there is a function in
+    <a href="#7.3">&lt;complex.h&gt;</a> with the same name except for a c prefix, the corresponding type-
+    generic macro (for both functions) has the same name as the function in <a href="#7.12">&lt;math.h&gt;</a>. The
+    corresponding type-generic macro for fabs and cabs is fabs.
+
+
+
+
+    <sup><a name="note304" href="#note304"><b>304)</b></a></sup> Like other function-like macros in Standard libraries, each type-generic macro can be suppressed to
+         make available the corresponding ordinary function.
+    <sup><a name="note305" href="#note305"><b>305)</b></a></sup> If the type of the argument is not compatible with the type of the parameter for the selected function,
+         the behavior is undefined.
+
+[<a name="p370" href="#p370">page 370</a>] (<a href="#Contents">Contents</a>)
+
+             <a href="#7.12">&lt;math.h&gt;</a>         <a href="#7.3">&lt;complex.h&gt;</a>              type-generic
+              function           function                 macro
+               acos              cacos                   acos
+               asin              casin                   asin
+               atan              catan                   atan
+               acosh             cacosh                  acosh
+               asinh             casinh                  asinh
+               atanh             catanh                  atanh
+               cos               ccos                    cos
+               sin               csin                    sin
+               tan               ctan                    tan
+               cosh              ccosh                   cosh
+               sinh              csinh                   sinh
+               tanh              ctanh                   tanh
+               exp               cexp                    exp
+               log               clog                    log
+               pow               cpow                    pow
+               sqrt              csqrt                   sqrt
+               fabs              cabs                    fabs
+    If at least one argument for a generic parameter is complex, then use of the macro invokes
+    a complex function; otherwise, use of the macro invokes a real function.
+5   For each unsuffixed function in <a href="#7.12">&lt;math.h&gt;</a> without a c-prefixed counterpart in
+    <a href="#7.3">&lt;complex.h&gt;</a> (except modf), the corresponding type-generic macro has the same
+    name as the function. These type-generic macros are:
+            atan2              fma                  llround              remainder
+            cbrt               fmax                 log10                remquo
+            ceil               fmin                 log1p                rint
+            copysign           fmod                 log2                 round
+            erf                frexp                logb                 scalbn
+            erfc               hypot                lrint                scalbln
+            exp2               ilogb                lround               tgamma
+            expm1              ldexp                nearbyint            trunc
+            fdim               lgamma               nextafter
+            floor              llrint               nexttoward
+    If all arguments for generic parameters are real, then use of the macro invokes a real
+    function; otherwise, use of the macro results in undefined behavior.
+
+[<a name="p371" href="#p371">page 371</a>] (<a href="#Contents">Contents</a>)
+
+6   For each unsuffixed function in <a href="#7.3">&lt;complex.h&gt;</a> that is not a c-prefixed counterpart to a
+    function in <a href="#7.12">&lt;math.h&gt;</a>, the corresponding type-generic macro has the same name as the
+    function. These type-generic macros are:
+           carg                     conj                     creal
+           cimag                    cproj
+    Use of the macro with any real or complex argument invokes a complex function.
+7   EXAMPLE       With the declarations
+            #include <a href="#7.24">&lt;tgmath.h&gt;</a>
+            int n;
+            float f;
+            double d;
+            long double ld;
+            float complex fc;
+            double complex dc;
+            long double complex ldc;
+    functions invoked by use of type-generic macros are shown in the following table:
+                     macro use                                  invokes
+                exp(n)                              exp(n), the function
+                acosh(f)                            acoshf(f)
+                sin(d)                              sin(d), the function
+                atan(ld)                            atanl(ld)
+                log(fc)                             clogf(fc)
+                sqrt(dc)                            csqrt(dc)
+                pow(ldc, f)                         cpowl(ldc, f)
+                remainder(n, n)                     remainder(n, n), the function
+                nextafter(d, f)                     nextafter(d, f), the function
+                nexttoward(f, ld)                   nexttowardf(f, ld)
+                copysign(n, ld)                     copysignl(n, ld)
+                ceil(fc)                            undefined behavior
+                rint(dc)                            undefined behavior
+                fmax(ldc, ld)                       undefined behavior
+                carg(n)                             carg(n), the function
+                cproj(f)                            cprojf(f)
+                creal(d)                            creal(d), the function
+                cimag(ld)                           cimagl(ld)
+                fabs(fc)                            cabsf(fc)
+                carg(dc)                            carg(dc), the function
+                cproj(ldc)                          cprojl(ldc)
+
+[<a name="p372" href="#p372">page 372</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.25" href="#7.25"><b>    7.25 Threads &lt;threads.h&gt;</b></a>
+<a name="7.25.1" href="#7.25.1"><b>    7.25.1 Introduction</b></a>
+1   The header <a href="#7.25">&lt;threads.h&gt;</a> defines macros, and declares types, enumeration constants,
+    and functions that support multiple threads of execution.
+2   Implementations that define the macro __STDC_NO_THREADS__ need not provide
+    this header nor support any of its facilities.
+3   The macros are
+            ONCE_FLAG_INIT
+    which expands to a value that can be used to initialize an object of type once_flag;
+    and
+            TSS_DTOR_ITERATIONS
+    which expands to an integer constant expression representing the maximum number of
+    times that destructors will be called when a thread terminates.
+4   The types are
+            cnd_t
+    which is a complete object type that holds an identifier for a condition variable;
+            thrd_t
+    which is a complete object type that holds an identifier for a thread;
+            tss_t
+    which is a complete object type that holds an identifier for a thread-specific storage
+    pointer;
+            mtx_t
+    which is a complete object type that holds an identifier for a mutex;
+            tss_dtor_t
+    which is the function pointer type void (*)(void*), used for a destructor for a
+    thread-specific storage pointer;
+            thrd_start_t
+    which is the function pointer type int (*)(void*) that is passed to thrd_create
+    to create a new thread;
+            once_flag
+    which is a complete object type that holds a flag for use by call_once; and
+
+[<a name="p373" href="#p373">page 373</a>] (<a href="#Contents">Contents</a>)
+
+           xtime
+    which is a structure type that holds a time specified in seconds and nanoseconds. The
+    structure shall contain at least the following members, in any order.
+           time_t sec;
+           long nsec;
+5   The enumeration constants are
+           mtx_plain
+    which is passed to mtx_init to create a mutex object that supports neither timeout nor
+    test and return;
+           mtx_recursive
+    which is passed to mtx_init to create a mutex object that supports recursive locking;
+           mtx_timed
+    which is passed to mtx_init to create a mutex object that supports timeout;
+           mtx_try
+    which is passed to mtx_init to create a mutex object that supports test and return;
+           thrd_timeout
+    which is returned by a timed wait function to indicate that the time specified in the call
+    was reached without acquiring the requested resource;
+           thrd_success
+    which is returned by a function to indicate that the requested operation succeeded;
+           thrd_busy
+    which is returned by a function to indicate that the requested operation failed because a
+    resource requested by a test and return function is already in use;
+           thrd_error
+    which is returned by a function to indicate that the requested operation failed; and
+           thrd_nomem
+    which is returned by a function to indicate that the requested operation failed because it
+    was unable to allocate memory.
+
+[<a name="p374" href="#p374">page 374</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.25.2" href="#7.25.2"><b>    7.25.2 Initialization functions</b></a>
+<a name="7.25.2.1" href="#7.25.2.1"><b>    7.25.2.1 The call_once function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            void call_once(once_flag *flag, void (*func)(void));
+<b>    Description</b>
+2   The call_once function uses the once_flag pointed to by flag to ensure that
+    func is called exactly once, the first time the call_once function is called with that
+    value of flag. Completion of an effective call to the call_once function synchronizes
+    with all subsequent calls to the call_once function with the same value of flag.
+<b>    Returns</b>
+3   The call_once function returns no value.
+<a name="7.25.3" href="#7.25.3"><b>    7.25.3 Condition variable functions</b></a>
+<a name="7.25.3.1" href="#7.25.3.1"><b>    7.25.3.1 The cnd_broadcast function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int cnd_broadcast(cnd_t *cond);
+<b>    Description</b>
+2   The cnd_broadcast function unblocks all of the threads that are blocked on the
+    condition variable pointed to by cond at the time of the call. If no threads are blocked
+    on the condition variable pointed to by cond at the time of the call, the function does
+    nothing.
+<b>    Returns</b>
+3   The cnd_broadcast function returns thrd_success on success, or thrd_error
+    if the request could not be honored.
+<a name="7.25.3.2" href="#7.25.3.2"><b>    7.25.3.2 The cnd_destroy function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            void cnd_destroy(cnd_t *cond);
+<b>    Description</b>
+2   The cnd_destroy function releases all resources used by the condition variable
+    pointed to by cond. The cnd_destroy function requires that no threads be blocked
+    waiting for the condition variable pointed to by cond.
+
+[<a name="p375" href="#p375">page 375</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The cnd_destroy function returns no value.
+<a name="7.25.3.3" href="#7.25.3.3"><b>    7.25.3.3 The cnd_init function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int cnd_init(cnd_t *cond);
+<b>    Description</b>
+2   The cnd_init function creates a condition variable. If it succeeds it sets the variable
+    pointed to by cond to a value that uniquely identifies the newly created condition
+    variable. A thread that calls cnd_wait on a newly created condition variable will
+    block.
+<b>    Returns</b>
+3   The cnd_init function returns thrd_success on success, or thrd_nomem if no
+    memory could be allocated for the newly created condition, or thrd_error if the
+    request could not be honored.
+<a name="7.25.3.4" href="#7.25.3.4"><b>    7.25.3.4 The cnd_signal function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int cnd_signal(cnd_t *cond);
+<b>    Description</b>
+2   The cnd_signal function unblocks one of the threads that are blocked on the
+    condition variable pointed to by cond at the time of the call. If no threads are blocked
+    on the condition variable at the time of the call, the function does nothing and return
+    success.
+<b>    Returns</b>
+3   The cnd_signal function returns thrd_success on success or thrd_error if
+    the request could not be honored.
+<a name="7.25.3.5" href="#7.25.3.5"><b>    7.25.3.5 The cnd_timedwait function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int cnd_timedwait(cnd_t *cond, mtx_t *mtx,
+                const xtime *xt);
+
+[<a name="p376" href="#p376">page 376</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The cnd_timedwait function atomically unlocks the mutex pointed to by mtx and
+    endeavors to block until the condition variable pointed to by cond is signaled by a call to
+    cnd_signal or to cnd_broadcast, or until after the time specified by the xtime
+    object pointed to by xt. When the calling thread becomes unblocked it locks the variable
+    pointed to by mtx before it returns. The cnd_timedwait function requires that the
+    mutex pointed to by mtx be locked by the calling thread.
+<b>    Returns</b>
+3   The cnd_timedwait function returns thrd_success upon success, or
+    thrd_timeout if the time specified in the call was reached without acquiring the
+    requested resource, or thrd_error if the request could not be honored.
+<a name="7.25.3.6" href="#7.25.3.6"><b>    7.25.3.6 The cnd_wait function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int cnd_wait(cnd_t *cond, mtx_t *mtx);
+<b>    Description</b>
+2   The cnd_wait function atomically unlocks the mutex pointed to by mtx and endeavors
+    to block until the condition variable pointed to by cond is signaled by a call to
+    cnd_signal or to cnd_broadcast. When the calling thread becomes unblocked it
+    locks the mutex pointed to by mtx before it returns. If the mutex pointed to by mtx is
+    not locked by the calling thread, the cnd_wait function will act as if the abort
+    function is called.
+<b>    Returns</b>
+3   The cnd_wait function returns thrd_success on success or thrd_error if the
+    request could not be honored.
+<a name="7.25.4" href="#7.25.4"><b>    7.25.4 Mutex functions</b></a>
+<a name="7.25.4.1" href="#7.25.4.1"><b>    7.25.4.1 The mtx_destroy function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            void mtx_destroy(mtx_t *mtx);
+<b>    Description</b>
+2   The mtx_destroy function releases any resources used by the mutex pointed to by
+    mtx. No threads can be blocked waiting for the mutex pointed to by mtx.
+
+[<a name="p377" href="#p377">page 377</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The mtx_destroy function returns no value.
+<a name="7.25.4.2" href="#7.25.4.2"><b>    7.25.4.2 The mtx_init function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int mtx_init(mtx_t *mtx, int type);
+<b>    Description</b>
+2   The mtx_init function creates a mutex object with properties indicated by type,
+    which must have one of the six values:
+    mtx_plain for a simple non-recursive mutex,
+    mtx_timed for a non-recursive mutex that supports timeout,
+    mtx_try      for a non-recursive mutex that supports test and return,
+    mtx_plain | mtx_recursive for a simple recursive mutex,
+    mtx_timed | mtx_recursive for a recursive mutex that supports timeout, or
+    mtx_try | mtx_recursive for a recursive mutex that supports test and return.
+3   If the mtx_init function succeeds, it sets the mutex pointed to by mtx to a value that
+    uniquely identifies the newly created mutex.
+<b>    Returns</b>
+4   The mtx_init function returns thrd_success on success, or thrd_error if the
+    request could not be honored.
+<a name="7.25.4.3" href="#7.25.4.3"><b>    7.25.4.3 The mtx_lock function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int mtx_lock(mtx_t *mtx);
+<b>    Description</b>
+2   The mtx_lock function blocks until it locks the mutex pointed to by mtx. If the mutex
+    is non-recursive, it shall not be locked by the calling thread. Prior calls to mtx_unlock
+    on the same mutex shall synchronize with this operation.
+<b>    Returns</b>
+3   The mtx_lock function returns thrd_success on success, or thrd_busy if the
+    resource requested is already in use, or thrd_error if the request could not be
+    honored.
+
+[<a name="p378" href="#p378">page 378</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.25.4.4" href="#7.25.4.4"><b>    7.25.4.4 The mtx_timedlock function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int mtx_timedlock(mtx_t *mtx, const xtime *xt);
+<b>    Description</b>
+2   The mtx_timedlock function endeavors to block until it locks the mutex pointed to by
+    mtx or until the time specified by the xtime object xt has passed. The specified mutex
+    shall support timeout. If the operation succeeds, prior calls to mtx_unlock on the same
+    mutex shall synchronize with this operation.
+<b>    Returns</b>
+3   The mtx_timedlock function returns thrd_success on success, or thrd_busy
+    if the resource requested is already in use, or thrd_timeout if the time specified was
+    reached without acquiring the requested resource, or thrd_error if the request could
+    not be honored.
+<a name="7.25.4.5" href="#7.25.4.5"><b>    7.25.4.5 The mtx_trylock function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int mtx_trylock(mtx_t *mtx);
+<b>    Description</b>
+2   The mtx_trylock function endeavors to lock the mutex pointed to by mtx. The
+    specified mutex shall support either test and return or timeout. If the mutex is already
+    locked, the function returns without blocking. If the operation succeeds, prior calls to
+    mtx_unlock on the same mutex shall synchronize with this operation.
+<b>    Returns</b>
+3   The mtx_trylock function returns thrd_success on success, or thrd_busy if
+    the resource requested is already in use, or thrd_error if the request could not be
+    honored.
+<a name="7.25.4.6" href="#7.25.4.6"><b>    7.25.4.6 The mtx_unlock function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int mtx_unlock(mtx_t *mtx);
+<b>    Description</b>
+2   The mtx_unlock function unlocks the mutex pointed to by mtx. The mutex pointed to
+    by mtx shall be locked by the calling thread.
+
+[<a name="p379" href="#p379">page 379</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The mtx_unlock function returns thrd_success on success or thrd_error if
+    the request could not be honored.
+<a name="7.25.5" href="#7.25.5"><b>    7.25.5 Thread functions</b></a>
+<a name="7.25.5.1" href="#7.25.5.1"><b>    7.25.5.1 The thrd_create function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int thrd_create(thrd_t *thr, thrd_start_t func,
+                void *arg);
+<b>    Description</b>
+2   The thrd_create function creates a new thread executing func(arg). If the
+    thrd_create function succeeds, it sets the object pointed to by thr to the identifier of
+    the newly created thread. (A thread's identifier may be reused for a different thread once
+    the original thread has exited and either been detached or joined to another thread.) The
+    completion of the thrd_create function synchronizes with the beginning of the
+    execution of the new thread.
+<b>    Returns</b>
+3   The thrd_create function returns thrd_success on success, or thrd_nomem if
+    no memory could be allocated for the thread requested, or thrd_error if the request
+    could not be honored.
+<a name="7.25.5.2" href="#7.25.5.2"><b>    7.25.5.2 The thrd_current function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           thrd_t thrd_current(void);
+<b>    Description</b>
+2   The thrd_current function identifies the thread that called it.
+<b>    Returns</b>
+3   The thrd_current function returns the identifier of the thread that called it.
+<a name="7.25.5.3" href="#7.25.5.3"><b>    7.25.5.3 The thrd_detach function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int thrd_detach(thrd_t thr);
+
+[<a name="p380" href="#p380">page 380</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The thrd_detach function tells the operating system to dispose of any resources
+    allocated to the thread identified by thr when that thread terminates. The thread
+    identified by thr shall not have been previously detached or joined with another thread.
+<b>    Returns</b>
+3   The thrd_detach function returns thrd_success on success or thrd_error if
+    the request could not be honored.
+<a name="7.25.5.4" href="#7.25.5.4"><b>    7.25.5.4 The thrd_equal function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int thrd_equal(thrd_t thr0, thrd_t thr1);
+<b>    Description</b>
+2   The thrd_equal function will determine whether the thread identified by thr0 refers
+    to the thread identified by thr1.
+<b>    Returns</b>
+3   The thrd_equal function returns zero if the thread thr0 and the thread thr1 refer to
+    different threads. Otherwise the thrd_equal function returns a nonzero value.
+<a name="7.25.5.5" href="#7.25.5.5"><b>    7.25.5.5 The thrd_exit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            void thrd_exit(int res);
+<b>    Description</b>
+2   The thrd_exit function terminates execution of the calling thread and sets its result
+    code to res.
+<b>    Returns</b>
+3   The thrd_exit function returns no value.
+<a name="7.25.5.6" href="#7.25.5.6"><b>    7.25.5.6 The thrd_join function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int thrd_join(thrd_t thr, int *res);
+<b>    Description</b>
+2   The thrd_join function joins the thread identified by thr with the current thread by
+    blocking until the other thread has terminated. If the parameter res is not a null pointer,
+
+[<a name="p381" href="#p381">page 381</a>] (<a href="#Contents">Contents</a>)
+
+    it stores the thread's result code in the integer pointed to by res. The termination of the
+    other thread synchronizes with the completion of the thrd_join function. The thread
+    identified by thr shall not have been previously detached or joined with another thread.
+<b>    Returns</b>
+3   The thrd_join function returns thrd_success on success or thrd_error if the
+    request could not be honored.
+<a name="7.25.5.7" href="#7.25.5.7"><b>    7.25.5.7 The thrd_sleep function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           void thrd_sleep(const xtime *xt);
+<b>    Description</b>
+2   The thrd_sleep function suspends execution of the calling thread until after the time
+    specified by the xtime object pointed to by xt.
+<b>    Returns</b>
+3   The thrd_sleep function returns no value.
+<a name="7.25.5.8" href="#7.25.5.8"><b>    7.25.5.8 The thrd_yield function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           void thrd_yield(void);
+<b>    Description</b>
+2   The thrd_yield function endeavors to permit other threads to run, even if the current
+    thread would ordinarily continue to run.
+<b>    Returns</b>
+3   The thrd_yield function returns no value.
+<a name="7.25.6" href="#7.25.6"><b>    7.25.6 Thread-specific storage functions</b></a>
+<a name="7.25.6.1" href="#7.25.6.1"><b>    7.25.6.1 The tss_create function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.25">&lt;threads.h&gt;</a>
+           int tss_create(tss_t *key, tss_dtor_t dtor);
+<b>    Description</b>
+2   The tss_create function creates a thread-specific storage pointer with destructor
+    dtor, which may be null.
+
+[<a name="p382" href="#p382">page 382</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   If the tss_create function is successful, it sets the thread-specific storage pointed to
+    by key to a value that uniquely identifies the newly created pointer and returns
+    thrd_success; otherwise, thrd_error is returned and the thread-specific storage
+    pointed to by key is set to an undefined value.
+<a name="7.25.6.2" href="#7.25.6.2"><b>    7.25.6.2 The tss_delete function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            void tss_delete(tss_t key);
+<b>    Description</b>
+2   The tss_delete function releases any resources used by the thread-specific storage
+    identified by key.
+<b>    Returns</b>
+3   The tss_delete function returns no value.
+<a name="7.25.6.3" href="#7.25.6.3"><b>    7.25.6.3 The tss_get function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            void *tss_get(tss_t key);
+<b>    Description</b>
+2   The tss_get function returns the value for the current thread held in the thread-specific
+    storage identified by key.
+<b>    Returns</b>
+3   The tss_get function returns the value for the current thread if successful, or zero if
+    unsuccessful.
+<a name="7.25.6.4" href="#7.25.6.4"><b>    7.25.6.4 The tss_set function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int tss_set(tss_t key, void *val);
+<b>    Description</b>
+2   The tss_set function sets the value for the current thread held in the thread-specific
+    storage identified by key to val.
+
+[<a name="p383" href="#p383">page 383</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The tss_set function returns thrd_success on success or thrd_error if the
+    request could not be honored.
+<a name="7.25.7" href="#7.25.7"><b>    7.25.7 Time functions</b></a>
+<a name="7.25.7.1" href="#7.25.7.1"><b>    7.25.7.1 The xtime_get function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.25">&lt;threads.h&gt;</a>
+            int xtime_get(xtime *xt, int base);
+<b>    Description</b>
+2   The xtime_get function sets the xtime object pointed to by xt to hold the current
+    time based on the time base base.
+<b>    Returns</b>
+3   If the xtime_get function is successful it returns the nonzero value base, which must
+    be TIME_UTC; otherwise, it returns zero.<sup><a href="#note306"><b>306)</b></a></sup>
+
+
+
+
+    <sup><a name="note306" href="#note306"><b>306)</b></a></sup> Although an xtime object describes times with nanosecond resolution, the actual resolution in an
+         xtime object is system dependent.
+
+[<a name="p384" href="#p384">page 384</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.26" href="#7.26"><b>    7.26 Date and time &lt;time.h&gt;</b></a>
+<a name="7.26.1" href="#7.26.1"><b>    7.26.1 Components of time</b></a>
+1   The header <a href="#7.26">&lt;time.h&gt;</a> defines two macros, and declares several types and functions for
+    manipulating time. Many functions deal with a calendar time that represents the current
+    date (according to the Gregorian calendar) and time. Some functions deal with local
+    time, which is the calendar time expressed for some specific time zone, and with Daylight
+    Saving Time, which is a temporary change in the algorithm for determining local time.
+    The local time zone and Daylight Saving Time are implementation-defined.
+2   The macros defined are NULL (described in <a href="#7.19">7.19</a>); and
+            CLOCKS_PER_SEC
+    which expands to an expression with type clock_t (described below) that is the
+    number per second of the value returned by the clock function.
+3   The types declared are size_t (described in <a href="#7.19">7.19</a>);
+            clock_t
+    and
+            time_t
+    which are arithmetic types capable of representing times; and
+            struct tm
+    which holds the components of a calendar time, called the broken-down time.
+4   The range and precision of times representable in clock_t and time_t are
+    implementation-defined. The tm structure shall contain at least the following members,
+    in any order. The semantics of the members and their normal ranges are expressed in the
+    comments.<sup><a href="#note307"><b>307)</b></a></sup>
+            int    tm_sec;           //   seconds after the minute -- [0, 60]
+            int    tm_min;           //   minutes after the hour -- [0, 59]
+            int    tm_hour;          //   hours since midnight -- [0, 23]
+            int    tm_mday;          //   day of the month -- [1, 31]
+            int    tm_mon;           //   months since January -- [0, 11]
+            int    tm_year;          //   years since 1900
+            int    tm_wday;          //   days since Sunday -- [0, 6]
+            int    tm_yday;          //   days since January 1 -- [0, 365]
+            int    tm_isdst;         //   Daylight Saving Time flag
+
+
+
+    <sup><a name="note307" href="#note307"><b>307)</b></a></sup> The range [0, 60] for tm_sec allows for a positive leap second.
+
+[<a name="p385" href="#p385">page 385</a>] (<a href="#Contents">Contents</a>)
+
+    The value of tm_isdst is positive if Daylight Saving Time is in effect, zero if Daylight
+    Saving Time is not in effect, and negative if the information is not available.
+<a name="7.26.2" href="#7.26.2"><b>    7.26.2 Time manipulation functions</b></a>
+<a name="7.26.2.1" href="#7.26.2.1"><b>    7.26.2.1 The clock function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.26">&lt;time.h&gt;</a>
+            clock_t clock(void);
+<b>    Description</b>
+2   The clock function determines the processor time used.
+<b>    Returns</b>
+3   The clock function returns the implementation's best approximation to the processor
+    time used by the program since the beginning of an implementation-defined era related
+    only to the program invocation. To determine the time in seconds, the value returned by
+    the clock function should be divided by the value of the macro CLOCKS_PER_SEC. If
+    the processor time used is not available or its value cannot be represented, the function
+    returns the value (clock_t)(-1).<sup><a href="#note308"><b>308)</b></a></sup>
+<a name="7.26.2.2" href="#7.26.2.2"><b>    7.26.2.2 The difftime function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.26">&lt;time.h&gt;</a>
+            double difftime(time_t time1, time_t time0);
+<b>    Description</b>
+2   The difftime function computes the difference between two calendar times: time1 -
+    time0.
+<b>    Returns</b>
+3   The difftime function returns the difference expressed in seconds as a double.
+
+
+
+
+    <sup><a name="note308" href="#note308"><b>308)</b></a></sup> In order to measure the time spent in a program, the clock function should be called at the start of
+         the program and its return value subtracted from the value returned by subsequent calls.
+
+[<a name="p386" href="#p386">page 386</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.26.2.3" href="#7.26.2.3"><b>    7.26.2.3 The mktime function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.26">&lt;time.h&gt;</a>
+            time_t mktime(struct tm *timeptr);
+<b>    Description</b>
+2   The mktime function converts the broken-down time, expressed as local time, in the
+    structure pointed to by timeptr into a calendar time value with the same encoding as
+    that of the values returned by the time function. The original values of the tm_wday
+    and tm_yday components of the structure are ignored, and the original values of the
+    other components are not restricted to the ranges indicated above.<sup><a href="#note309"><b>309)</b></a></sup> On successful
+    completion, the values of the tm_wday and tm_yday components of the structure are
+    set appropriately, and the other components are set to represent the specified calendar
+    time, but with their values forced to the ranges indicated above; the final value of
+    tm_mday is not set until tm_mon and tm_year are determined.
+<b>    Returns</b>
+3   The mktime function returns the specified calendar time encoded as a value of type
+    time_t. If the calendar time cannot be represented, the function returns the value
+    (time_t)(-1).
+4   EXAMPLE       What day of the week is July 4, 2001?
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.26">&lt;time.h&gt;</a>
+            static const char *const wday[] = {
+                    "Sunday", "Monday", "Tuesday", "Wednesday",
+                    "Thursday", "Friday", "Saturday", "-unknown-"
+            };
+            struct tm time_str;
+            /* ... */
+
+
+
+
+    <sup><a name="note309" href="#note309"><b>309)</b></a></sup> Thus, a positive or zero value for tm_isdst causes the mktime function to presume initially that
+         Daylight Saving Time, respectively, is or is not in effect for the specified time. A negative value
+         causes it to attempt to determine whether Daylight Saving Time is in effect for the specified time.
+
+[<a name="p387" href="#p387">page 387</a>] (<a href="#Contents">Contents</a>)
+
+           time_str.tm_year   = 2001 - 1900;
+           time_str.tm_mon    = 7 - 1;
+           time_str.tm_mday   = 4;
+           time_str.tm_hour   = 0;
+           time_str.tm_min    = 0;
+           time_str.tm_sec    = 1;
+           time_str.tm_isdst = -1;
+           if (mktime(&amp;time_str) == (time_t)(-1))
+                 time_str.tm_wday = 7;
+           printf("%s\n", wday[time_str.tm_wday]);
+
+<a name="7.26.2.4" href="#7.26.2.4"><b>    7.26.2.4 The time function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.26">&lt;time.h&gt;</a>
+           time_t time(time_t *timer);
+<b>    Description</b>
+2   The time function determines the current calendar time. The encoding of the value is
+    unspecified.
+<b>    Returns</b>
+3   The time function returns the implementation's best approximation to the current
+    calendar time. The value (time_t)(-1) is returned if the calendar time is not
+    available. If timer is not a null pointer, the return value is also assigned to the object it
+    points to.
+<a name="7.26.3" href="#7.26.3"><b>    7.26.3 Time conversion functions</b></a>
+1   Except for the strftime function, these functions each return a pointer to one of two
+    types of static objects: a broken-down time structure or an array of char. Execution of
+    any of the functions that return a pointer to one of these object types may overwrite the
+    information in any object of the same type pointed to by the value returned from any
+    previous call to any of them and the functions are not required to avoid data races. The
+    implementation shall behave as if no other library functions call these functions.
+<a name="7.26.3.1" href="#7.26.3.1"><b>    7.26.3.1 The asctime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.26">&lt;time.h&gt;</a>
+           char *asctime(const struct tm *timeptr);
+<b>    Description</b>
+2   The asctime function converts the broken-down time in the structure pointed to by
+    timeptr into a string in the form
+           Sun Sep 16 01:03:52 1973\n\0
+
+[<a name="p388" href="#p388">page 388</a>] (<a href="#Contents">Contents</a>)
+
+    using the equivalent of the following algorithm.
+    char *asctime(const struct tm *timeptr)
+    {
+         static const char wday_name[7][3] = {
+              "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+         };
+         static const char mon_name[12][3] = {
+              "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+         };
+         static char result[26];
+            sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
+                 wday_name[timeptr-&gt;tm_wday],
+                 mon_name[timeptr-&gt;tm_mon],
+                 timeptr-&gt;tm_mday, timeptr-&gt;tm_hour,
+                 timeptr-&gt;tm_min, timeptr-&gt;tm_sec,
+                 1900 + timeptr-&gt;tm_year);
+            return result;
+    }
+3   If any of the fields of the broken-down time contain values that are outside their normal
+    ranges,<sup><a href="#note310"><b>310)</b></a></sup> the behavior of the asctime function is undefined. Likewise, if the
+    calculated year exceeds four digits or is less than the year 1000, the behavior is
+    undefined.
+<b>    Returns</b>
+4   The asctime function returns a pointer to the string.
+<a name="7.26.3.2" href="#7.26.3.2"><b>    7.26.3.2 The ctime function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.26">&lt;time.h&gt;</a>
+            char *ctime(const time_t *timer);
+<b>    Description</b>
+2   The ctime function converts the calendar time pointed to by timer to local time in the
+    form of a string. It is equivalent to
+            asctime(localtime(timer))
+
+
+
+    <sup><a name="note310" href="#note310"><b>310)</b></a></sup> See <a href="#7.26.1">7.26.1</a>.
+
+[<a name="p389" href="#p389">page 389</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The ctime function returns the pointer returned by the asctime function with that
+    broken-down time as argument.
+    Forward references: the localtime function (<a href="#7.26.3.4">7.26.3.4</a>).
+<a name="7.26.3.3" href="#7.26.3.3"><b>    7.26.3.3 The gmtime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.26">&lt;time.h&gt;</a>
+           struct tm *gmtime(const time_t *timer);
+<b>    Description</b>
+2   The gmtime function converts the calendar time pointed to by timer into a broken-
+    down time, expressed as UTC.
+<b>    Returns</b>
+3   The gmtime function returns a pointer to the broken-down time, or a null pointer if the
+    specified time cannot be converted to UTC.
+<a name="7.26.3.4" href="#7.26.3.4"><b>    7.26.3.4 The localtime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.26">&lt;time.h&gt;</a>
+           struct tm *localtime(const time_t *timer);
+<b>    Description</b>
+2   The localtime function converts the calendar time pointed to by timer into a
+    broken-down time, expressed as local time.
+<b>    Returns</b>
+3   The localtime function returns a pointer to the broken-down time, or a null pointer if
+    the specified time cannot be converted to local time.
+<a name="7.26.3.5" href="#7.26.3.5"><b>    7.26.3.5 The strftime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.26">&lt;time.h&gt;</a>
+           size_t strftime(char * restrict s,
+                size_t maxsize,
+                const char * restrict format,
+                const struct tm * restrict timeptr);
+
+[<a name="p390" href="#p390">page 390</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The strftime function places characters into the array pointed to by s as controlled by
+    the string pointed to by format. The format shall be a multibyte character sequence,
+    beginning and ending in its initial shift state. The format string consists of zero or
+    more conversion specifiers and ordinary multibyte characters. A conversion specifier
+    consists of a % character, possibly followed by an E or O modifier character (described
+    below), followed by a character that determines the behavior of the conversion specifier.
+    All ordinary multibyte characters (including the terminating null character) are copied
+    unchanged into the array. If copying takes place between objects that overlap, the
+    behavior is undefined. No more than maxsize characters are placed into the array.
+3   Each conversion specifier is replaced by appropriate characters as described in the
+    following list. The appropriate characters are determined using the LC_TIME category
+    of the current locale and by the values of zero or more members of the broken-down time
+    structure pointed to by timeptr, as specified in brackets in the description. If any of
+    the specified values is outside the normal range, the characters stored are unspecified.
+    %a   is replaced by the locale's abbreviated weekday name. [tm_wday]
+    %A   is replaced by the locale's full weekday name. [tm_wday]
+    %b   is replaced by the locale's abbreviated month name. [tm_mon]
+    %B   is replaced by the locale's full month name. [tm_mon]
+    %c   is replaced by the locale's appropriate date and time representation. [all specified
+         in <a href="#7.26.1">7.26.1</a>]
+    %C   is replaced by the year divided by 100 and truncated to an integer, as a decimal
+         number (00-99). [tm_year]
+    %d   is replaced by the day of the month as a decimal number (01-31). [tm_mday]
+    %D   is equivalent to ''%m/%d/%y''. [tm_mon, tm_mday, tm_year]
+    %e   is replaced by the day of the month as a decimal number (1-31); a single digit is
+         preceded by a space. [tm_mday]
+    %F   is equivalent to ''%Y-%m-%d'' (the ISO 8601 date format). [tm_year, tm_mon,
+         tm_mday]
+    %g   is replaced by the last 2 digits of the week-based year (see below) as a decimal
+         number (00-99). [tm_year, tm_wday, tm_yday]
+    %G   is replaced by the week-based year (see below) as a decimal number (e.g., 1997).
+         [tm_year, tm_wday, tm_yday]
+    %h   is equivalent to ''%b''. [tm_mon]
+    %H   is replaced by the hour (24-hour clock) as a decimal number (00-23). [tm_hour]
+    %I   is replaced by the hour (12-hour clock) as a decimal number (01-12). [tm_hour]
+    %j   is replaced by the day of the year as a decimal number (001-366). [tm_yday]
+    %m   is replaced by the month as a decimal number (01-12). [tm_mon]
+    %M   is replaced by the minute as a decimal number (00-59). [tm_min]
+    %n   is replaced by a new-line character.
+
+[<a name="p391" href="#p391">page 391</a>] (<a href="#Contents">Contents</a>)
+
+    %p    is replaced by the locale's equivalent of the AM/PM designations associated with a
+          12-hour clock. [tm_hour]
+    %r    is replaced by the locale's 12-hour clock time. [tm_hour, tm_min, tm_sec]
+    %R    is equivalent to ''%H:%M''. [tm_hour, tm_min]
+    %S    is replaced by the second as a decimal number (00-60). [tm_sec]
+    %t    is replaced by a horizontal-tab character.
+    %T    is equivalent to ''%H:%M:%S'' (the ISO 8601 time format). [tm_hour, tm_min,
+          tm_sec]
+    %u    is replaced by the ISO 8601 weekday as a decimal number (1-7), where Monday
+          is 1. [tm_wday]
+    %U    is replaced by the week number of the year (the first Sunday as the first day of week
+          <sup><a name="note1" href="#note1"><b>1)</b></a></sup> as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
+    %V    is replaced by the ISO 8601 week number (see below) as a decimal number
+          (01-53). [tm_year, tm_wday, tm_yday]
+    %w    is replaced by the weekday as a decimal number (0-6), where Sunday is 0.
+          [tm_wday]
+    %W    is replaced by the week number of the year (the first Monday as the first day of
+          week 1) as a decimal number (00-53). [tm_year, tm_wday, tm_yday]
+    %x    is replaced by the locale's appropriate date representation. [all specified in <a href="#7.26.1">7.26.1</a>]
+    %X    is replaced by the locale's appropriate time representation. [all specified in <a href="#7.26.1">7.26.1</a>]
+    %y    is replaced by the last 2 digits of the year as a decimal number (00-99).
+          [tm_year]
+    %Y    is replaced by the year as a decimal number (e.g., 1997). [tm_year]
+    %z    is replaced by the offset from UTC in the ISO 8601 format ''-0430'' (meaning 4
+          hours 30 minutes behind UTC, west of Greenwich), or by no characters if no time
+          zone is determinable. [tm_isdst]
+    %Z    is replaced by the locale's time zone name or abbreviation, or by no characters if no
+          time zone is determinable. [tm_isdst]
+    %%    is replaced by %.
+4   Some conversion specifiers can be modified by the inclusion of an E or O modifier
+    character to indicate an alternative format or specification. If the alternative format or
+    specification does not exist for the current locale, the modifier is ignored.
+    %Ec is replaced by the locale's alternative date and time representation.
+    %EC is replaced by the name of the base year (period) in the locale's alternative
+        representation.
+    %Ex is replaced by the locale's alternative date representation.
+    %EX is replaced by the locale's alternative time representation.
+    %Ey is replaced by the offset from %EC (year only) in the locale's alternative
+        representation.
+    %EY is replaced by the locale's full alternative year representation.
+
+[<a name="p392" href="#p392">page 392</a>] (<a href="#Contents">Contents</a>)
+
+    %Od is replaced by the day of the month, using the locale's alternative numeric symbols
+        (filled as needed with leading zeros, or with leading spaces if there is no alternative
+        symbol for zero).
+    %Oe is replaced by the day of the month, using the locale's alternative numeric symbols
+        (filled as needed with leading spaces).
+    %OH is replaced by the hour (24-hour clock), using the locale's alternative numeric
+        symbols.
+    %OI is replaced by the hour (12-hour clock), using the locale's alternative numeric
+        symbols.
+    %Om is replaced by the month, using the locale's alternative numeric symbols.
+    %OM is replaced by the minutes, using the locale's alternative numeric symbols.
+    %OS is replaced by the seconds, using the locale's alternative numeric symbols.
+    %Ou is replaced by the ISO 8601 weekday as a number in the locale's alternative
+        representation, where Monday is 1.
+    %OU is replaced by the week number, using the locale's alternative numeric symbols.
+    %OV is replaced by the ISO 8601 week number, using the locale's alternative numeric
+        symbols.
+    %Ow is replaced by the weekday as a number, using the locale's alternative numeric
+        symbols.
+    %OW is replaced by the week number of the year, using the locale's alternative numeric
+        symbols.
+    %Oy is replaced by the last 2 digits of the year, using the locale's alternative numeric
+        symbols.
+5   %g, %G, and %V give values according to the ISO 8601 week-based year. In this system,
+    weeks begin on a Monday and week 1 of the year is the week that includes January 4th,
+    which is also the week that includes the first Thursday of the year, and is also the first
+    week that contains at least four days in the year. If the first Monday of January is the
+    2nd, 3rd, or 4th, the preceding days are part of the last week of the preceding year; thus,
+    for Saturday 2nd January 1999, %G is replaced by 1998 and %V is replaced by 53. If
+    December 29th, 30th, or 31st is a Monday, it and any following days are part of week 1 of
+    the following year. Thus, for Tuesday 30th December 1997, %G is replaced by 1998 and
+    %V is replaced by 01.
+6   If a conversion specifier is not one of the above, the behavior is undefined.
+7   In the "C" locale, the E and O modifiers are ignored and the replacement strings for the
+    following specifiers are:
+    %a the first three characters of %A.
+    %A one of ''Sunday'', ''Monday'', ... , ''Saturday''.
+    %b the first three characters of %B.
+    %B one of ''January'', ''February'', ... , ''December''.
+    %c equivalent to ''%a %b %e %T %Y''.
+
+[<a name="p393" href="#p393">page 393</a>] (<a href="#Contents">Contents</a>)
+
+    %p    one of ''AM'' or ''PM''.
+    %r    equivalent to ''%I:%M:%S %p''.
+    %x    equivalent to ''%m/%d/%y''.
+    %X    equivalent to %T.
+    %Z    implementation-defined.
+<b>    Returns</b>
+8   If the total number of resulting characters including the terminating null character is not
+    more than maxsize, the strftime function returns the number of characters placed
+    into the array pointed to by s not including the terminating null character. Otherwise,
+    zero is returned and the contents of the array are indeterminate.
+
+[<a name="p394" href="#p394">page 394</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.27" href="#7.27"><b>    7.27 Unicode utilities &lt;uchar.h&gt;</b></a>
+1   The header <a href="#7.27">&lt;uchar.h&gt;</a> declares types and functions for manipulating Unicode
+    characters.
+2   The types declared are mbstate_t (described in <a href="#7.29.1">7.29.1</a>) and size_t (described in
+<a name="7.19);" href="#7.19);"><b>    7.19);</b></a>
+            char16_t
+    which is an unsigned integer type used for 16-bit characters and is the same type as
+    uint_least16_t (described in <a href="#7.20.1.2">7.20.1.2</a>); and
+            char32_t
+    which is an unsigned integer type used for 32-bit characters and is the same type as
+    uint_least32_t (also described in <a href="#7.20.1.2">7.20.1.2</a>).
+<a name="7.27.1" href="#7.27.1"><b>    7.27.1 Restartable multibyte/wide character conversion functions</b></a>
+1   These functions have a parameter, ps, of type pointer to mbstate_t that points to an
+    object that can completely describe the current conversion state of the associated
+    multibyte character sequence, which the functions alter as necessary. If ps is a null
+    pointer, each function uses its own internal mbstate_t object instead, which is
+    initialized at program startup to the initial conversion state; the functions are not required
+    to avoid data races in this case. The implementation behaves as if no library function
+    calls these functions with a null pointer for ps.
+<a name="7.27.1.1" href="#7.27.1.1"><b>    7.27.1.1 The mbrtoc16 function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
+            size_t mbrtoc16(char16_t * restrict pc16,
+                 const char * restrict s, size_t n,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the mbrtoc16 function is equivalent to the call:
+                   mbrtoc16(NULL, "", 1, ps)
+    In this case, the values of the parameters pc16 and n are ignored.
+3   If s is not a null pointer, the mbrtoc16 function inspects at most n bytes beginning with
+    the byte pointed to by s to determine the number of bytes needed to complete the next
+    multibyte character (including any shift sequences). If the function determines that the
+    next multibyte character is complete and valid, it determines the values of the
+    corresponding wide characters and then, if pc16 is not a null pointer, stores the value of
+    the first (or only) such character in the object pointed to by pc16. Subsequent calls will
+
+[<a name="p395" href="#p395">page 395</a>] (<a href="#Contents">Contents</a>)
+
+    store successive wide characters without consuming any additional input until all the
+    characters have been stored. If the corresponding wide character is the null wide
+    character, the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The mbrtoc16 function returns the first of the following that applies (given the current
+    conversion state):
+    0                     if the next n or fewer bytes complete the multibyte character that
+                          corresponds to the null wide character (which is the value stored).
+    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+                       character (which is the value stored); the value returned is the number
+                       of bytes that complete the multibyte character.
+    (size_t)(-3) if the next character resulting from a previous call has been stored (no
+                 bytes from the input have been consumed by this call).
+    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+                 multibyte character, and all n bytes have been processed (no value is
+                 stored).<sup><a href="#note311"><b>311)</b></a></sup>
+    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+                 do not contribute to a complete and valid multibyte character (no
+                 value is stored); the value of the macro EILSEQ is stored in errno,
+                 and the conversion state is unspecified.
+<a name="7.27.1.2" href="#7.27.1.2"><b>    7.27.1.2 The c16rtomb function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
+            size_t c16rtomb(char * restrict s, char16_t c16,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the c16rtomb function is equivalent to the call
+                    c16rtomb(buf, L'\0', ps)
+    where buf is an internal buffer.
+3   If s is not a null pointer, the c16rtomb function determines the number of bytes needed
+    to represent the multibyte character that corresponds to the wide character given by c16
+    (including any shift sequences), and stores the multibyte character representation in the
+
+
+    <sup><a name="note311" href="#note311"><b>311)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+         sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+[<a name="p396" href="#p396">page 396</a>] (<a href="#Contents">Contents</a>)
+
+    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+    c16 is a null wide character, a null byte is stored, preceded by any shift sequence needed
+    to restore the initial shift state; the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The c16rtomb function returns the number of bytes stored in the array object (including
+    any shift sequences). When c16 is not a valid wide character, an encoding error occurs:
+    the function stores the value of the macro EILSEQ in errno and returns
+    (size_t)(-1); the conversion state is unspecified.
+<a name="7.27.1.3" href="#7.27.1.3"><b>    7.27.1.3 The mbrtoc32 function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
+            size_t mbrtoc32(char32_t * restrict pc32,
+                 const char * restrict s, size_t n,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the mbrtoc32 function is equivalent to the call:
+                    mbrtoc32(NULL, "", 1, ps)
+    In this case, the values of the parameters pc32 and n are ignored.
+3   If s is not a null pointer, the mbrtoc32 function inspects at most n bytes beginning with
+    the byte pointed to by s to determine the number of bytes needed to complete the next
+    multibyte character (including any shift sequences). If the function determines that the
+    next multibyte character is complete and valid, it determines the values of the
+    corresponding wide characters and then, if pc32 is not a null pointer, stores the value of
+    the first (or only) such character in the object pointed to by pc32. Subsequent calls will
+    store successive wide characters without consuming any additional input until all the
+    characters have been stored. If the corresponding wide character is the null wide
+    character, the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The mbrtoc32 function returns the first of the following that applies (given the current
+    conversion state):
+    0                    if the next n or fewer bytes complete the multibyte character that
+                         corresponds to the null wide character (which is the value stored).
+    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+                       character (which is the value stored); the value returned is the number
+                       of bytes that complete the multibyte character.
+
+[<a name="p397" href="#p397">page 397</a>] (<a href="#Contents">Contents</a>)
+
+    (size_t)(-3) if the next character resulting from a previous call has been stored (no
+                 bytes from the input have been consumed by this call).
+    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+                 multibyte character, and all n bytes have been processed (no value is
+                 stored).<sup><a href="#note312"><b>312)</b></a></sup>
+    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+                 do not contribute to a complete and valid multibyte character (no
+                 value is stored); the value of the macro EILSEQ is stored in errno,
+                 and the conversion state is unspecified.
+<a name="7.27.1.4" href="#7.27.1.4"><b>    7.27.1.4 The c32rtomb function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.27">&lt;uchar.h&gt;</a>
+            size_t c32rtomb(char * restrict s, char32_t c32,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the c32rtomb function is equivalent to the call
+                    c32rtomb(buf, L'\0', ps)
+    where buf is an internal buffer.
+3   If s is not a null pointer, the c32rtomb function determines the number of bytes needed
+    to represent the multibyte character that corresponds to the wide character given by c32
+    (including any shift sequences), and stores the multibyte character representation in the
+    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+    c32 is a null wide character, a null byte is stored, preceded by any shift sequence needed
+    to restore the initial shift state; the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The c32rtomb function returns the number of bytes stored in the array object (including
+    any shift sequences). When c32 is not a valid wide character, an encoding error occurs:
+    the function stores the value of the macro EILSEQ in errno and returns
+    (size_t)(-1); the conversion state is unspecified.
+
+
+
+
+    <sup><a name="note312" href="#note312"><b>312)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+         sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+[<a name="p398" href="#p398">page 398</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28" href="#7.28"><b>    7.28 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
+<a name="7.28.1" href="#7.28.1"><b>    7.28.1 Introduction</b></a>
+1   The header <a href="#7.28">&lt;wchar.h&gt;</a> defines four macros, and declares four data types, one tag, and
+    many functions.<sup><a href="#note313"><b>313)</b></a></sup>
+2   The types declared are wchar_t and size_t (both described in <a href="#7.19">7.19</a>);
+              mbstate_t
+    which is a complete object type other than an array type that can hold the conversion state
+    information necessary to convert between sequences of multibyte characters and wide
+    characters;
+             wint_t
+    which is an integer type unchanged by default argument promotions that can hold any
+    value corresponding to members of the extended character set, as well as at least one
+    value that does not correspond to any member of the extended character set (see WEOF
+    below);<sup><a href="#note314"><b>314)</b></a></sup> and
+             struct tm
+    which is declared as an incomplete structure type (the contents are described in <a href="#7.26.1">7.26.1</a>).
+3   The macros defined are NULL (described in <a href="#7.19">7.19</a>); WCHAR_MIN and WCHAR_MAX
+    (described in <a href="#7.20.3">7.20.3</a>); and
+             WEOF
+    which expands to a constant expression of type wint_t whose value does not
+    correspond to any member of the extended character set.<sup><a href="#note315"><b>315)</b></a></sup> It is accepted (and returned)
+    by several functions in this subclause to indicate end-of-file, that is, no more input from a
+    stream. It is also used as a wide character value that does not correspond to any member
+    of the extended character set.
+4   The functions declared are grouped as follows:
+    -- Functions that perform input and output of wide characters, or multibyte characters,
+      or both;
+    -- Functions that provide wide string numeric conversion;
+    -- Functions that perform general wide string manipulation;
+
+
+    <sup><a name="note313" href="#note313"><b>313)</b></a></sup> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+    <sup><a name="note314" href="#note314"><b>314)</b></a></sup> wchar_t and wint_t can be the same integer type.
+    <sup><a name="note315" href="#note315"><b>315)</b></a></sup> The value of the macro WEOF may differ from that of EOF and need not be negative.
+
+[<a name="p399" href="#p399">page 399</a>] (<a href="#Contents">Contents</a>)
+
+    -- Functions for wide string date and time conversion; and
+    -- Functions that provide extended capabilities for conversion between multibyte and
+      wide character sequences.
+5   Unless explicitly stated otherwise, if the execution of a function described in this
+    subclause causes copying to take place between objects that overlap, the behavior is
+    undefined.
+<a name="7.28.2" href="#7.28.2"><b>    7.28.2 Formatted wide character input/output functions</b></a>
+1   The formatted wide character input/output functions shall behave as if there is a sequence
+    point after the actions associated with each specifier.<sup><a href="#note316"><b>316)</b></a></sup>
+<a name="7.28.2.1" href="#7.28.2.1"><b>    7.28.2.1 The fwprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int fwprintf(FILE * restrict stream,
+                 const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The fwprintf function writes output to the stream pointed to by stream, under
+    control of the wide string pointed to by format that specifies how subsequent arguments
+    are converted for output. If there are insufficient arguments for the format, the behavior
+    is undefined. If the format is exhausted while arguments remain, the excess arguments
+    are evaluated (as always) but are otherwise ignored. The fwprintf function returns
+    when the end of the format string is encountered.
+3   The format is composed of zero or more directives: ordinary wide characters (not %),
+    which are copied unchanged to the output stream; and conversion specifications, each of
+    which results in fetching zero or more subsequent arguments, converting them, if
+    applicable, according to the corresponding conversion specifier, and then writing the
+    result to the output stream.
+4   Each conversion specification is introduced by the wide character %. After the %, the
+    following appear in sequence:
+    -- Zero or more flags (in any order) that modify the meaning of the conversion
+      specification.
+    -- An optional minimum field width. If the converted value has fewer wide characters
+      than the field width, it is padded with spaces (by default) on the left (or right, if the
+
+
+    <sup><a name="note316" href="#note316"><b>316)</b></a></sup> The fwprintf functions perform writes to memory for the %n specifier.
+
+[<a name="p400" href="#p400">page 400</a>] (<a href="#Contents">Contents</a>)
+
+        left adjustment flag, described later, has been given) to the field width. The field
+        width takes the form of an asterisk * (described later) or a nonnegative decimal
+        integer.<sup><a href="#note317"><b>317)</b></a></sup>
+    -- An optional precision that gives the minimum number of digits to appear for the d, i,
+      o, u, x, and X conversions, the number of digits to appear after the decimal-point
+      wide character for a, A, e, E, f, and F conversions, the maximum number of
+      significant digits for the g and G conversions, or the maximum number of wide
+      characters to be written for s conversions. The precision takes the form of a period
+      (.) followed either by an asterisk * (described later) or by an optional decimal
+      integer; if only the period is specified, the precision is taken as zero. If a precision
+      appears with any other conversion specifier, the behavior is undefined.
+    -- An optional length modifier that specifies the size of the argument.
+    -- A conversion specifier wide character that specifies the type of conversion to be
+      applied.
+5   As noted above, a field width, or precision, or both, may be indicated by an asterisk. In
+    this case, an int argument supplies the field width or precision. The arguments
+    specifying field width, or precision, or both, shall appear (in that order) before the
+    argument (if any) to be converted. A negative field width argument is taken as a - flag
+    followed by a positive field width. A negative precision argument is taken as if the
+    precision were omitted.
+6   The flag wide characters and their meanings are:
+    -        The result of the conversion is left-justified within the field. (It is right-justified if
+             this flag is not specified.)
+    +        The result of a signed conversion always begins with a plus or minus sign. (It
+             begins with a sign only when a negative value is converted if this flag is not
+             specified.)<sup><a href="#note318"><b>318)</b></a></sup>
+    space If the first wide character of a signed conversion is not a sign, or if a signed
+          conversion results in no wide characters, a space is prefixed to the result. If the
+          space and + flags both appear, the space flag is ignored.
+    #        The result is converted to an ''alternative form''. For o conversion, it increases
+             the precision, if and only if necessary, to force the first digit of the result to be a
+             zero (if the value and precision are both 0, a single 0 is printed). For x (or X)
+             conversion, a nonzero result has 0x (or 0X) prefixed to it. For a, A, e, E, f, F, g,
+
+
+    <sup><a name="note317" href="#note317"><b>317)</b></a></sup> Note that 0 is taken as a flag, not as the beginning of a field width.
+    <sup><a name="note318" href="#note318"><b>318)</b></a></sup> The results of all floating conversions of a negative zero, and of negative values that round to zero,
+         include a minus sign.
+
+[<a name="p401" href="#p401">page 401</a>] (<a href="#Contents">Contents</a>)
+
+              and G conversions, the result of converting a floating-point number always
+              contains a decimal-point wide character, even if no digits follow it. (Normally, a
+              decimal-point wide character appears in the result of these conversions only if a
+              digit follows it.) For g and G conversions, trailing zeros are not removed from the
+              result. For other conversions, the behavior is undefined.
+    0         For d, i, o, u, x, X, a, A, e, E, f, F, g, and G conversions, leading zeros
+              (following any indication of sign or base) are used to pad to the field width rather
+              than performing space padding, except when converting an infinity or NaN. If the
+              0 and - flags both appear, the 0 flag is ignored. For d, i, o, u, x, and X
+              conversions, if a precision is specified, the 0 flag is ignored. For other
+              conversions, the behavior is undefined.
+7   The length modifiers and their meanings are:
+    hh             Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   signed char or unsigned char argument (the argument will have
+                   been promoted according to the integer promotions, but its value shall be
+                   converted to signed char or unsigned char before printing); or that
+                   a following n conversion specifier applies to a pointer to a signed char
+                   argument.
+    h              Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   short int or unsigned short int argument (the argument will
+                   have been promoted according to the integer promotions, but its value shall
+                   be converted to short int or unsigned short int before printing);
+                   or that a following n conversion specifier applies to a pointer to a short
+                   int argument.
+    l (ell)        Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                   long int or unsigned long int argument; that a following n
+                   conversion specifier applies to a pointer to a long int argument; that a
+                   following c conversion specifier applies to a wint_t argument; that a
+                   following s conversion specifier applies to a pointer to a wchar_t
+                   argument; or has no effect on a following a, A, e, E, f, F, g, or G conversion
+                   specifier.
+    ll (ell-ell) Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 long long int or unsigned long long int argument; or that a
+                 following n conversion specifier applies to a pointer to a long long int
+                 argument.
+    j              Specifies that a following d, i, o, u, x, or X conversion specifier applies to
+                   an intmax_t or uintmax_t argument; or that a following n conversion
+                   specifier applies to a pointer to an intmax_t argument.
+
+[<a name="p402" href="#p402">page 402</a>] (<a href="#Contents">Contents</a>)
+
+    z            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 size_t or the corresponding signed integer type argument; or that a
+                 following n conversion specifier applies to a pointer to a signed integer type
+                 corresponding to size_t argument.
+    t            Specifies that a following d, i, o, u, x, or X conversion specifier applies to a
+                 ptrdiff_t or the corresponding unsigned integer type argument; or that a
+                 following n conversion specifier applies to a pointer to a ptrdiff_t
+                 argument.
+    L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                 applies to a long double argument.
+    If a length modifier appears with any conversion specifier other than as specified above,
+    the behavior is undefined.
+8   The conversion specifiers and their meanings are:
+    d,i         The int argument is converted to signed decimal in the style [-]dddd. The
+                precision specifies the minimum number of digits to appear; if the value
+                being converted can be represented in fewer digits, it is expanded with
+                leading zeros. The default precision is 1. The result of converting a zero
+                value with a precision of zero is no wide characters.
+    o,u,x,X The unsigned int argument is converted to unsigned octal (o), unsigned
+            decimal (u), or unsigned hexadecimal notation (x or X) in the style dddd; the
+            letters abcdef are used for x conversion and the letters ABCDEF for X
+            conversion. The precision specifies the minimum number of digits to appear;
+            if the value being converted can be represented in fewer digits, it is expanded
+            with leading zeros. The default precision is 1. The result of converting a
+            zero value with a precision of zero is no wide characters.
+    f,F         A double argument representing a floating-point number is converted to
+                decimal notation in the style [-]ddd.ddd, where the number of digits after
+                the decimal-point wide character is equal to the precision specification. If the
+                precision is missing, it is taken as 6; if the precision is zero and the # flag is
+                not specified, no decimal-point wide character appears. If a decimal-point
+                wide character appears, at least one digit appears before it. The value is
+                rounded to the appropriate number of digits.
+                A double argument representing an infinity is converted in one of the styles
+                [-]inf or [-]infinity -- which style is implementation-defined. A
+                double argument representing a NaN is converted in one of the styles
+                [-]nan or [-]nan(n-wchar-sequence) -- which style, and the meaning of
+                any n-wchar-sequence, is implementation-defined. The F conversion
+                specifier produces INF, INFINITY, or NAN instead of inf, infinity, or
+
+[<a name="p403" href="#p403">page 403</a>] (<a href="#Contents">Contents</a>)
+
+             nan, respectively.<sup><a href="#note319"><b>319)</b></a></sup>
+e,E          A double argument representing a floating-point number is converted in the
+             style [-]d.ddd e(+-)dd, where there is one digit (which is nonzero if the
+             argument is nonzero) before the decimal-point wide character and the number
+             of digits after it is equal to the precision; if the precision is missing, it is taken
+             as 6; if the precision is zero and the # flag is not specified, no decimal-point
+             wide character appears. The value is rounded to the appropriate number of
+             digits. The E conversion specifier produces a number with E instead of e
+             introducing the exponent. The exponent always contains at least two digits,
+             and only as many more digits as necessary to represent the exponent. If the
+             value is zero, the exponent is zero.
+             A double argument representing an infinity or NaN is converted in the style
+             of an f or F conversion specifier.
+g,G          A double argument representing a floating-point number is converted in
+             style f or e (or in style F or E in the case of a G conversion specifier),
+             depending on the value converted and the precision. Let P equal the
+             precision if nonzero, 6 if the precision is omitted, or 1 if the precision is zero.
+             Then, if a conversion with style E would have an exponent of X:
+             -- if P &gt; X &gt;= -4, the conversion is with style f (or F) and precision
+               P - (X + 1).
+             -- otherwise, the conversion is with style e (or E) and precision P - 1.
+             Finally, unless the # flag is used, any trailing zeros are removed from the
+             fractional portion of the result and the decimal-point wide character is
+             removed if there is no fractional portion remaining.
+             A double argument representing an infinity or NaN is converted in the style
+             of an f or F conversion specifier.
+a,A          A double argument representing a floating-point number is converted in the
+             style [-]0xh.hhhh p(+-)d, where there is one hexadecimal digit (which is
+             nonzero if the argument is a normalized floating-point number and is
+             otherwise unspecified) before the decimal-point wide character<sup><a href="#note320"><b>320)</b></a></sup> and the
+             number of hexadecimal digits after it is equal to the precision; if the precision
+             is missing and FLT_RADIX is a power of 2, then the precision is sufficient
+
+
+<sup><a name="note319" href="#note319"><b>319)</b></a></sup> When applied to infinite and NaN values, the -, +, and space flag wide characters have their usual
+     meaning; the # and 0 flag wide characters have no effect.
+<sup><a name="note320" href="#note320"><b>320)</b></a></sup> Binary implementations can choose the hexadecimal digit to the left of the decimal-point wide
+     character so that subsequent digits align to nibble (4-bit) boundaries.
+
+[<a name="p404" href="#p404">page 404</a>] (<a href="#Contents">Contents</a>)
+
+             for an exact representation of the value; if the precision is missing and
+             FLT_RADIX is not a power of 2, then the precision is sufficient to
+             distinguish<sup><a href="#note321"><b>321)</b></a></sup> values of type double, except that trailing zeros may be
+             omitted; if the precision is zero and the # flag is not specified, no decimal-
+             point wide character appears. The letters abcdef are used for a conversion
+             and the letters ABCDEF for A conversion. The A conversion specifier
+             produces a number with X and P instead of x and p. The exponent always
+             contains at least one digit, and only as many more digits as necessary to
+             represent the decimal exponent of 2. If the value is zero, the exponent is
+             zero.
+             A double argument representing an infinity or NaN is converted in the style
+             of an f or F conversion specifier.
+c            If no l length modifier is present, the int argument is converted to a wide
+             character as if by calling btowc and the resulting wide character is written.
+             If an l length modifier is present, the wint_t argument is converted to
+             wchar_t and written.
+s            If no l length modifier is present, the argument shall be a pointer to the initial
+             element of a character array containing a multibyte character sequence
+             beginning in the initial shift state. Characters from the array are converted as
+             if by repeated calls to the mbrtowc function, with the conversion state
+             described by an mbstate_t object initialized to zero before the first
+             multibyte character is converted, and written up to (but not including) the
+             terminating null wide character. If the precision is specified, no more than
+             that many wide characters are written. If the precision is not specified or is
+             greater than the size of the converted array, the converted array shall contain a
+             null wide character.
+             If an l length modifier is present, the argument shall be a pointer to the initial
+             element of an array of wchar_t type. Wide characters from the array are
+             written up to (but not including) a terminating null wide character. If the
+             precision is specified, no more than that many wide characters are written. If
+             the precision is not specified or is greater than the size of the array, the array
+             shall contain a null wide character.
+p            The argument shall be a pointer to void. The value of the pointer is
+             converted to a sequence of printing wide characters, in an implementation-
+
+<sup><a name="note321" href="#note321"><b>321)</b></a></sup> The precision p is sufficient to distinguish values of the source type if 16 p-1 &gt; b n where b is
+     FLT_RADIX and n is the number of base-b digits in the significand of the source type. A smaller p
+     might suffice depending on the implementation's scheme for determining the digit to the left of the
+     decimal-point wide character.
+
+[<a name="p405" href="#p405">page 405</a>] (<a href="#Contents">Contents</a>)
+
+                    defined manner.
+     n              The argument shall be a pointer to signed integer into which is written the
+                    number of wide characters written to the output stream so far by this call to
+                    fwprintf. No argument is converted, but one is consumed. If the
+                    conversion specification includes any flags, a field width, or a precision, the
+                    behavior is undefined.
+     %              A % wide character is written. No argument is converted. The complete
+                    conversion specification shall be %%.
+9    If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note322"><b>322)</b></a></sup> If any argument is
+     not the correct type for the corresponding conversion specification, the behavior is
+     undefined.
+10   In no case does a nonexistent or small field width cause truncation of a field; if the result
+     of a conversion is wider than the field width, the field is expanded to contain the
+     conversion result.
+11   For a and A conversions, if FLT_RADIX is a power of 2, the value is correctly rounded
+     to a hexadecimal floating number with the given precision.
+     Recommended practice
+12   For a and A conversions, if FLT_RADIX is not a power of 2 and the result is not exactly
+     representable in the given precision, the result should be one of the two adjacent numbers
+     in hexadecimal floating style with the given precision, with the extra stipulation that the
+     error should have a correct sign for the current rounding direction.
+13   For e, E, f, F, g, and G conversions, if the number of significant decimal digits is at most
+     DECIMAL_DIG, then the result should be correctly rounded.<sup><a href="#note323"><b>323)</b></a></sup> If the number of
+     significant decimal digits is more than DECIMAL_DIG but the source value is exactly
+     representable with DECIMAL_DIG digits, then the result should be an exact
+     representation with trailing zeros. Otherwise, the source value is bounded by two
+     adjacent decimal strings L &lt; U, both having DECIMAL_DIG significant digits; the value
+     of the resultant decimal string D should satisfy L &lt;= D &lt;= U, with the extra stipulation that
+     the error should have a correct sign for the current rounding direction.
+<b>     Returns</b>
+14   The fwprintf function returns the number of wide characters transmitted, or a negative
+     value if an output or encoding error occurred.
+
+     <sup><a name="note322" href="#note322"><b>322)</b></a></sup> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+     <sup><a name="note323" href="#note323"><b>323)</b></a></sup> For binary-to-decimal conversion, the result format's values are the numbers representable with the
+          given format specifier. The number of significant digits is determined by the format specifier, and in
+          the case of fixed-point conversion by the source value as well.
+
+[<a name="p406" href="#p406">page 406</a>] (<a href="#Contents">Contents</a>)
+
+     Environmental limits
+15   The number of wide characters that can be produced by any single conversion shall be at
+     least 4095.
+16   EXAMPLE       To print a date and time in the form ''Sunday, July 3, 10:02'' followed by pi to five decimal
+     places:
+             #include <a href="#7.12">&lt;math.h&gt;</a>
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             /* ... */
+             wchar_t *weekday, *month; // pointers to wide strings
+             int day, hour, min;
+             fwprintf(stdout, L"%ls, %ls %d, %.2d:%.2d\n",
+                     weekday, month, day, hour, min);
+             fwprintf(stdout, L"pi = %.5f\n", 4 * atan(1.0));
+
+     Forward references:          the btowc function (<a href="#7.28.6.1.1">7.28.6.1.1</a>), the mbrtowc function
+     (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
+<a name="7.28.2.2" href="#7.28.2.2"><b>     7.28.2.2 The fwscanf function</b></a>
+<b>     Synopsis</b>
+1            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             int fwscanf(FILE * restrict stream,
+                  const wchar_t * restrict format, ...);
+<b>     Description</b>
+2    The fwscanf function reads input from the stream pointed to by stream, under
+     control of the wide string pointed to by format that specifies the admissible input
+     sequences and how they are to be converted for assignment, using subsequent arguments
+     as pointers to the objects to receive the converted input. If there are insufficient
+     arguments for the format, the behavior is undefined. If the format is exhausted while
+     arguments remain, the excess arguments are evaluated (as always) but are otherwise
+     ignored.
+3    The format is composed of zero or more directives: one or more white-space wide
+     characters, an ordinary wide character (neither % nor a white-space wide character), or a
+     conversion specification. Each conversion specification is introduced by the wide
+     character %. After the %, the following appear in sequence:
+     -- An optional assignment-suppressing wide character *.
+     -- An optional decimal integer greater than zero that specifies the maximum field width
+       (in wide characters).
+
+[<a name="p407" href="#p407">page 407</a>] (<a href="#Contents">Contents</a>)
+
+     -- An optional length modifier that specifies the size of the receiving object.
+     -- A conversion specifier wide character that specifies the type of conversion to be
+       applied.
+4    The fwscanf function executes each directive of the format in turn. When all directives
+     have been executed, or if a directive fails (as detailed below), the function returns.
+     Failures are described as input failures (due to the occurrence of an encoding error or the
+     unavailability of input characters), or matching failures (due to inappropriate input).
+5    A directive composed of white-space wide character(s) is executed by reading input up to
+     the first non-white-space wide character (which remains unread), or until no more wide
+     characters can be read.
+6    A directive that is an ordinary wide character is executed by reading the next wide
+     character of the stream. If that wide character differs from the directive, the directive
+     fails and the differing and subsequent wide characters remain unread. Similarly, if end-
+     of-file, an encoding error, or a read error prevents a wide character from being read, the
+     directive fails.
+7    A directive that is a conversion specification defines a set of matching input sequences, as
+     described below for each specifier. A conversion specification is executed in the
+     following steps:
+8    Input white-space wide characters (as specified by the iswspace function) are skipped,
+     unless the specification includes a [, c, or n specifier.<sup><a href="#note324"><b>324)</b></a></sup>
+9    An input item is read from the stream, unless the specification includes an n specifier. An
+     input item is defined as the longest sequence of input wide characters which does not
+     exceed any specified field width and which is, or is a prefix of, a matching input
+     sequence.<sup><a href="#note325"><b>325)</b></a></sup> The first wide character, if any, after the input item remains unread. If the
+     length of the input item is zero, the execution of the directive fails; this condition is a
+     matching failure unless end-of-file, an encoding error, or a read error prevented input
+     from the stream, in which case it is an input failure.
+10   Except in the case of a % specifier, the input item (or, in the case of a %n directive, the
+     count of input wide characters) is converted to a type appropriate to the conversion
+     specifier. If the input item is not a matching sequence, the execution of the directive fails:
+     this condition is a matching failure. Unless assignment suppression was indicated by a *,
+     the result of the conversion is placed in the object pointed to by the first argument
+     following the format argument that has not already received a conversion result. If this
+
+
+     <sup><a name="note324" href="#note324"><b>324)</b></a></sup> These white-space wide characters are not counted against a specified field width.
+     <sup><a name="note325" href="#note325"><b>325)</b></a></sup> fwscanf pushes back at most one input wide character onto the input stream. Therefore, some
+          sequences that are acceptable to wcstod, wcstol, etc., are unacceptable to fwscanf.
+
+[<a name="p408" href="#p408">page 408</a>] (<a href="#Contents">Contents</a>)
+
+     object does not have an appropriate type, or if the result of the conversion cannot be
+     represented in the object, the behavior is undefined.
+11   The length modifiers and their meanings are:
+     hh           Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to signed char or unsigned char.
+     h            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to short int or unsigned short
+                  int.
+     l (ell)      Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to long int or unsigned long
+                  int; that a following a, A, e, E, f, F, g, or G conversion specifier applies to
+                  an argument with type pointer to double; or that a following c, s, or [
+                  conversion specifier applies to an argument with type pointer to wchar_t.
+     ll (ell-ell) Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to long long int or unsigned
+                  long long int.
+     j            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to intmax_t or uintmax_t.
+     z            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to size_t or the corresponding signed
+                  integer type.
+     t            Specifies that a following d, i, o, u, x, X, or n conversion specifier applies
+                  to an argument with type pointer to ptrdiff_t or the corresponding
+                  unsigned integer type.
+     L            Specifies that a following a, A, e, E, f, F, g, or G conversion specifier
+                  applies to an argument with type pointer to long double.
+     If a length modifier appears with any conversion specifier other than as specified above,
+     the behavior is undefined.
+12   The conversion specifiers and their meanings are:
+     d           Matches an optionally signed decimal integer, whose format is the same as
+                 expected for the subject sequence of the wcstol function with the value 10
+                 for the base argument. The corresponding argument shall be a pointer to
+                 signed integer.
+     i           Matches an optionally signed integer, whose format is the same as expected
+                 for the subject sequence of the wcstol function with the value 0 for the
+                 base argument. The corresponding argument shall be a pointer to signed
+
+[<a name="p409" href="#p409">page 409</a>] (<a href="#Contents">Contents</a>)
+
+          integer.
+o         Matches an optionally signed octal integer, whose format is the same as
+          expected for the subject sequence of the wcstoul function with the value 8
+          for the base argument. The corresponding argument shall be a pointer to
+          unsigned integer.
+u         Matches an optionally signed decimal integer, whose format is the same as
+          expected for the subject sequence of the wcstoul function with the value 10
+          for the base argument. The corresponding argument shall be a pointer to
+          unsigned integer.
+x         Matches an optionally signed hexadecimal integer, whose format is the same
+          as expected for the subject sequence of the wcstoul function with the value
+          16 for the base argument. The corresponding argument shall be a pointer to
+          unsigned integer.
+a,e,f,g Matches an optionally signed floating-point number, infinity, or NaN, whose
+        format is the same as expected for the subject sequence of the wcstod
+        function. The corresponding argument shall be a pointer to floating.
+c         Matches a sequence of wide characters of exactly the number specified by the
+          field width (1 if no field width is present in the directive).
+          If no l length modifier is present, characters from the input field are
+          converted as if by repeated calls to the wcrtomb function, with the
+          conversion state described by an mbstate_t object initialized to zero
+          before the first wide character is converted. The corresponding argument
+          shall be a pointer to the initial element of a character array large enough to
+          accept the sequence. No null character is added.
+          If an l length modifier is present, the corresponding argument shall be a
+          pointer to the initial element of an array of wchar_t large enough to accept
+          the sequence. No null wide character is added.
+s         Matches a sequence of non-white-space wide characters.
+          If no l length modifier is present, characters from the input field are
+          converted as if by repeated calls to the wcrtomb function, with the
+          conversion state described by an mbstate_t object initialized to zero
+          before the first wide character is converted. The corresponding argument
+          shall be a pointer to the initial element of a character array large enough to
+          accept the sequence and a terminating null character, which will be added
+          automatically.
+          If an l length modifier is present, the corresponding argument shall be a
+          pointer to the initial element of an array of wchar_t large enough to accept
+
+[<a name="p410" href="#p410">page 410</a>] (<a href="#Contents">Contents</a>)
+
+            the sequence and the terminating null wide character, which will be added
+            automatically.
+[           Matches a nonempty sequence of wide characters from a set of expected
+            characters (the scanset).
+            If no l length modifier is present, characters from the input field are
+            converted as if by repeated calls to the wcrtomb function, with the
+            conversion state described by an mbstate_t object initialized to zero
+            before the first wide character is converted. The corresponding argument
+            shall be a pointer to the initial element of a character array large enough to
+            accept the sequence and a terminating null character, which will be added
+            automatically.
+            If an l length modifier is present, the corresponding argument shall be a
+            pointer to the initial element of an array of wchar_t large enough to accept
+            the sequence and the terminating null wide character, which will be added
+            automatically.
+            The conversion specifier includes all subsequent wide characters in the
+            format string, up to and including the matching right bracket (]). The wide
+            characters between the brackets (the scanlist) compose the scanset, unless the
+            wide character after the left bracket is a circumflex (^), in which case the
+            scanset contains all wide characters that do not appear in the scanlist between
+            the circumflex and the right bracket. If the conversion specifier begins with
+            [] or [^], the right bracket wide character is in the scanlist and the next
+            following right bracket wide character is the matching right bracket that ends
+            the specification; otherwise the first following right bracket wide character is
+            the one that ends the specification. If a - wide character is in the scanlist and
+            is not the first, nor the second where the first wide character is a ^, nor the
+            last character, the behavior is implementation-defined.
+p           Matches an implementation-defined set of sequences, which should be the
+            same as the set of sequences that may be produced by the %p conversion of
+            the fwprintf function. The corresponding argument shall be a pointer to a
+            pointer to void. The input item is converted to a pointer value in an
+            implementation-defined manner. If the input item is a value converted earlier
+            during the same program execution, the pointer that results shall compare
+            equal to that value; otherwise the behavior of the %p conversion is undefined.
+n           No input is consumed. The corresponding argument shall be a pointer to
+            signed integer into which is to be written the number of wide characters read
+            from the input stream so far by this call to the fwscanf function. Execution
+            of a %n directive does not increment the assignment count returned at the
+            completion of execution of the fwscanf function. No argument is
+
+[<a name="p411" href="#p411">page 411</a>] (<a href="#Contents">Contents</a>)
+
+                    converted, but one is consumed. If the conversion specification includes an
+                    assignment-suppressing wide character or a field width, the behavior is
+                    undefined.
+     %              Matches a single % wide character; no conversion or assignment occurs. The
+                    complete conversion specification shall be %%.
+13   If a conversion specification is invalid, the behavior is undefined.<sup><a href="#note326"><b>326)</b></a></sup>
+14   The conversion specifiers A, E, F, G, and X are also valid and behave the same as,
+     respectively, a, e, f, g, and x.
+15   Trailing white space (including new-line wide characters) is left unread unless matched
+     by a directive. The success of literal matches and suppressed assignments is not directly
+     determinable other than via the %n directive.
+<b>     Returns</b>
+16   The fwscanf function returns the value of the macro EOF if an input failure occurs
+     before the first conversion (if any) has completed. Otherwise, the function returns the
+     number of input items assigned, which can be fewer than provided for, or even zero, in
+     the event of an early matching failure.
+17   EXAMPLE 1        The call:
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              #include <a href="#7.28">&lt;wchar.h&gt;</a>
+              /* ... */
+              int n, i; float x; wchar_t name[50];
+              n = fwscanf(stdin, L"%d%f%ls", &amp;i, &amp;x, name);
+     with the input line:
+              25 54.32E-1 thompson
+     will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+     thompson\0.
+
+18   EXAMPLE 2        The call:
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              #include <a href="#7.28">&lt;wchar.h&gt;</a>
+              /* ... */
+              int i; float x; double y;
+              fwscanf(stdin, L"%2d%f%*d %lf", &amp;i, &amp;x, &amp;y);
+     with input:
+              56789 0123 56a72
+     will assign to i the value 56 and to x the value 789.0, will skip past 0123, and will assign to y the value
+     56.0. The next wide character read from the input stream will be a.
+
+
+     <sup><a name="note326" href="#note326"><b>326)</b></a></sup> See ''future library directions'' (<a href="#7.30.12">7.30.12</a>).
+
+[<a name="p412" href="#p412">page 412</a>] (<a href="#Contents">Contents</a>)
+
+    Forward references: the wcstod, wcstof, and wcstold functions (<a href="#7.28.4.1.1">7.28.4.1.1</a>), the
+    wcstol, wcstoll, wcstoul, and wcstoull functions (<a href="#7.28.4.1.2">7.28.4.1.2</a>), the wcrtomb
+    function (<a href="#7.28.6.3.3">7.28.6.3.3</a>).
+<a name="7.28.2.3" href="#7.28.2.3"><b>    7.28.2.3 The swprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int swprintf(wchar_t * restrict s,
+                 size_t n,
+                 const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The swprintf function is equivalent to fwprintf, except that the argument s
+    specifies an array of wide characters into which the generated output is to be written,
+    rather than written to a stream. No more than n wide characters are written, including a
+    terminating null wide character, which is always added (unless n is zero).
+<b>    Returns</b>
+3   The swprintf function returns the number of wide characters written in the array, not
+    counting the terminating null wide character, or a negative value if an encoding error
+    occurred or if n or more wide characters were requested to be written.
+<a name="7.28.2.4" href="#7.28.2.4"><b>    7.28.2.4 The swscanf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int swscanf(const wchar_t * restrict s,
+                 const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The swscanf function is equivalent to fwscanf, except that the argument s specifies a
+    wide string from which the input is to be obtained, rather than from a stream. Reaching
+    the end of the wide string is equivalent to encountering end-of-file for the fwscanf
+    function.
+<b>    Returns</b>
+3   The swscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the swscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+
+[<a name="p413" href="#p413">page 413</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.2.5" href="#7.28.2.5"><b>    7.28.2.5 The vfwprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           int vfwprintf(FILE * restrict stream,
+                const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vfwprintf function is equivalent to fwprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfwprintf function does not invoke the
+    va_end macro.<sup><a href="#note327"><b>327)</b></a></sup>
+<b>    Returns</b>
+3   The vfwprintf function returns the number of wide characters transmitted, or a
+    negative value if an output or encoding error occurred.
+4   EXAMPLE       The following shows the use of the vfwprintf function in a general error-reporting
+    routine.
+           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           void error(char *function_name, wchar_t *format, ...)
+           {
+                 va_list args;
+                    va_start(args, format);
+                    // print out name of function causing error
+                    fwprintf(stderr, L"ERROR in %s: ", function_name);
+                    // print out remainder of message
+                    vfwprintf(stderr, format, args);
+                    va_end(args);
+           }
+
+
+
+
+    <sup><a name="note327" href="#note327"><b>327)</b></a></sup> As the functions vfwprintf, vswprintf, vfwscanf, vwprintf, vwscanf, and vswscanf
+         invoke the va_arg macro, the value of arg after the return is indeterminate.
+
+[<a name="p414" href="#p414">page 414</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.2.6" href="#7.28.2.6"><b>    7.28.2.6 The vfwscanf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vfwscanf(FILE * restrict stream,
+                 const wchar_t * restrict format,
+                 va_list arg);
+<b>    Description</b>
+2   The vfwscanf function is equivalent to fwscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfwscanf function does not invoke the
+    va_end macro.327)
+<b>    Returns</b>
+3   The vfwscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the vfwscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.28.2.7" href="#7.28.2.7"><b>    7.28.2.7 The vswprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vswprintf(wchar_t * restrict s,
+                 size_t n,
+                 const wchar_t * restrict format,
+                 va_list arg);
+<b>    Description</b>
+2   The vswprintf function is equivalent to swprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vswprintf function does not invoke the
+    va_end macro.327)
+<b>    Returns</b>
+3   The vswprintf function returns the number of wide characters written in the array, not
+    counting the terminating null wide character, or a negative value if an encoding error
+    occurred or if n or more wide characters were requested to be generated.
+
+[<a name="p415" href="#p415">page 415</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.2.8" href="#7.28.2.8"><b>    7.28.2.8 The vswscanf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           int vswscanf(const wchar_t * restrict s,
+                const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vswscanf function is equivalent to swscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vswscanf function does not invoke the
+    va_end macro.327)
+<b>    Returns</b>
+3   The vswscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the vswscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.28.2.9" href="#7.28.2.9"><b>    7.28.2.9 The vwprintf function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           int vwprintf(const wchar_t * restrict format,
+                va_list arg);
+<b>    Description</b>
+2   The vwprintf function is equivalent to wprintf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vwprintf function does not invoke the
+    va_end macro.327)
+<b>    Returns</b>
+3   The vwprintf function returns the number of wide characters transmitted, or a negative
+    value if an output or encoding error occurred.
+
+[<a name="p416" href="#p416">page 416</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.2.10" href="#7.28.2.10"><b>    7.28.2.10 The vwscanf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vwscanf(const wchar_t * restrict format,
+                 va_list arg);
+<b>    Description</b>
+2   The vwscanf function is equivalent to wscanf, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vwscanf function does not invoke the
+    va_end macro.327)
+<b>    Returns</b>
+3   The vwscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the vwscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.28.2.11" href="#7.28.2.11"><b>    7.28.2.11 The wprintf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int wprintf(const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The wprintf function is equivalent to fwprintf with the argument stdout
+    interposed before the arguments to wprintf.
+<b>    Returns</b>
+3   The wprintf function returns the number of wide characters transmitted, or a negative
+    value if an output or encoding error occurred.
+<a name="7.28.2.12" href="#7.28.2.12"><b>    7.28.2.12 The wscanf function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int wscanf(const wchar_t * restrict format, ...);
+<b>    Description</b>
+2   The wscanf function is equivalent to fwscanf with the argument stdin interposed
+    before the arguments to wscanf.
+
+[<a name="p417" href="#p417">page 417</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The wscanf function returns the value of the macro EOF if an input failure occurs
+    before the first conversion (if any) has completed. Otherwise, the wscanf function
+    returns the number of input items assigned, which can be fewer than provided for, or even
+    zero, in the event of an early matching failure.
+<a name="7.28.3" href="#7.28.3"><b>    7.28.3 Wide character input/output functions</b></a>
+<a name="7.28.3.1" href="#7.28.3.1"><b>    7.28.3.1 The fgetwc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wint_t fgetwc(FILE *stream);
+<b>    Description</b>
+2   If the end-of-file indicator for the input stream pointed to by stream is not set and a
+    next wide character is present, the fgetwc function obtains that wide character as a
+    wchar_t converted to a wint_t and advances the associated file position indicator for
+    the stream (if defined).
+<b>    Returns</b>
+3   If the end-of-file indicator for the stream is set, or if the stream is at end-of-file, the end-
+    of-file indicator for the stream is set and the fgetwc function returns WEOF. Otherwise,
+    the fgetwc function returns the next wide character from the input stream pointed to by
+    stream. If a read error occurs, the error indicator for the stream is set and the fgetwc
+    function returns WEOF. If an encoding error occurs (including too few bytes), the value of
+    the macro EILSEQ is stored in errno and the fgetwc function returns WEOF.<sup><a href="#note328"><b>328)</b></a></sup>
+<a name="7.28.3.2" href="#7.28.3.2"><b>    7.28.3.2 The fgetws function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *fgetws(wchar_t * restrict s,
+                 int n, FILE * restrict stream);
+<b>    Description</b>
+2   The fgetws function reads at most one less than the number of wide characters
+    specified by n from the stream pointed to by stream into the array pointed to by s. No
+
+
+    <sup><a name="note328" href="#note328"><b>328)</b></a></sup> An end-of-file and a read error can be distinguished by use of the feof and ferror functions.
+         Also, errno will be set to EILSEQ by input/output functions only if an encoding error occurs.
+
+[<a name="p418" href="#p418">page 418</a>] (<a href="#Contents">Contents</a>)
+
+    additional wide characters are read after a new-line wide character (which is retained) or
+    after end-of-file. A null wide character is written immediately after the last wide
+    character read into the array.
+<b>    Returns</b>
+3   The fgetws function returns s if successful. If end-of-file is encountered and no
+    characters have been read into the array, the contents of the array remain unchanged and a
+    null pointer is returned. If a read or encoding error occurs during the operation, the array
+    contents are indeterminate and a null pointer is returned.
+<a name="7.28.3.3" href="#7.28.3.3"><b>    7.28.3.3 The fputwc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wint_t fputwc(wchar_t c, FILE *stream);
+<b>    Description</b>
+2   The fputwc function writes the wide character specified by c to the output stream
+    pointed to by stream, at the position indicated by the associated file position indicator
+    for the stream (if defined), and advances the indicator appropriately. If the file cannot
+    support positioning requests, or if the stream was opened with append mode, the
+    character is appended to the output stream.
+<b>    Returns</b>
+3   The fputwc function returns the wide character written. If a write error occurs, the
+    error indicator for the stream is set and fputwc returns WEOF. If an encoding error
+    occurs, the value of the macro EILSEQ is stored in errno and fputwc returns WEOF.
+<a name="7.28.3.4" href="#7.28.3.4"><b>    7.28.3.4 The fputws function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int fputws(const wchar_t * restrict s,
+                 FILE * restrict stream);
+<b>    Description</b>
+2   The fputws function writes the wide string pointed to by s to the stream pointed to by
+    stream. The terminating null wide character is not written.
+<b>    Returns</b>
+3   The fputws function returns EOF if a write or encoding error occurs; otherwise, it
+    returns a nonnegative value.
+
+[<a name="p419" href="#p419">page 419</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.3.5" href="#7.28.3.5"><b>    7.28.3.5 The fwide function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int fwide(FILE *stream, int mode);
+<b>    Description</b>
+2   The fwide function determines the orientation of the stream pointed to by stream. If
+    mode is greater than zero, the function first attempts to make the stream wide oriented. If
+    mode is less than zero, the function first attempts to make the stream byte oriented.<sup><a href="#note329"><b>329)</b></a></sup>
+    Otherwise, mode is zero and the function does not alter the orientation of the stream.
+<b>    Returns</b>
+3   The fwide function returns a value greater than zero if, after the call, the stream has
+    wide orientation, a value less than zero if the stream has byte orientation, or zero if the
+    stream has no orientation.
+<a name="7.28.3.6" href="#7.28.3.6"><b>    7.28.3.6 The getwc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wint_t getwc(FILE *stream);
+<b>    Description</b>
+2   The getwc function is equivalent to fgetwc, except that if it is implemented as a
+    macro, it may evaluate stream more than once, so the argument should never be an
+    expression with side effects.
+<b>    Returns</b>
+3   The getwc function returns the next wide character from the input stream pointed to by
+    stream, or WEOF.
+<a name="7.28.3.7" href="#7.28.3.7"><b>    7.28.3.7 The getwchar function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wint_t getwchar(void);
+
+
+
+
+    <sup><a name="note329" href="#note329"><b>329)</b></a></sup> If the orientation of the stream has already been determined, fwide does not change it.
+
+[<a name="p420" href="#p420">page 420</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The getwchar function is equivalent to getwc with the argument stdin.
+<b>    Returns</b>
+3   The getwchar function returns the next wide character from the input stream pointed to
+    by stdin, or WEOF.
+<a name="7.28.3.8" href="#7.28.3.8"><b>    7.28.3.8 The putwc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wint_t putwc(wchar_t c, FILE *stream);
+<b>    Description</b>
+2   The putwc function is equivalent to fputwc, except that if it is implemented as a
+    macro, it may evaluate stream more than once, so that argument should never be an
+    expression with side effects.
+<b>    Returns</b>
+3   The putwc function returns the wide character written, or WEOF.
+<a name="7.28.3.9" href="#7.28.3.9"><b>    7.28.3.9 The putwchar function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wint_t putwchar(wchar_t c);
+<b>    Description</b>
+2   The putwchar function is equivalent to putwc with the second argument stdout.
+<b>    Returns</b>
+3   The putwchar function returns the character written, or WEOF.
+<a name="7.28.3.10" href="#7.28.3.10"><b>    7.28.3.10 The ungetwc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wint_t ungetwc(wint_t c, FILE *stream);
+<b>    Description</b>
+2   The ungetwc function pushes the wide character specified by c back onto the input
+    stream pointed to by stream. Pushed-back wide characters will be returned by
+    subsequent reads on that stream in the reverse order of their pushing. A successful
+
+[<a name="p421" href="#p421">page 421</a>] (<a href="#Contents">Contents</a>)
+
+    intervening call (with the stream pointed to by stream) to a file positioning function
+    (fseek, fsetpos, or rewind) discards any pushed-back wide characters for the
+    stream. The external storage corresponding to the stream is unchanged.
+3   One wide character of pushback is guaranteed, even if the call to the ungetwc function
+    follows just after a call to a formatted wide character input function fwscanf,
+    vfwscanf, vwscanf, or wscanf. If the ungetwc function is called too many times
+    on the same stream without an intervening read or file positioning operation on that
+    stream, the operation may fail.
+4   If the value of c equals that of the macro WEOF, the operation fails and the input stream is
+    unchanged.
+5   A successful call to the ungetwc function clears the end-of-file indicator for the stream.
+    The value of the file position indicator for the stream after reading or discarding all
+    pushed-back wide characters is the same as it was before the wide characters were pushed
+    back. For a text or binary stream, the value of its file position indicator after a successful
+    call to the ungetwc function is unspecified until all pushed-back wide characters are
+    read or discarded.
+<b>    Returns</b>
+6   The ungetwc function returns the wide character pushed back, or WEOF if the operation
+    fails.
+<a name="7.28.4" href="#7.28.4"><b>    7.28.4 General wide string utilities</b></a>
+1   The header <a href="#7.28">&lt;wchar.h&gt;</a> declares a number of functions useful for wide string
+    manipulation. Various methods are used for determining the lengths of the arrays, but in
+    all cases a wchar_t * argument points to the initial (lowest addressed) element of the
+    array. If an array is accessed beyond the end of an object, the behavior is undefined.
+2   Where an argument declared as size_t n determines the length of the array for a
+    function, n can have the value zero on a call to that function. Unless explicitly stated
+    otherwise in the description of a particular function in this subclause, pointer arguments
+    on such a call shall still have valid values, as described in <a href="#7.1.4">7.1.4</a>. On such a call, a
+    function that locates a wide character finds no occurrence, a function that compares two
+    wide character sequences returns zero, and a function that copies wide characters copies
+    zero wide characters.
+
+[<a name="p422" href="#p422">page 422</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.4.1" href="#7.28.4.1"><b>    7.28.4.1 Wide string numeric conversion functions</b></a>
+<a name="7.28.4.1.1" href="#7.28.4.1.1"><b>    7.28.4.1.1 The wcstod, wcstof, and wcstold functions</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            double wcstod(const wchar_t * restrict nptr,
+                 wchar_t ** restrict endptr);
+            float wcstof(const wchar_t * restrict nptr,
+                 wchar_t ** restrict endptr);
+            long double wcstold(const wchar_t * restrict nptr,
+                 wchar_t ** restrict endptr);
+<b>    Description</b>
+2   The wcstod, wcstof, and wcstold functions convert the initial portion of the wide
+    string pointed to by nptr to double, float, and long double representation,
+    respectively. First, they decompose the input string into three parts: an initial, possibly
+    empty, sequence of white-space wide characters (as specified by the iswspace
+    function), a subject sequence resembling a floating-point constant or representing an
+    infinity or NaN; and a final wide string of one or more unrecognized wide characters,
+    including the terminating null wide character of the input wide string. Then, they attempt
+    to convert the subject sequence to a floating-point number, and return the result.
+3   The expected form of the subject sequence is an optional plus or minus sign, then one of
+    the following:
+    -- a nonempty sequence of decimal digits optionally containing a decimal-point wide
+      character, then an optional exponent part as defined for the corresponding single-byte
+      characters in <a href="#6.4.4.2">6.4.4.2</a>;
+    -- a 0x or 0X, then a nonempty sequence of hexadecimal digits optionally containing a
+      decimal-point wide character, then an optional binary exponent part as defined in
+      <a href="#6.4.4.2">6.4.4.2</a>;
+    -- INF or INFINITY, or any other wide string equivalent except for case
+    -- NAN or NAN(n-wchar-sequenceopt), or any other wide string equivalent except for
+      case in the NAN part, where:
+               n-wchar-sequence:
+                     digit
+                     nondigit
+                     n-wchar-sequence digit
+                     n-wchar-sequence nondigit
+    The subject sequence is defined as the longest initial subsequence of the input wide
+    string, starting with the first non-white-space wide character, that is of the expected form.
+
+[<a name="p423" href="#p423">page 423</a>] (<a href="#Contents">Contents</a>)
+
+    The subject sequence contains no wide characters if the input wide string is not of the
+    expected form.
+4   If the subject sequence has the expected form for a floating-point number, the sequence of
+    wide characters starting with the first digit or the decimal-point wide character
+    (whichever occurs first) is interpreted as a floating constant according to the rules of
+    <a href="#6.4.4.2">6.4.4.2</a>, except that the decimal-point wide character is used in place of a period, and that
+    if neither an exponent part nor a decimal-point wide character appears in a decimal
+    floating point number, or if a binary exponent part does not appear in a hexadecimal
+    floating point number, an exponent part of the appropriate type with value zero is
+    assumed to follow the last digit in the string. If the subject sequence begins with a minus
+    sign, the sequence is interpreted as negated.<sup><a href="#note330"><b>330)</b></a></sup> A wide character sequence INF or
+    INFINITY is interpreted as an infinity, if representable in the return type, else like a
+    floating constant that is too large for the range of the return type. A wide character
+    sequence NAN or NAN(n-wchar-sequenceopt) is interpreted as a quiet NaN, if supported
+    in the return type, else like a subject sequence part that does not have the expected form;
+    the meaning of the n-wchar sequences is implementation-defined.<sup><a href="#note331"><b>331)</b></a></sup> A pointer to the
+    final wide string is stored in the object pointed to by endptr, provided that endptr is
+    not a null pointer.
+5   If the subject sequence has the hexadecimal form and FLT_RADIX is a power of 2, the
+    value resulting from the conversion is correctly rounded.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+    Recommended practice
+8   If the subject sequence has the hexadecimal form, FLT_RADIX is not a power of 2, and
+    the result is not exactly representable, the result should be one of the two numbers in the
+    appropriate internal format that are adjacent to the hexadecimal floating source value,
+    with the extra stipulation that the error should have a correct sign for the current rounding
+    direction.
+
+
+
+    <sup><a name="note330" href="#note330"><b>330)</b></a></sup> It is unspecified whether a minus-signed sequence is converted to a negative number directly or by
+         negating the value resulting from converting the corresponding unsigned sequence (see <a href="#F.5">F.5</a>); the two
+         methods may yield different results if rounding is toward positive or negative infinity. In either case,
+         the functions honor the sign of zero if floating-point arithmetic supports signed zeros.
+    <sup><a name="note331" href="#note331"><b>331)</b></a></sup> An implementation may use the n-wchar sequence to determine extra information to be represented in
+         the NaN's significand.
+
+[<a name="p424" href="#p424">page 424</a>] (<a href="#Contents">Contents</a>)
+
+9    If the subject sequence has the decimal form and at most DECIMAL_DIG (defined in
+     <a href="#7.7">&lt;float.h&gt;</a>) significant digits, the result should be correctly rounded. If the subject
+     sequence D has the decimal form and more than DECIMAL_DIG significant digits,
+     consider the two bounding, adjacent decimal strings L and U, both having
+     DECIMAL_DIG significant digits, such that the values of L, D, and U satisfy L &lt;= D &lt;= U.
+     The result should be one of the (equal or adjacent) values that would be obtained by
+     correctly rounding L and U according to the current rounding direction, with the extra
+     stipulation that the error with respect to D should have a correct sign for the current
+     rounding direction.<sup><a href="#note332"><b>332)</b></a></sup>
+<b>     Returns</b>
+10   The functions return the converted value, if any. If no conversion could be performed,
+     zero is returned. If the correct value overflows and default rounding is in effect (<a href="#7.12.1">7.12.1</a>),
+     plus or minus HUGE_VAL, HUGE_VALF, or HUGE_VALL is returned (according to the
+     return type and sign of the value), and the value of the macro ERANGE is stored in
+     errno. If the result underflows (<a href="#7.12.1">7.12.1</a>), the functions return a value whose magnitude is
+     no greater than the smallest normalized positive number in the return type; whether
+     errno acquires the value ERANGE is implementation-defined.
+
+
+
+
+     <sup><a name="note332" href="#note332"><b>332)</b></a></sup> DECIMAL_DIG, defined in <a href="#7.7">&lt;float.h&gt;</a>, should be sufficiently large that L and U will usually round
+          to the same internal floating value, but if not will round to adjacent values.
+
+[<a name="p425" href="#p425">page 425</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.4.1.2" href="#7.28.4.1.2"><b>    7.28.4.1.2 The wcstol, wcstoll, wcstoul, and wcstoull functions</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           long int wcstol(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+           long long int wcstoll(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+           unsigned long int wcstoul(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+           unsigned long long int wcstoull(
+                const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr,
+                int base);
+<b>    Description</b>
+2   The wcstol, wcstoll, wcstoul, and wcstoull functions convert the initial
+    portion of the wide string pointed to by nptr to long int, long long int,
+    unsigned long int, and unsigned long long int representation,
+    respectively. First, they decompose the input string into three parts: an initial, possibly
+    empty, sequence of white-space wide characters (as specified by the iswspace
+    function), a subject sequence resembling an integer represented in some radix determined
+    by the value of base, and a final wide string of one or more unrecognized wide
+    characters, including the terminating null wide character of the input wide string. Then,
+    they attempt to convert the subject sequence to an integer, and return the result.
+3   If the value of base is zero, the expected form of the subject sequence is that of an
+    integer constant as described for the corresponding single-byte characters in <a href="#6.4.4.1">6.4.4.1</a>,
+    optionally preceded by a plus or minus sign, but not including an integer suffix. If the
+    value of base is between 2 and 36 (inclusive), the expected form of the subject sequence
+    is a sequence of letters and digits representing an integer with the radix specified by
+    base, optionally preceded by a plus or minus sign, but not including an integer suffix.
+    The letters from a (or A) through z (or Z) are ascribed the values 10 through 35; only
+    letters and digits whose ascribed values are less than that of base are permitted. If the
+    value of base is 16, the wide characters 0x or 0X may optionally precede the sequence
+    of letters and digits, following the sign if present.
+
+[<a name="p426" href="#p426">page 426</a>] (<a href="#Contents">Contents</a>)
+
+4   The subject sequence is defined as the longest initial subsequence of the input wide
+    string, starting with the first non-white-space wide character, that is of the expected form.
+    The subject sequence contains no wide characters if the input wide string is empty or
+    consists entirely of white space, or if the first non-white-space wide character is other
+    than a sign or a permissible letter or digit.
+5   If the subject sequence has the expected form and the value of base is zero, the sequence
+    of wide characters starting with the first digit is interpreted as an integer constant
+    according to the rules of <a href="#6.4.4.1">6.4.4.1</a>. If the subject sequence has the expected form and the
+    value of base is between 2 and 36, it is used as the base for conversion, ascribing to each
+    letter its value as given above. If the subject sequence begins with a minus sign, the value
+    resulting from the conversion is negated (in the return type). A pointer to the final wide
+    string is stored in the object pointed to by endptr, provided that endptr is not a null
+    pointer.
+6   In other than the "C" locale, additional locale-specific subject sequence forms may be
+    accepted.
+7   If the subject sequence is empty or does not have the expected form, no conversion is
+    performed; the value of nptr is stored in the object pointed to by endptr, provided
+    that endptr is not a null pointer.
+<b>    Returns</b>
+8   The wcstol, wcstoll, wcstoul, and wcstoull functions return the converted
+    value, if any. If no conversion could be performed, zero is returned. If the correct value
+    is outside the range of representable values, LONG_MIN, LONG_MAX, LLONG_MIN,
+    LLONG_MAX, ULONG_MAX, or ULLONG_MAX is returned (according to the return type
+    sign of the value, if any), and the value of the macro ERANGE is stored in errno.
+<a name="7.28.4.2" href="#7.28.4.2"><b>    7.28.4.2 Wide string copying functions</b></a>
+<a name="7.28.4.2.1" href="#7.28.4.2.1"><b>    7.28.4.2.1 The wcscpy function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wcscpy(wchar_t * restrict s1,
+                 const wchar_t * restrict s2);
+<b>    Description</b>
+2   The wcscpy function copies the wide string pointed to by s2 (including the terminating
+    null wide character) into the array pointed to by s1.
+<b>    Returns</b>
+3   The wcscpy function returns the value of s1.
+
+[<a name="p427" href="#p427">page 427</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.4.2.2" href="#7.28.4.2.2"><b>    7.28.4.2.2 The wcsncpy function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             wchar_t *wcsncpy(wchar_t * restrict s1,
+                  const wchar_t * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The wcsncpy function copies not more than n wide characters (those that follow a null
+    wide character are not copied) from the array pointed to by s2 to the array pointed to by
+    s1.<sup><a href="#note333"><b>333)</b></a></sup>
+3   If the array pointed to by s2 is a wide string that is shorter than n wide characters, null
+    wide characters are appended to the copy in the array pointed to by s1, until n wide
+    characters in all have been written.
+<b>    Returns</b>
+4   The wcsncpy function returns the value of s1.
+<a name="7.28.4.2.3" href="#7.28.4.2.3"><b>    7.28.4.2.3 The wmemcpy function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             wchar_t *wmemcpy(wchar_t * restrict s1,
+                  const wchar_t * restrict s2,
+                  size_t n);
+<b>    Description</b>
+2   The wmemcpy function copies n wide characters from the object pointed to by s2 to the
+    object pointed to by s1.
+<b>    Returns</b>
+3   The wmemcpy function returns the value of s1.
+
+
+
+
+    <sup><a name="note333" href="#note333"><b>333)</b></a></sup> Thus, if there is no null wide character in the first n wide characters of the array pointed to by s2, the
+         result will not be null-terminated.
+
+[<a name="p428" href="#p428">page 428</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.4.2.4" href="#7.28.4.2.4"><b>    7.28.4.2.4 The wmemmove function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+                 size_t n);
+<b>    Description</b>
+2   The wmemmove function copies n wide characters from the object pointed to by s2 to
+    the object pointed to by s1. Copying takes place as if the n wide characters from the
+    object pointed to by s2 are first copied into a temporary array of n wide characters that
+    does not overlap the objects pointed to by s1 or s2, and then the n wide characters from
+    the temporary array are copied into the object pointed to by s1.
+<b>    Returns</b>
+3   The wmemmove function returns the value of s1.
+<a name="7.28.4.3" href="#7.28.4.3"><b>    7.28.4.3 Wide string concatenation functions</b></a>
+<a name="7.28.4.3.1" href="#7.28.4.3.1"><b>    7.28.4.3.1 The wcscat function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wcscat(wchar_t * restrict s1,
+                 const wchar_t * restrict s2);
+<b>    Description</b>
+2   The wcscat function appends a copy of the wide string pointed to by s2 (including the
+    terminating null wide character) to the end of the wide string pointed to by s1. The initial
+    wide character of s2 overwrites the null wide character at the end of s1.
+<b>    Returns</b>
+3   The wcscat function returns the value of s1.
+<a name="7.28.4.3.2" href="#7.28.4.3.2"><b>    7.28.4.3.2 The wcsncat function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wcsncat(wchar_t * restrict s1,
+                 const wchar_t * restrict s2,
+                 size_t n);
+<b>    Description</b>
+2   The wcsncat function appends not more than n wide characters (a null wide character
+    and those that follow it are not appended) from the array pointed to by s2 to the end of
+
+[<a name="p429" href="#p429">page 429</a>] (<a href="#Contents">Contents</a>)
+
+    the wide string pointed to by s1. The initial wide character of s2 overwrites the null
+    wide character at the end of s1. A terminating null wide character is always appended to
+    the result.<sup><a href="#note334"><b>334)</b></a></sup>
+<b>    Returns</b>
+3   The wcsncat function returns the value of s1.
+<a name="7.28.4.4" href="#7.28.4.4"><b>    7.28.4.4 Wide string comparison functions</b></a>
+1   Unless explicitly stated otherwise, the functions described in this subclause order two
+    wide characters the same way as two integers of the underlying integer type designated
+    by wchar_t.
+<a name="7.28.4.4.1" href="#7.28.4.4.1"><b>    7.28.4.4.1 The wcscmp function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int wcscmp(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcscmp function compares the wide string pointed to by s1 to the wide string
+    pointed to by s2.
+<b>    Returns</b>
+3   The wcscmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+    wide string pointed to by s2.
+<a name="7.28.4.4.2" href="#7.28.4.4.2"><b>    7.28.4.4.2 The wcscoll function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int wcscoll(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcscoll function compares the wide string pointed to by s1 to the wide string
+    pointed to by s2, both interpreted as appropriate to the LC_COLLATE category of the
+    current locale.
+<b>    Returns</b>
+3   The wcscoll function returns an integer greater than, equal to, or less than zero,
+    accordingly as the wide string pointed to by s1 is greater than, equal to, or less than the
+
+
+    <sup><a name="note334" href="#note334"><b>334)</b></a></sup> Thus, the maximum number of wide characters that can end up in the array pointed to by s1 is
+         wcslen(s1)+n+1.
+
+[<a name="p430" href="#p430">page 430</a>] (<a href="#Contents">Contents</a>)
+
+    wide string pointed to by s2 when both are interpreted as appropriate to the current
+    locale.
+<a name="7.28.4.4.3" href="#7.28.4.4.3"><b>    7.28.4.4.3 The wcsncmp function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+                 size_t n);
+<b>    Description</b>
+2   The wcsncmp function compares not more than n wide characters (those that follow a
+    null wide character are not compared) from the array pointed to by s1 to the array
+    pointed to by s2.
+<b>    Returns</b>
+3   The wcsncmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the possibly null-terminated array pointed to by s1 is greater than, equal
+    to, or less than the possibly null-terminated array pointed to by s2.
+<a name="7.28.4.4.4" href="#7.28.4.4.4"><b>    7.28.4.4.4 The wcsxfrm function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            size_t wcsxfrm(wchar_t * restrict s1,
+                 const wchar_t * restrict s2,
+                 size_t n);
+<b>    Description</b>
+2   The wcsxfrm function transforms the wide string pointed to by s2 and places the
+    resulting wide string into the array pointed to by s1. The transformation is such that if
+    the wcscmp function is applied to two transformed wide strings, it returns a value greater
+    than, equal to, or less than zero, corresponding to the result of the wcscoll function
+    applied to the same two original wide strings. No more than n wide characters are placed
+    into the resulting array pointed to by s1, including the terminating null wide character. If
+    n is zero, s1 is permitted to be a null pointer.
+<b>    Returns</b>
+3   The wcsxfrm function returns the length of the transformed wide string (not including
+    the terminating null wide character). If the value returned is n or greater, the contents of
+    the array pointed to by s1 are indeterminate.
+4   EXAMPLE The value of the following expression is the length of the array needed to hold the
+    transformation of the wide string pointed to by s:
+
+[<a name="p431" href="#p431">page 431</a>] (<a href="#Contents">Contents</a>)
+
+           1 + wcsxfrm(NULL, s, 0)
+
+<a name="7.28.4.4.5" href="#7.28.4.4.5"><b>    7.28.4.4.5 The wmemcmp function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           int wmemcmp(const wchar_t *s1, const wchar_t *s2,
+                size_t n);
+<b>    Description</b>
+2   The wmemcmp function compares the first n wide characters of the object pointed to by
+    s1 to the first n wide characters of the object pointed to by s2.
+<b>    Returns</b>
+3   The wmemcmp function returns an integer greater than, equal to, or less than zero,
+    accordingly as the object pointed to by s1 is greater than, equal to, or less than the object
+    pointed to by s2.
+<a name="7.28.4.5" href="#7.28.4.5"><b>    7.28.4.5 Wide string search functions</b></a>
+<a name="7.28.4.5.1" href="#7.28.4.5.1"><b>    7.28.4.5.1 The wcschr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           wchar_t *wcschr(const wchar_t *s, wchar_t c);
+<b>    Description</b>
+2   The wcschr function locates the first occurrence of c in the wide string pointed to by s.
+    The terminating null wide character is considered to be part of the wide string.
+<b>    Returns</b>
+3   The wcschr function returns a pointer to the located wide character, or a null pointer if
+    the wide character does not occur in the wide string.
+<a name="7.28.4.5.2" href="#7.28.4.5.2"><b>    7.28.4.5.2 The wcscspn function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcscspn function computes the length of the maximum initial segment of the wide
+    string pointed to by s1 which consists entirely of wide characters not from the wide
+    string pointed to by s2.
+
+[<a name="p432" href="#p432">page 432</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The wcscspn function returns the length of the segment.
+<a name="7.28.4.5.3" href="#7.28.4.5.3"><b>    7.28.4.5.3 The wcspbrk function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcspbrk function locates the first occurrence in the wide string pointed to by s1 of
+    any wide character from the wide string pointed to by s2.
+<b>    Returns</b>
+3   The wcspbrk function returns a pointer to the wide character in s1, or a null pointer if
+    no wide character from s2 occurs in s1.
+<a name="7.28.4.5.4" href="#7.28.4.5.4"><b>    7.28.4.5.4 The wcsrchr function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
+<b>    Description</b>
+2   The wcsrchr function locates the last occurrence of c in the wide string pointed to by
+    s. The terminating null wide character is considered to be part of the wide string.
+<b>    Returns</b>
+3   The wcsrchr function returns a pointer to the wide character, or a null pointer if c does
+    not occur in the wide string.
+<a name="7.28.4.5.5" href="#7.28.4.5.5"><b>    7.28.4.5.5 The wcsspn function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcsspn function computes the length of the maximum initial segment of the wide
+    string pointed to by s1 which consists entirely of wide characters from the wide string
+    pointed to by s2.
+<b>    Returns</b>
+3   The wcsspn function returns the length of the segment.
+
+[<a name="p433" href="#p433">page 433</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.4.5.6" href="#7.28.4.5.6"><b>    7.28.4.5.6 The wcsstr function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
+<b>    Description</b>
+2   The wcsstr function locates the first occurrence in the wide string pointed to by s1 of
+    the sequence of wide characters (excluding the terminating null wide character) in the
+    wide string pointed to by s2.
+<b>    Returns</b>
+3   The wcsstr function returns a pointer to the located wide string, or a null pointer if the
+    wide string is not found. If s2 points to a wide string with zero length, the function
+    returns s1.
+<a name="7.28.4.5.7" href="#7.28.4.5.7"><b>    7.28.4.5.7 The wcstok function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           wchar_t *wcstok(wchar_t * restrict s1,
+                const wchar_t * restrict s2,
+                wchar_t ** restrict ptr);
+<b>    Description</b>
+2   A sequence of calls to the wcstok function breaks the wide string pointed to by s1 into
+    a sequence of tokens, each of which is delimited by a wide character from the wide string
+    pointed to by s2. The third argument points to a caller-provided wchar_t pointer into
+    which the wcstok function stores information necessary for it to continue scanning the
+    same wide string.
+3   The first call in a sequence has a non-null first argument and stores an initial value in the
+    object pointed to by ptr. Subsequent calls in the sequence have a null first argument and
+    the object pointed to by ptr is required to have the value stored by the previous call in
+    the sequence, which is then updated. The separator wide string pointed to by s2 may be
+    different from call to call.
+4   The first call in the sequence searches the wide string pointed to by s1 for the first wide
+    character that is not contained in the current separator wide string pointed to by s2. If no
+    such wide character is found, then there are no tokens in the wide string pointed to by s1
+    and the wcstok function returns a null pointer. If such a wide character is found, it is
+    the start of the first token.
+5   The wcstok function then searches from there for a wide character that is contained in
+    the current separator wide string. If no such wide character is found, the current token
+
+[<a name="p434" href="#p434">page 434</a>] (<a href="#Contents">Contents</a>)
+
+    extends to the end of the wide string pointed to by s1, and subsequent searches in the
+    same wide string for a token return a null pointer. If such a wide character is found, it is
+    overwritten by a null wide character, which terminates the current token.
+6   In all cases, the wcstok function stores sufficient information in the pointer pointed to
+    by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+    value for ptr, shall start searching just past the element overwritten by a null wide
+    character (if any).
+<b>    Returns</b>
+7   The wcstok function returns a pointer to the first wide character of a token, or a null
+    pointer if there is no token.
+8   EXAMPLE
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            static wchar_t str1[] = L"?a???b,,,#c";
+            static wchar_t str2[] = L"\t \t";
+            wchar_t *t, *ptr1, *ptr2;
+            t   =   wcstok(str1,   L"?", &amp;ptr1);         //   t   points to the token L"a"
+            t   =   wcstok(NULL,   L",", &amp;ptr1);         //   t   points to the token L"??b"
+            t   =   wcstok(str2,   L" \t", &amp;ptr2);       //   t   is a null pointer
+            t   =   wcstok(NULL,   L"#,", &amp;ptr1);        //   t   points to the token L"c"
+            t   =   wcstok(NULL,   L"?", &amp;ptr1);         //   t   is a null pointer
+
+<a name="7.28.4.5.8" href="#7.28.4.5.8"><b>    7.28.4.5.8 The wmemchr function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wmemchr(const wchar_t *s, wchar_t c,
+                 size_t n);
+<b>    Description</b>
+2   The wmemchr function locates the first occurrence of c in the initial n wide characters of
+    the object pointed to by s.
+<b>    Returns</b>
+3   The wmemchr function returns a pointer to the located wide character, or a null pointer if
+    the wide character does not occur in the object.
+
+[<a name="p435" href="#p435">page 435</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.4.6" href="#7.28.4.6"><b>    7.28.4.6 Miscellaneous functions</b></a>
+<a name="7.28.4.6.1" href="#7.28.4.6.1"><b>    7.28.4.6.1 The wcslen function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           size_t wcslen(const wchar_t *s);
+<b>    Description</b>
+2   The wcslen function computes the length of the wide string pointed to by s.
+<b>    Returns</b>
+3   The wcslen function returns the number of wide characters that precede the terminating
+    null wide character.
+<a name="7.28.4.6.2" href="#7.28.4.6.2"><b>    7.28.4.6.2 The wmemset function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
+<b>    Description</b>
+2   The wmemset function copies the value of c into each of the first n wide characters of
+    the object pointed to by s.
+<b>    Returns</b>
+3   The wmemset function returns the value of s.
+<a name="7.28.5" href="#7.28.5"><b>    7.28.5 Wide character time conversion functions</b></a>
+<a name="7.28.5.1" href="#7.28.5.1"><b>    7.28.5.1 The wcsftime function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.26">&lt;time.h&gt;</a>
+           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           size_t wcsftime(wchar_t * restrict s,
+                size_t maxsize,
+                const wchar_t * restrict format,
+                const struct tm * restrict timeptr);
+<b>    Description</b>
+2   The wcsftime function is equivalent to the strftime function, except that:
+    -- The argument s points to the initial element of an array of wide characters into which
+      the generated output is to be placed.
+
+[<a name="p436" href="#p436">page 436</a>] (<a href="#Contents">Contents</a>)
+
+    -- The argument maxsize indicates the limiting number of wide characters.
+    -- The argument format is a wide string and the conversion specifiers are replaced by
+      corresponding sequences of wide characters.
+    -- The return value indicates the number of wide characters.
+<b>    Returns</b>
+3   If the total number of resulting wide characters including the terminating null wide
+    character is not more than maxsize, the wcsftime function returns the number of
+    wide characters placed into the array pointed to by s not including the terminating null
+    wide character. Otherwise, zero is returned and the contents of the array are
+    indeterminate.
+<a name="7.28.6" href="#7.28.6"><b>    7.28.6 Extended multibyte/wide character conversion utilities</b></a>
+1   The header <a href="#7.28">&lt;wchar.h&gt;</a> declares an extended set of functions useful for conversion
+    between multibyte characters and wide characters.
+2   Most of the following functions -- those that are listed as ''restartable'', <a href="#7.28.6.3">7.28.6.3</a> and
+    <a href="#7.28.6.4">7.28.6.4</a> -- take as a last argument a pointer to an object of type mbstate_t that is used
+    to describe the current conversion state from a particular multibyte character sequence to
+    a wide character sequence (or the reverse) under the rules of a particular setting for the
+    LC_CTYPE category of the current locale.
+3   The initial conversion state corresponds, for a conversion in either direction, to the
+    beginning of a new multibyte character in the initial shift state. A zero-valued
+    mbstate_t object is (at least) one way to describe an initial conversion state. A zero-
+    valued mbstate_t object can be used to initiate conversion involving any multibyte
+    character sequence, in any LC_CTYPE category setting. If an mbstate_t object has
+    been altered by any of the functions described in this subclause, and is then used with a
+    different multibyte character sequence, or in the other conversion direction, or with a
+    different LC_CTYPE category setting than on earlier function calls, the behavior is
+    undefined.<sup><a href="#note335"><b>335)</b></a></sup>
+4   On entry, each function takes the described conversion state (either internal or pointed to
+    by an argument) as current. The conversion state described by the referenced object is
+    altered as needed to track the shift state, and the position within a multibyte character, for
+    the associated multibyte character sequence.
+
+
+
+
+    <sup><a name="note335" href="#note335"><b>335)</b></a></sup> Thus, a particular mbstate_t object can be used, for example, with both the mbrtowc and
+         mbsrtowcs functions as long as they are used to step sequentially through the same multibyte
+         character string.
+
+[<a name="p437" href="#p437">page 437</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.6.1" href="#7.28.6.1"><b>    7.28.6.1 Single-byte/wide character conversion functions</b></a>
+<a name="7.28.6.1.1" href="#7.28.6.1.1"><b>    7.28.6.1.1 The btowc function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>                                                                        *
+           wint_t btowc(int c);
+<b>    Description</b>
+2   The btowc function determines whether c constitutes a valid single-byte character in the
+    initial shift state.
+<b>    Returns</b>
+3   The btowc function returns WEOF if c has the value EOF or if (unsigned char)c
+    does not constitute a valid single-byte character in the initial shift state. Otherwise, it
+    returns the wide character representation of that character.
+<a name="7.28.6.1.2" href="#7.28.6.1.2"><b>    7.28.6.1.2 The wctob function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>                                                                        *
+           int wctob(wint_t c);
+<b>    Description</b>
+2   The wctob function determines whether c corresponds to a member of the extended
+    character set whose multibyte character representation is a single byte when in the initial
+    shift state.
+<b>    Returns</b>
+3   The wctob function returns EOF if c does not correspond to a multibyte character with
+    length one in the initial shift state. Otherwise, it returns the single-byte representation of
+    that character as an unsigned char converted to an int.
+<a name="7.28.6.2" href="#7.28.6.2"><b>    7.28.6.2 Conversion state functions</b></a>
+<a name="7.28.6.2.1" href="#7.28.6.2.1"><b>    7.28.6.2.1 The mbsinit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           int mbsinit(const mbstate_t *ps);
+<b>    Description</b>
+2   If ps is not a null pointer, the mbsinit function determines whether the referenced
+    mbstate_t object describes an initial conversion state.
+
+[<a name="p438" href="#p438">page 438</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+3   The mbsinit function returns nonzero if ps is a null pointer or if the referenced object
+    describes an initial conversion state; otherwise, it returns zero.
+<a name="7.28.6.3" href="#7.28.6.3"><b>    7.28.6.3 Restartable multibyte/wide character conversion functions</b></a>
+1   These functions differ from the corresponding multibyte character functions of <a href="#7.22.7">7.22.7</a>
+    (mblen, mbtowc, and wctomb) in that they have an extra parameter, ps, of type
+    pointer to mbstate_t that points to an object that can completely describe the current
+    conversion state of the associated multibyte character sequence. If ps is a null pointer,
+    each function uses its own internal mbstate_t object instead, which is initialized at
+    program startup to the initial conversion state; the functions are not required to avoid data
+    races in this case. The implementation behaves as if no library function calls these
+    functions with a null pointer for ps.
+2   Also unlike their corresponding functions, the return value does not represent whether the
+    encoding is state-dependent.
+<a name="7.28.6.3.1" href="#7.28.6.3.1"><b>    7.28.6.3.1 The mbrlen function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            size_t mbrlen(const char * restrict s,
+                 size_t n,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   The mbrlen function is equivalent to the call:
+            mbrtowc(NULL, s, n, ps != NULL ? ps : &amp;internal)
+    where internal is the mbstate_t object for the mbrlen function, except that the
+    expression designated by ps is evaluated only once.
+<b>    Returns</b>
+3   The mbrlen function returns a value between zero and n, inclusive, (size_t)(-2),
+    or (size_t)(-1).
+    Forward references: the mbrtowc function (<a href="#7.28.6.3.2">7.28.6.3.2</a>).
+
+[<a name="p439" href="#p439">page 439</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.6.3.2" href="#7.28.6.3.2"><b>    7.28.6.3.2 The mbrtowc function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            size_t mbrtowc(wchar_t * restrict pwc,
+                 const char * restrict s,
+                 size_t n,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the mbrtowc function is equivalent to the call:
+                    mbrtowc(NULL, "", 1, ps)
+    In this case, the values of the parameters pwc and n are ignored.
+3   If s is not a null pointer, the mbrtowc function inspects at most n bytes beginning with
+    the byte pointed to by s to determine the number of bytes needed to complete the next
+    multibyte character (including any shift sequences). If the function determines that the
+    next multibyte character is complete and valid, it determines the value of the
+    corresponding wide character and then, if pwc is not a null pointer, stores that value in
+    the object pointed to by pwc. If the corresponding wide character is the null wide
+    character, the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The mbrtowc function returns the first of the following that applies (given the current
+    conversion state):
+    0                     if the next n or fewer bytes complete the multibyte character that
+                          corresponds to the null wide character (which is the value stored).
+    between 1 and n inclusive if the next n or fewer bytes complete a valid multibyte
+                       character (which is the value stored); the value returned is the number
+                       of bytes that complete the multibyte character.
+    (size_t)(-2) if the next n bytes contribute to an incomplete (but potentially valid)
+                 multibyte character, and all n bytes have been processed (no value is
+                 stored).<sup><a href="#note336"><b>336)</b></a></sup>
+    (size_t)(-1) if an encoding error occurs, in which case the next n or fewer bytes
+                 do not contribute to a complete and valid multibyte character (no
+                 value is stored); the value of the macro EILSEQ is stored in errno,
+                 and the conversion state is unspecified.
+
+    <sup><a name="note336" href="#note336"><b>336)</b></a></sup> When n has at least the value of the MB_CUR_MAX macro, this case can only occur if s points at a
+         sequence of redundant shift sequences (for implementations with state-dependent encodings).
+
+[<a name="p440" href="#p440">page 440</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.6.3.3" href="#7.28.6.3.3"><b>    7.28.6.3.3 The wcrtomb function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            size_t wcrtomb(char * restrict s,
+                 wchar_t wc,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   If s is a null pointer, the wcrtomb function is equivalent to the call
+                    wcrtomb(buf, L'\0', ps)
+    where buf is an internal buffer.
+3   If s is not a null pointer, the wcrtomb function determines the number of bytes needed
+    to represent the multibyte character that corresponds to the wide character given by wc
+    (including any shift sequences), and stores the multibyte character representation in the
+    array whose first element is pointed to by s. At most MB_CUR_MAX bytes are stored. If
+    wc is a null wide character, a null byte is stored, preceded by any shift sequence needed
+    to restore the initial shift state; the resulting state described is the initial conversion state.
+<b>    Returns</b>
+4   The wcrtomb function returns the number of bytes stored in the array object (including
+    any shift sequences). When wc is not a valid wide character, an encoding error occurs:
+    the function stores the value of the macro EILSEQ in errno and returns
+    (size_t)(-1); the conversion state is unspecified.
+<a name="7.28.6.4" href="#7.28.6.4"><b>    7.28.6.4 Restartable multibyte/wide string conversion functions</b></a>
+1   These functions differ from the corresponding multibyte string functions of <a href="#7.22.8">7.22.8</a>
+    (mbstowcs and wcstombs) in that they have an extra parameter, ps, of type pointer to
+    mbstate_t that points to an object that can completely describe the current conversion
+    state of the associated multibyte character sequence. If ps is a null pointer, each function
+    uses its own internal mbstate_t object instead, which is initialized at program startup
+    to the initial conversion state; the functions are not required to avoid data races in this
+    case. The implementation behaves as if no library function calls these functions with a
+    null pointer for ps.
+2   Also unlike their corresponding functions, the conversion source parameter, src, has a
+    pointer-to-pointer type. When the function is storing the results of conversions (that is,
+    when dst is not a null pointer), the pointer object pointed to by this parameter is updated
+    to reflect the amount of the source processed by that invocation.
+
+[<a name="p441" href="#p441">page 441</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.6.4.1" href="#7.28.6.4.1"><b>    7.28.6.4.1 The mbsrtowcs function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             size_t mbsrtowcs(wchar_t * restrict dst,
+                  const char ** restrict src,
+                  size_t len,
+                  mbstate_t * restrict ps);
+<b>    Description</b>
+2   The mbsrtowcs function converts a sequence of multibyte characters that begins in the
+    conversion state described by the object pointed to by ps, from the array indirectly
+    pointed to by src into a sequence of corresponding wide characters. If dst is not a null
+    pointer, the converted characters are stored into the array pointed to by dst. Conversion
+    continues up to and including a terminating null character, which is also stored.
+    Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
+    not form a valid multibyte character, or (if dst is not a null pointer) when len wide
+    characters have been stored into the array pointed to by dst.<sup><a href="#note337"><b>337)</b></a></sup> Each conversion takes
+    place as if by a call to the mbrtowc function.
+3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+    pointer (if conversion stopped due to reaching a terminating null character) or the address
+    just past the last multibyte character converted (if any). If conversion stopped due to
+    reaching a terminating null character and if dst is not a null pointer, the resulting state
+    described is the initial conversion state.
+<b>    Returns</b>
+4   If the input conversion encounters a sequence of bytes that do not form a valid multibyte
+    character, an encoding error occurs: the mbsrtowcs function stores the value of the
+    macro EILSEQ in errno and returns (size_t)(-1); the conversion state is
+    unspecified. Otherwise, it returns the number of multibyte characters successfully
+    converted, not including the terminating null character (if any).
+
+
+
+
+    <sup><a name="note337" href="#note337"><b>337)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
+
+[<a name="p442" href="#p442">page 442</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.28.6.4.2" href="#7.28.6.4.2"><b>    7.28.6.4.2 The wcsrtombs function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            size_t wcsrtombs(char * restrict dst,
+                 const wchar_t ** restrict src,
+                 size_t len,
+                 mbstate_t * restrict ps);
+<b>    Description</b>
+2   The wcsrtombs function converts a sequence of wide characters from the array
+    indirectly pointed to by src into a sequence of corresponding multibyte characters that
+    begins in the conversion state described by the object pointed to by ps. If dst is not a
+    null pointer, the converted characters are then stored into the array pointed to by dst.
+    Conversion continues up to and including a terminating null wide character, which is also
+    stored. Conversion stops earlier in two cases: when a wide character is reached that does
+    not correspond to a valid multibyte character, or (if dst is not a null pointer) when the
+    next multibyte character would exceed the limit of len total bytes to be stored into the
+    array pointed to by dst. Each conversion takes place as if by a call to the wcrtomb
+    function.<sup><a href="#note338"><b>338)</b></a></sup>
+3   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+    pointer (if conversion stopped due to reaching a terminating null wide character) or the
+    address just past the last wide character converted (if any). If conversion stopped due to
+    reaching a terminating null wide character, the resulting state described is the initial
+    conversion state.
+<b>    Returns</b>
+4   If conversion stops because a wide character is reached that does not correspond to a
+    valid multibyte character, an encoding error occurs: the wcsrtombs function stores the
+    value of the macro EILSEQ in errno and returns (size_t)(-1); the conversion
+    state is unspecified. Otherwise, it returns the number of bytes in the resulting multibyte
+    character sequence, not including the terminating null character (if any).
+
+
+
+
+    <sup><a name="note338" href="#note338"><b>338)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
+         include those necessary to reach the initial shift state immediately before the null byte.
+
+[<a name="p443" href="#p443">page 443</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.29" href="#7.29"><b>    7.29 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
+<a name="7.29.1" href="#7.29.1"><b>    7.29.1 Introduction</b></a>
+1   The header <a href="#7.29">&lt;wctype.h&gt;</a> defines one macro, and declares three data types and many
+    functions.<sup><a href="#note339"><b>339)</b></a></sup>
+2   The types declared are
+             wint_t
+    described in <a href="#7.28.1">7.28.1</a>;
+             wctrans_t
+    which is a scalar type that can hold values which represent locale-specific character
+    mappings; and
+             wctype_t
+    which is a scalar type that can hold values which represent locale-specific character
+    classifications.
+3   The macro defined is WEOF (described in <a href="#7.28.1">7.28.1</a>).
+4   The functions declared are grouped as follows:
+    -- Functions that provide wide character classification;
+    -- Extensible functions that provide wide character classification;
+    -- Functions that provide wide character case mapping;
+    -- Extensible functions that provide wide character mapping.
+5   For all functions described in this subclause that accept an argument of type wint_t, the
+    value shall be representable as a wchar_t or shall equal the value of the macro WEOF. If
+    this argument has any other value, the behavior is undefined.
+6   The behavior of these functions is affected by the LC_CTYPE category of the current
+    locale.
+
+
+
+
+    <sup><a name="note339" href="#note339"><b>339)</b></a></sup> See ''future library directions'' (<a href="#7.30.13">7.30.13</a>).
+
+[<a name="p444" href="#p444">page 444</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.29.2" href="#7.29.2"><b>    7.29.2 Wide character classification utilities</b></a>
+1   The header <a href="#7.29">&lt;wctype.h&gt;</a> declares several functions useful for classifying wide
+    characters.
+2   The term printing wide character refers to a member of a locale-specific set of wide
+    characters, each of which occupies at least one printing position on a display device. The
+    term control wide character refers to a member of a locale-specific set of wide characters
+    that are not printing wide characters.
+<a name="7.29.2.1" href="#7.29.2.1"><b>    7.29.2.1 Wide character classification functions</b></a>
+1   The functions in this subclause return nonzero (true) if and only if the value of the
+    argument wc conforms to that in the description of the function.
+2   Each of the following functions returns true for each wide character that corresponds (as
+    if by a call to the wctob function) to a single-byte character for which the corresponding
+    character classification function from <a href="#7.4.1">7.4.1</a> returns true, except that the iswgraph and
+    iswpunct functions may differ with respect to wide characters other than L' ' that are
+    both printing and white-space wide characters.<sup><a href="#note340"><b>340)</b></a></sup>
+    Forward references: the wctob function (<a href="#7.28.6.1.2">7.28.6.1.2</a>).
+<a name="7.29.2.1.1" href="#7.29.2.1.1"><b>    7.29.2.1.1 The iswalnum function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswalnum(wint_t wc);
+<b>    Description</b>
+2   The iswalnum function tests for any wide character for which iswalpha or
+    iswdigit is true.
+<a name="7.29.2.1.2" href="#7.29.2.1.2"><b>    7.29.2.1.2 The iswalpha function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswalpha(wint_t wc);
+<b>    Description</b>
+2   The iswalpha function tests for any wide character for which iswupper or
+    iswlower is true, or any wide character that is one of a locale-specific set of alphabetic
+
+    <sup><a name="note340" href="#note340"><b>340)</b></a></sup> For example, if the expression isalpha(wctob(wc)) evaluates to true, then the call
+         iswalpha(wc) also returns true. But, if the expression isgraph(wctob(wc)) evaluates to true
+         (which cannot occur for wc == L' ' of course), then either iswgraph(wc) or iswprint(wc)
+         &amp;&amp; iswspace(wc) is true, but not both.
+
+[<a name="p445" href="#p445">page 445</a>] (<a href="#Contents">Contents</a>)
+
+    wide characters for which none of iswcntrl, iswdigit, iswpunct, or iswspace
+    is true.<sup><a href="#note341"><b>341)</b></a></sup>
+<a name="7.29.2.1.3" href="#7.29.2.1.3"><b>    7.29.2.1.3 The iswblank function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswblank(wint_t wc);
+<b>    Description</b>
+2   The iswblank function tests for any wide character that is a standard blank wide
+    character or is one of a locale-specific set of wide characters for which iswspace is true
+    and that is used to separate words within a line of text. The standard blank wide
+    characters are the following: space (L' '), and horizontal tab (L'\t'). In the "C"
+    locale, iswblank returns true only for the standard blank characters.
+<a name="7.29.2.1.4" href="#7.29.2.1.4"><b>    7.29.2.1.4 The iswcntrl function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswcntrl(wint_t wc);
+<b>    Description</b>
+2   The iswcntrl function tests for any control wide character.
+<a name="7.29.2.1.5" href="#7.29.2.1.5"><b>    7.29.2.1.5 The iswdigit function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswdigit(wint_t wc);
+<b>    Description</b>
+2   The iswdigit function tests for any wide character that corresponds to a decimal-digit
+    character (as defined in <a href="#5.2.1">5.2.1</a>).
+<a name="7.29.2.1.6" href="#7.29.2.1.6"><b>    7.29.2.1.6 The iswgraph function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswgraph(wint_t wc);
+
+
+
+
+    <sup><a name="note341" href="#note341"><b>341)</b></a></sup> The functions iswlower and iswupper test true or false separately for each of these additional
+         wide characters; all four combinations are possible.
+
+[<a name="p446" href="#p446">page 446</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The iswgraph function tests for any wide character for which iswprint is true and
+    iswspace is false.<sup><a href="#note342"><b>342)</b></a></sup>
+<a name="7.29.2.1.7" href="#7.29.2.1.7"><b>    7.29.2.1.7 The iswlower function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswlower(wint_t wc);
+<b>    Description</b>
+2   The iswlower function tests for any wide character that corresponds to a lowercase
+    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+    iswdigit, iswpunct, or iswspace is true.
+<a name="7.29.2.1.8" href="#7.29.2.1.8"><b>    7.29.2.1.8 The iswprint function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswprint(wint_t wc);
+<b>    Description</b>
+2   The iswprint function tests for any printing wide character.
+<a name="7.29.2.1.9" href="#7.29.2.1.9"><b>    7.29.2.1.9 The iswpunct function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswpunct(wint_t wc);
+<b>    Description</b>
+2   The iswpunct function tests for any printing wide character that is one of a locale-
+    specific set of punctuation wide characters for which neither iswspace nor iswalnum
+    is true.342)
+<a name="7.29.2.1.10" href="#7.29.2.1.10"><b>    7.29.2.1.10 The iswspace function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            int iswspace(wint_t wc);
+
+
+
+    <sup><a name="note342" href="#note342"><b>342)</b></a></sup> Note that the behavior of the iswgraph and iswpunct functions may differ from their
+         corresponding functions in <a href="#7.4.1">7.4.1</a> with respect to printing, white-space, single-byte execution
+         characters other than ' '.
+
+[<a name="p447" href="#p447">page 447</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+2   The iswspace function tests for any wide character that corresponds to a locale-specific
+    set of white-space wide characters for which none of iswalnum, iswgraph, or
+    iswpunct is true.
+<a name="7.29.2.1.11" href="#7.29.2.1.11"><b>    7.29.2.1.11 The iswupper function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
+           int iswupper(wint_t wc);
+<b>    Description</b>
+2   The iswupper function tests for any wide character that corresponds to an uppercase
+    letter or is one of a locale-specific set of wide characters for which none of iswcntrl,
+    iswdigit, iswpunct, or iswspace is true.
+<a name="7.29.2.1.12" href="#7.29.2.1.12"><b>    7.29.2.1.12 The iswxdigit function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
+           int iswxdigit(wint_t wc);
+<b>    Description</b>
+2   The iswxdigit function tests for any wide character that corresponds to a
+    hexadecimal-digit character (as defined in <a href="#6.4.4.1">6.4.4.1</a>).
+<a name="7.29.2.2" href="#7.29.2.2"><b>    7.29.2.2 Extensible wide character classification functions</b></a>
+1   The functions wctype and iswctype provide extensible wide character classification
+    as well as testing equivalent to that performed by the functions described in the previous
+    subclause (<a href="#7.29.2.1">7.29.2.1</a>).
+<a name="7.29.2.2.1" href="#7.29.2.2.1"><b>    7.29.2.2.1 The iswctype function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
+           int iswctype(wint_t wc, wctype_t desc);
+<b>    Description</b>
+2   The iswctype function determines whether the wide character wc has the property
+    described by desc. The current setting of the LC_CTYPE category shall be the same as
+    during the call to wctype that returned the value desc.
+3   Each of the following expressions has a truth-value equivalent to the call to the wide
+    character classification function (<a href="#7.29.2.1">7.29.2.1</a>) in the comment that follows the expression:
+
+[<a name="p448" href="#p448">page 448</a>] (<a href="#Contents">Contents</a>)
+
+            iswctype(wc,      wctype("alnum"))              //   iswalnum(wc)
+            iswctype(wc,      wctype("alpha"))              //   iswalpha(wc)
+            iswctype(wc,      wctype("blank"))              //   iswblank(wc)
+            iswctype(wc,      wctype("cntrl"))              //   iswcntrl(wc)
+            iswctype(wc,      wctype("digit"))              //   iswdigit(wc)
+            iswctype(wc,      wctype("graph"))              //   iswgraph(wc)
+            iswctype(wc,      wctype("lower"))              //   iswlower(wc)
+            iswctype(wc,      wctype("print"))              //   iswprint(wc)
+            iswctype(wc,      wctype("punct"))              //   iswpunct(wc)
+            iswctype(wc,      wctype("space"))              //   iswspace(wc)
+            iswctype(wc,      wctype("upper"))              //   iswupper(wc)
+            iswctype(wc,      wctype("xdigit"))             //   iswxdigit(wc)
+<b>    Returns</b>
+4   The iswctype function returns nonzero (true) if and only if the value of the wide
+    character wc has the property described by desc. If desc is zero, the iswctype
+    function returns zero (false).
+    Forward references: the wctype function (<a href="#7.29.2.2.2">7.29.2.2.2</a>).
+<a name="7.29.2.2.2" href="#7.29.2.2.2"><b>    7.29.2.2.2 The wctype function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            wctype_t wctype(const char *property);
+<b>    Description</b>
+2   The wctype function constructs a value with type wctype_t that describes a class of
+    wide characters identified by the string argument property.
+3   The strings listed in the description of the iswctype function shall be valid in all
+    locales as property arguments to the wctype function.
+<b>    Returns</b>
+4   If property identifies a valid class of wide characters according to the LC_CTYPE
+    category of the current locale, the wctype function returns a nonzero value that is valid
+    as the second argument to the iswctype function; otherwise, it returns zero.
+
+[<a name="p449" href="#p449">page 449</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.29.3" href="#7.29.3"><b>    7.29.3 Wide character case mapping utilities</b></a>
+1   The header <a href="#7.29">&lt;wctype.h&gt;</a> declares several functions useful for mapping wide characters.
+<a name="7.29.3.1" href="#7.29.3.1"><b>    7.29.3.1 Wide character case mapping functions</b></a>
+<a name="7.29.3.1.1" href="#7.29.3.1.1"><b>    7.29.3.1.1 The towlower function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
+           wint_t towlower(wint_t wc);
+<b>    Description</b>
+2   The towlower function converts an uppercase letter to a corresponding lowercase letter.
+<b>    Returns</b>
+3   If the argument is a wide character for which iswupper is true and there are one or
+    more corresponding wide characters, as specified by the current locale, for which
+    iswlower is true, the towlower function returns one of the corresponding wide
+    characters (always the same one for any given locale); otherwise, the argument is
+    returned unchanged.
+<a name="7.29.3.1.2" href="#7.29.3.1.2"><b>    7.29.3.1.2 The towupper function</b></a>
+<b>    Synopsis</b>
+1          #include <a href="#7.29">&lt;wctype.h&gt;</a>
+           wint_t towupper(wint_t wc);
+<b>    Description</b>
+2   The towupper function converts a lowercase letter to a corresponding uppercase letter.
+<b>    Returns</b>
+3   If the argument is a wide character for which iswlower is true and there are one or
+    more corresponding wide characters, as specified by the current locale, for which
+    iswupper is true, the towupper function returns one of the corresponding wide
+    characters (always the same one for any given locale); otherwise, the argument is
+    returned unchanged.
+<a name="7.29.3.2" href="#7.29.3.2"><b>    7.29.3.2 Extensible wide character case mapping functions</b></a>
+1   The functions wctrans and towctrans provide extensible wide character mapping as
+    well as case mapping equivalent to that performed by the functions described in the
+    previous subclause (<a href="#7.29.3.1">7.29.3.1</a>).
+
+[<a name="p450" href="#p450">page 450</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.29.3.2.1" href="#7.29.3.2.1"><b>    7.29.3.2.1 The towctrans function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            wint_t towctrans(wint_t wc, wctrans_t desc);
+<b>    Description</b>
+2   The towctrans function maps the wide character wc using the mapping described by
+    desc. The current setting of the LC_CTYPE category shall be the same as during the call
+    to wctrans that returned the value desc.
+3   Each of the following expressions behaves the same as the call to the wide character case
+    mapping function (<a href="#7.29.3.1">7.29.3.1</a>) in the comment that follows the expression:
+            towctrans(wc, wctrans("tolower"))                     // towlower(wc)
+            towctrans(wc, wctrans("toupper"))                     // towupper(wc)
+<b>    Returns</b>
+4   The towctrans function returns the mapped value of wc using the mapping described
+    by desc. If desc is zero, the towctrans function returns the value of wc.
+<a name="7.29.3.2.2" href="#7.29.3.2.2"><b>    7.29.3.2.2 The wctrans function</b></a>
+<b>    Synopsis</b>
+1           #include <a href="#7.29">&lt;wctype.h&gt;</a>
+            wctrans_t wctrans(const char *property);
+<b>    Description</b>
+2   The wctrans function constructs a value with type wctrans_t that describes a
+    mapping between wide characters identified by the string argument property.
+3   The strings listed in the description of the towctrans function shall be valid in all
+    locales as property arguments to the wctrans function.
+<b>    Returns</b>
+4   If property identifies a valid mapping of wide characters according to the LC_CTYPE
+    category of the current locale, the wctrans function returns a nonzero value that is valid
+    as the second argument to the towctrans function; otherwise, it returns zero.
+
+[<a name="p451" href="#p451">page 451</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.30" href="#7.30"><b>    7.30 Future library directions</b></a>
+1   The following names are grouped under individual headers for convenience. All external
+    names described below are reserved no matter what headers are included by the program.
+<a name="7.30.1" href="#7.30.1"><b>    7.30.1 Complex arithmetic &lt;complex.h&gt;</b></a>
+1   The function names
+          cerf               cexpm1              clog2
+          cerfc              clog10              clgamma
+          cexp2              clog1p              ctgamma
+    and the same names suffixed with f or l may be added to the declarations in the
+    <a href="#7.3">&lt;complex.h&gt;</a> header.
+<a name="7.30.2" href="#7.30.2"><b>    7.30.2 Character handling &lt;ctype.h&gt;</b></a>
+1   Function names that begin with either is or to, and a lowercase letter may be added to
+    the declarations in the <a href="#7.4">&lt;ctype.h&gt;</a> header.
+<a name="7.30.3" href="#7.30.3"><b>    7.30.3 Errors &lt;errno.h&gt;</b></a>
+1   Macros that begin with E and a digit or E and an uppercase letter may be added to the
+    declarations in the <a href="#7.5">&lt;errno.h&gt;</a> header.
+<a name="7.30.4" href="#7.30.4"><b>    7.30.4 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
+1   Macro names beginning with PRI or SCN followed by any lowercase letter or X may be
+    added to the macros defined in the <a href="#7.8">&lt;inttypes.h&gt;</a> header.
+<a name="7.30.5" href="#7.30.5"><b>    7.30.5 Localization &lt;locale.h&gt;</b></a>
+1   Macros that begin with LC_ and an uppercase letter may be added to the definitions in
+    the <a href="#7.11">&lt;locale.h&gt;</a> header.
+<a name="7.30.6" href="#7.30.6"><b>    7.30.6 Signal handling &lt;signal.h&gt;</b></a>
+1   Macros that begin with either SIG and an uppercase letter or SIG_ and an uppercase
+    letter may be added to the definitions in the <a href="#7.14">&lt;signal.h&gt;</a> header.
+<a name="7.30.7" href="#7.30.7"><b>    7.30.7 Boolean type and values &lt;stdbool.h&gt;</b></a>
+1   The ability to undefine and perhaps then redefine the macros bool, true, and false is
+    an obsolescent feature.
+<a name="7.30.8" href="#7.30.8"><b>    7.30.8 Integer types &lt;stdint.h&gt;</b></a>
+1   Typedef names beginning with int or uint and ending with _t may be added to the
+    types defined in the <a href="#7.20">&lt;stdint.h&gt;</a> header. Macro names beginning with INT or UINT
+    and ending with _MAX, _MIN, or _C may be added to the macros defined in the
+    <a href="#7.20">&lt;stdint.h&gt;</a> header.
+
+[<a name="p452" href="#p452">page 452</a>] (<a href="#Contents">Contents</a>)
+
+<a name="7.30.9" href="#7.30.9"><b>    7.30.9 Input/output &lt;stdio.h&gt;</b></a>
+1   Lowercase letters may be added to the conversion specifiers and length modifiers in
+    fprintf and fscanf. Other characters may be used in extensions.
+2   The use of ungetc on a binary stream where the file position indicator is zero prior to *
+    the call is an obsolescent feature.
+<a name="7.30.10" href="#7.30.10"><b>    7.30.10 General utilities &lt;stdlib.h&gt;</b></a>
+1   Function names that begin with str and a lowercase letter may be added to the
+    declarations in the <a href="#7.22">&lt;stdlib.h&gt;</a> header.
+<a name="7.30.11" href="#7.30.11"><b>    7.30.11 String handling &lt;string.h&gt;</b></a>
+1   Function names that begin with str, mem, or wcs and a lowercase letter may be added
+    to the declarations in the <a href="#7.23">&lt;string.h&gt;</a> header.
+<a name="7.30.12" href="#7.30.12"><b>    7.30.12 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
+1   Function names that begin with wcs and a lowercase letter may be added to the
+    declarations in the <a href="#7.28">&lt;wchar.h&gt;</a> header.
+2   Lowercase letters may be added to the conversion specifiers and length modifiers in
+    fwprintf and fwscanf. Other characters may be used in extensions.
+<a name="7.30.13" href="#7.30.13"><b>    7.30.13 Wide character classification and mapping utilities</b></a>
+    <a href="#7.29">&lt;wctype.h&gt;</a>
+1   Function names that begin with is or to and a lowercase letter may be added to the
+    declarations in the <a href="#7.29">&lt;wctype.h&gt;</a> header.
+
+[<a name="p453" href="#p453">page 453</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A" href="#A"><b>                                                 Annex A</b></a>
+                                               (informative)
+                                Language syntax summary
+1   NOTE   The notation is described in <a href="#6.1">6.1</a>.
+
+<a name="A.1" href="#A.1"><b>    A.1 Lexical grammar</b></a>
+<a name="A.1.1" href="#A.1.1"><b>    A.1.1 Lexical elements</b></a>
+    (<a href="#6.4">6.4</a>) token:
+                   keyword
+                   identifier
+                   constant
+                   string-literal
+                   punctuator
+    (<a href="#6.4">6.4</a>) preprocessing-token:
+                  header-name
+                  identifier
+                  pp-number
+                  character-constant
+                  string-literal
+                  punctuator
+                  each non-white-space character that cannot be one of the above
+
+[<a name="p454" href="#p454">page 454</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.1.2" href="#A.1.2"><b>A.1.2 Keywords</b></a>
+(<a href="#6.4.1">6.4.1</a>) keyword: one of
+              alignof                     goto                  union
+              auto                        if                    unsigned
+              break                       inline                void
+              case                        int                   volatile
+              char                        long                  while
+              const                       register              _Alignas
+              continue                    restrict              _Atomic
+              default                     return                _Bool
+              do                          short                 _Complex
+              double                      signed                _Generic
+              else                        sizeof                _Imaginary
+              enum                        static                _Noreturn
+              extern                      struct                _Static_assert
+              float                       switch                _Thread_local
+              for                         typedef
+<a name="A.1.3" href="#A.1.3"><b>A.1.3 Identifiers</b></a>
+(<a href="#6.4.2.1">6.4.2.1</a>) identifier:
+               identifier-nondigit
+               identifier identifier-nondigit
+               identifier digit
+(<a href="#6.4.2.1">6.4.2.1</a>) identifier-nondigit:
+               nondigit
+               universal-character-name
+               other implementation-defined characters
+(<a href="#6.4.2.1">6.4.2.1</a>) nondigit: one of
+              _ a b          c    d   e    f   g   h    i   j   k   l   m
+                   n o       p    q   r    s   t   u    v   w   x   y   z
+                   A B       C    D   E    F   G   H    I   J   K   L   M
+                   N O       P    Q   R    S   T   U    V   W   X   Y   Z
+(<a href="#6.4.2.1">6.4.2.1</a>) digit: one of
+               0 1 2         3    4   5    6   7   8    9
+
+[<a name="p455" href="#p455">page 455</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.1.4" href="#A.1.4"><b>A.1.4 Universal character names</b></a>
+(<a href="#6.4.3">6.4.3</a>) universal-character-name:
+              \u hex-quad
+              \U hex-quad hex-quad
+(<a href="#6.4.3">6.4.3</a>) hex-quad:
+              hexadecimal-digit hexadecimal-digit
+                           hexadecimal-digit hexadecimal-digit
+<a name="A.1.5" href="#A.1.5"><b>A.1.5 Constants</b></a>
+(<a href="#6.4.4">6.4.4</a>) constant:
+              integer-constant
+              floating-constant
+              enumeration-constant
+              character-constant
+(<a href="#6.4.4.1">6.4.4.1</a>) integer-constant:
+               decimal-constant integer-suffixopt
+               octal-constant integer-suffixopt
+               hexadecimal-constant integer-suffixopt
+(<a href="#6.4.4.1">6.4.4.1</a>) decimal-constant:
+              nonzero-digit
+              decimal-constant digit
+(<a href="#6.4.4.1">6.4.4.1</a>) octal-constant:
+               0
+               octal-constant octal-digit
+(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-constant:
+              hexadecimal-prefix hexadecimal-digit
+              hexadecimal-constant hexadecimal-digit
+(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-prefix: one of
+              0x 0X
+(<a href="#6.4.4.1">6.4.4.1</a>) nonzero-digit: one of
+              1 2 3 4 5              6      7   8   9
+(<a href="#6.4.4.1">6.4.4.1</a>) octal-digit: one of
+               0 1 2 3           4   5      6   7
+
+[<a name="p456" href="#p456">page 456</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.4.4.1">6.4.4.1</a>) hexadecimal-digit: one of
+              0 1 2 3 4 5                6    7    8   9
+              a b c d e f
+              A B C D E F
+(<a href="#6.4.4.1">6.4.4.1</a>) integer-suffix:
+               unsigned-suffix long-suffixopt
+               unsigned-suffix long-long-suffix
+               long-suffix unsigned-suffixopt
+               long-long-suffix unsigned-suffixopt
+(<a href="#6.4.4.1">6.4.4.1</a>) unsigned-suffix: one of
+               u U
+(<a href="#6.4.4.1">6.4.4.1</a>) long-suffix: one of
+               l L
+(<a href="#6.4.4.1">6.4.4.1</a>) long-long-suffix: one of
+               ll LL
+(<a href="#6.4.4.2">6.4.4.2</a>) floating-constant:
+               decimal-floating-constant
+               hexadecimal-floating-constant
+(<a href="#6.4.4.2">6.4.4.2</a>) decimal-floating-constant:
+              fractional-constant exponent-partopt floating-suffixopt
+              digit-sequence exponent-part floating-suffixopt
+(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-floating-constant:
+              hexadecimal-prefix hexadecimal-fractional-constant
+                            binary-exponent-part floating-suffixopt
+              hexadecimal-prefix hexadecimal-digit-sequence
+                            binary-exponent-part floating-suffixopt
+(<a href="#6.4.4.2">6.4.4.2</a>) fractional-constant:
+               digit-sequenceopt . digit-sequence
+               digit-sequence .
+(<a href="#6.4.4.2">6.4.4.2</a>) exponent-part:
+              e signopt digit-sequence
+              E signopt digit-sequence
+(<a href="#6.4.4.2">6.4.4.2</a>) sign: one of
+               + -
+
+[<a name="p457" href="#p457">page 457</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.4.4.2">6.4.4.2</a>) digit-sequence:
+               digit
+               digit-sequence digit
+(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-fractional-constant:
+              hexadecimal-digit-sequenceopt .
+                             hexadecimal-digit-sequence
+              hexadecimal-digit-sequence .
+(<a href="#6.4.4.2">6.4.4.2</a>) binary-exponent-part:
+               p signopt digit-sequence
+               P signopt digit-sequence
+(<a href="#6.4.4.2">6.4.4.2</a>) hexadecimal-digit-sequence:
+              hexadecimal-digit
+              hexadecimal-digit-sequence hexadecimal-digit
+(<a href="#6.4.4.2">6.4.4.2</a>) floating-suffix: one of
+               f l F L
+(<a href="#6.4.4.3">6.4.4.3</a>) enumeration-constant:
+              identifier
+(<a href="#6.4.4.4">6.4.4.4</a>) character-constant:
+              ' c-char-sequence '
+              L' c-char-sequence '
+              u' c-char-sequence '
+              U' c-char-sequence '
+(<a href="#6.4.4.4">6.4.4.4</a>) c-char-sequence:
+               c-char
+               c-char-sequence c-char
+(<a href="#6.4.4.4">6.4.4.4</a>) c-char:
+               any member of the source character set except
+                            the single-quote ', backslash \, or new-line character
+               escape-sequence
+(<a href="#6.4.4.4">6.4.4.4</a>) escape-sequence:
+              simple-escape-sequence
+              octal-escape-sequence
+              hexadecimal-escape-sequence
+              universal-character-name
+
+[<a name="p458" href="#p458">page 458</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.4.4.4">6.4.4.4</a>) simple-escape-sequence: one of
+              \' \" \? \\
+              \a \b \f \n \r \t                   \v
+(<a href="#6.4.4.4">6.4.4.4</a>) octal-escape-sequence:
+               \ octal-digit
+               \ octal-digit octal-digit
+               \ octal-digit octal-digit octal-digit
+(<a href="#6.4.4.4">6.4.4.4</a>) hexadecimal-escape-sequence:
+              \x hexadecimal-digit
+              hexadecimal-escape-sequence hexadecimal-digit
+<a name="A.1.6" href="#A.1.6"><b>A.1.6 String literals</b></a>
+(<a href="#6.4.5">6.4.5</a>) string-literal:
+               encoding-prefixopt " s-char-sequenceopt "
+(<a href="#6.4.5">6.4.5</a>) encoding-prefix:
+              u8
+              u
+              U
+              L
+(<a href="#6.4.5">6.4.5</a>) s-char-sequence:
+               s-char
+               s-char-sequence s-char
+(<a href="#6.4.5">6.4.5</a>) s-char:
+               any member of the source character set except
+                            the double-quote ", backslash \, or new-line character
+               escape-sequence
+<a name="A.1.7" href="#A.1.7"><b>A.1.7 Punctuators</b></a>
+(<a href="#6.4.6">6.4.6</a>) punctuator: one of
+              [ ] ( ) { } . -&gt;
+              ++ -- &amp; * + - ~ !
+              / % &lt;&lt; &gt;&gt; &lt; &gt; &lt;= &gt;=                      ==    !=    ^    |   &amp;&amp;   ||
+              ? : ; ...
+              = *= /= %= += -= &lt;&lt;=                     &gt;&gt;=    &amp;=       ^=   |=
+              , # ##
+              &lt;: :&gt; &lt;% %&gt; %: %:%:
+
+[<a name="p459" href="#p459">page 459</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.1.8" href="#A.1.8"><b>A.1.8 Header names</b></a>
+(<a href="#6.4.7">6.4.7</a>) header-name:
+              &lt; h-char-sequence &gt;
+              " q-char-sequence "
+(<a href="#6.4.7">6.4.7</a>) h-char-sequence:
+              h-char
+              h-char-sequence h-char
+(<a href="#6.4.7">6.4.7</a>) h-char:
+              any member of the source character set except
+                           the new-line character and &gt;
+(<a href="#6.4.7">6.4.7</a>) q-char-sequence:
+              q-char
+              q-char-sequence q-char
+(<a href="#6.4.7">6.4.7</a>) q-char:
+              any member of the source character set except
+                           the new-line character and "
+<a name="A.1.9" href="#A.1.9"><b>A.1.9 Preprocessing numbers</b></a>
+(<a href="#6.4.8">6.4.8</a>) pp-number:
+              digit
+              . digit
+              pp-number   digit
+              pp-number   identifier-nondigit
+              pp-number   e sign
+              pp-number   E sign
+              pp-number   p sign
+              pp-number   P sign
+              pp-number   .
+
+[<a name="p460" href="#p460">page 460</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.2" href="#A.2"><b>A.2 Phrase structure grammar</b></a>
+<a name="A.2.1" href="#A.2.1"><b>A.2.1 Expressions</b></a>
+(<a href="#6.5.1">6.5.1</a>) primary-expression:
+              identifier
+              constant
+              string-literal
+              ( expression )
+              generic-selection
+(<a href="#6.5.1.1">6.5.1.1</a>) generic-selection:
+              _Generic ( assignment-expression , generic-assoc-list )
+(<a href="#6.5.1.1">6.5.1.1</a>) generic-assoc-list:
+              generic-association
+              generic-assoc-list , generic-association
+(<a href="#6.5.1.1">6.5.1.1</a>) generic-association:
+              type-name : assignment-expression
+              default : assignment-expression
+(<a href="#6.5.2">6.5.2</a>) postfix-expression:
+              primary-expression
+              postfix-expression [ expression ]
+              postfix-expression ( argument-expression-listopt )
+              postfix-expression . identifier
+              postfix-expression -&gt; identifier
+              postfix-expression ++
+              postfix-expression --
+              ( type-name ) { initializer-list }
+              ( type-name ) { initializer-list , }
+(<a href="#6.5.2">6.5.2</a>) argument-expression-list:
+             assignment-expression
+             argument-expression-list , assignment-expression
+(<a href="#6.5.3">6.5.3</a>) unary-expression:
+              postfix-expression
+              ++ unary-expression
+              -- unary-expression
+              unary-operator cast-expression
+              sizeof unary-expression
+              sizeof ( type-name )
+              alignof ( type-name )
+
+[<a name="p461" href="#p461">page 461</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.5.3">6.5.3</a>) unary-operator: one of
+              &amp; * + - ~                !
+(<a href="#6.5.4">6.5.4</a>) cast-expression:
+               unary-expression
+               ( type-name ) cast-expression
+(<a href="#6.5.5">6.5.5</a>) multiplicative-expression:
+               cast-expression
+               multiplicative-expression * cast-expression
+               multiplicative-expression / cast-expression
+               multiplicative-expression % cast-expression
+(<a href="#6.5.6">6.5.6</a>) additive-expression:
+               multiplicative-expression
+               additive-expression + multiplicative-expression
+               additive-expression - multiplicative-expression
+(<a href="#6.5.7">6.5.7</a>) shift-expression:
+                additive-expression
+                shift-expression &lt;&lt; additive-expression
+                shift-expression &gt;&gt; additive-expression
+(<a href="#6.5.8">6.5.8</a>) relational-expression:
+               shift-expression
+               relational-expression   &lt;    shift-expression
+               relational-expression   &gt;    shift-expression
+               relational-expression   &lt;=   shift-expression
+               relational-expression   &gt;=   shift-expression
+(<a href="#6.5.9">6.5.9</a>) equality-expression:
+               relational-expression
+               equality-expression == relational-expression
+               equality-expression != relational-expression
+(<a href="#6.5.10">6.5.10</a>) AND-expression:
+             equality-expression
+             AND-expression &amp; equality-expression
+(<a href="#6.5.11">6.5.11</a>) exclusive-OR-expression:
+              AND-expression
+              exclusive-OR-expression ^ AND-expression
+
+[<a name="p462" href="#p462">page 462</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.5.12">6.5.12</a>) inclusive-OR-expression:
+               exclusive-OR-expression
+               inclusive-OR-expression | exclusive-OR-expression
+(<a href="#6.5.13">6.5.13</a>) logical-AND-expression:
+              inclusive-OR-expression
+              logical-AND-expression &amp;&amp; inclusive-OR-expression
+(<a href="#6.5.14">6.5.14</a>) logical-OR-expression:
+              logical-AND-expression
+              logical-OR-expression || logical-AND-expression
+(<a href="#6.5.15">6.5.15</a>) conditional-expression:
+              logical-OR-expression
+              logical-OR-expression ? expression : conditional-expression
+(<a href="#6.5.16">6.5.16</a>) assignment-expression:
+              conditional-expression
+              unary-expression assignment-operator assignment-expression
+(<a href="#6.5.16">6.5.16</a>) assignment-operator: one of
+              = *= /= %= +=                -=    &lt;&lt;=    &gt;&gt;=      &amp;=    ^=   |=
+(<a href="#6.5.17">6.5.17</a>) expression:
+              assignment-expression
+              expression , assignment-expression
+(<a href="#6.6">6.6</a>) constant-expression:
+              conditional-expression
+<a name="A.2.2" href="#A.2.2"><b>A.2.2 Declarations</b></a>
+(<a href="#6.7">6.7</a>) declaration:
+               declaration-specifiers init-declarator-listopt ;
+               static_assert-declaration
+(<a href="#6.7">6.7</a>) declaration-specifiers:
+               storage-class-specifier declaration-specifiersopt
+               type-specifier declaration-specifiersopt
+               type-qualifier declaration-specifiersopt
+               function-specifier declaration-specifiersopt
+               alignment-specifier declaration-specifiersopt
+(<a href="#6.7">6.7</a>) init-declarator-list:
+               init-declarator
+               init-declarator-list , init-declarator
+
+[<a name="p463" href="#p463">page 463</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7">6.7</a>) init-declarator:
+               declarator
+               declarator = initializer
+(<a href="#6.7.1">6.7.1</a>) storage-class-specifier:
+              typedef
+              extern
+              static
+              _Thread_local
+              auto
+              register
+(<a href="#6.7.2">6.7.2</a>) type-specifier:
+               void
+               char
+               short
+               int
+               long
+               float
+               double
+               signed
+               unsigned
+               _Bool
+               _Complex
+               atomic-type-specifier
+               struct-or-union-specifier
+               enum-specifier
+               typedef-name
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union-specifier:
+               struct-or-union identifieropt { struct-declaration-list }
+               struct-or-union identifier
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-or-union:
+               struct
+               union
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration-list:
+               struct-declaration
+               struct-declaration-list struct-declaration
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declaration:
+               specifier-qualifier-list struct-declarator-listopt ;
+               static_assert-declaration
+
+[<a name="p464" href="#p464">page 464</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7.2.1">6.7.2.1</a>) specifier-qualifier-list:
+               type-specifier specifier-qualifier-listopt
+               type-qualifier specifier-qualifier-listopt
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator-list:
+               struct-declarator
+               struct-declarator-list , struct-declarator
+(<a href="#6.7.2.1">6.7.2.1</a>) struct-declarator:
+               declarator
+               declaratoropt : constant-expression
+(<a href="#6.7.2.2">6.7.2.2</a>) enum-specifier:
+              enum identifieropt { enumerator-list }
+              enum identifieropt { enumerator-list , }
+              enum identifier
+(<a href="#6.7.2.2">6.7.2.2</a>) enumerator-list:
+              enumerator
+              enumerator-list , enumerator
+(<a href="#6.7.2.2">6.7.2.2</a>) enumerator:
+              enumeration-constant
+              enumeration-constant = constant-expression
+(<a href="#6.7.2.4">6.7.2.4</a>) atomic-type-specifier:
+              _Atomic ( type-name )
+(<a href="#6.7.3">6.7.3</a>) type-qualifier:
+              const
+              restrict
+              volatile
+              _Atomic
+(<a href="#6.7.4">6.7.4</a>) function-specifier:
+               inline
+               _Noreturn
+(<a href="#6.7.5">6.7.5</a>) alignment-specifier:
+              _Alignas ( type-name )
+              _Alignas ( constant-expression )
+(<a href="#6.7.6">6.7.6</a>) declarator:
+              pointeropt direct-declarator
+
+[<a name="p465" href="#p465">page 465</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7.6">6.7.6</a>) direct-declarator:
+               identifier
+               ( declarator )
+               direct-declarator [ type-qualifier-listopt assignment-expressionopt ]
+               direct-declarator [ static type-qualifier-listopt assignment-expression ]
+               direct-declarator [ type-qualifier-list static assignment-expression ]
+               direct-declarator [ type-qualifier-listopt * ]
+               direct-declarator ( parameter-type-list )
+               direct-declarator ( identifier-listopt )
+(<a href="#6.7.6">6.7.6</a>) pointer:
+               * type-qualifier-listopt
+               * type-qualifier-listopt pointer
+(<a href="#6.7.6">6.7.6</a>) type-qualifier-list:
+              type-qualifier
+              type-qualifier-list type-qualifier
+(<a href="#6.7.6">6.7.6</a>) parameter-type-list:
+             parameter-list
+             parameter-list , ...
+(<a href="#6.7.6">6.7.6</a>) parameter-list:
+             parameter-declaration
+             parameter-list , parameter-declaration
+(<a href="#6.7.6">6.7.6</a>) parameter-declaration:
+             declaration-specifiers declarator
+             declaration-specifiers abstract-declaratoropt
+(<a href="#6.7.6">6.7.6</a>) identifier-list:
+               identifier
+               identifier-list , identifier
+(<a href="#6.7.7">6.7.7</a>) type-name:
+              specifier-qualifier-list abstract-declaratoropt
+(<a href="#6.7.7">6.7.7</a>) abstract-declarator:
+              pointer
+              pointeropt direct-abstract-declarator
+
+[<a name="p466" href="#p466">page 466</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.7.7">6.7.7</a>) direct-abstract-declarator:
+               ( abstract-declarator )
+               direct-abstract-declaratoropt [ type-qualifier-listopt
+                              assignment-expressionopt ]
+               direct-abstract-declaratoropt [ static type-qualifier-listopt
+                              assignment-expression ]
+               direct-abstract-declaratoropt [ type-qualifier-list static
+                              assignment-expression ]
+               direct-abstract-declaratoropt [ * ]
+               direct-abstract-declaratoropt ( parameter-type-listopt )
+(<a href="#6.7.8">6.7.8</a>) typedef-name:
+              identifier
+(<a href="#6.7.9">6.7.9</a>) initializer:
+                assignment-expression
+                { initializer-list }
+                { initializer-list , }
+(<a href="#6.7.9">6.7.9</a>) initializer-list:
+                designationopt initializer
+                initializer-list , designationopt initializer
+(<a href="#6.7.9">6.7.9</a>) designation:
+              designator-list =
+(<a href="#6.7.9">6.7.9</a>) designator-list:
+              designator
+              designator-list designator
+(<a href="#6.7.9">6.7.9</a>) designator:
+              [ constant-expression ]
+              . identifier
+(<a href="#6.7.10">6.7.10</a>) static_assert-declaration:
+               _Static_assert ( constant-expression , string-literal ) ;
+
+[<a name="p467" href="#p467">page 467</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.2.3" href="#A.2.3"><b>A.2.3 Statements</b></a>
+(<a href="#6.8">6.8</a>) statement:
+              labeled-statement
+              compound-statement
+              expression-statement
+              selection-statement
+              iteration-statement
+              jump-statement
+(<a href="#6.8.1">6.8.1</a>) labeled-statement:
+               identifier : statement
+               case constant-expression : statement
+               default : statement
+(<a href="#6.8.2">6.8.2</a>) compound-statement:
+             { block-item-listopt }
+(<a href="#6.8.2">6.8.2</a>) block-item-list:
+               block-item
+               block-item-list block-item
+(<a href="#6.8.2">6.8.2</a>) block-item:
+               declaration
+               statement
+(<a href="#6.8.3">6.8.3</a>) expression-statement:
+              expressionopt ;
+(<a href="#6.8.4">6.8.4</a>) selection-statement:
+               if ( expression ) statement
+               if ( expression ) statement else statement
+               switch ( expression ) statement
+(<a href="#6.8.5">6.8.5</a>) iteration-statement:
+                while ( expression ) statement
+                do statement while ( expression ) ;
+                for ( expressionopt ; expressionopt ; expressionopt ) statement
+                for ( declaration expressionopt ; expressionopt ) statement
+(<a href="#6.8.6">6.8.6</a>) jump-statement:
+              goto identifier ;
+              continue ;
+              break ;
+              return expressionopt ;
+
+[<a name="p468" href="#p468">page 468</a>] (<a href="#Contents">Contents</a>)
+
+<a name="A.2.4" href="#A.2.4"><b>A.2.4 External definitions</b></a>
+(<a href="#6.9">6.9</a>) translation-unit:
+               external-declaration
+               translation-unit external-declaration
+(<a href="#6.9">6.9</a>) external-declaration:
+               function-definition
+               declaration
+(<a href="#6.9.1">6.9.1</a>) function-definition:
+               declaration-specifiers declarator declaration-listopt compound-statement
+(<a href="#6.9.1">6.9.1</a>) declaration-list:
+              declaration
+              declaration-list declaration
+<a name="A.3" href="#A.3"><b>A.3 Preprocessing directives</b></a>
+(<a href="#6.10">6.10</a>) preprocessing-file:
+              groupopt
+(<a href="#6.10">6.10</a>) group:
+                group-part
+                group group-part
+(<a href="#6.10">6.10</a>) group-part:
+              if-section
+              control-line
+              text-line
+              # non-directive
+(<a href="#6.10">6.10</a>) if-section:
+                if-group elif-groupsopt else-groupopt endif-line
+(<a href="#6.10">6.10</a>) if-group:
+               # if     constant-expression new-line groupopt
+               # ifdef identifier new-line groupopt
+               # ifndef identifier new-line groupopt
+(<a href="#6.10">6.10</a>) elif-groups:
+               elif-group
+               elif-groups elif-group
+(<a href="#6.10">6.10</a>) elif-group:
+               # elif       constant-expression new-line groupopt
+
+[<a name="p469" href="#p469">page 469</a>] (<a href="#Contents">Contents</a>)
+
+(<a href="#6.10">6.10</a>) else-group:
+               # else        new-line groupopt
+(<a href="#6.10">6.10</a>) endif-line:
+               # endif       new-line
+(<a href="#6.10">6.10</a>) control-line:
+              # include pp-tokens new-line
+              # define identifier replacement-list new-line
+              # define identifier lparen identifier-listopt )
+                                              replacement-list new-line
+              # define identifier lparen ... ) replacement-list new-line
+              # define identifier lparen identifier-list , ... )
+                                              replacement-list new-line
+              # undef   identifier new-line
+              # line    pp-tokens new-line
+              # error   pp-tokensopt new-line
+              # pragma pp-tokensopt new-line
+              #         new-line
+(<a href="#6.10">6.10</a>) text-line:
+               pp-tokensopt new-line
+(<a href="#6.10">6.10</a>) non-directive:
+              pp-tokens new-line
+(<a href="#6.10">6.10</a>) lparen:
+                 a ( character not immediately preceded by white-space
+(<a href="#6.10">6.10</a>) replacement-list:
+              pp-tokensopt
+(<a href="#6.10">6.10</a>) pp-tokens:
+              preprocessing-token
+              pp-tokens preprocessing-token
+(<a href="#6.10">6.10</a>) new-line:
+              the new-line character
+
+[<a name="p470" href="#p470">page 470</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B" href="#B"><b>                               Annex B</b></a>
+                             (informative)
+                         Library summary
+<a name="B.1" href="#B.1"><b>B.1 Diagnostics &lt;assert.h&gt;</b></a>
+        NDEBUG
+        static_assert
+        void assert(scalar expression);
+<a name="B.2" href="#B.2"><b>B.2 Complex &lt;complex.h&gt;</b></a>
+        __STDC_NO_COMPLEX__           imaginary
+        complex                         _Imaginary_I
+        _Complex_I                      I
+        #pragma STDC CX_LIMITED_RANGE on-off-switch
+        double complex cacos(double complex z);
+        float complex cacosf(float complex z);
+        long double complex cacosl(long double complex z);
+        double complex casin(double complex z);
+        float complex casinf(float complex z);
+        long double complex casinl(long double complex z);
+        double complex catan(double complex z);
+        float complex catanf(float complex z);
+        long double complex catanl(long double complex z);
+        double complex ccos(double complex z);
+        float complex ccosf(float complex z);
+        long double complex ccosl(long double complex z);
+        double complex csin(double complex z);
+        float complex csinf(float complex z);
+        long double complex csinl(long double complex z);
+        double complex ctan(double complex z);
+        float complex ctanf(float complex z);
+        long double complex ctanl(long double complex z);
+        double complex cacosh(double complex z);
+        float complex cacoshf(float complex z);
+        long double complex cacoshl(long double complex z);
+        double complex casinh(double complex z);
+        float complex casinhf(float complex z);
+        long double complex casinhl(long double complex z);
+
+[<a name="p471" href="#p471">page 471</a>] (<a href="#Contents">Contents</a>)
+
+      double complex catanh(double complex z);
+      float complex catanhf(float complex z);
+      long double complex catanhl(long double complex z);
+      double complex ccosh(double complex z);
+      float complex ccoshf(float complex z);
+      long double complex ccoshl(long double complex z);
+      double complex csinh(double complex z);
+      float complex csinhf(float complex z);
+      long double complex csinhl(long double complex z);
+      double complex ctanh(double complex z);
+      float complex ctanhf(float complex z);
+      long double complex ctanhl(long double complex z);
+      double complex cexp(double complex z);
+      float complex cexpf(float complex z);
+      long double complex cexpl(long double complex z);
+      double complex clog(double complex z);
+      float complex clogf(float complex z);
+      long double complex clogl(long double complex z);
+      double cabs(double complex z);
+      float cabsf(float complex z);
+      long double cabsl(long double complex z);
+      double complex cpow(double complex x, double complex y);
+      float complex cpowf(float complex x, float complex y);
+      long double complex cpowl(long double complex x,
+           long double complex y);
+      double complex csqrt(double complex z);
+      float complex csqrtf(float complex z);
+      long double complex csqrtl(long double complex z);
+      double carg(double complex z);
+      float cargf(float complex z);
+      long double cargl(long double complex z);
+      double cimag(double complex z);
+      float cimagf(float complex z);
+      long double cimagl(long double complex z);
+      double complex CMPLX(double x, double y);
+      float complex CMPLXF(float x, float y);
+      long double complex CMPLXL(long double x, long double y);
+      double complex conj(double complex z);
+      float complex conjf(float complex z);
+      long double complex conjl(long double complex z);
+      double complex cproj(double complex z);
+
+[<a name="p472" href="#p472">page 472</a>] (<a href="#Contents">Contents</a>)
+
+        float complex cprojf(float complex z);
+        long double complex cprojl(long double complex z);
+        double creal(double complex z);
+        float crealf(float complex z);
+        long double creall(long double complex z);
+<a name="B.3" href="#B.3"><b>B.3 Character handling &lt;ctype.h&gt;</b></a>
+        int   isalnum(int c);
+        int   isalpha(int c);
+        int   isblank(int c);
+        int   iscntrl(int c);
+        int   isdigit(int c);
+        int   isgraph(int c);
+        int   islower(int c);
+        int   isprint(int c);
+        int   ispunct(int c);
+        int   isspace(int c);
+        int   isupper(int c);
+        int   isxdigit(int c);
+        int   tolower(int c);
+        int   toupper(int c);
+<a name="B.4" href="#B.4"><b>B.4 Errors &lt;errno.h&gt;</b></a>
+        EDOM           EILSEQ            ERANGE           errno
+        __STDC_WANT_LIB_EXT1__
+        errno_t
+<a name="B.5" href="#B.5"><b>B.5 Floating-point environment &lt;fenv.h&gt;</b></a>
+        fenv_t               FE_OVERFLOW             FE_TOWARDZERO
+        fexcept_t            FE_UNDERFLOW            FE_UPWARD
+        FE_DIVBYZERO         FE_ALL_EXCEPT           FE_DFL_ENV
+        FE_INEXACT           FE_DOWNWARD
+        FE_INVALID           FE_TONEAREST
+        #pragma STDC FENV_ACCESS on-off-switch
+        int feclearexcept(int excepts);
+        int fegetexceptflag(fexcept_t *flagp, int excepts);
+        int feraiseexcept(int excepts);
+        int fesetexceptflag(const fexcept_t *flagp,
+             int excepts);
+        int fetestexcept(int excepts);
+
+[<a name="p473" href="#p473">page 473</a>] (<a href="#Contents">Contents</a>)
+
+      int   fegetround(void);
+      int   fesetround(int round);
+      int   fegetenv(fenv_t *envp);
+      int   feholdexcept(fenv_t *envp);
+      int   fesetenv(const fenv_t *envp);
+      int   feupdateenv(const fenv_t *envp);
+<a name="B.6" href="#B.6"><b>B.6 Characteristics of floating types &lt;float.h&gt;</b></a>
+      FLT_ROUNDS              DBL_DIG                 FLT_MAX
+      FLT_EVAL_METHOD         LDBL_DIG                DBL_MAX
+      FLT_HAS_SUBNORM         FLT_MIN_EXP             LDBL_MAX
+      DBL_HAS_SUBNORM         DBL_MIN_EXP             FLT_EPSILON
+      LDBL_HAS_SUBNORM        LDBL_MIN_EXP            DBL_EPSILON
+      FLT_RADIX               FLT_MIN_10_EXP          LDBL_EPSILON
+      FLT_MANT_DIG            DBL_MIN_10_EXP          FLT_MIN
+      DBL_MANT_DIG            LDBL_MIN_10_EXP         DBL_MIN
+      LDBL_MANT_DIG           FLT_MAX_EXP             LDBL_MIN
+      FLT_DECIMAL_DIG         DBL_MAX_EXP             FLT_TRUE_MIN
+      DBL_DECIMAL_DIG         LDBL_MAX_EXP            DBL_TRUE_MIN
+      LDBL_DECIMAL_DIG        FLT_MAX_10_EXP          LDBL_TRUE_MIN
+      DECIMAL_DIG             DBL_MAX_10_EXP
+      FLT_DIG                 LDBL_MAX_10_EXP
+<a name="B.7" href="#B.7"><b>B.7 Format conversion of integer types &lt;inttypes.h&gt;</b></a>
+      imaxdiv_t
+      PRIdN         PRIdLEASTN       PRIdFASTN        PRIdMAX    PRIdPTR
+      PRIiN         PRIiLEASTN       PRIiFASTN        PRIiMAX    PRIiPTR
+      PRIoN         PRIoLEASTN       PRIoFASTN        PRIoMAX    PRIoPTR
+      PRIuN         PRIuLEASTN       PRIuFASTN        PRIuMAX    PRIuPTR
+      PRIxN         PRIxLEASTN       PRIxFASTN        PRIxMAX    PRIxPTR
+      PRIXN         PRIXLEASTN       PRIXFASTN        PRIXMAX    PRIXPTR
+      SCNdN         SCNdLEASTN       SCNdFASTN        SCNdMAX    SCNdPTR
+      SCNiN         SCNiLEASTN       SCNiFASTN        SCNiMAX    SCNiPTR
+      SCNoN         SCNoLEASTN       SCNoFASTN        SCNoMAX    SCNoPTR
+      SCNuN         SCNuLEASTN       SCNuFASTN        SCNuMAX    SCNuPTR
+      SCNxN         SCNxLEASTN       SCNxFASTN        SCNxMAX    SCNxPTR
+      intmax_t imaxabs(intmax_t j);
+      imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+      intmax_t strtoimax(const char * restrict nptr,
+              char ** restrict endptr, int base);
+
+[<a name="p474" href="#p474">page 474</a>] (<a href="#Contents">Contents</a>)
+
+        uintmax_t strtoumax(const char * restrict nptr,
+                char ** restrict endptr, int base);
+        intmax_t wcstoimax(const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr, int base);
+        uintmax_t wcstoumax(const wchar_t * restrict nptr,
+                wchar_t ** restrict endptr, int base);
+<a name="B.8" href="#B.8"><b>B.8 Alternative spellings &lt;iso646.h&gt;</b></a>
+        and            bitor             not_eq           xor
+        and_eq         compl             or               xor_eq
+        bitand         not               or_eq
+<a name="B.9" href="#B.9"><b>B.9 Sizes of integer types &lt;limits.h&gt;</b></a>
+        CHAR_BIT       CHAR_MAX          INT_MIN          ULONG_MAX
+        SCHAR_MIN      MB_LEN_MAX        INT_MAX          LLONG_MIN
+        SCHAR_MAX      SHRT_MIN          UINT_MAX         LLONG_MAX
+        UCHAR_MAX      SHRT_MAX          LONG_MIN         ULLONG_MAX
+        CHAR_MIN       USHRT_MAX         LONG_MAX
+<a name="B.10" href="#B.10"><b>B.10 Localization &lt;locale.h&gt;</b></a>
+        struct lconv   LC_ALL            LC_CTYPE         LC_NUMERIC
+        NULL           LC_COLLATE        LC_MONETARY      LC_TIME
+        char *setlocale(int category, const char *locale);
+        struct lconv *localeconv(void);
+<a name="B.11" href="#B.11"><b>B.11 Mathematics &lt;math.h&gt;</b></a>
+        float_t              FP_INFINITE             FP_FAST_FMAL
+        double_t             FP_NAN                  FP_ILOGB0
+        HUGE_VAL             FP_NORMAL               FP_ILOGBNAN
+        HUGE_VALF            FP_SUBNORMAL            MATH_ERRNO
+        HUGE_VALL            FP_ZERO                 MATH_ERREXCEPT
+        INFINITY             FP_FAST_FMA             math_errhandling
+        NAN                  FP_FAST_FMAF
+        #pragma STDC FP_CONTRACT on-off-switch
+        int fpclassify(real-floating x);
+        int isfinite(real-floating x);
+        int isinf(real-floating x);
+        int isnan(real-floating x);
+        int isnormal(real-floating x);
+        int signbit(real-floating x);
+
+[<a name="p475" href="#p475">page 475</a>] (<a href="#Contents">Contents</a>)
+
+      double acos(double x);
+      float acosf(float x);
+      long double acosl(long double x);
+      double asin(double x);
+      float asinf(float x);
+      long double asinl(long double x);
+      double atan(double x);
+      float atanf(float x);
+      long double atanl(long double x);
+      double atan2(double y, double x);
+      float atan2f(float y, float x);
+      long double atan2l(long double y, long double x);
+      double cos(double x);
+      float cosf(float x);
+      long double cosl(long double x);
+      double sin(double x);
+      float sinf(float x);
+      long double sinl(long double x);
+      double tan(double x);
+      float tanf(float x);
+      long double tanl(long double x);
+      double acosh(double x);
+      float acoshf(float x);
+      long double acoshl(long double x);
+      double asinh(double x);
+      float asinhf(float x);
+      long double asinhl(long double x);
+      double atanh(double x);
+      float atanhf(float x);
+      long double atanhl(long double x);
+      double cosh(double x);
+      float coshf(float x);
+      long double coshl(long double x);
+      double sinh(double x);
+      float sinhf(float x);
+      long double sinhl(long double x);
+      double tanh(double x);
+      float tanhf(float x);
+      long double tanhl(long double x);
+      double exp(double x);
+      float expf(float x);
+
+[<a name="p476" href="#p476">page 476</a>] (<a href="#Contents">Contents</a>)
+
+        long double expl(long double x);
+        double exp2(double x);
+        float exp2f(float x);
+        long double exp2l(long double x);
+        double expm1(double x);
+        float expm1f(float x);
+        long double expm1l(long double x);
+        double frexp(double value, int *exp);
+        float frexpf(float value, int *exp);
+        long double frexpl(long double value, int *exp);
+        int ilogb(double x);
+        int ilogbf(float x);
+        int ilogbl(long double x);
+        double ldexp(double x, int exp);
+        float ldexpf(float x, int exp);
+        long double ldexpl(long double x, int exp);
+        double log(double x);
+        float logf(float x);
+        long double logl(long double x);
+        double log10(double x);
+        float log10f(float x);
+        long double log10l(long double x);
+        double log1p(double x);
+        float log1pf(float x);
+        long double log1pl(long double x);
+        double log2(double x);
+        float log2f(float x);
+        long double log2l(long double x);
+        double logb(double x);
+        float logbf(float x);
+        long double logbl(long double x);
+        double modf(double value, double *iptr);
+        float modff(float value, float *iptr);
+        long double modfl(long double value, long double *iptr);
+        double scalbn(double x, int n);
+        float scalbnf(float x, int n);
+        long double scalbnl(long double x, int n);
+        double scalbln(double x, long int n);
+        float scalblnf(float x, long int n);
+        long double scalblnl(long double x, long int n);
+        double cbrt(double x);
+
+[<a name="p477" href="#p477">page 477</a>] (<a href="#Contents">Contents</a>)
+
+      float cbrtf(float x);
+      long double cbrtl(long double x);
+      double fabs(double x);
+      float fabsf(float x);
+      long double fabsl(long double x);
+      double hypot(double x, double y);
+      float hypotf(float x, float y);
+      long double hypotl(long double x, long double y);
+      double pow(double x, double y);
+      float powf(float x, float y);
+      long double powl(long double x, long double y);
+      double sqrt(double x);
+      float sqrtf(float x);
+      long double sqrtl(long double x);
+      double erf(double x);
+      float erff(float x);
+      long double erfl(long double x);
+      double erfc(double x);
+      float erfcf(float x);
+      long double erfcl(long double x);
+      double lgamma(double x);
+      float lgammaf(float x);
+      long double lgammal(long double x);
+      double tgamma(double x);
+      float tgammaf(float x);
+      long double tgammal(long double x);
+      double ceil(double x);
+      float ceilf(float x);
+      long double ceill(long double x);
+      double floor(double x);
+      float floorf(float x);
+      long double floorl(long double x);
+      double nearbyint(double x);
+      float nearbyintf(float x);
+      long double nearbyintl(long double x);
+      double rint(double x);
+      float rintf(float x);
+      long double rintl(long double x);
+      long int lrint(double x);
+      long int lrintf(float x);
+      long int lrintl(long double x);
+
+[<a name="p478" href="#p478">page 478</a>] (<a href="#Contents">Contents</a>)
+
+        long long int llrint(double x);
+        long long int llrintf(float x);
+        long long int llrintl(long double x);
+        double round(double x);
+        float roundf(float x);
+        long double roundl(long double x);
+        long int lround(double x);
+        long int lroundf(float x);
+        long int lroundl(long double x);
+        long long int llround(double x);
+        long long int llroundf(float x);
+        long long int llroundl(long double x);
+        double trunc(double x);
+        float truncf(float x);
+        long double truncl(long double x);
+        double fmod(double x, double y);
+        float fmodf(float x, float y);
+        long double fmodl(long double x, long double y);
+        double remainder(double x, double y);
+        float remainderf(float x, float y);
+        long double remainderl(long double x, long double y);
+        double remquo(double x, double y, int *quo);
+        float remquof(float x, float y, int *quo);
+        long double remquol(long double x, long double y,
+             int *quo);
+        double copysign(double x, double y);
+        float copysignf(float x, float y);
+        long double copysignl(long double x, long double y);
+        double nan(const char *tagp);
+        float nanf(const char *tagp);
+        long double nanl(const char *tagp);
+        double nextafter(double x, double y);
+        float nextafterf(float x, float y);
+        long double nextafterl(long double x, long double y);
+        double nexttoward(double x, long double y);
+        float nexttowardf(float x, long double y);
+        long double nexttowardl(long double x, long double y);
+        double fdim(double x, double y);
+        float fdimf(float x, float y);
+        long double fdiml(long double x, long double y);
+        double fmax(double x, double y);
+
+[<a name="p479" href="#p479">page 479</a>] (<a href="#Contents">Contents</a>)
+
+      float fmaxf(float x, float y);
+      long double fmaxl(long double x, long double y);
+      double fmin(double x, double y);
+      float fminf(float x, float y);
+      long double fminl(long double x, long double y);
+      double fma(double x, double y, double z);
+      float fmaf(float x, float y, float z);
+      long double fmal(long double x, long double y,
+           long double z);
+      int isgreater(real-floating x, real-floating y);
+      int isgreaterequal(real-floating x, real-floating y);
+      int isless(real-floating x, real-floating y);
+      int islessequal(real-floating x, real-floating y);
+      int islessgreater(real-floating x, real-floating y);
+      int isunordered(real-floating x, real-floating y);
+<a name="B.12" href="#B.12"><b>B.12 Nonlocal jumps &lt;setjmp.h&gt;</b></a>
+      jmp_buf
+      int setjmp(jmp_buf env);
+      _Noreturn void longjmp(jmp_buf env, int val);
+<a name="B.13" href="#B.13"><b>B.13 Signal handling &lt;signal.h&gt;</b></a>
+      sig_atomic_t    SIG_IGN           SIGILL           SIGTERM
+      SIG_DFL         SIGABRT           SIGINT
+      SIG_ERR         SIGFPE            SIGSEGV
+      void (*signal(int sig, void (*func)(int)))(int);
+      int raise(int sig);
+
+[<a name="p480" href="#p480">page 480</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.14" href="#B.14"><b>B.14 Alignment &lt;stdalign.h&gt;</b></a>
+        alignas
+        __alignas_is_defined
+<a name="B.15" href="#B.15"><b>B.15 Variable arguments &lt;stdarg.h&gt;</b></a>
+        va_list
+        type va_arg(va_list ap, type);
+        void va_copy(va_list dest, va_list src);
+        void va_end(va_list ap);
+        void va_start(va_list ap, parmN);
+<a name="B.16" href="#B.16"><b>B.16 Atomics &lt;stdatomic.h&gt;</b></a>
+        ATOMIC_CHAR_LOCK_FREE           atomic_uint
+        ATOMIC_CHAR16_T_LOCK_FREE       atomic_long
+        ATOMIC_CHAR32_T_LOCK_FREE       atomic_ulong
+        ATOMIC_WCHAR_T_LOCK_FREE        atomic_llong
+        ATOMIC_SHORT_LOCK_FREE          atomic_ullong
+        ATOMIC_INT_LOCK_FREE            atomic_char16_t
+        ATOMIC_LONG_LOCK_FREE           atomic_char32_t
+        ATOMIC_LLONG_LOCK_FREE          atomic_wchar_t
+        ATOMIC_ADDRESS_LOCK_FREE        atomic_int_least8_t
+        ATOMIC_FLAG_INIT                atomic_uint_least8_t
+        memory_order                    atomic_int_least16_t
+        atomic_flag                     atomic_uint_least16_t
+        atomic_bool                     atomic_int_least32_t
+        atomic_address                  atomic_uint_least32_t
+        memory_order_relaxed            atomic_int_least64_t
+        memory_order_consume            atomic_uint_least64_t
+        memory_order_acquire            atomic_int_fast8_t
+        memory_order_release            atomic_uint_fast8_t
+        memory_order_acq_rel            atomic_int_fast16_t
+        memory_order_seq_cst            atomic_uint_fast16_t
+        atomic_char                     atomic_int_fast32_t
+        atomic_schar                    atomic_uint_fast32_t
+        atomic_uchar                    atomic_int_fast64_t
+        atomic_short                    atomic_uint_fast64_t
+        atomic_ushort                   atomic_intptr_t
+        atomic_int                      atomic_uintptr_t
+
+[<a name="p481" href="#p481">page 481</a>] (<a href="#Contents">Contents</a>)
+
+      atomic_size_t                     atomic_intmax_t
+      atomic_ptrdiff_t                  atomic_uintmax_t
+      #define ATOMIC_VAR_INIT(C value)
+      void atomic_init(volatile A *obj, C value);
+      type kill_dependency(type y);
+      void atomic_thread_fence(memory_order order);
+      void atomic_signal_fence(memory_order order);
+      _Bool atomic_is_lock_free(atomic_type const volatile *obj);
+      void atomic_store(volatile A *object, C desired);
+      void atomic_store_explicit(volatile A *object,
+            C desired, memory_order order);
+      C atomic_load(volatile A *object);
+      C atomic_load_explicit(volatile A *object,
+            memory_order order);
+      C atomic_exchange(volatile A *object, C desired);
+      C atomic_exchange_explicit(volatile A *object,
+            C desired, memory_order order);
+      _Bool atomic_compare_exchange_strong(volatile A *object,
+            C *expected, C desired);
+      _Bool atomic_compare_exchange_strong_explicit(
+            volatile A *object, C *expected, C desired,
+            memory_order success, memory_order failure);
+      _Bool atomic_compare_exchange_weak(volatile A *object,
+            C *expected, C desired);
+      _Bool atomic_compare_exchange_weak_explicit(
+            volatile A *object, C *expected, C desired,
+            memory_order success, memory_order failure);
+      C atomic_fetch_key(volatile A *object, M operand);
+      C atomic_fetch_key_explicit(volatile A *object,
+            M operand, memory_order order);
+      bool atomic_flag_test_and_set(
+            volatile atomic_flag *object);
+      bool atomic_flag_test_and_set_explicit(
+            volatile atomic_flag *object, memory_order order);
+      void atomic_flag_clear(volatile atomic_flag *object);
+      void atomic_flag_clear_explicit(
+            volatile atomic_flag *object, memory_order order);
+
+[<a name="p482" href="#p482">page 482</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.17" href="#B.17"><b>B.17 Boolean type and values &lt;stdbool.h&gt;</b></a>
+        bool
+        true
+        false
+        __bool_true_false_are_defined
+<a name="B.18" href="#B.18"><b>B.18 Common definitions &lt;stddef.h&gt;</b></a>
+        ptrdiff_t       max_align_t       NULL
+        size_t          wchar_t
+        offsetof(type, member-designator)
+        __STDC_WANT_LIB_EXT1__
+        rsize_t
+<a name="B.19" href="#B.19"><b>B.19 Integer types &lt;stdint.h&gt;</b></a>
+        intN_t                INT_LEASTN_MIN          PTRDIFF_MAX
+        uintN_t               INT_LEASTN_MAX          SIG_ATOMIC_MIN
+        int_leastN_t          UINT_LEASTN_MAX         SIG_ATOMIC_MAX
+        uint_leastN_t         INT_FASTN_MIN           SIZE_MAX
+        int_fastN_t           INT_FASTN_MAX           WCHAR_MIN
+        uint_fastN_t          UINT_FASTN_MAX          WCHAR_MAX
+        intptr_t              INTPTR_MIN              WINT_MIN
+        uintptr_t             INTPTR_MAX              WINT_MAX
+        intmax_t              UINTPTR_MAX             INTN_C(value)
+        uintmax_t             INTMAX_MIN              UINTN_C(value)
+        INTN_MIN              INTMAX_MAX              INTMAX_C(value)
+        INTN_MAX              UINTMAX_MAX             UINTMAX_C(value)
+        UINTN_MAX             PTRDIFF_MIN
+        __STDC_WANT_LIB_EXT1__
+        RSIZE_MAX
+
+[<a name="p483" href="#p483">page 483</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.20" href="#B.20"><b>B.20 Input/output &lt;stdio.h&gt;</b></a>
+      size_t          _IOLBF            FILENAME_MAX     TMP_MAX
+      FILE            _IONBF            L_tmpnam         stderr
+      fpos_t          BUFSIZ            SEEK_CUR         stdin
+      NULL            EOF               SEEK_END         stdout
+      _IOFBF          FOPEN_MAX         SEEK_SET
+      int remove(const char *filename);
+      int rename(const char *old, const char *new);
+      FILE *tmpfile(void);
+      char *tmpnam(char *s);
+      int fclose(FILE *stream);
+      int fflush(FILE *stream);
+      FILE *fopen(const char * restrict filename,
+           const char * restrict mode);
+      FILE *freopen(const char * restrict filename,
+           const char * restrict mode,
+           FILE * restrict stream);
+      void setbuf(FILE * restrict stream,
+           char * restrict buf);
+      int setvbuf(FILE * restrict stream,
+           char * restrict buf,
+           int mode, size_t size);
+      int fprintf(FILE * restrict stream,
+           const char * restrict format, ...);
+      int fscanf(FILE * restrict stream,
+           const char * restrict format, ...);
+      int printf(const char * restrict format, ...);
+      int scanf(const char * restrict format, ...);
+      int snprintf(char * restrict s, size_t n,
+           const char * restrict format, ...);
+      int sprintf(char * restrict s,
+           const char * restrict format, ...);
+      int sscanf(const char * restrict s,
+           const char * restrict format, ...);
+      int vfprintf(FILE * restrict stream,
+           const char * restrict format, va_list arg);
+      int vfscanf(FILE * restrict stream,
+           const char * restrict format, va_list arg);
+      int vprintf(const char * restrict format, va_list arg);
+      int vscanf(const char * restrict format, va_list arg);
+
+[<a name="p484" href="#p484">page 484</a>] (<a href="#Contents">Contents</a>)
+
+        int vsnprintf(char * restrict s, size_t n,
+             const char * restrict format, va_list arg);
+        int vsprintf(char * restrict s,
+             const char * restrict format, va_list arg);
+        int vsscanf(const char * restrict s,
+             const char * restrict format, va_list arg);
+        int fgetc(FILE *stream);
+        char *fgets(char * restrict s, int n,
+             FILE * restrict stream);
+        int fputc(int c, FILE *stream);
+        int fputs(const char * restrict s,
+             FILE * restrict stream);
+        int getc(FILE *stream);
+        int getchar(void);
+        int putc(int c, FILE *stream);                                       *
+        int putchar(int c);
+        int puts(const char *s);
+        int ungetc(int c, FILE *stream);
+        size_t fread(void * restrict ptr,
+             size_t size, size_t nmemb,
+             FILE * restrict stream);
+        size_t fwrite(const void * restrict ptr,
+             size_t size, size_t nmemb,
+             FILE * restrict stream);
+        int fgetpos(FILE * restrict stream,
+             fpos_t * restrict pos);
+        int fseek(FILE *stream, long int offset, int whence);
+        int fsetpos(FILE *stream, const fpos_t *pos);
+        long int ftell(FILE *stream);
+        void rewind(FILE *stream);
+        void clearerr(FILE *stream);
+        int feof(FILE *stream);
+        int ferror(FILE *stream);
+        void perror(const char *s);
+        __STDC_WANT_LIB_EXT1__
+        L_tmpnam_s    TMP_MAX_S         errno_t          rsize_t
+        errno_t tmpfile_s(FILE * restrict * restrict streamptr);
+        errno_t tmpnam_s(char *s, rsize_t maxsize);
+
+[<a name="p485" href="#p485">page 485</a>] (<a href="#Contents">Contents</a>)
+
+      errno_t fopen_s(FILE * restrict * restrict streamptr,
+           const char * restrict filename,
+           const char * restrict mode);
+      errno_t freopen_s(FILE * restrict * restrict newstreamptr,
+           const char * restrict filename,
+           const char * restrict mode,
+           FILE * restrict stream);
+      int fprintf_s(FILE * restrict stream,
+           const char * restrict format, ...);
+      int fscanf_s(FILE * restrict stream,
+           const char * restrict format, ...);
+      int printf_s(const char * restrict format, ...);
+      int scanf_s(const char * restrict format, ...);
+      int snprintf_s(char * restrict s, rsize_t n,
+           const char * restrict format, ...);
+      int sprintf_s(char * restrict s, rsize_t n,
+           const char * restrict format, ...);
+      int sscanf_s(const char * restrict s,
+           const char * restrict format, ...);
+      int vfprintf_s(FILE * restrict stream,
+           const char * restrict format,
+           va_list arg);
+      int vfscanf_s(FILE * restrict stream,
+           const char * restrict format,
+           va_list arg);
+      int vprintf_s(const char * restrict format,
+           va_list arg);
+      int vscanf_s(const char * restrict format,
+           va_list arg);
+      int vsnprintf_s(char * restrict s, rsize_t n,
+           const char * restrict format,
+           va_list arg);
+      int vsprintf_s(char * restrict s, rsize_t n,
+           const char * restrict format,
+           va_list arg);
+      int vsscanf_s(const char * restrict s,
+           const char * restrict format,
+           va_list arg);
+      char *gets_s(char *s, rsize_t n);
+
+[<a name="p486" href="#p486">page 486</a>] (<a href="#Contents">Contents</a>)
+
+<a name="B.21" href="#B.21"><b>B.21 General utilities &lt;stdlib.h&gt;</b></a>
+        size_t       ldiv_t            EXIT_FAILURE     MB_CUR_MAX
+        wchar_t      lldiv_t           EXIT_SUCCESS
+        div_t        NULL              RAND_MAX
+        double atof(const char *nptr);
+        int atoi(const char *nptr);
+        long int atol(const char *nptr);
+        long long int atoll(const char *nptr);
+        double strtod(const char * restrict nptr,
+             char ** restrict endptr);
+        float strtof(const char * restrict nptr,
+             char ** restrict endptr);
+        long double strtold(const char * restrict nptr,
+             char ** restrict endptr);
+        long int strtol(const char * restrict nptr,
+             char ** restrict endptr, int base);
+        long long int strtoll(const char * restrict nptr,
+             char ** restrict endptr, int base);
+        unsigned long int strtoul(
+             const char * restrict nptr,
+             char ** restrict endptr, int base);
+        unsigned long long int strtoull(
+             const char * restrict nptr,
+             char ** restrict endptr, int base);
+        int rand(void);
+        void srand(unsigned int seed);
+        void *aligned_alloc(size_t alignment, size_t size);
+        void *calloc(size_t nmemb, size_t size);
+        void free(void *ptr);
+        void *malloc(size_t size);
+        void *realloc(void *ptr, size_t size);
+        _Noreturn void abort(void);
+        int atexit(void (*func)(void));
+        int at_quick_exit(void (*func)(void));
+        _Noreturn void exit(int status);
+        _Noreturn void _Exit(int status);
+        char *getenv(const char *name);
+        _Noreturn void quick_exit(int status);
+        int system(const char *string);
+
+[<a name="p487" href="#p487">page 487</a>] (<a href="#Contents">Contents</a>)
+
+      void *bsearch(const void *key, const void *base,
+           size_t nmemb, size_t size,
+           int (*compar)(const void *, const void *));
+      void qsort(void *base, size_t nmemb, size_t size,
+           int (*compar)(const void *, const void *));
+      int abs(int j);
+      long int labs(long int j);
+      long long int llabs(long long int j);
+      div_t div(int numer, int denom);
+      ldiv_t ldiv(long int numer, long int denom);
+      lldiv_t lldiv(long long int numer,
+           long long int denom);
+      int mblen(const char *s, size_t n);
+      int mbtowc(wchar_t * restrict pwc,
+           const char * restrict s, size_t n);
+      int wctomb(char *s, wchar_t wchar);
+      size_t mbstowcs(wchar_t * restrict pwcs,
+           const char * restrict s, size_t n);
+      size_t wcstombs(char * restrict s,
+           const wchar_t * restrict pwcs, size_t n);
+      __STDC_WANT_LIB_EXT1__
+      errno_t
+      rsize_t
+      constraint_handler_t
+      constraint_handler_t set_constraint_handler_s(
+           constraint_handler_t handler);
+      void abort_handler_s(
+           const char * restrict msg,
+           void * restrict ptr,
+           errno_t error);
+      void ignore_handler_s(
+           const char * restrict msg,
+           void * restrict ptr,
+           errno_t error);
+      errno_t getenv_s(size_t * restrict len,
+                char * restrict value, rsize_t maxsize,
+                const char * restrict name);
+
+[<a name="p488" href="#p488">page 488</a>] (<a href="#Contents">Contents</a>)
+
+        void *bsearch_s(const void *key, const void *base,
+             rsize_t nmemb, rsize_t size,
+             int (*compar)(const void *k, const void *y,
+                             void *context),
+             void *context);
+        errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
+             int (*compar)(const void *x, const void *y,
+                             void *context),
+             void *context);
+        errno_t wctomb_s(int * restrict status,
+             char * restrict s,
+             rsize_t smax,
+             wchar_t wc);
+        errno_t mbstowcs_s(size_t * restrict retval,
+             wchar_t * restrict dst, rsize_t dstmax,
+             const char * restrict src, rsize_t len);
+        errno_t wcstombs_s(size_t * restrict retval,
+             char * restrict dst, rsize_t dstmax,
+             const wchar_t * restrict src, rsize_t len);
+<a name="B.22" href="#B.22"><b>B.22 String handling &lt;string.h&gt;</b></a>
+        size_t
+        NULL
+        void *memcpy(void * restrict s1,
+             const void * restrict s2, size_t n);
+        void *memmove(void *s1, const void *s2, size_t n);
+        char *strcpy(char * restrict s1,
+             const char * restrict s2);
+        char *strncpy(char * restrict s1,
+             const char * restrict s2, size_t n);
+        char *strcat(char * restrict s1,
+             const char * restrict s2);
+        char *strncat(char * restrict s1,
+             const char * restrict s2, size_t n);
+        int memcmp(const void *s1, const void *s2, size_t n);
+        int strcmp(const char *s1, const char *s2);
+        int strcoll(const char *s1, const char *s2);
+        int strncmp(const char *s1, const char *s2, size_t n);
+        size_t strxfrm(char * restrict s1,
+             const char * restrict s2, size_t n);
+        void *memchr(const void *s, int c, size_t n);
+
+[<a name="p489" href="#p489">page 489</a>] (<a href="#Contents">Contents</a>)
+
+      char *strchr(const char *s, int c);
+      size_t strcspn(const char *s1, const char *s2);
+      char *strpbrk(const char *s1, const char *s2);
+      char *strrchr(const char *s, int c);
+      size_t strspn(const char *s1, const char *s2);
+      char *strstr(const char *s1, const char *s2);
+      char *strtok(char * restrict s1,
+           const char * restrict s2);
+      void *memset(void *s, int c, size_t n);
+      char *strerror(int errnum);
+      size_t strlen(const char *s);
+      __STDC_WANT_LIB_EXT1__
+      errno_t
+      rsize_t
+      errno_t memcpy_s(void * restrict s1, rsize_t s1max,
+           const void * restrict s2, rsize_t n);
+      errno_t memmove_s(void *s1, rsize_t s1max,
+           const void *s2, rsize_t n);
+      errno_t strcpy_s(char * restrict s1,
+           rsize_t s1max,
+           const char * restrict s2);
+      errno_t strncpy_s(char * restrict s1,
+           rsize_t s1max,
+           const char * restrict s2,
+           rsize_t n);
+      errno_t strcat_s(char * restrict s1,
+           rsize_t s1max,
+           const char * restrict s2);
+      errno_t strncat_s(char * restrict s1,
+           rsize_t s1max,
+           const char * restrict s2,
+           rsize_t n);
+      char *strtok_s(char * restrict s1,
+           rsize_t * restrict s1max,
+           const char * restrict s2,
+           char ** restrict ptr);
+      errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)
+      errno_t strerror_s(char *s, rsize_t maxsize,
+           errno_t errnum);
+      size_t strerrorlen_s(errno_t errnum);
+
+[<a name="p490" href="#p490">page 490</a>] (<a href="#Contents">Contents</a>)
+
+        size_t strnlen_s(const char *s, size_t maxsize);
+<a name="B.23" href="#B.23"><b>B.23 Type-generic math &lt;tgmath.h&gt;</b></a>
+        acos         sqrt              fmod             nextafter
+        asin         fabs              frexp            nexttoward
+        atan         atan2             hypot            remainder
+        acosh        cbrt              ilogb            remquo
+        asinh        ceil              ldexp            rint
+        atanh        copysign          lgamma           round
+        cos          erf               llrint           scalbn
+        sin          erfc              llround          scalbln
+        tan          exp2              log10            tgamma
+        cosh         expm1             log1p            trunc
+        sinh         fdim              log2             carg
+        tanh         floor             logb             cimag
+        exp          fma               lrint            conj
+        log          fmax              lround           cproj
+        pow          fmin              nearbyint        creal
+<a name="B.24" href="#B.24"><b>B.24 Threads &lt;threads.h&gt;</b></a>
+        ONCE_FLAG_INIT                 mtx_plain
+        TSS_DTOR_ITERATIONS            mtx_recursive
+        cnd_t                          mtx_timed
+        thrd_t                         mtx_try
+        tss_t                          thrd_timeout
+        mtx_t                          thrd_success
+        tss_dtor_t                     thrd_busy
+        thrd_start_t                   thrd_error
+        once_flag                      thrd_nomem
+        xtime
+      void call_once(once_flag *flag, void (*func)(void));
+      int cnd_broadcast(cnd_t *cond);
+      void cnd_destroy(cnd_t *cond);
+      int cnd_init(cnd_t *cond);
+      int cnd_signal(cnd_t *cond);
+      int cnd_timedwait(cnd_t *cond, mtx_t *mtx,
+           const xtime *xt);
+      int cnd_wait(cnd_t *cond, mtx_t *mtx);
+      void mtx_destroy(mtx_t *mtx);
+      int mtx_init(mtx_t *mtx, int type);
+      int mtx_lock(mtx_t *mtx);
+
+[<a name="p491" href="#p491">page 491</a>] (<a href="#Contents">Contents</a>)
+
+      int mtx_timedlock(mtx_t *mtx, const xtime *xt);
+      int mtx_trylock(mtx_t *mtx);
+      int mtx_unlock(mtx_t *mtx);
+      int thrd_create(thrd_t *thr, thrd_start_t func,
+           void *arg);
+      thrd_t thrd_current(void);
+      int thrd_detach(thrd_t thr);
+      int thrd_equal(thrd_t thr0, thrd_t thr1);
+      void thrd_exit(int res);
+      int thrd_join(thrd_t thr, int *res);
+      void thrd_sleep(const xtime *xt);
+      void thrd_yield(void);
+      int tss_create(tss_t *key, tss_dtor_t dtor);
+      void tss_delete(tss_t key);
+      void *tss_get(tss_t key);
+      int tss_set(tss_t key, void *val);
+      int xtime_get(xtime *xt, int base);
+<a name="B.25" href="#B.25"><b>B.25 Date and time &lt;time.h&gt;</b></a>
+      NULL                  size_t                  time_t
+      CLOCKS_PER_SEC        clock_t                 struct tm
+      clock_t clock(void);
+      double difftime(time_t time1, time_t time0);
+      time_t mktime(struct tm *timeptr);
+      time_t time(time_t *timer);
+      char *asctime(const struct tm *timeptr);
+      char *ctime(const time_t *timer);
+      struct tm *gmtime(const time_t *timer);
+      struct tm *localtime(const time_t *timer);
+      size_t strftime(char * restrict s,
+           size_t maxsize,
+           const char * restrict format,
+           const struct tm * restrict timeptr);
+      __STDC_WANT_LIB_EXT1__
+      errno_t
+      rsize_t
+      errno_t asctime_s(char *s, rsize_t maxsize,
+           const struct tm *timeptr);
+
+[<a name="p492" href="#p492">page 492</a>] (<a href="#Contents">Contents</a>)
+
+        errno_t ctime_s(char *s, rsize_t maxsize,
+             const time_t *timer);
+        struct tm *gmtime_s(const time_t * restrict timer,
+             struct tm * restrict result);
+        struct tm *localtime_s(const time_t * restrict timer,
+             struct tm * restrict result);
+<a name="B.26" href="#B.26"><b>B.26 Unicode utilities &lt;uchar.h&gt;</b></a>
+        mbstate_t     size_t            char16_t         char32_t
+        size_t mbrtoc16(char16_t * restrict pc16,
+             const char * restrict s, size_t n,
+             mbstate_t * restrict ps);
+        size_t c16rtomb(char * restrict s, char16_t c16,
+             mbstate_t * restrict ps);
+        size_t mbrtoc32(char32_t * restrict pc32,
+             const char * restrict s, size_t n,
+             mbstate_t * restrict ps);
+        size_t c32rtomb(char * restrict s, char32_t c32,
+             mbstate_t * restrict ps);
+<a name="B.27" href="#B.27"><b>B.27 Extended multibyte/wide character utilities &lt;wchar.h&gt;</b></a>
+        wchar_t             wint_t                  WCHAR_MAX
+        size_t              struct tm               WCHAR_MIN
+        mbstate_t           NULL                    WEOF
+        int fwprintf(FILE * restrict stream,
+             const wchar_t * restrict format, ...);
+        int fwscanf(FILE * restrict stream,
+             const wchar_t * restrict format, ...);
+        int swprintf(wchar_t * restrict s, size_t n,
+             const wchar_t * restrict format, ...);
+        int swscanf(const wchar_t * restrict s,
+             const wchar_t * restrict format, ...);
+        int vfwprintf(FILE * restrict stream,
+             const wchar_t * restrict format, va_list arg);
+        int vfwscanf(FILE * restrict stream,
+             const wchar_t * restrict format, va_list arg);
+        int vswprintf(wchar_t * restrict s, size_t n,
+             const wchar_t * restrict format, va_list arg);
+
+[<a name="p493" href="#p493">page 493</a>] (<a href="#Contents">Contents</a>)
+
+      int vswscanf(const wchar_t * restrict s,
+           const wchar_t * restrict format, va_list arg);
+      int vwprintf(const wchar_t * restrict format,
+           va_list arg);
+      int vwscanf(const wchar_t * restrict format,
+           va_list arg);
+      int wprintf(const wchar_t * restrict format, ...);
+      int wscanf(const wchar_t * restrict format, ...);
+      wint_t fgetwc(FILE *stream);
+      wchar_t *fgetws(wchar_t * restrict s, int n,
+           FILE * restrict stream);
+      wint_t fputwc(wchar_t c, FILE *stream);
+      int fputws(const wchar_t * restrict s,
+           FILE * restrict stream);
+      int fwide(FILE *stream, int mode);
+      wint_t getwc(FILE *stream);
+      wint_t getwchar(void);
+      wint_t putwc(wchar_t c, FILE *stream);
+      wint_t putwchar(wchar_t c);
+      wint_t ungetwc(wint_t c, FILE *stream);
+      double wcstod(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr);
+      float wcstof(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr);
+      long double wcstold(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr);
+      long int wcstol(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      long long int wcstoll(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      unsigned long int wcstoul(const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      unsigned long long int wcstoull(
+           const wchar_t * restrict nptr,
+           wchar_t ** restrict endptr, int base);
+      wchar_t *wcscpy(wchar_t * restrict s1,
+           const wchar_t * restrict s2);
+      wchar_t *wcsncpy(wchar_t * restrict s1,
+           const wchar_t * restrict s2, size_t n);
+
+[<a name="p494" href="#p494">page 494</a>] (<a href="#Contents">Contents</a>)
+
+        wchar_t *wmemcpy(wchar_t * restrict s1,
+             const wchar_t * restrict s2, size_t n);
+        wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2,
+             size_t n);
+        wchar_t *wcscat(wchar_t * restrict s1,
+             const wchar_t * restrict s2);
+        wchar_t *wcsncat(wchar_t * restrict s1,
+             const wchar_t * restrict s2, size_t n);
+        int wcscmp(const wchar_t *s1, const wchar_t *s2);
+        int wcscoll(const wchar_t *s1, const wchar_t *s2);
+        int wcsncmp(const wchar_t *s1, const wchar_t *s2,
+             size_t n);
+        size_t wcsxfrm(wchar_t * restrict s1,
+             const wchar_t * restrict s2, size_t n);
+        int wmemcmp(const wchar_t *s1, const wchar_t *s2,
+             size_t n);
+        wchar_t *wcschr(const wchar_t *s, wchar_t c);
+        size_t wcscspn(const wchar_t *s1, const wchar_t *s2);
+        wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);
+        wchar_t *wcsrchr(const wchar_t *s, wchar_t c);
+        size_t wcsspn(const wchar_t *s1, const wchar_t *s2);
+        wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);
+        wchar_t *wcstok(wchar_t * restrict s1,
+             const wchar_t * restrict s2,
+             wchar_t ** restrict ptr);
+        wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);
+        size_t wcslen(const wchar_t *s);
+        wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);
+        size_t wcsftime(wchar_t * restrict s, size_t maxsize,
+             const wchar_t * restrict format,
+             const struct tm * restrict timeptr);
+        wint_t btowc(int c);
+        int wctob(wint_t c);
+        int mbsinit(const mbstate_t *ps);
+        size_t mbrlen(const char * restrict s, size_t n,
+             mbstate_t * restrict ps);
+        size_t mbrtowc(wchar_t * restrict pwc,
+             const char * restrict s, size_t n,
+             mbstate_t * restrict ps);
+
+[<a name="p495" href="#p495">page 495</a>] (<a href="#Contents">Contents</a>)
+
+      size_t wcrtomb(char * restrict s, wchar_t wc,
+           mbstate_t * restrict ps);
+      size_t mbsrtowcs(wchar_t * restrict dst,
+           const char ** restrict src, size_t len,
+           mbstate_t * restrict ps);
+      size_t wcsrtombs(char * restrict dst,
+           const wchar_t ** restrict src, size_t len,
+           mbstate_t * restrict ps);
+      __STDC_WANT_LIB_EXT1__
+      errno_t
+      rsize_t
+      int fwprintf_s(FILE * restrict stream,
+           const wchar_t * restrict format, ...);
+      int fwscanf_s(FILE * restrict stream,
+           const wchar_t * restrict format, ...);
+      int snwprintf_s(wchar_t * restrict s,
+           rsize_t n,
+           const wchar_t * restrict format, ...);
+      int swprintf_s(wchar_t * restrict s, rsize_t n,
+           const wchar_t * restrict format, ...);
+      int swscanf_s(const wchar_t * restrict s,
+           const wchar_t * restrict format, ...);
+      int vfwprintf_s(FILE * restrict stream,
+           const wchar_t * restrict format,
+           va_list arg);
+      int vfwscanf_s(FILE * restrict stream,
+           const wchar_t * restrict format, va_list arg);
+      int vsnwprintf_s(wchar_t * restrict s,
+           rsize_t n,
+           const wchar_t * restrict format,
+           va_list arg);
+      int vswprintf_s(wchar_t * restrict s,
+           rsize_t n,
+           const wchar_t * restrict format,
+           va_list arg);
+      int vswscanf_s(const wchar_t * restrict s,
+           const wchar_t * restrict format,
+           va_list arg);
+
+[<a name="p496" href="#p496">page 496</a>] (<a href="#Contents">Contents</a>)
+
+        int vwprintf_s(const wchar_t * restrict format,
+             va_list arg);
+        int vwscanf_s(const wchar_t * restrict format,
+             va_list arg);
+        int wprintf_s(const wchar_t * restrict format, ...);
+        int wscanf_s(const wchar_t * restrict format, ...);
+        errno_t wcscpy_s(wchar_t * restrict s1,
+             rsize_t s1max,
+             const wchar_t * restrict s2);
+        errno_t wcsncpy_s(wchar_t * restrict s1,
+             rsize_t s1max,
+             const wchar_t * restrict s2,
+             rsize_t n);
+        errno_t wmemcpy_s(wchar_t * restrict s1,
+             rsize_t s1max,
+             const wchar_t * restrict s2,
+             rsize_t n);
+        errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
+             const wchar_t *s2, rsize_t n);
+        errno_t wcscat_s(wchar_t * restrict s1,
+             rsize_t s1max,
+             const wchar_t * restrict s2);
+        errno_t wcsncat_s(wchar_t * restrict s1,
+             rsize_t s1max,
+             const wchar_t * restrict s2,
+             rsize_t n);
+        wchar_t *wcstok_s(wchar_t * restrict s1,
+             rsize_t * restrict s1max,
+             const wchar_t * restrict s2,
+             wchar_t ** restrict ptr);
+        size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
+        errno_t wcrtomb_s(size_t * restrict retval,
+             char * restrict s, rsize_t smax,
+             wchar_t wc, mbstate_t * restrict ps);
+        errno_t mbsrtowcs_s(size_t * restrict retval,
+             wchar_t * restrict dst, rsize_t dstmax,
+             const char ** restrict src, rsize_t len,
+             mbstate_t * restrict ps);
+
+[<a name="p497" href="#p497">page 497</a>] (<a href="#Contents">Contents</a>)
+
+      errno_t wcsrtombs_s(size_t * restrict retval,
+           char * restrict dst, rsize_t dstmax,
+           const wchar_t ** restrict src, rsize_t len,
+           mbstate_t * restrict ps);
+<a name="B.28" href="#B.28"><b>B.28 Wide character classification and mapping utilities &lt;wctype.h&gt;</b></a>
+      wint_t          wctrans_t         wctype_t         WEOF
+      int iswalnum(wint_t wc);
+      int iswalpha(wint_t wc);
+      int iswblank(wint_t wc);
+      int iswcntrl(wint_t wc);
+      int iswdigit(wint_t wc);
+      int iswgraph(wint_t wc);
+      int iswlower(wint_t wc);
+      int iswprint(wint_t wc);
+      int iswpunct(wint_t wc);
+      int iswspace(wint_t wc);
+      int iswupper(wint_t wc);
+      int iswxdigit(wint_t wc);
+      int iswctype(wint_t wc, wctype_t desc);
+      wctype_t wctype(const char *property);
+      wint_t towlower(wint_t wc);
+      wint_t towupper(wint_t wc);
+      wint_t towctrans(wint_t wc, wctrans_t desc);
+      wctrans_t wctrans(const char *property);
+
+[<a name="p498" href="#p498">page 498</a>] (<a href="#Contents">Contents</a>)
+
+<a name="C" href="#C"><b>                                          Annex C</b></a>
+                                        (informative)
+                                      Sequence points
+1   The following are the sequence points described in <a href="#5.1.2.3">5.1.2.3</a>:
+    -- Between the evaluations of the function designator and actual arguments in a function
+      call and the actual call. (<a href="#6.5.2.2">6.5.2.2</a>).
+    -- Between the evaluations of the first and second operands of the following operators:
+      logical AND &amp;&amp; (<a href="#6.5.13">6.5.13</a>); logical OR || (<a href="#6.5.14">6.5.14</a>); comma , (<a href="#6.5.17">6.5.17</a>).                  *
+    -- Between the evaluations of the first operand of the conditional ? : operator and
+      whichever of the second and third operands is evaluated (<a href="#6.5.15">6.5.15</a>).
+    -- The end of a full declarator: declarators (<a href="#6.7.6">6.7.6</a>);
+    -- Between the evaluation of a full expression and the next full expression to be
+      evaluated. The following are full expressions: an initializer that is not part of a
+      compound literal (<a href="#6.7.9">6.7.9</a>); the expression in an expression statement (<a href="#6.8.3">6.8.3</a>); the
+      controlling expression of a selection statement (if or switch) (<a href="#6.8.4">6.8.4</a>); the
+      controlling expression of a while or do statement (<a href="#6.8.5">6.8.5</a>); each of the (optional)
+      expressions of a for statement (<a href="#6.8.5.3">6.8.5.3</a>); the (optional) expression in a return
+      statement (<a href="#6.8.6.4">6.8.6.4</a>).
+    -- Immediately before a library function returns (<a href="#7.1.4">7.1.4</a>).
+    -- After the actions associated with each formatted input/output function conversion
+      specifier (<a href="#7.21.6">7.21.6</a>, <a href="#7.28.2">7.28.2</a>).
+    -- Immediately before and immediately after each call to a comparison function, and
+      also between any call to a comparison function and any movement of the objects
+      passed as arguments to that call (<a href="#7.22.5">7.22.5</a>).
+
+[<a name="p499" href="#p499">page 499</a>] (<a href="#Contents">Contents</a>)
+
+<a name="D" href="#D"><b>                                         Annex D</b></a>
+                                        (normative)
+                   Universal character names for identifiers
+1   This clause lists the hexadecimal code values that are valid in universal character names
+    in identifiers.
+<a name="D.1" href="#D.1"><b>    D.1 Ranges of characters allowed</b></a>
+1   00A8, 00AA, 00AD, 00AF, 00B2-00B5, 00B7-00BA, 00BC-00BE, 00C0-00D6,
+    00D8-00F6, 00F8-00FF
+2   0100-167F, 1681-180D, 180F-1FFF
+3   200B-200D, 202A-202E, 203F-2040, 2054, 2060-206F
+4   2070-218F, 2460-24FF, 2776-2793, 2C00-2DFF, 2E80-2FFF
+5   3004-3007, 3021-302F, 3031-303F
+6   3040-D7FF
+7   F900-FD3D, FD40-FDCF, FDF0-FE44, FE47-FFFD
+8   10000-1FFFD, 20000-2FFFD, 30000-3FFFD, 40000-4FFFD, 50000-5FFFD,
+    60000-6FFFD, 70000-7FFFD, 80000-8FFFD, 90000-9FFFD, A0000-AFFFD,
+    B0000-BFFFD, C0000-CFFFD, D0000-DFFFD, E0000-EFFFD
+<a name="D.2" href="#D.2"><b>    D.2 Ranges of characters disallowed initially</b></a>
+1   0300-036F, 1DC0-1DFF, 20D0-20FF, FE20-FE2F
+
+[<a name="p500" href="#p500">page 500</a>] (<a href="#Contents">Contents</a>)
+
+<a name="E" href="#E"><b>                                         Annex E</b></a>
+                                       (informative)
+                                Implementation limits
+1   The contents of the header <a href="#7.10">&lt;limits.h&gt;</a> are given below, in alphabetical order. The
+    minimum magnitudes shown shall be replaced by implementation-defined magnitudes
+    with the same sign. The values shall all be constant expressions suitable for use in #if
+    preprocessing directives. The components are described further in <a href="#5.2.4.2.1">5.2.4.2.1</a>.
+            #define    CHAR_BIT                               8
+            #define    CHAR_MAX          UCHAR_MAX or SCHAR_MAX
+            #define    CHAR_MIN                  0 or SCHAR_MIN
+            #define    INT_MAX                           +32767
+            #define    INT_MIN                           -32767
+            #define    LONG_MAX                     +2147483647
+            #define    LONG_MIN                     -2147483647
+            #define    LLONG_MAX           +9223372036854775807
+            #define    LLONG_MIN           -9223372036854775807
+            #define    MB_LEN_MAX                             1
+            #define    SCHAR_MAX                           +127
+            #define    SCHAR_MIN                           -127
+            #define    SHRT_MAX                          +32767
+            #define    SHRT_MIN                          -32767
+            #define    UCHAR_MAX                            255
+            #define    USHRT_MAX                          65535
+            #define    UINT_MAX                           65535
+            #define    ULONG_MAX                     4294967295
+            #define    ULLONG_MAX          18446744073709551615
+2   The contents of the header <a href="#7.7">&lt;float.h&gt;</a> are given below. All integer values, except
+    FLT_ROUNDS, shall be constant expressions suitable for use in #if preprocessing
+    directives; all floating values shall be constant expressions. The components are
+    described further in <a href="#5.2.4.2.2">5.2.4.2.2</a>.
+3   The values given in the following list shall be replaced by implementation-defined
+    expressions:
+            #define FLT_EVAL_METHOD
+            #define FLT_ROUNDS
+4   The values given in the following list shall be replaced by implementation-defined
+    constant expressions that are greater or equal in magnitude (absolute value) to those
+    shown, with the same sign:
+
+[<a name="p501" href="#p501">page 501</a>] (<a href="#Contents">Contents</a>)
+
+           #define    DLB_DECIMAL_DIG                                10
+           #define    DBL_DIG                                        10
+           #define    DBL_MANT_DIG
+           #define    DBL_MAX_10_EXP                               +37
+           #define    DBL_MAX_EXP
+           #define    DBL_MIN_10_EXP                               -37
+           #define    DBL_MIN_EXP
+           #define    DECIMAL_DIG                                    10
+           #define    FLT_DECIMAL_DIG                                 6
+           #define    FLT_DIG                                         6
+           #define    FLT_MANT_DIG
+           #define    FLT_MAX_10_EXP                               +37
+           #define    FLT_MAX_EXP
+           #define    FLT_MIN_10_EXP                               -37
+           #define    FLT_MIN_EXP
+           #define    FLT_RADIX                                       2
+           #define    LDLB_DECIMAL_DIG                               10
+           #define    LDBL_DIG                                       10
+           #define    LDBL_MANT_DIG
+           #define    LDBL_MAX_10_EXP                              +37
+           #define    LDBL_MAX_EXP
+           #define    LDBL_MIN_10_EXP                              -37
+           #define    LDBL_MIN_EXP
+5   The values given in the following list shall be replaced by implementation-defined
+    constant expressions with values that are greater than or equal to those shown:
+           #define DBL_MAX                                      1E+37
+           #define FLT_MAX                                      1E+37
+           #define LDBL_MAX                                     1E+37
+6   The values given in the following list shall be replaced by implementation-defined
+    constant expressions with (positive) values that are less than or equal to those shown:
+           #define    DBL_EPSILON                                1E-9
+           #define    DBL_MIN                                   1E-37
+           #define    FLT_EPSILON                                1E-5
+           #define    FLT_MIN                                   1E-37
+           #define    LDBL_EPSILON                               1E-9
+           #define    LDBL_MIN                                  1E-37
+
+[<a name="p502" href="#p502">page 502</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F" href="#F"><b>                                               Annex F</b></a>
+                                              (normative)
+                          IEC 60559 floating-point arithmetic
+<a name="F.1" href="#F.1"><b>    F.1 Introduction</b></a>
+1   This annex specifies C language support for the IEC 60559 floating-point standard. The
+    IEC 60559 floating-point standard is specifically Binary floating-point arithmetic for
+    microprocessor systems, second edition (IEC 60559:1989), previously designated
+    IEC 559:1989 and as IEEE Standard for Binary Floating-Point Arithmetic
+    (ANSI/IEEE 754-1985). IEEE Standard for Radix-Independent Floating-Point
+    Arithmetic (ANSI/IEEE 854-1987) generalizes the binary standard to remove
+    dependencies on radix and word length. IEC 60559 generally refers to the floating-point
+    standard, as in IEC 60559 operation, IEC 60559 format, etc. An implementation that
+    defines __STDC_IEC_559__ shall conform to the specifications in this annex.<sup><a href="#note343"><b>343)</b></a></sup>
+    Where a binding between the C language and IEC 60559 is indicated, the
+    IEC 60559-specified behavior is adopted by reference, unless stated otherwise. Since
+    negative and positive infinity are representable in IEC 60559 formats, all real numbers lie
+    within the range of representable values.
+<a name="F.2" href="#F.2"><b>    F.2 Types</b></a>
+1   The C floating types match the IEC 60559 formats as follows:
+    -- The float type matches the IEC 60559 single format.
+    -- The double type matches the IEC 60559 double format.
+    -- The long double type matches an IEC 60559 extended format,<sup><a href="#note344"><b>344)</b></a></sup> else a
+      non-IEC 60559 extended format, else the IEC 60559 double format.
+    Any non-IEC 60559 extended format used for the long double type shall have more
+    precision than IEC 60559 double and at least the range of IEC 60559 double.<sup><a href="#note345"><b>345)</b></a></sup>
+
+
+
+
+    <sup><a name="note343" href="#note343"><b>343)</b></a></sup> Implementations that do not define __STDC_IEC_559__ are not required to conform to these
+         specifications.
+    <sup><a name="note344" href="#note344"><b>344)</b></a></sup> ''Extended'' is IEC 60559's double-extended data format. Extended refers to both the common 80-bit
+         and quadruple 128-bit IEC 60559 formats.
+    <sup><a name="note345" href="#note345"><b>345)</b></a></sup> A non-IEC 60559 long double type is required to provide infinity and NaNs, as its values include
+         all double values.
+
+[<a name="p503" href="#p503">page 503</a>] (<a href="#Contents">Contents</a>)
+
+    Recommended practice
+2   The long double type should match an IEC 60559 extended format.
+<a name="F.2.1" href="#F.2.1"><b>    F.2.1 Infinities, signed zeros, and NaNs</b></a>
+1   This specification does not define the behavior of signaling NaNs.<sup><a href="#note346"><b>346)</b></a></sup> It generally uses
+    the term NaN to denote quiet NaNs. The NAN and INFINITY macros and the nan
+    functions in <a href="#7.12">&lt;math.h&gt;</a> provide designations for IEC 60559 NaNs and infinities.
+<a name="F.3" href="#F.3"><b>    F.3 Operators and functions</b></a>
+1   C operators and functions provide IEC 60559 required and recommended facilities as
+    listed below.
+    -- The +, -, *, and / operators provide the IEC 60559 add, subtract, multiply, and
+      divide operations.
+    -- The sqrt functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 square root operation.
+    -- The remainder functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 remainder
+      operation. The remquo functions in <a href="#7.12">&lt;math.h&gt;</a> provide the same operation but
+      with additional information.
+    -- The rint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559 operation that rounds a
+      floating-point number to an integer value (in the same precision). The nearbyint
+      functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nearbyinteger function recommended in the
+      Appendix to ANSI/IEEE 854.
+    -- The conversions for floating types provide the IEC 60559 conversions between
+      floating-point precisions.
+    -- The conversions from integer to floating types provide the IEC 60559 conversions
+      from integer to floating point.
+    -- The conversions from floating to integer types provide IEC 60559-like conversions
+      but always round toward zero.
+    -- The lrint and llrint functions in <a href="#7.12">&lt;math.h&gt;</a> provide the IEC 60559
+      conversions, which honor the directed rounding mode, from floating point to the
+      long int and long long int integer formats. The lrint and llrint
+      functions can be used to implement IEC 60559 conversions from floating to other
+      integer formats.
+    -- The translation time conversion of floating constants and the strtod, strtof,
+      strtold, fprintf, fscanf, and related library functions in <a href="#7.22">&lt;stdlib.h&gt;</a>,
+
+
+    <sup><a name="note346" href="#note346"><b>346)</b></a></sup> Since NaNs created by IEC 60559 operations are always quiet, quiet NaNs (along with infinities) are
+         sufficient for closure of the arithmetic.
+
+[<a name="p504" href="#p504">page 504</a>] (<a href="#Contents">Contents</a>)
+
+   <a href="#7.21">&lt;stdio.h&gt;</a>, and <a href="#7.28">&lt;wchar.h&gt;</a> provide IEC 60559 binary-decimal conversions. The
+   strtold function in <a href="#7.22">&lt;stdlib.h&gt;</a> provides the conv function recommended in the
+   Appendix to ANSI/IEEE 854.
+-- The relational and equality operators provide IEC 60559 comparisons. IEC 60559
+  identifies a need for additional comparison predicates to facilitate writing code that
+  accounts for NaNs. The comparison macros (isgreater, isgreaterequal,
+  isless, islessequal, islessgreater, and isunordered) in <a href="#7.12">&lt;math.h&gt;</a>
+  supplement the language operators to address this need. The islessgreater and
+  isunordered macros provide respectively a quiet version of the &lt;&gt; predicate and
+  the unordered predicate recommended in the Appendix to IEC 60559.
+-- The feclearexcept, feraiseexcept, and fetestexcept functions in
+  <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to test and alter the IEC 60559 floating-point
+  exception status flags. The fegetexceptflag and fesetexceptflag
+  functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility to save and restore all five status flags at
+  one time. These functions are used in conjunction with the type fexcept_t and the
+  floating-point     exception      macros      (FE_INEXACT,         FE_DIVBYZERO,
+  FE_UNDERFLOW, FE_OVERFLOW, FE_INVALID) also in <a href="#7.6">&lt;fenv.h&gt;</a>.
+-- The fegetround and fesetround functions in <a href="#7.6">&lt;fenv.h&gt;</a> provide the facility
+  to select among the IEC 60559 directed rounding modes represented by the rounding
+  direction macros in <a href="#7.6">&lt;fenv.h&gt;</a> (FE_TONEAREST, FE_UPWARD, FE_DOWNWARD,
+  FE_TOWARDZERO) and the values 0, 1, 2, and 3 of FLT_ROUNDS are the
+  IEC 60559 directed rounding modes.
+-- The fegetenv, feholdexcept, fesetenv, and feupdateenv functions in
+  <a href="#7.6">&lt;fenv.h&gt;</a> provide a facility to manage the floating-point environment, comprising
+  the IEC 60559 status flags and control modes.
+-- The copysign functions in <a href="#7.12">&lt;math.h&gt;</a> provide the copysign function
+  recommended in the Appendix to IEC 60559.
+-- The fabs functions in <a href="#7.12">&lt;math.h&gt;</a> provide the abs function recommended in the
+  Appendix to IEC 60559.
+-- The unary minus (-) operator provides the unary minus (-) operation recommended
+  in the Appendix to IEC 60559.
+-- The scalbn and scalbln functions in <a href="#7.12">&lt;math.h&gt;</a> provide the scalb function
+  recommended in the Appendix to IEC 60559.
+-- The logb functions in <a href="#7.12">&lt;math.h&gt;</a> provide the logb function recommended in the
+  Appendix to IEC 60559, but following the newer specifications in ANSI/IEEE 854.
+-- The nextafter and nexttoward functions in <a href="#7.12">&lt;math.h&gt;</a> provide the nextafter
+  function recommended in the Appendix to IEC 60559 (but with a minor change to
+
+[<a name="p505" href="#p505">page 505</a>] (<a href="#Contents">Contents</a>)
+
+        better handle signed zeros).
+    -- The isfinite macro in <a href="#7.12">&lt;math.h&gt;</a> provides the finite function recommended in
+      the Appendix to IEC 60559.
+    -- The isnan macro in <a href="#7.12">&lt;math.h&gt;</a> provides the isnan function recommended in the
+      Appendix to IEC 60559.
+    -- The signbit macro and the fpclassify macro in <a href="#7.12">&lt;math.h&gt;</a>, used in
+      conjunction with the number classification macros (FP_NAN, FP_INFINITE,
+      FP_NORMAL, FP_SUBNORMAL, FP_ZERO), provide the facility of the class
+      function recommended in the Appendix to IEC 60559 (except that the classification
+      macros defined in <a href="#7.12.3">7.12.3</a> do not distinguish signaling from quiet NaNs).
+<a name="F.4" href="#F.4"><b>    F.4 Floating to integer conversion</b></a>
+1   If the integer type is _Bool, <a href="#6.3.1.2">6.3.1.2</a> applies and no floating-point exceptions are raised
+    (even for NaN). Otherwise, if the floating value is infinite or NaN or if the integral part
+    of the floating value exceeds the range of the integer type, then the ''invalid'' floating-
+    point exception is raised and the resulting value is unspecified. Otherwise, the resulting
+    value is determined by <a href="#6.3.1.4">6.3.1.4</a>. Conversion of an integral floating value that does not
+    exceed the range of the integer type raises no floating-point exceptions; whether
+    conversion of a non-integral floating value raises the ''inexact'' floating-point exception is
+    unspecified.<sup><a href="#note347"><b>347)</b></a></sup>
+<a name="F.5" href="#F.5"><b>    F.5 Binary-decimal conversion</b></a>
+1   Conversion from the widest supported IEC 60559 format to decimal with
+    DECIMAL_DIG digits and back is the identity function.<sup><a href="#note348"><b>348)</b></a></sup>
+2   Conversions involving IEC 60559 formats follow all pertinent recommended practice. In
+    particular, conversion between any supported IEC 60559 format and decimal with
+    DECIMAL_DIG or fewer significant digits is correctly rounded (honoring the current
+    rounding mode), which assures that conversion from the widest supported IEC 60559
+    format to decimal with DECIMAL_DIG digits and back is the identity function.
+
+
+
+    <sup><a name="note347" href="#note347"><b>347)</b></a></sup> ANSI/IEEE 854, but not IEC 60559 (ANSI/IEEE 754), directly specifies that floating-to-integer
+         conversions raise the ''inexact'' floating-point exception for non-integer in-range values. In those
+         cases where it matters, library functions can be used to effect such conversions with or without raising
+         the ''inexact'' floating-point exception. See rint, lrint, llrint, and nearbyint in
+         <a href="#7.12">&lt;math.h&gt;</a>.
+    <sup><a name="note348" href="#note348"><b>348)</b></a></sup> If the minimum-width IEC 60559 extended format (64 bits of precision) is supported,
+         DECIMAL_DIG shall be at least 21. If IEC 60559 double (53 bits of precision) is the widest
+         IEC 60559 format supported, then DECIMAL_DIG shall be at least 17. (By contrast, LDBL_DIG and
+         DBL_DIG are 18 and 15, respectively, for these formats.)
+
+[<a name="p506" href="#p506">page 506</a>] (<a href="#Contents">Contents</a>)
+
+3   Functions such as strtod that convert character sequences to floating types honor the
+    rounding direction. Hence, if the rounding direction might be upward or downward, the
+    implementation cannot convert a minus-signed sequence by negating the converted
+    unsigned sequence.
+<a name="F.6" href="#F.6"><b>    F.6 The return statement</b></a>
+    If the return expression is evaluated in a floating-point format different from the return
+    type, the expression is converted as if by assignment<sup><a href="#note349"><b>349)</b></a></sup> to the return type of the function
+    and the resulting value is returned to the caller.
+<a name="F.7" href="#F.7"><b>    F.7 Contracted expressions</b></a>
+1   A contracted expression is correctly rounded (once) and treats infinities, NaNs, signed
+    zeros, subnormals, and the rounding directions in a manner consistent with the basic
+    arithmetic operations covered by IEC 60559.
+    Recommended practice
+2   A contracted expression should raise floating-point exceptions in a manner generally
+    consistent with the basic arithmetic operations.                                    *
+<a name="F.8" href="#F.8"><b>    F.8 Floating-point environment</b></a>
+1   The floating-point environment defined in <a href="#7.6">&lt;fenv.h&gt;</a> includes the IEC 60559 floating-
+    point exception status flags and directed-rounding control modes. It includes also
+    IEC 60559 dynamic rounding precision and trap enablement modes, if the
+    implementation supports them.<sup><a href="#note350"><b>350)</b></a></sup>
+<a name="F.8.1" href="#F.8.1"><b>    F.8.1 Environment management</b></a>
+1   IEC 60559 requires that floating-point operations implicitly raise floating-point exception
+    status flags, and that rounding control modes can be set explicitly to affect result values of
+    floating-point operations. When the state for the FENV_ACCESS pragma (defined in
+    <a href="#7.6">&lt;fenv.h&gt;</a>) is ''on'', these changes to the floating-point state are treated as side effects
+    which respect sequence points.<sup><a href="#note351"><b>351)</b></a></sup>
+
+
+
+
+    <sup><a name="note349" href="#note349"><b>349)</b></a></sup> Assignment removes any extra range and precision.
+    <sup><a name="note350" href="#note350"><b>350)</b></a></sup> This specification does not require dynamic rounding precision nor trap enablement modes.
+    <sup><a name="note351" href="#note351"><b>351)</b></a></sup> If the state for the FENV_ACCESS pragma is ''off'', the implementation is free to assume the floating-
+         point control modes will be the default ones and the floating-point status flags will not be tested,
+         which allows certain optimizations (see <a href="#F.9">F.9</a>).
+
+[<a name="p507" href="#p507">page 507</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.8.2" href="#F.8.2"><b>    F.8.2 Translation</b></a>
+1   During translation the IEC 60559 default modes are in effect:
+    -- The rounding direction mode is rounding to nearest.
+    -- The rounding precision mode (if supported) is set so that results are not shortened.
+    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+    Recommended practice
+2   The implementation should produce a diagnostic message for each translation-time
+    floating-point exception, other than ''inexact'';<sup><a href="#note352"><b>352)</b></a></sup> the implementation should then
+    proceed with the translation of the program.
+<a name="F.8.3" href="#F.8.3"><b>    F.8.3 Execution</b></a>
+1   At program startup the floating-point environment is initialized as prescribed by
+    IEC 60559:
+    -- All floating-point exception status flags are cleared.
+    -- The rounding direction mode is rounding to nearest.
+    -- The dynamic rounding precision mode (if supported) is set so that results are not
+      shortened.
+    -- Trapping or stopping (if supported) is disabled on all floating-point exceptions.
+<a name="F.8.4" href="#F.8.4"><b>    F.8.4 Constant expressions</b></a>
+1   An arithmetic constant expression of floating type, other than one in an initializer for an
+    object that has static or thread storage duration, is evaluated (as if) during execution; thus,
+    it is affected by any operative floating-point control modes and raises floating-point
+    exceptions as required by IEC 60559 (provided the state for the FENV_ACCESS pragma
+    is ''on'').<sup><a href="#note353"><b>353)</b></a></sup>
+2   EXAMPLE
+
+
+
+    <sup><a name="note352" href="#note352"><b>352)</b></a></sup> As floating constants are converted to appropriate internal representations at translation time, their
+         conversion is subject to default rounding modes and raises no execution-time floating-point exceptions
+         (even where the state of the FENV_ACCESS pragma is ''on''). Library functions, for example
+         strtod, provide execution-time conversion of numeric strings.
+    <sup><a name="note353" href="#note353"><b>353)</b></a></sup> Where the state for the FENV_ACCESS pragma is ''on'', results of inexact expressions like 1.0/3.0
+         are affected by rounding modes set at execution time, and expressions such as 0.0/0.0 and
+         1.0/0.0 generate execution-time floating-point exceptions. The programmer can achieve the
+         efficiency of translation-time evaluation through static initialization, such as
+                  const static double one_third = 1.0/3.0;
+
+[<a name="p508" href="#p508">page 508</a>] (<a href="#Contents">Contents</a>)
+
+             #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             #pragma STDC FENV_ACCESS ON
+             void f(void)
+             {
+                   float w[] = { 0.0/0.0 };                  //   raises an exception
+                   static float x = 0.0/0.0;                 //   does not raise an exception
+                   float y = 0.0/0.0;                        //   raises an exception
+                   double z = 0.0/0.0;                       //   raises an exception
+                   /* ... */
+             }
+3   For the static initialization, the division is done at translation time, raising no (execution-time) floating-
+    point exceptions. On the other hand, for the three automatic initializations the invalid division occurs at
+    execution time.
+
+<a name="F.8.5" href="#F.8.5"><b>    F.8.5 Initialization</b></a>
+1   All computation for automatic initialization is done (as if) at execution time; thus, it is
+    affected by any operative modes and raises floating-point exceptions as required by
+    IEC 60559 (provided the state for the FENV_ACCESS pragma is ''on''). All computation
+    for initialization of objects that have static or thread storage duration is done (as if) at
+    translation time.
+2   EXAMPLE
+             #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             #pragma STDC FENV_ACCESS ON
+             void f(void)
+             {
+                   float u[] = { 1.1e75 };                  //   raises exceptions
+                   static float v = 1.1e75;                 //   does not raise exceptions
+                   float w = 1.1e75;                        //   raises exceptions
+                   double x = 1.1e75;                       //   may raise exceptions
+                   float y = 1.1e75f;                       //   may raise exceptions
+                   long double z = 1.1e75;                  //   does not raise exceptions
+                   /* ... */
+             }
+3   The static initialization of v raises no (execution-time) floating-point exceptions because its computation is
+    done at translation time. The automatic initialization of u and w require an execution-time conversion to
+    float of the wider value 1.1e75, which raises floating-point exceptions. The automatic initializations
+    of x and y entail execution-time conversion; however, in some expression evaluation methods, the
+    conversions is not to a narrower format, in which case no floating-point exception is raised.<sup><a href="#note354"><b>354)</b></a></sup> The
+    automatic initialization of z entails execution-time conversion, but not to a narrower format, so no floating-
+    point exception is raised. Note that the conversions of the floating constants 1.1e75 and 1.1e75f to
+
+
+
+    <sup><a name="note354" href="#note354"><b>354)</b></a></sup> Use of float_t and double_t variables increases the likelihood of translation-time computation.
+         For example, the automatic initialization
+                  double_t x = 1.1e75;
+         could be done at translation time, regardless of the expression evaluation method.
+
+[<a name="p509" href="#p509">page 509</a>] (<a href="#Contents">Contents</a>)
+
+    their internal representations occur at translation time in all cases.
+
+<a name="F.8.6" href="#F.8.6"><b>    F.8.6 Changing the environment</b></a>
+1   Operations defined in <a href="#6.5">6.5</a> and functions and macros defined for the standard libraries
+    change floating-point status flags and control modes just as indicated by their
+    specifications (including conformance to IEC 60559). They do not change flags or modes
+    (so as to be detectable by the user) in any other cases.
+2   If the argument to the feraiseexcept function in <a href="#7.6">&lt;fenv.h&gt;</a> represents IEC 60559
+    valid coincident floating-point exceptions for atomic operations (namely ''overflow'' and
+    ''inexact'', or ''underflow'' and ''inexact''), then ''overflow'' or ''underflow'' is raised
+    before ''inexact''.
+<a name="F.9" href="#F.9"><b>    F.9 Optimization</b></a>
+1   This section identifies code transformations that might subvert IEC 60559-specified
+    behavior, and others that do not.
+<a name="F.9.1" href="#F.9.1"><b>    F.9.1 Global transformations</b></a>
+1   Floating-point arithmetic operations and external function calls may entail side effects
+    which optimization shall honor, at least where the state of the FENV_ACCESS pragma is
+    ''on''. The flags and modes in the floating-point environment may be regarded as global
+    variables; floating-point operations (+, *, etc.) implicitly read the modes and write the
+    flags.
+2   Concern about side effects may inhibit code motion and removal of seemingly useless
+    code. For example, in
+             #include <a href="#7.6">&lt;fenv.h&gt;</a>
+             #pragma STDC FENV_ACCESS ON
+             void f(double x)
+             {
+                  /* ... */
+                  for (i = 0; i &lt; n; i++) x + 1;
+                  /* ... */
+             }
+    x + 1 might raise floating-point exceptions, so cannot be removed. And since the loop
+    body might not execute (maybe 0 &gt;= n), x + 1 cannot be moved out of the loop. (Of
+    course these optimizations are valid if the implementation can rule out the nettlesome
+    cases.)
+3   This specification does not require support for trap handlers that maintain information
+    about the order or count of floating-point exceptions. Therefore, between function calls,
+    floating-point exceptions need not be precise: the actual order and number of occurrences
+    of floating-point exceptions (&gt; 1) may vary from what the source code expresses. Thus,
+
+[<a name="p510" href="#p510">page 510</a>] (<a href="#Contents">Contents</a>)
+
+    the preceding loop could be treated as
+             if (0 &lt; n) x + 1;
+<a name="F.9.2" href="#F.9.2"><b>    F.9.2 Expression transformations</b></a>
+1   x/2 &lt;-&gt; x x 0.5          Although similar transformations involving inexact constants
+                           generally do not yield numerically equivalent expressions, if the
+                           constants are exact then such transformations can be made on
+                           IEC 60559 machines and others that round perfectly.
+    1 x x and x/1 -&gt; x The expressions 1 x x, x/1, and x are equivalent (on IEC 60559
+                      machines, among others).<sup><a href="#note355"><b>355)</b></a></sup>
+    x/x -&gt; 1.0             The expressions x/x and 1.0 are not equivalent if x can be zero,
+                           infinite, or NaN.
+    x - y &lt;-&gt; x + (-y)       The expressions x - y, x + (-y), and (-y) + x are equivalent (on
+                           IEC 60559 machines, among others).
+    x - y &lt;-&gt; -(y - x)       The expressions x - y and -(y - x) are not equivalent because 1 - 1
+                           is +0 but -(1 - 1) is -0 (in the default rounding direction).<sup><a href="#note356"><b>356)</b></a></sup>
+    x - x -&gt; 0.0           The expressions x - x and 0.0 are not equivalent if x is a NaN or
+                           infinite.
+    0 x x -&gt; 0.0           The expressions 0 x x and 0.0 are not equivalent if x is a NaN,
+                           infinite, or -0.
+    x+0-&gt; x                 The expressions x + 0 and x are not equivalent if x is -0, because
+                           (-0) + (+0) yields +0 (in the default rounding direction), not -0.
+    x-0-&gt; x                 (+0) - (+0) yields -0 when rounding is downward (toward -(inf)), but
+                           +0 otherwise, and (-0) - (+0) always yields -0; so, if the state of the
+                           FENV_ACCESS pragma is ''off'', promising default rounding, then
+                           the implementation can replace x - 0 by x, even if x might be zero.
+    -x &lt;-&gt; 0 - x             The expressions -x and 0 - x are not equivalent if x is +0, because
+                           -(+0) yields -0, but 0 - (+0) yields +0 (unless rounding is
+                           downward).
+
+    <sup><a name="note355" href="#note355"><b>355)</b></a></sup> Strict support for signaling NaNs -- not required by this specification -- would invalidate these and
+         other transformations that remove arithmetic operators.
+    <sup><a name="note356" href="#note356"><b>356)</b></a></sup> IEC 60559 prescribes a signed zero to preserve mathematical identities across certain discontinuities.
+         Examples include:
+            1/(1/ (+-) (inf)) is (+-) (inf)
+         and
+            conj(csqrt(z)) is csqrt(conj(z)),
+         for complex z.
+
+[<a name="p511" href="#p511">page 511</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.9.3" href="#F.9.3"><b>    F.9.3 Relational operators</b></a>
+1   x != x -&gt; false           The expression x != x is true if x is a NaN.
+    x = x -&gt; true            The expression x = x is false if x is a NaN.
+    x &lt; y -&gt; isless(x,y) (and similarly for &lt;=, &gt;, &gt;=) Though numerically equal, these
+                   expressions are not equivalent because of side effects when x or y is a
+                   NaN and the state of the FENV_ACCESS pragma is ''on''. This
+                   transformation, which would be desirable if extra code were required
+                   to cause the ''invalid'' floating-point exception for unordered cases,
+                   could be performed provided the state of the FENV_ACCESS pragma
+                   is ''off''.
+    The sense of relational operators shall be maintained. This includes handling unordered
+    cases as expressed by the source code.
+2   EXAMPLE
+             // calls g and raises ''invalid'' if a and b are unordered
+             if (a &lt; b)
+                     f();
+             else
+                     g();
+    is not equivalent to
+             // calls f and raises ''invalid'' if a and b are unordered
+             if (a &gt;= b)
+                     g();
+             else
+                     f();
+    nor to
+             // calls f without raising ''invalid'' if a and b are unordered
+             if (isgreaterequal(a,b))
+                     g();
+             else
+                     f();
+    nor, unless the state of the FENV_ACCESS pragma is ''off'', to
+             // calls g without raising ''invalid'' if a and b are unordered
+             if (isless(a,b))
+                     f();
+             else
+                     g();
+    but is equivalent to
+
+[<a name="p512" href="#p512">page 512</a>] (<a href="#Contents">Contents</a>)
+
+            if (!(a &lt; b))
+                  g();
+            else
+                  f();
+
+<a name="F.9.4" href="#F.9.4"><b>    F.9.4 Constant arithmetic</b></a>
+1   The implementation shall honor floating-point exceptions raised by execution-time
+    constant arithmetic wherever the state of the FENV_ACCESS pragma is ''on''. (See <a href="#F.8.4">F.8.4</a>
+    and <a href="#F.8.5">F.8.5</a>.) An operation on constants that raises no floating-point exception can be
+    folded during translation, except, if the state of the FENV_ACCESS pragma is ''on'', a
+    further check is required to assure that changing the rounding direction to downward does
+    not alter the sign of the result,<sup><a href="#note357"><b>357)</b></a></sup> and implementations that support dynamic rounding
+    precision modes shall assure further that the result of the operation raises no floating-
+    point exception when converted to the semantic type of the operation.
+<a name="F.10" href="#F.10"><b>    F.10 Mathematics &lt;math.h&gt;</b></a>
+1   This subclause contains specifications of <a href="#7.12">&lt;math.h&gt;</a> facilities that are particularly suited
+    for IEC 60559 implementations.
+2   The Standard C macro HUGE_VAL and its float and long double analogs,
+    HUGE_VALF and HUGE_VALL, expand to expressions whose values are positive
+    infinities.
+3   Special cases for functions in <a href="#7.12">&lt;math.h&gt;</a> are covered directly or indirectly by
+    IEC 60559. The functions that IEC 60559 specifies directly are identified in <a href="#F.3">F.3</a>. The
+    other functions in <a href="#7.12">&lt;math.h&gt;</a> treat infinities, NaNs, signed zeros, subnormals, and
+    (provided the state of the FENV_ACCESS pragma is ''on'') the floating-point status flags
+    in a manner consistent with the basic arithmetic operations covered by IEC 60559.
+4   The expression math_errhandling &amp; MATH_ERREXCEPT shall evaluate to a
+    nonzero value.
+5   The ''invalid'' and ''divide-by-zero'' floating-point exceptions are raised as specified in
+    subsequent subclauses of this annex.
+6   The ''overflow'' floating-point exception is raised whenever an infinity -- or, because of
+    rounding direction, a maximal-magnitude finite number -- is returned in lieu of a value
+    whose magnitude is too large.
+7   The ''underflow'' floating-point exception is raised whenever a result is tiny (essentially
+    subnormal or zero) and suffers loss of accuracy.<sup><a href="#note358"><b>358)</b></a></sup>
+
+
+    <sup><a name="note357" href="#note357"><b>357)</b></a></sup> 0 - 0 yields -0 instead of +0 just when the rounding direction is downward.
+    <sup><a name="note358" href="#note358"><b>358)</b></a></sup> IEC 60559 allows different definitions of underflow. They all result in the same values, but differ on
+         when the floating-point exception is raised.
+
+[<a name="p513" href="#p513">page 513</a>] (<a href="#Contents">Contents</a>)
+
+8    Whether or when library functions raise the ''inexact'' floating-point exception is
+     unspecified, unless explicitly specified otherwise.
+9    Whether or when library functions raise an undeserved ''underflow'' floating-point
+     exception is unspecified.<sup><a href="#note359"><b>359)</b></a></sup> Otherwise, as implied by <a href="#F.8.6">F.8.6</a>, the <a href="#7.12">&lt;math.h&gt;</a> functions do
+     not raise spurious floating-point exceptions (detectable by the user), other than the
+     ''inexact'' floating-point exception.
+10   Whether the functions honor the rounding direction mode is implementation-defined,
+     unless explicitly specified otherwise.
+11   Functions with a NaN argument return a NaN result and raise no floating-point exception,
+     except where stated otherwise.
+12   The specifications in the following subclauses append to the definitions in <a href="#7.12">&lt;math.h&gt;</a>.
+     For families of functions, the specifications apply to all of the functions even though only
+     the principal function is shown. Unless otherwise specified, where the symbol ''(+-)''
+     occurs in both an argument and the result, the result has the same sign as the argument.
+     Recommended practice
+13   If a function with one or more NaN arguments returns a NaN result, the result should be
+     the same as one of the NaN arguments (after possible type conversion), except perhaps
+     for the sign.
+<a name="F.10.1" href="#F.10.1"><b>     F.10.1 Trigonometric functions</b></a>
+<a name="F.10.1.1" href="#F.10.1.1"><b>     F.10.1.1 The acos functions</b></a>
+1    -- acos(1) returns +0.
+     -- acos(x) returns a NaN and raises the ''invalid'' floating-point exception for
+       | x | &gt; 1.
+<a name="F.10.1.2" href="#F.10.1.2"><b>     F.10.1.2 The asin functions</b></a>
+1    -- asin((+-)0) returns (+-)0.
+     -- asin(x) returns a NaN and raises the ''invalid'' floating-point exception for
+       | x | &gt; 1.
+
+
+
+
+     <sup><a name="note359" href="#note359"><b>359)</b></a></sup> It is intended that undeserved ''underflow'' and ''inexact'' floating-point exceptions are raised only if
+          avoiding them would be too costly.
+
+[<a name="p514" href="#p514">page 514</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.1.3" href="#F.10.1.3"><b>    F.10.1.3 The atan functions</b></a>
+1   -- atan((+-)0) returns (+-)0.
+    -- atan((+-)(inf)) returns (+-)pi /2.
+<a name="F.10.1.4" href="#F.10.1.4"><b>    F.10.1.4 The atan2 functions</b></a>
+1   -- atan2((+-)0, -0) returns (+-)pi .<sup><a href="#note360"><b>360)</b></a></sup>
+    -- atan2((+-)0, +0) returns (+-)0.
+    -- atan2((+-)0, x) returns (+-)pi for x &lt; 0.
+    -- atan2((+-)0, x) returns (+-)0 for x &gt; 0.
+    -- atan2(y, (+-)0) returns -pi /2 for y &lt; 0.
+    -- atan2(y, (+-)0) returns pi /2 for y &gt; 0.
+    -- atan2((+-)y, -(inf)) returns (+-)pi for finite y &gt; 0.
+    -- atan2((+-)y, +(inf)) returns (+-)0 for finite y &gt; 0.
+    -- atan2((+-)(inf), x) returns (+-)pi /2 for finite x.
+    -- atan2((+-)(inf), -(inf)) returns (+-)3pi /4.
+    -- atan2((+-)(inf), +(inf)) returns (+-)pi /4.
+<a name="F.10.1.5" href="#F.10.1.5"><b>    F.10.1.5 The cos functions</b></a>
+1   -- cos((+-)0) returns 1.
+    -- cos((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+<a name="F.10.1.6" href="#F.10.1.6"><b>    F.10.1.6 The sin functions</b></a>
+1   -- sin((+-)0) returns (+-)0.
+    -- sin((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+<a name="F.10.1.7" href="#F.10.1.7"><b>    F.10.1.7 The tan functions</b></a>
+1   -- tan((+-)0) returns (+-)0.
+    -- tan((+-)(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+
+
+
+
+    <sup><a name="note360" href="#note360"><b>360)</b></a></sup> atan2(0, 0) does not raise the ''invalid'' floating-point exception, nor does atan2( y , 0) raise
+         the ''divide-by-zero'' floating-point exception.
+
+[<a name="p515" href="#p515">page 515</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.2" href="#F.10.2"><b>    F.10.2 Hyperbolic functions</b></a>
+<a name="F.10.2.1" href="#F.10.2.1"><b>    F.10.2.1 The acosh functions</b></a>
+1   -- acosh(1) returns +0.
+    -- acosh(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 1.
+    -- acosh(+(inf)) returns +(inf).
+<a name="F.10.2.2" href="#F.10.2.2"><b>    F.10.2.2 The asinh functions</b></a>
+1   -- asinh((+-)0) returns (+-)0.
+    -- asinh((+-)(inf)) returns (+-)(inf).
+<a name="F.10.2.3" href="#F.10.2.3"><b>    F.10.2.3 The atanh functions</b></a>
+1   -- atanh((+-)0) returns (+-)0.
+    -- atanh((+-)1) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- atanh(x) returns a NaN and raises the ''invalid'' floating-point exception for
+      | x | &gt; 1.
+<a name="F.10.2.4" href="#F.10.2.4"><b>    F.10.2.4 The cosh functions</b></a>
+1   -- cosh((+-)0) returns 1.
+    -- cosh((+-)(inf)) returns +(inf).
+<a name="F.10.2.5" href="#F.10.2.5"><b>    F.10.2.5 The sinh functions</b></a>
+1   -- sinh((+-)0) returns (+-)0.
+    -- sinh((+-)(inf)) returns (+-)(inf).
+<a name="F.10.2.6" href="#F.10.2.6"><b>    F.10.2.6 The tanh functions</b></a>
+1   -- tanh((+-)0) returns (+-)0.
+    -- tanh((+-)(inf)) returns (+-)1.
+<a name="F.10.3" href="#F.10.3"><b>    F.10.3 Exponential and logarithmic functions</b></a>
+<a name="F.10.3.1" href="#F.10.3.1"><b>    F.10.3.1 The exp functions</b></a>
+1   -- exp((+-)0) returns 1.
+    -- exp(-(inf)) returns +0.
+    -- exp(+(inf)) returns +(inf).
+
+[<a name="p516" href="#p516">page 516</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.3.2" href="#F.10.3.2"><b>    F.10.3.2 The exp2 functions</b></a>
+1   -- exp2((+-)0) returns 1.
+    -- exp2(-(inf)) returns +0.
+    -- exp2(+(inf)) returns +(inf).
+<a name="F.10.3.3" href="#F.10.3.3"><b>    F.10.3.3 The expm1 functions</b></a>
+1   -- expm1((+-)0) returns (+-)0.
+    -- expm1(-(inf)) returns -1.
+    -- expm1(+(inf)) returns +(inf).
+<a name="F.10.3.4" href="#F.10.3.4"><b>    F.10.3.4 The frexp functions</b></a>
+1   -- frexp((+-)0, exp) returns (+-)0, and stores 0 in the object pointed to by exp.
+    -- frexp((+-)(inf), exp) returns (+-)(inf), and stores an unspecified value in the object
+      pointed to by exp.
+    -- frexp(NaN, exp) stores an unspecified value in the object pointed to by exp
+      (and returns a NaN).
+2   frexp raises no floating-point exceptions.
+3   When the radix of the argument is a power of 2, the returned value is exact and is
+    independent of the current rounding direction mode.
+4   On a binary system, the body of the frexp function might be
+            {
+                   *exp = (value == 0) ? 0 : (int)(1 + logb(value));
+                   return scalbn(value, -(*exp));
+            }
+<a name="F.10.3.5" href="#F.10.3.5"><b>    F.10.3.5 The ilogb functions</b></a>
+1   When the correct result is representable in the range of the return type, the returned value
+    is exact and is independent of the current rounding direction mode.
+2   If the correct result is outside the range of the return type, the numeric result is
+    unspecified and the ''invalid'' floating-point exception is raised.
+
+[<a name="p517" href="#p517">page 517</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.3.6" href="#F.10.3.6"><b>    F.10.3.6 The ldexp functions</b></a>
+1   On a binary system, ldexp(x, exp) is equivalent to scalbn(x, exp).
+<a name="F.10.3.7" href="#F.10.3.7"><b>    F.10.3.7 The log functions</b></a>
+1   -- log((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log(1) returns +0.
+    -- log(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+    -- log(+(inf)) returns +(inf).
+<a name="F.10.3.8" href="#F.10.3.8"><b>    F.10.3.8 The log10 functions</b></a>
+1   -- log10((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log10(1) returns +0.
+    -- log10(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+    -- log10(+(inf)) returns +(inf).
+<a name="F.10.3.9" href="#F.10.3.9"><b>    F.10.3.9 The log1p functions</b></a>
+1   -- log1p((+-)0) returns (+-)0.
+    -- log1p(-1) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log1p(x) returns a NaN and raises the ''invalid'' floating-point exception for
+      x &lt; -1.
+    -- log1p(+(inf)) returns +(inf).
+<a name="F.10.3.10" href="#F.10.3.10"><b>    F.10.3.10 The log2 functions</b></a>
+1   -- log2((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- log2(1) returns +0.
+    -- log2(x) returns a NaN and raises the ''invalid'' floating-point exception for x &lt; 0.
+    -- log2(+(inf)) returns +(inf).
+<a name="F.10.3.11" href="#F.10.3.11"><b>    F.10.3.11 The logb functions</b></a>
+1   -- logb((+-)0) returns -(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- logb((+-)(inf)) returns +(inf).
+2   The returned value is exact and is independent of the current rounding direction mode.
+
+[<a name="p518" href="#p518">page 518</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.3.12" href="#F.10.3.12"><b>    F.10.3.12 The modf functions</b></a>
+1   -- modf((+-)x, iptr) returns a result with the same sign as x.
+    -- modf((+-)(inf), iptr) returns (+-)0 and stores (+-)(inf) in the object pointed to by iptr.
+    -- modf(NaN, iptr) stores a NaN in the object pointed to by iptr (and returns a
+      NaN).
+2   The returned values are exact and are independent of the current rounding direction
+    mode.
+3   modf behaves as though implemented by
+            #include <a href="#7.12">&lt;math.h&gt;</a>
+            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            #pragma STDC FENV_ACCESS ON
+            double modf(double value, double *iptr)
+            {
+                 int save_round = fegetround();
+                 fesetround(FE_TOWARDZERO);
+                 *iptr = nearbyint(value);
+                 fesetround(save_round);
+                 return copysign(
+                      isinf(value) ? 0.0 :
+                           value - (*iptr), value);
+            }
+<a name="F.10.3.13" href="#F.10.3.13"><b>    F.10.3.13 The scalbn and scalbln functions</b></a>
+1   -- scalbn((+-)0, n) returns (+-)0.
+    -- scalbn(x, 0) returns x.
+    -- scalbn((+-)(inf), n) returns (+-)(inf).
+2   If the calculation does not overflow or underflow, the returned value is exact and
+    independent of the current rounding direction mode.
+
+[<a name="p519" href="#p519">page 519</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.4" href="#F.10.4"><b>    F.10.4 Power and absolute value functions</b></a>
+<a name="F.10.4.1" href="#F.10.4.1"><b>    F.10.4.1 The cbrt functions</b></a>
+1   -- cbrt((+-)0) returns (+-)0.
+    -- cbrt((+-)(inf)) returns (+-)(inf).
+<a name="F.10.4.2" href="#F.10.4.2"><b>    F.10.4.2 The fabs functions</b></a>
+1   -- fabs((+-)0) returns +0.
+    -- fabs((+-)(inf)) returns +(inf).
+2   The returned value is exact and is independent of the current rounding direction mode.
+<a name="F.10.4.3" href="#F.10.4.3"><b>    F.10.4.3 The hypot functions</b></a>
+1   -- hypot(x, y), hypot(y, x), and hypot(x, -y) are equivalent.
+    -- hypot(x, (+-)0) is equivalent to fabs(x).
+    -- hypot((+-)(inf), y) returns +(inf), even if y is a NaN.
+<a name="F.10.4.4" href="#F.10.4.4"><b>    F.10.4.4 The pow functions</b></a>
+1   -- pow((+-)0, y) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception
+      for y an odd integer &lt; 0.
+    -- pow((+-)0, y) returns +(inf) and raises the ''divide-by-zero'' floating-point exception
+      for y &lt; 0, finite, and not an odd integer.
+    -- pow((+-)0, -(inf)) returns +(inf) and may raise the ''divide-by-zero'' floating-point
+      exception.
+    -- pow((+-)0, y) returns (+-)0 for y an odd integer &gt; 0.
+    -- pow((+-)0, y) returns +0 for y &gt; 0 and not an odd integer.
+    -- pow(-1, (+-)(inf)) returns 1.
+    -- pow(+1, y) returns 1 for any y, even a NaN.
+    -- pow(x, (+-)0) returns 1 for any x, even a NaN.
+    -- pow(x, y) returns a NaN and raises the ''invalid'' floating-point exception for
+      finite x &lt; 0 and finite non-integer y.
+    -- pow(x, -(inf)) returns +(inf) for | x | &lt; 1.
+    -- pow(x, -(inf)) returns +0 for | x | &gt; 1.
+    -- pow(x, +(inf)) returns +0 for | x | &lt; 1.
+    -- pow(x, +(inf)) returns +(inf) for | x | &gt; 1.
+
+[<a name="p520" href="#p520">page 520</a>] (<a href="#Contents">Contents</a>)
+
+    -- pow(-(inf), y) returns -0 for y an odd integer &lt; 0.
+    -- pow(-(inf), y) returns +0 for y &lt; 0 and not an odd integer.
+    -- pow(-(inf), y) returns -(inf) for y an odd integer &gt; 0.
+    -- pow(-(inf), y) returns +(inf) for y &gt; 0 and not an odd integer.
+    -- pow(+(inf), y) returns +0 for y &lt; 0.
+    -- pow(+(inf), y) returns +(inf) for y &gt; 0.
+<a name="F.10.4.5" href="#F.10.4.5"><b>    F.10.4.5 The sqrt functions</b></a>
+1   sqrt is fully specified as a basic arithmetic operation in IEC 60559. The returned value
+    is dependent on the current rounding direction mode.
+<a name="F.10.5" href="#F.10.5"><b>    F.10.5 Error and gamma functions</b></a>
+<a name="F.10.5.1" href="#F.10.5.1"><b>    F.10.5.1 The erf functions</b></a>
+1   -- erf((+-)0) returns (+-)0.
+    -- erf((+-)(inf)) returns (+-)1.
+<a name="F.10.5.2" href="#F.10.5.2"><b>    F.10.5.2 The erfc functions</b></a>
+1   -- erfc(-(inf)) returns 2.
+    -- erfc(+(inf)) returns +0.
+<a name="F.10.5.3" href="#F.10.5.3"><b>    F.10.5.3 The lgamma functions</b></a>
+1   -- lgamma(1) returns +0.
+    -- lgamma(2) returns +0.
+    -- lgamma(x) returns +(inf) and raises the ''divide-by-zero'' floating-point exception for
+      x a negative integer or zero.
+    -- lgamma(-(inf)) returns +(inf).
+    -- lgamma(+(inf)) returns +(inf).
+<a name="F.10.5.4" href="#F.10.5.4"><b>    F.10.5.4 The tgamma functions</b></a>
+1   -- tgamma((+-)0) returns (+-)(inf) and raises the ''divide-by-zero'' floating-point exception.
+    -- tgamma(x) returns a NaN and raises the ''invalid'' floating-point exception for x a
+      negative integer.
+    -- tgamma(-(inf)) returns a NaN and raises the ''invalid'' floating-point exception.
+    -- tgamma(+(inf)) returns +(inf).
+
+[<a name="p521" href="#p521">page 521</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.6" href="#F.10.6"><b>    F.10.6 Nearest integer functions</b></a>
+<a name="F.10.6.1" href="#F.10.6.1"><b>    F.10.6.1 The ceil functions</b></a>
+1   -- ceil((+-)0) returns (+-)0.
+    -- ceil((+-)(inf)) returns (+-)(inf).
+2   The returned value is independent of the current rounding direction mode.
+3   The double version of ceil behaves as though implemented by
+           #include <a href="#7.12">&lt;math.h&gt;</a>
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           #pragma STDC FENV_ACCESS ON
+           double ceil(double x)
+           {
+                double result;
+                int save_round = fegetround();
+                fesetround(FE_UPWARD);
+                result = rint(x); // or nearbyint instead of rint
+                fesetround(save_round);
+                return result;
+           }
+4   The ceil functions may, but are not required to, raise the ''inexact'' floating-point
+    exception for finite non-integer arguments, as this implementation does.
+<a name="F.10.6.2" href="#F.10.6.2"><b>    F.10.6.2 The floor functions</b></a>
+1   -- floor((+-)0) returns (+-)0.
+    -- floor((+-)(inf)) returns (+-)(inf).
+2   The returned value and is independent of the current rounding direction mode.
+3   See the sample implementation for ceil in <a href="#F.10.6.1">F.10.6.1</a>. The floor functions may, but are
+    not required to, raise the ''inexact'' floating-point exception for finite non-integer
+    arguments, as that implementation does.
+<a name="F.10.6.3" href="#F.10.6.3"><b>    F.10.6.3 The nearbyint functions</b></a>
+1   The nearbyint functions use IEC 60559 rounding according to the current rounding
+    direction. They do not raise the ''inexact'' floating-point exception if the result differs in
+    value from the argument.
+    -- nearbyint((+-)0) returns (+-)0 (for all rounding directions).
+    -- nearbyint((+-)(inf)) returns (+-)(inf) (for all rounding directions).
+
+[<a name="p522" href="#p522">page 522</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.6.4" href="#F.10.6.4"><b>    F.10.6.4 The rint functions</b></a>
+1   The rint functions differ from the nearbyint functions only in that they do raise the
+    ''inexact'' floating-point exception if the result differs in value from the argument.
+<a name="F.10.6.5" href="#F.10.6.5"><b>    F.10.6.5 The lrint and llrint functions</b></a>
+1   The lrint and llrint functions provide floating-to-integer conversion as prescribed
+    by IEC 60559. They round according to the current rounding direction. If the rounded
+    value is outside the range of the return type, the numeric result is unspecified and the
+    ''invalid'' floating-point exception is raised. When they raise no other floating-point
+    exception and the result differs from the argument, they raise the ''inexact'' floating-point
+    exception.
+<a name="F.10.6.6" href="#F.10.6.6"><b>    F.10.6.6 The round functions</b></a>
+1   -- round((+-)0) returns (+-)0.
+    -- round((+-)(inf)) returns (+-)(inf).
+2   The returned value is independent of the current rounding direction mode.
+3   The double version of round behaves as though implemented by
+            #include <a href="#7.12">&lt;math.h&gt;</a>
+            #include <a href="#7.6">&lt;fenv.h&gt;</a>
+            #pragma STDC FENV_ACCESS ON
+            double round(double x)
+            {
+                 double result;
+                 fenv_t save_env;
+                 feholdexcept(&amp;save_env);
+                 result = rint(x);
+                 if (fetestexcept(FE_INEXACT)) {
+                      fesetround(FE_TOWARDZERO);
+                      result = rint(copysign(0.5 + fabs(x), x));
+                 }
+                 feupdateenv(&amp;save_env);
+                 return result;
+            }
+    The round functions may, but are not required to, raise the ''inexact'' floating-point
+    exception for finite non-integer numeric arguments, as this implementation does.
+
+[<a name="p523" href="#p523">page 523</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.6.7" href="#F.10.6.7"><b>    F.10.6.7 The lround and llround functions</b></a>
+1   The lround and llround functions differ from the lrint and llrint functions
+    with the default rounding direction just in that the lround and llround functions
+    round halfway cases away from zero and need not raise the ''inexact'' floating-point
+    exception for non-integer arguments that round to within the range of the return type.
+<a name="F.10.6.8" href="#F.10.6.8"><b>    F.10.6.8 The trunc functions</b></a>
+1   The trunc functions use IEC 60559 rounding toward zero (regardless of the current
+    rounding direction). The returned value is exact.
+    -- trunc((+-)0) returns (+-)0.
+    -- trunc((+-)(inf)) returns (+-)(inf).
+2   The returned value is independent of the current rounding direction mode. The trunc
+    functions may, but are not required to, raise the ''inexact'' floating-point exception for
+    finite non-integer arguments.
+<a name="F.10.7" href="#F.10.7"><b>    F.10.7 Remainder functions</b></a>
+<a name="F.10.7.1" href="#F.10.7.1"><b>    F.10.7.1 The fmod functions</b></a>
+1   -- fmod((+-)0, y) returns (+-)0 for y not zero.
+    -- fmod(x, y) returns a NaN and raises the ''invalid'' floating-point exception for x
+      infinite or y zero (and neither is a NaN).
+    -- fmod(x, (+-)(inf)) returns x for x not infinite.
+2   When subnormal results are supported, the returned value is exact and is independent of
+    the current rounding direction mode.
+3   The double version of fmod behaves as though implemented by
+           #include <a href="#7.12">&lt;math.h&gt;</a>
+           #include <a href="#7.6">&lt;fenv.h&gt;</a>
+           #pragma STDC FENV_ACCESS ON
+           double fmod(double x, double y)
+           {
+                double result;
+                result = remainder(fabs(x), (y = fabs(y)));
+                if (signbit(result)) result += y;
+                return copysign(result, x);
+           }
+
+[<a name="p524" href="#p524">page 524</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.7.2" href="#F.10.7.2"><b>    F.10.7.2 The remainder functions</b></a>
+1   The remainder functions are fully specified as a basic arithmetic operation in
+    IEC 60559.
+2   When subnormal results are supported, the returned value is exact and is independent of
+    the current rounding direction mode.
+<a name="F.10.7.3" href="#F.10.7.3"><b>    F.10.7.3 The remquo functions</b></a>
+1   The remquo functions follow the specifications for the remainder functions. They
+    have no further specifications special to IEC 60559 implementations.
+2   When subnormal results are supported, the returned value is exact and is independent of
+    the current rounding direction mode.
+<a name="F.10.8" href="#F.10.8"><b>    F.10.8 Manipulation functions</b></a>
+<a name="F.10.8.1" href="#F.10.8.1"><b>    F.10.8.1 The copysign functions</b></a>
+1   copysign is specified in the Appendix to IEC 60559.
+2   The returned value is exact and is independent of the current rounding direction mode.
+<a name="F.10.8.2" href="#F.10.8.2"><b>    F.10.8.2 The nan functions</b></a>
+1   All IEC 60559 implementations support quiet NaNs, in all floating formats.
+2   The returned value is exact and is independent of the current rounding direction mode.
+<a name="F.10.8.3" href="#F.10.8.3"><b>    F.10.8.3 The nextafter functions</b></a>
+1   -- nextafter(x, y) raises the ''overflow'' and ''inexact'' floating-point exceptions
+      for x finite and the function value infinite.
+    -- nextafter(x, y) raises the ''underflow'' and ''inexact'' floating-point
+      exceptions for the function value subnormal or zero and x != y.
+2   Even though underflow or overflow can occur, the returned value is independent of the
+    current rounding direction mode.
+<a name="F.10.8.4" href="#F.10.8.4"><b>    F.10.8.4 The nexttoward functions</b></a>
+1   No additional requirements beyond those on nextafter.
+2   Even though underflow or overflow can occur, the returned value is independent of the
+    current rounding direction mode.
+
+[<a name="p525" href="#p525">page 525</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.9" href="#F.10.9"><b>    F.10.9 Maximum, minimum, and positive difference functions</b></a>
+<a name="F.10.9.1" href="#F.10.9.1"><b>    F.10.9.1 The fdim functions</b></a>
+1   No additional requirements.
+<a name="F.10.9.2" href="#F.10.9.2"><b>    F.10.9.2 The fmax functions</b></a>
+1   If just one argument is a NaN, the fmax functions return the other argument (if both
+    arguments are NaNs, the functions return a NaN).
+2   The returned value is exact and is independent of the current rounding direction mode.
+3   The body of the fmax function might be<sup><a href="#note361"><b>361)</b></a></sup>
+           { return (isgreaterequal(x, y) ||
+                isnan(y)) ? x : y; }
+<a name="F.10.9.3" href="#F.10.9.3"><b>    F.10.9.3 The fmin functions</b></a>
+1   The fmin functions are analogous to the fmax functions (see <a href="#F.10.9.2">F.10.9.2</a>).
+2   The returned value is exact and is independent of the current rounding direction mode.
+<a name="F.10.10" href="#F.10.10"><b>    F.10.10 Floating multiply-add</b></a>
+<a name="F.10.10.1" href="#F.10.10.1"><b>    F.10.10.1 The fma functions</b></a>
+1   -- fma(x, y, z) computes xy + z, correctly rounded once.
+    -- fma(x, y, z) returns a NaN and optionally raises the ''invalid'' floating-point
+      exception if one of x and y is infinite, the other is zero, and z is a NaN.
+    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if
+      one of x and y is infinite, the other is zero, and z is not a NaN.
+    -- fma(x, y, z) returns a NaN and raises the ''invalid'' floating-point exception if x
+      times y is an exact infinity and z is also an infinity but with the opposite sign.
+
+
+
+
+    <sup><a name="note361" href="#note361"><b>361)</b></a></sup> Ideally, fmax would be sensitive to the sign of zero, for example fmax(-0.0, +0.0) would
+         return +0; however, implementation in software might be impractical.
+
+[<a name="p526" href="#p526">page 526</a>] (<a href="#Contents">Contents</a>)
+
+<a name="F.10.11" href="#F.10.11"><b>    F.10.11 Comparison macros</b></a>
+1   Relational operators and their corresponding comparison macros (<a href="#7.12.14">7.12.14</a>) produce
+    equivalent result values, even if argument values are represented in wider formats. Thus,
+    comparison macro arguments represented in formats wider than their semantic types are
+    not converted to the semantic types, unless the wide evaluation method converts operands
+    of relational operators to their semantic types. The standard wide evaluation methods
+    characterized by FLT_EVAL_METHOD equal to 1 or 2 (<a href="#5.2.4.2.2">5.2.4.2.2</a>), do not convert
+    operands of relational operators to their semantic types.
+
+[<a name="p527" href="#p527">page 527</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G" href="#G"><b>                                           Annex G</b></a>
+                                          (normative)
+                   IEC 60559-compatible complex arithmetic
+<a name="G.1" href="#G.1"><b>    G.1 Introduction</b></a>
+1   This annex supplements <a href="#F">annex F</a> to specify complex arithmetic for compatibility with
+    IEC 60559 real floating-point arithmetic. An implementation that defines *
+    __STDC_IEC_559_COMPLEX__ shall conform to the specifications in this annex.<sup><a href="#note362"><b>362)</b></a></sup>
+<a name="G.2" href="#G.2"><b>    G.2 Types</b></a>
+1   There is a new keyword _Imaginary, which is used to specify imaginary types. It is
+    used as a type specifier within declaration specifiers in the same way as _Complex is
+    (thus, _Imaginary float is a valid type name).
+2   There are three imaginary types, designated as float _Imaginary, double
+    _Imaginary, and long double _Imaginary. The imaginary types (along with
+    the real floating and complex types) are floating types.
+3   For imaginary types, the corresponding real type is given by deleting the keyword
+    _Imaginary from the type name.
+4   Each imaginary type has the same representation and alignment requirements as the
+    corresponding real type. The value of an object of imaginary type is the value of the real
+    representation times the imaginary unit.
+5   The imaginary type domain comprises the imaginary types.
+<a name="G.3" href="#G.3"><b>    G.3 Conventions</b></a>
+1   A complex or imaginary value with at least one infinite part is regarded as an infinity
+    (even if its other part is a NaN). A complex or imaginary value is a finite number if each
+    of its parts is a finite number (neither infinite nor NaN). A complex or imaginary value is
+    a zero if each of its parts is a zero.
+
+
+
+
+    <sup><a name="note362" href="#note362"><b>362)</b></a></sup> Implementations that do not define __STDC_IEC_559_COMPLEX__ are not required to conform
+         to these specifications.
+
+[<a name="p528" href="#p528">page 528</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.4" href="#G.4"><b>    G.4 Conversions</b></a>
+<a name="G.4.1" href="#G.4.1"><b>    G.4.1 Imaginary types</b></a>
+1   Conversions among imaginary types follow rules analogous to those for real floating
+    types.
+<a name="G.4.2" href="#G.4.2"><b>    G.4.2 Real and imaginary</b></a>
+1   When a value of imaginary type is converted to a real type other than _Bool,<sup><a href="#note363"><b>363)</b></a></sup> the
+    result is a positive zero.
+2   When a value of real type is converted to an imaginary type, the result is a positive
+    imaginary zero.
+<a name="G.4.3" href="#G.4.3"><b>    G.4.3 Imaginary and complex</b></a>
+1   When a value of imaginary type is converted to a complex type, the real part of the
+    complex result value is a positive zero and the imaginary part of the complex result value
+    is determined by the conversion rules for the corresponding real types.
+2   When a value of complex type is converted to an imaginary type, the real part of the
+    complex value is discarded and the value of the imaginary part is converted according to
+    the conversion rules for the corresponding real types.
+<a name="G.5" href="#G.5"><b>    G.5 Binary operators</b></a>
+1   The following subclauses supplement <a href="#6.5">6.5</a> in order to specify the type of the result for an
+    operation with an imaginary operand.
+2   For most operand types, the value of the result of a binary operator with an imaginary or
+    complex operand is completely determined, with reference to real arithmetic, by the usual
+    mathematical formula. For some operand types, the usual mathematical formula is
+    problematic because of its treatment of infinities and because of undue overflow or
+    underflow; in these cases the result satisfies certain properties (specified in <a href="#G.5.1">G.5.1</a>), but is
+    not completely determined.
+
+
+
+
+    <sup><a name="note363" href="#note363"><b>363)</b></a></sup> See <a href="#6.3.1.2">6.3.1.2</a>.
+
+[<a name="p529" href="#p529">page 529</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.5.1" href="#G.5.1"><b>    G.5.1 Multiplicative operators</b></a>
+<b>    Semantics</b>
+1   If one operand has real type and the other operand has imaginary type, then the result has
+    imaginary type. If both operands have imaginary type, then the result has real type. (If
+    either operand has complex type, then the result has complex type.)
+2   If the operands are not both complex, then the result and floating-point exception
+    behavior of the * operator is defined by the usual mathematical formula:
+           *                  u                   iv                 u + iv
+
+           x                  xu                i(xv)            (xu) + i(xv)
+
+           iy               i(yu)                -yv            (-yv) + i(yu)
+
+           x + iy       (xu) + i(yu)        (-yv) + i(xv)
+3   If the second operand is not complex, then the result and floating-point exception
+    behavior of the / operator is defined by the usual mathematical formula:
+           /                   u                       iv
+
+           x                  x/u                 i(-x/v)
+
+           iy               i(y/u)                     y/v
+
+           x + iy       (x/u) + i(y/u)        (y/v) + i(-x/v)
+4   The * and / operators satisfy the following infinity properties for all real, imaginary, and
+    complex operands:<sup><a href="#note364"><b>364)</b></a></sup>
+    -- if one operand is an infinity and the other operand is a nonzero finite number or an
+      infinity, then the result of the * operator is an infinity;
+    -- if the first operand is an infinity and the second operand is a finite number, then the
+      result of the / operator is an infinity;
+    -- if the first operand is a finite number and the second operand is an infinity, then the
+      result of the / operator is a zero;
+
+
+
+
+    <sup><a name="note364" href="#note364"><b>364)</b></a></sup> These properties are already implied for those cases covered in the tables, but are required for all cases
+         (at least where the state for CX_LIMITED_RANGE is ''off'').
+
+[<a name="p530" href="#p530">page 530</a>] (<a href="#Contents">Contents</a>)
+
+    -- if the first operand is a nonzero finite number or an infinity and the second operand is
+      a zero, then the result of the / operator is an infinity.
+5   If both operands of the * operator are complex or if the second operand of the / operator
+    is complex, the operator raises floating-point exceptions if appropriate for the calculation
+    of the parts of the result, and may raise spurious floating-point exceptions.
+6   EXAMPLE 1 Multiplication of double _Complex operands could be implemented as follows. Note
+    that the imaginary unit I has imaginary type (see <a href="#G.6">G.6</a>).
+             #include <a href="#7.12">&lt;math.h&gt;</a>
+             #include <a href="#7.3">&lt;complex.h&gt;</a>
+             /* Multiply z * w ... */
+             double complex _Cmultd(double complex z, double complex w)
+             {
+                    #pragma STDC FP_CONTRACT OFF
+                    double a, b, c, d, ac, bd, ad, bc, x, y;
+                    a = creal(z); b = cimag(z);
+                    c = creal(w); d = cimag(w);
+                    ac = a * c;       bd = b * d;
+                    ad = a * d;       bc = b * c;
+                    x = ac - bd; y = ad + bc;
+                    if (isnan(x) &amp;&amp; isnan(y)) {
+                            /* Recover infinities that computed as NaN+iNaN ... */
+                            int recalc = 0;
+                            if ( isinf(a) || isinf(b) ) { // z is infinite
+                                    /* "Box" the infinity and change NaNs in the other factor to 0 */
+                                    a = copysign(isinf(a) ? 1.0 : 0.0, a);
+                                    b = copysign(isinf(b) ? 1.0 : 0.0, b);
+                                    if (isnan(c)) c = copysign(0.0, c);
+                                    if (isnan(d)) d = copysign(0.0, d);
+                                    recalc = 1;
+                            }
+                            if ( isinf(c) || isinf(d) ) { // w is infinite
+                                    /* "Box" the infinity and change NaNs in the other factor to 0 */
+                                    c = copysign(isinf(c) ? 1.0 : 0.0, c);
+                                    d = copysign(isinf(d) ? 1.0 : 0.0, d);
+                                    if (isnan(a)) a = copysign(0.0, a);
+                                    if (isnan(b)) b = copysign(0.0, b);
+                                    recalc = 1;
+                            }
+                            if (!recalc &amp;&amp; (isinf(ac) || isinf(bd) ||
+                                                   isinf(ad) || isinf(bc))) {
+                                    /* Recover infinities from overflow by changing NaNs to 0 ... */
+                                    if (isnan(a)) a = copysign(0.0, a);
+                                    if (isnan(b)) b = copysign(0.0, b);
+                                    if (isnan(c)) c = copysign(0.0, c);
+                                    if (isnan(d)) d = copysign(0.0, d);
+                                    recalc = 1;
+                            }
+                            if (recalc) {
+
+[<a name="p531" href="#p531">page 531</a>] (<a href="#Contents">Contents</a>)
+
+                                      x = INFINITY * ( a * c - b * d );
+                                      y = INFINITY * ( a * d + b * c );
+                           }
+                     }
+                     return x + I * y;
+            }
+7   This implementation achieves the required treatment of infinities at the cost of only one isnan test in
+    ordinary (finite) cases. It is less than ideal in that undue overflow and underflow may occur.
+
+8   EXAMPLE 2      Division of two double _Complex operands could be implemented as follows.
+            #include <a href="#7.12">&lt;math.h&gt;</a>
+            #include <a href="#7.3">&lt;complex.h&gt;</a>
+            /* Divide z / w ... */
+            double complex _Cdivd(double complex z, double complex w)
+            {
+                   #pragma STDC FP_CONTRACT OFF
+                   double a, b, c, d, logbw, denom, x, y;
+                   int ilogbw = 0;
+                   a = creal(z); b = cimag(z);
+                   c = creal(w); d = cimag(w);
+                   logbw = logb(fmax(fabs(c), fabs(d)));
+                   if (logbw == INFINITY) {
+                          ilogbw = (int)logbw;
+                          c = scalbn(c, -ilogbw); d = scalbn(d, -ilogbw);
+                   }
+                   denom = c * c + d * d;
+                   x = scalbn((a * c + b * d) / denom, -ilogbw);
+                   y = scalbn((b * c - a * d) / denom, -ilogbw);
+                     /* Recover infinities and zeros that computed as NaN+iNaN;                 */
+                     /* the only cases are nonzero/zero, infinite/finite, and finite/infinite, ... */
+                     if (isnan(x) &amp;&amp; isnan(y)) {
+                           if ((denom == 0.0) &amp;&amp;
+                                 (!isnan(a) || !isnan(b))) {
+                                 x = copysign(INFINITY, c) * a;
+                                 y = copysign(INFINITY, c) * b;
+                           }
+                           else if ((isinf(a) || isinf(b)) &amp;&amp;
+                                 isfinite(c) &amp;&amp; isfinite(d)) {
+                                 a = copysign(isinf(a) ? 1.0 : 0.0,                        a);
+                                 b = copysign(isinf(b) ? 1.0 : 0.0,                        b);
+                                 x = INFINITY * ( a * c + b * d );
+                                 y = INFINITY * ( b * c - a * d );
+                           }
+                           else if (isinf(logbw) &amp;&amp;
+                                 isfinite(a) &amp;&amp; isfinite(b)) {
+                                 c = copysign(isinf(c) ? 1.0 : 0.0,                        c);
+                                 d = copysign(isinf(d) ? 1.0 : 0.0,                        d);
+                                 x = 0.0 * ( a * c + b * d );
+                                 y = 0.0 * ( b * c - a * d );
+
+[<a name="p532" href="#p532">page 532</a>] (<a href="#Contents">Contents</a>)
+
+                           }
+                     }
+                     return x + I * y;
+            }
+9   Scaling the denominator alleviates the main overflow and underflow problem, which is more serious than
+    for multiplication. In the spirit of the multiplication example above, this code does not defend against
+    overflow and underflow in the calculation of the numerator. Scaling with the scalbn function, instead of
+    with division, provides better roundoff characteristics.
+
+<a name="G.5.2" href="#G.5.2"><b>    G.5.2 Additive operators</b></a>
+<b>    Semantics</b>
+1   If both operands have imaginary type, then the result has imaginary type. (If one operand
+    has real type and the other operand has imaginary type, or if either operand has complex
+    type, then the result has complex type.)
+2   In all cases the result and floating-point exception behavior of a + or - operator is defined
+    by the usual mathematical formula:
+           + or -              u                       iv                    u + iv
+
+           x                 x(+-)u                     x (+-) iv              (x (+-) u) (+-) iv
+
+           iy               (+-)u + iy                 i(y (+-) v)             (+-)u + i(y (+-) v)
+
+           x + iy         (x (+-) u) + iy            x + i(y (+-) v)        (x (+-) u) + i(y (+-) v)
+<a name="G.6" href="#G.6"><b>    G.6 Complex arithmetic &lt;complex.h&gt;</b></a>
+1   The macros
+            imaginary
+    and
+            _Imaginary_I
+    are defined, respectively, as _Imaginary and a constant expression of type const
+    float _Imaginary with the value of the imaginary unit. The macro
+            I
+    is defined to be _Imaginary_I (not _Complex_I as stated in <a href="#7.3">7.3</a>). Notwithstanding
+    the provisions of <a href="#7.1.3">7.1.3</a>, a program may undefine and then perhaps redefine the macro
+    imaginary.
+2   This subclause contains specifications for the <a href="#7.3">&lt;complex.h&gt;</a> functions that are
+    particularly suited to IEC 60559 implementations. For families of functions, the
+    specifications apply to all of the functions even though only the principal function is
+
+[<a name="p533" href="#p533">page 533</a>] (<a href="#Contents">Contents</a>)
+
+    shown. Unless otherwise specified, where the symbol ''(+-)'' occurs in both an argument
+    and the result, the result has the same sign as the argument.
+3   The functions are continuous onto both sides of their branch cuts, taking into account the
+    sign of zero. For example, csqrt(-2 (+-) i0) = (+-)i(sqrt)2.  -
+4   Since complex and imaginary values are composed of real values, each function may be
+    regarded as computing real values from real values. Except as noted, the functions treat
+    real infinities, NaNs, signed zeros, subnormals, and the floating-point exception flags in a
+    manner consistent with the specifications for real functions in F.10.<sup><a href="#note365"><b>365)</b></a></sup>
+5   The functions cimag, conj, cproj, and creal are fully specified for all
+    implementations, including IEC 60559 ones, in <a href="#7.3.9">7.3.9</a>. These functions raise no floating-
+    point exceptions.
+6   Each of the functions cabs and carg is specified by a formula in terms of a real
+    function (whose special cases are covered in <a href="#F">annex F</a>):
+            cabs(x + iy) = hypot(x, y)
+            carg(x + iy) = atan2(y, x)
+7   Each of the functions casin, catan, ccos, csin, and ctan is specified implicitly by
+    a formula in terms of other complex functions (whose special cases are specified below):
+            casin(z)        =   -i casinh(iz)
+            catan(z)        =   -i catanh(iz)
+            ccos(z)         =   ccosh(iz)
+            csin(z)         =   -i csinh(iz)
+            ctan(z)         =   -i ctanh(iz)
+8   For the other functions, the following subclauses specify behavior for special cases,
+    including treatment of the ''invalid'' and ''divide-by-zero'' floating-point exceptions. For
+    families of functions, the specifications apply to all of the functions even though only the
+    principal function is shown. For a function f satisfying f (conj(z)) = conj( f (z)), the
+    specifications for the upper half-plane imply the specifications for the lower half-plane; if
+    the function f is also either even, f (-z) = f (z), or odd, f (-z) = - f (z), then the
+    specifications for the first quadrant imply the specifications for the other three quadrants.
+9   In the following subclauses, cis(y) is defined as cos(y) + i sin(y).
+
+
+
+
+    <sup><a name="note365" href="#note365"><b>365)</b></a></sup> As noted in <a href="#G.3">G.3</a>, a complex value with at least one infinite part is regarded as an infinity even if its
+         other part is a NaN.
+
+[<a name="p534" href="#p534">page 534</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.6.1" href="#G.6.1"><b>    G.6.1 Trigonometric functions</b></a>
+<a name="G.6.1.1" href="#G.6.1.1"><b>    G.6.1.1 The cacos functions</b></a>
+1   -- cacos(conj(z)) = conj(cacos(z)).
+    -- cacos((+-)0 + i0) returns pi /2 - i0.
+    -- cacos((+-)0 + iNaN) returns pi /2 + iNaN.
+    -- cacos(x + i (inf)) returns pi /2 - i (inf), for finite x.
+    -- cacos(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for nonzero finite x.
+    -- cacos(-(inf) + iy) returns pi - i (inf), for positive-signed finite y.
+    -- cacos(+(inf) + iy) returns +0 - i (inf), for positive-signed finite y.
+    -- cacos(-(inf) + i (inf)) returns 3pi /4 - i (inf).
+    -- cacos(+(inf) + i (inf)) returns pi /4 - i (inf).
+    -- cacos((+-)(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+      result is unspecified).
+    -- cacos(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite y.
+    -- cacos(NaN + i (inf)) returns NaN - i (inf).
+    -- cacos(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2" href="#G.6.2"><b>    G.6.2 Hyperbolic functions</b></a>
+<a name="G.6.2.1" href="#G.6.2.1"><b>    G.6.2.1 The cacosh functions</b></a>
+1   -- cacosh(conj(z)) = conj(cacosh(z)).
+    -- cacosh((+-)0 + i0) returns +0 + ipi /2.
+    -- cacosh(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+    -- cacosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite x.
+    -- cacosh(-(inf) + iy) returns +(inf) + ipi , for positive-signed finite y.
+    -- cacosh(+(inf) + iy) returns +(inf) + i0, for positive-signed finite y.
+    -- cacosh(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+    -- cacosh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+    -- cacosh((+-)(inf) + iNaN) returns +(inf) + iNaN.
+
+[<a name="p535" href="#p535">page 535</a>] (<a href="#Contents">Contents</a>)
+
+    -- cacosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite y.
+    -- cacosh(NaN + i (inf)) returns +(inf) + iNaN.
+    -- cacosh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.2" href="#G.6.2.2"><b>    G.6.2.2 The casinh functions</b></a>
+1   -- casinh(conj(z)) = conj(casinh(z)) and casinh is odd.
+    -- casinh(+0 + i0) returns 0 + i0.
+    -- casinh(x + i (inf)) returns +(inf) + ipi /2 for positive-signed finite x.
+    -- casinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite x.
+    -- casinh(+(inf) + iy) returns +(inf) + i0 for positive-signed finite y.
+    -- casinh(+(inf) + i (inf)) returns +(inf) + ipi /4.
+    -- casinh(+(inf) + iNaN) returns +(inf) + iNaN.
+    -- casinh(NaN + i0) returns NaN + i0.
+    -- casinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite nonzero y.
+    -- casinh(NaN + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+      is unspecified).
+    -- casinh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.3" href="#G.6.2.3"><b>    G.6.2.3 The catanh functions</b></a>
+1   -- catanh(conj(z)) = conj(catanh(z)) and catanh is odd.
+    -- catanh(+0 + i0) returns +0 + i0.
+    -- catanh(+0 + iNaN) returns +0 + iNaN.
+    -- catanh(+1 + i0) returns +(inf) + i0 and raises the ''divide-by-zero'' floating-point
+      exception.
+    -- catanh(x + i (inf)) returns +0 + ipi /2, for finite positive-signed x.
+    -- catanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for nonzero finite x.
+    -- catanh(+(inf) + iy) returns +0 + ipi /2, for finite positive-signed y.
+    -- catanh(+(inf) + i (inf)) returns +0 + ipi /2.
+    -- catanh(+(inf) + iNaN) returns +0 + iNaN.
+
+[<a name="p536" href="#p536">page 536</a>] (<a href="#Contents">Contents</a>)
+
+    -- catanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid''
+      floating-point exception, for finite y.
+    -- catanh(NaN + i (inf)) returns (+-)0 + ipi /2 (where the sign of the real part of the result is
+      unspecified).
+    -- catanh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.4" href="#G.6.2.4"><b>    G.6.2.4 The ccosh functions</b></a>
+1   -- ccosh(conj(z)) = conj(ccosh(z)) and ccosh is even.
+    -- ccosh(+0 + i0) returns 1 + i0.
+    -- ccosh(+0 + i (inf)) returns NaN (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified) and raises the ''invalid'' floating-point exception.
+    -- ccosh(+0 + iNaN) returns NaN (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified).
+    -- ccosh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for finite nonzero x.
+    -- ccosh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite nonzero x.
+    -- ccosh(+(inf) + i0) returns +(inf) + i0.
+    -- ccosh(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+    -- ccosh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+      unspecified) and raises the ''invalid'' floating-point exception.
+    -- ccosh(+(inf) + iNaN) returns +(inf) + iNaN.
+    -- ccosh(NaN + i0) returns NaN (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified).
+    -- ccosh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- ccosh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.5" href="#G.6.2.5"><b>    G.6.2.5 The csinh functions</b></a>
+1   -- csinh(conj(z)) = conj(csinh(z)) and csinh is odd.
+    -- csinh(+0 + i0) returns +0 + i0.
+    -- csinh(+0 + i (inf)) returns (+-)0 + iNaN (where the sign of the real part of the result is
+      unspecified) and raises the ''invalid'' floating-point exception.
+    -- csinh(+0 + iNaN) returns (+-)0 + iNaN (where the sign of the real part of the result is
+      unspecified).
+
+[<a name="p537" href="#p537">page 537</a>] (<a href="#Contents">Contents</a>)
+
+    -- csinh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for positive finite x.
+    -- csinh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite nonzero x.
+    -- csinh(+(inf) + i0) returns +(inf) + i0.
+    -- csinh(+(inf) + iy) returns +(inf) cis(y), for positive finite y.
+    -- csinh(+(inf) + i (inf)) returns (+-)(inf) + iNaN (where the sign of the real part of the result is
+      unspecified) and raises the ''invalid'' floating-point exception.
+    -- csinh(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+      is unspecified).
+    -- csinh(NaN + i0) returns NaN + i0.
+    -- csinh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- csinh(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.2.6" href="#G.6.2.6"><b>    G.6.2.6 The ctanh functions</b></a>
+1   -- ctanh(conj(z)) = conj(ctanh(z))and ctanh is odd.
+    -- ctanh(+0 + i0) returns +0 + i0.
+    -- ctanh(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for finite x.
+    -- ctanh(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+    -- ctanh(+(inf) + iy) returns 1 + i0 sin(2y), for positive-signed finite y.
+    -- ctanh(+(inf) + i (inf)) returns 1 (+-) i0 (where the sign of the imaginary part of the result
+      is unspecified).
+    -- ctanh(+(inf) + iNaN) returns 1 (+-) i0 (where the sign of the imaginary part of the
+      result is unspecified).
+    -- ctanh(NaN + i0) returns NaN + i0.
+    -- ctanh(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- ctanh(NaN + iNaN) returns NaN + iNaN.
+
+[<a name="p538" href="#p538">page 538</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.6.3" href="#G.6.3"><b>    G.6.3 Exponential and logarithmic functions</b></a>
+<a name="G.6.3.1" href="#G.6.3.1"><b>    G.6.3.1 The cexp functions</b></a>
+1   -- cexp(conj(z)) = conj(cexp(z)).
+    -- cexp((+-)0 + i0) returns 1 + i0.
+    -- cexp(x + i (inf)) returns NaN + iNaN and raises the ''invalid'' floating-point
+      exception, for finite x.
+    -- cexp(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+    -- cexp(+(inf) + i0) returns +(inf) + i0.
+    -- cexp(-(inf) + iy) returns +0 cis(y), for finite y.
+    -- cexp(+(inf) + iy) returns +(inf) cis(y), for finite nonzero y.
+    -- cexp(-(inf) + i (inf)) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts of
+      the result are unspecified).
+    -- cexp(+(inf) + i (inf)) returns (+-)(inf) + iNaN and raises the ''invalid'' floating-point
+      exception (where the sign of the real part of the result is unspecified).
+    -- cexp(-(inf) + iNaN) returns (+-)0 (+-) i0 (where the signs of the real and imaginary parts
+      of the result are unspecified).
+    -- cexp(+(inf) + iNaN) returns (+-)(inf) + iNaN (where the sign of the real part of the result
+      is unspecified).
+    -- cexp(NaN + i0) returns NaN + i0.
+    -- cexp(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for all nonzero numbers y.
+    -- cexp(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.3.2" href="#G.6.3.2"><b>    G.6.3.2 The clog functions</b></a>
+1   -- clog(conj(z)) = conj(clog(z)).
+    -- clog(-0 + i0) returns -(inf) + ipi and raises the ''divide-by-zero'' floating-point
+      exception.
+    -- clog(+0 + i0) returns -(inf) + i0 and raises the ''divide-by-zero'' floating-point
+      exception.
+    -- clog(x + i (inf)) returns +(inf) + ipi /2, for finite x.
+    -- clog(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+
+[<a name="p539" href="#p539">page 539</a>] (<a href="#Contents">Contents</a>)
+
+    -- clog(-(inf) + iy) returns +(inf) + ipi , for finite positive-signed y.
+    -- clog(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+    -- clog(-(inf) + i (inf)) returns +(inf) + i3pi /4.
+    -- clog(+(inf) + i (inf)) returns +(inf) + ipi /4.
+    -- clog((+-)(inf) + iNaN) returns +(inf) + iNaN.
+    -- clog(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite y.
+    -- clog(NaN + i (inf)) returns +(inf) + iNaN.
+    -- clog(NaN + iNaN) returns NaN + iNaN.
+<a name="G.6.4" href="#G.6.4"><b>    G.6.4 Power and absolute-value functions</b></a>
+<a name="G.6.4.1" href="#G.6.4.1"><b>    G.6.4.1 The cpow functions</b></a>
+1   The cpow functions raise floating-point exceptions if appropriate for the calculation of
+    the parts of the result, and may also raise spurious floating-point exceptions.<sup><a href="#note366"><b>366)</b></a></sup>
+<a name="G.6.4.2" href="#G.6.4.2"><b>    G.6.4.2 The csqrt functions</b></a>
+1   -- csqrt(conj(z)) = conj(csqrt(z)).
+    -- csqrt((+-)0 + i0) returns +0 + i0.
+    -- csqrt(x + i (inf)) returns +(inf) + i (inf), for all x (including NaN).
+    -- csqrt(x + iNaN) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite x.
+    -- csqrt(-(inf) + iy) returns +0 + i (inf), for finite positive-signed y.
+    -- csqrt(+(inf) + iy) returns +(inf) + i0, for finite positive-signed y.
+    -- csqrt(-(inf) + iNaN) returns NaN (+-) i (inf) (where the sign of the imaginary part of the
+      result is unspecified).
+    -- csqrt(+(inf) + iNaN) returns +(inf) + iNaN.
+    -- csqrt(NaN + iy) returns NaN + iNaN and optionally raises the ''invalid'' floating-
+      point exception, for finite y.
+    -- csqrt(NaN + iNaN) returns NaN + iNaN.
+
+
+
+
+    <sup><a name="note366" href="#note366"><b>366)</b></a></sup> This allows cpow( z , c ) to be implemented as cexp(c      clog( z )) without precluding
+         implementations that treat special cases more carefully.
+
+[<a name="p540" href="#p540">page 540</a>] (<a href="#Contents">Contents</a>)
+
+<a name="G.7" href="#G.7"><b>    G.7 Type-generic math &lt;tgmath.h&gt;</b></a>
+1   Type-generic macros that accept complex arguments also accept imaginary arguments. If
+    an argument is imaginary, the macro expands to an expression whose type is real,
+    imaginary, or complex, as appropriate for the particular function: if the argument is
+    imaginary, then the types of cos, cosh, fabs, carg, cimag, and creal are real; the
+    types of sin, tan, sinh, tanh, asin, atan, asinh, and atanh are imaginary; and
+    the types of the others are complex.
+2   Given an imaginary argument, each of the type-generic macros cos, sin, tan, cosh,
+    sinh, tanh, asin, atan, asinh, atanh is specified by a formula in terms of real
+    functions:
+            cos(iy)     =   cosh(y)
+            sin(iy)     =   i sinh(y)
+            tan(iy)     =   i tanh(y)
+            cosh(iy)    =   cos(y)
+            sinh(iy)    =   i sin(y)
+            tanh(iy)    =   i tan(y)
+            asin(iy)    =   i asinh(y)
+            atan(iy)    =   i atanh(y)
+            asinh(iy)   =   i asin(y)
+            atanh(iy)   =   i atan(y)
+
+[<a name="p541" href="#p541">page 541</a>] (<a href="#Contents">Contents</a>)
+
+<a name="H" href="#H"><b>                                          Annex H</b></a>
+                                        (informative)
+                        Language independent arithmetic
+<a name="H.1" href="#H.1"><b>    H.1 Introduction</b></a>
+1   This annex documents the extent to which the C language supports the ISO/IEC 10967-1
+    standard for language-independent arithmetic (LIA-1). LIA-1 is more general than
+    IEC 60559 (<a href="#F">annex F</a>) in that it covers integer and diverse floating-point arithmetics.
+<a name="H.2" href="#H.2"><b>    H.2 Types</b></a>
+1   The relevant C arithmetic types meet the requirements of LIA-1 types if an
+    implementation adds notification of exceptional arithmetic operations and meets the 1
+    unit in the last place (ULP) accuracy requirement (LIA-1 subclause <a href="#5.2.8">5.2.8</a>).
+<a name="H.2.1" href="#H.2.1"><b>    H.2.1 Boolean type</b></a>
+1   The LIA-1 data type Boolean is implemented by the C data type bool with values of
+    true and false, all from <a href="#7.18">&lt;stdbool.h&gt;</a>.
+<a name="H.2.2" href="#H.2.2"><b>    H.2.2 Integer types</b></a>
+1   The signed C integer types int, long int, long long int, and the corresponding
+    unsigned types are compatible with LIA-1. If an implementation adds support for the
+    LIA-1 exceptional values ''integer_overflow'' and ''undefined'', then those types are
+    LIA-1 conformant types. C's unsigned integer types are ''modulo'' in the LIA-1 sense
+    in that overflows or out-of-bounds results silently wrap. An implementation that defines
+    signed integer types as also being modulo need not detect integer overflow, in which case,
+    only integer divide-by-zero need be detected.
+2   The parameters for the integer data types can be accessed by the following:
+    maxint        INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX,
+                  ULLONG_MAX
+    minint        INT_MIN, LONG_MIN, LLONG_MIN
+3   The parameter ''bounded'' is always true, and is not provided. The parameter ''minint''
+    is always 0 for the unsigned types, and is not provided for those types.
+
+[<a name="p542" href="#p542">page 542</a>] (<a href="#Contents">Contents</a>)
+
+<a name="H.2.2.1" href="#H.2.2.1"><b>    H.2.2.1 Integer operations</b></a>
+1   The integer operations on integer types are the following:
+    addI           x + y
+    subI           x - y
+    mulI           x * y
+    divI, divtI    x / y
+    remI, remtI    x % y
+    negI           -x
+    absI           abs(x), labs(x), llabs(x)
+    eqI            x == y
+    neqI           x != y
+    lssI           x &lt; y
+    leqI           x &lt;= y
+    gtrI           x &gt; y
+    geqI           x &gt;= y
+    where x and y are expressions of the same integer type.
+<a name="H.2.3" href="#H.2.3"><b>    H.2.3 Floating-point types</b></a>
+1   The C floating-point types float, double, and long double are compatible with
+    LIA-1. If an implementation adds support for the LIA-1 exceptional values
+    ''underflow'', ''floating_overflow'', and ''"undefined'', then those types are conformant
+    with LIA-1. An implementation that uses IEC 60559 floating-point formats and
+    operations (see <a href="#F">annex F</a>) along with IEC 60559 status flags and traps has LIA-1
+    conformant types.
+<a name="H.2.3.1" href="#H.2.3.1"><b>    H.2.3.1 Floating-point parameters</b></a>
+1   The parameters for a floating point data type can be accessed by the following:
+    r              FLT_RADIX
+    p              FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG
+    emax           FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP
+    emin           FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP
+2   The derived constants for the floating point types are accessed by the following:
+
+[<a name="p543" href="#p543">page 543</a>] (<a href="#Contents">Contents</a>)
+
+    fmax          FLT_MAX, DBL_MAX, LDBL_MAX
+    fminN         FLT_MIN, DBL_MIN, LDBL_MIN
+    epsilon       FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON
+    rnd_style     FLT_ROUNDS
+<a name="H.2.3.2" href="#H.2.3.2"><b>    H.2.3.2 Floating-point operations</b></a>
+1   The floating-point operations on floating-point types are the following:
+    addF          x + y
+    subF          x - y
+    mulF          x * y
+    divF          x / y
+    negF          -x
+    absF          fabsf(x), fabs(x), fabsl(x)
+    exponentF     1.f+logbf(x), 1.0+logb(x), 1.L+logbl(x)
+    scaleF        scalbnf(x, n), scalbn(x, n), scalbnl(x, n),
+                  scalblnf(x, li), scalbln(x, li), scalblnl(x, li)
+    intpartF      modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+    fractpartF    modff(x, &amp;y), modf(x, &amp;y), modfl(x, &amp;y)
+    eqF           x == y
+    neqF          x != y
+    lssF          x &lt; y
+    leqF          x &lt;= y
+    gtrF          x &gt; y
+    geqF          x &gt;= y
+    where x and y are expressions of the same floating point type, n is of type int, and li
+    is of type long int.
+<a name="H.2.3.3" href="#H.2.3.3"><b>    H.2.3.3 Rounding styles</b></a>
+1   The C Standard requires all floating types to use the same radix and rounding style, so
+    that only one identifier for each is provided to map to LIA-1.
+2   The FLT_ROUNDS parameter can be used to indicate the LIA-1 rounding styles:
+    truncate      FLT_ROUNDS == 0
+
+[<a name="p544" href="#p544">page 544</a>] (<a href="#Contents">Contents</a>)
+
+    nearest       FLT_ROUNDS == 1
+    other         FLT_ROUNDS != 0 &amp;&amp; FLT_ROUNDS != 1
+    provided that an implementation extends FLT_ROUNDS to cover the rounding style used
+    in all relevant LIA-1 operations, not just addition as in C.
+<a name="H.2.4" href="#H.2.4"><b>    H.2.4 Type conversions</b></a>
+1   The LIA-1 type conversions are the following type casts:
+    cvtI' -&gt; I     (int)i, (long int)i, (long long int)i,
+                  (unsigned int)i, (unsigned long int)i,
+                  (unsigned long long int)i
+    cvtF -&gt; I      (int)x, (long int)x, (long long int)x,
+                  (unsigned int)x, (unsigned long int)x,
+                  (unsigned long long int)x
+    cvtI -&gt; F      (float)i, (double)i, (long double)i
+    cvtF' -&gt; F     (float)x, (double)x, (long double)x
+2   In the above conversions from floating to integer, the use of (cast)x can be replaced with
+    (cast)round(x), (cast)rint(x), (cast)nearbyint(x), (cast)trunc(x),
+    (cast)ceil(x), or (cast)floor(x). In addition, C's floating-point to integer
+    conversion functions, lrint(), llrint(), lround(), and llround(), can be
+    used. They all meet LIA-1's requirements on floating to integer rounding for in-range
+    values. For out-of-range values, the conversions shall silently wrap for the modulo types.
+3   The fmod() function is useful for doing silent wrapping to unsigned integer types, e.g.,
+    fmod( fabs(rint(x)), 65536.0 ) or (0.0 &lt;= (y = fmod( rint(x),
+    65536.0 )) ? y : 65536.0 + y) will compute an integer value in the range 0.0
+    to 65535.0 which can then be cast to unsigned short int. But, the
+    remainder() function is not useful for doing silent wrapping to signed integer types,
+    e.g., remainder( rint(x), 65536.0 ) will compute an integer value in the
+    range -32767.0 to +32768.0 which is not, in general, in the range of signed short
+    int.
+4   C's conversions (casts) from floating-point to floating-point can meet LIA-1
+    requirements if an implementation uses round-to-nearest (IEC 60559 default).
+5   C's conversions (casts) from integer to floating-point can meet LIA-1 requirements if an
+    implementation uses round-to-nearest.
+
+[<a name="p545" href="#p545">page 545</a>] (<a href="#Contents">Contents</a>)
+
+<a name="H.3" href="#H.3"><b>    H.3 Notification</b></a>
+1   Notification is the process by which a user or program is informed that an exceptional
+    arithmetic operation has occurred. C's operations are compatible with LIA-1 in that C
+    allows an implementation to cause a notification to occur when any arithmetic operation
+    returns an exceptional value as defined in LIA-1 clause 5.
+<a name="H.3.1" href="#H.3.1"><b>    H.3.1 Notification alternatives</b></a>
+1   LIA-1 requires at least the following two alternatives for handling of notifications:
+    setting indicators or trap-and-terminate. LIA-1 allows a third alternative: trap-and-
+    resume.
+2   An implementation need only support a given notification alternative for the entire
+    program. An implementation may support the ability to switch between notification
+    alternatives during execution, but is not required to do so. An implementation can
+    provide separate selection for each kind of notification, but this is not required.
+3   C allows an implementation to provide notification. C's SIGFPE (for traps) and
+    FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW (for indicators)
+    can provide LIA-1 notification.
+4   C's signal handlers are compatible with LIA-1. Default handling of SIGFPE can
+    provide trap-and-terminate behavior, except for those LIA-1 operations implemented by
+    math library function calls. User-provided signal handlers for SIGFPE allow for trap-
+    and-resume behavior with the same constraint.
+<a name="H.3.1.1" href="#H.3.1.1"><b>    H.3.1.1 Indicators</b></a>
+1   C's <a href="#7.6">&lt;fenv.h&gt;</a> status flags are compatible with the LIA-1 indicators.
+2   The following mapping is for floating-point types:
+    undefined                FE_INVALID, FE_DIVBYZERO
+    floating_overflow         FE_OVERFLOW
+    underflow                FE_UNDERFLOW
+3   The floating-point indicator interrogation and manipulation operations are:
+    set_indicators          feraiseexcept(i)
+    clear_indicators        feclearexcept(i)
+    test_indicators         fetestexcept(i)
+    current_indicators      fetestexcept(FE_ALL_EXCEPT)
+    where i is an expression of type int representing a subset of the LIA-1 indicators.
+4   C allows an implementation to provide the following LIA-1 required behavior: at
+    program termination if any indicator is set the implementation shall send an unambiguous
+
+[<a name="p546" href="#p546">page 546</a>] (<a href="#Contents">Contents</a>)
+
+    and ''hard to ignore'' message (see LIA-1 subclause <a href="#6.1.2">6.1.2</a>)
+5   LIA-1 does not make the distinction between floating-point and integer for ''undefined''.
+    This documentation makes that distinction because <a href="#7.6">&lt;fenv.h&gt;</a> covers only the floating-
+    point indicators.
+<a name="H.3.1.2" href="#H.3.1.2"><b>    H.3.1.2 Traps</b></a>
+1   C is compatible with LIA-1's trap requirements for arithmetic operations, but not for
+    math library functions (which are not permitted to invoke a user's signal handler for
+    SIGFPE). An implementation can provide an alternative of notification through
+    termination with a ''hard-to-ignore'' message (see LIA-1 subclause <a href="#6.1.3">6.1.3</a>).
+2   LIA-1 does not require that traps be precise.
+3   C does require that SIGFPE be the signal corresponding to LIA-1 arithmetic exceptions,
+    if there is any signal raised for them.
+4   C supports signal handlers for SIGFPE and allows trapping of LIA-1 arithmetic
+    exceptions. When LIA-1 arithmetic exceptions do trap, C's signal-handler mechanism
+    allows trap-and-terminate (either default implementation behavior or user replacement for
+    it) or trap-and-resume, at the programmer's option.
+
+[<a name="p547" href="#p547">page 547</a>] (<a href="#Contents">Contents</a>)
+
+<a name="I" href="#I"><b>                                           Annex I</b></a>
+                                        (informative)
+                                   Common warnings
+1   An implementation may generate warnings in many situations, none of which are
+    specified as part of this International Standard. The following are a few of the more
+    common situations.
+2   -- A new struct or union type appears in a function prototype (<a href="#6.2.1">6.2.1</a>, <a href="#6.7.2.3">6.7.2.3</a>).
+    -- A block with initialization of an object that has automatic storage duration is jumped
+      into (<a href="#6.2.4">6.2.4</a>).
+    -- An implicit narrowing conversion is encountered, such as the assignment of a long
+      int or a double to an int, or a pointer to void to a pointer to any type other than
+      a character type (<a href="#6.3">6.3</a>).
+    -- A hexadecimal floating constant cannot be represented exactly in its evaluation format
+      (<a href="#6.4.4.2">6.4.4.2</a>).
+    -- An integer character constant includes more than one character or a wide character
+      constant includes more than one multibyte character (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- The characters /* are found in a comment (<a href="#6.4.7">6.4.7</a>).
+    -- An ''unordered'' binary operator (not comma, &amp;&amp;, or ||) contains a side effect to an
+      lvalue in one operand, and a side effect to, or an access to the value of, the identical
+      lvalue in the other operand (<a href="#6.5">6.5</a>).
+    -- A function is called but no prototype has been supplied (<a href="#6.5.2.2">6.5.2.2</a>).
+    -- The arguments in a function call do not agree in number and type with those of the
+      parameters in a function definition that is not a prototype (<a href="#6.5.2.2">6.5.2.2</a>).
+    -- An object is defined but not used (<a href="#6.7">6.7</a>).
+    -- A value is given to an object of an enumerated type other than by assignment of an
+      enumeration constant that is a member of that type, or an enumeration object that has
+      the same type, or the value of a function that returns the same enumerated type
+      (<a href="#6.7.2.2">6.7.2.2</a>).
+    -- An aggregate has a partly bracketed initialization (<a href="#6.7.8">6.7.8</a>).
+    -- A statement cannot be reached (<a href="#6.8">6.8</a>).
+    -- A statement with no apparent effect is encountered (<a href="#6.8">6.8</a>).
+    -- A constant expression is used as the controlling expression of a selection statement
+      (<a href="#6.8.4">6.8.4</a>).
+
+[<a name="p548" href="#p548">page 548</a>] (<a href="#Contents">Contents</a>)
+
+-- An incorrectly formed preprocessing group is encountered while skipping a
+  preprocessing group (<a href="#6.10.1">6.10.1</a>).
+-- An unrecognized #pragma directive is encountered (<a href="#6.10.6">6.10.6</a>).
+
+[<a name="p549" href="#p549">page 549</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J" href="#J"><b>                                            Annex J</b></a>
+                                         (informative)
+                                      Portability issues
+1   This annex collects some information about portability that appears in this International
+    Standard.
+<a name="J.1" href="#J.1"><b>    J.1 Unspecified behavior</b></a>
+1   The following are unspecified:
+    -- The manner and timing of static initialization (<a href="#5.1.2">5.1.2</a>).
+    -- The termination status returned to the hosted environment if the return type of main
+      is not compatible with int (<a href="#5.1.2.2.3">5.1.2.2.3</a>).
+    -- The behavior of the display device if a printing character is written when the active
+      position is at the final position of a line (<a href="#5.2.2">5.2.2</a>).
+    -- The behavior of the display device if a backspace character is written when the active
+      position is at the initial position of a line (<a href="#5.2.2">5.2.2</a>).
+    -- The behavior of the display device if a horizontal tab character is written when the
+      active position is at or past the last defined horizontal tabulation position (<a href="#5.2.2">5.2.2</a>).
+    -- The behavior of the display device if a vertical tab character is written when the active
+      position is at or past the last defined vertical tabulation position (<a href="#5.2.2">5.2.2</a>).
+    -- How an extended source character that does not correspond to a universal character
+      name counts toward the significant initial characters in an external identifier (<a href="#5.2.4.1">5.2.4.1</a>).
+    -- Many aspects of the representations of types (<a href="#6.2.6">6.2.6</a>).
+    -- The value of padding bytes when storing values in structures or unions (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- The values of bytes that correspond to union members other than the one last stored
+      into (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- The representation used when storing a value in an object that has more than one
+      object representation for that value (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- The values of any padding bits in integer representations (<a href="#6.2.6.2">6.2.6.2</a>).
+    -- Whether certain operators can generate negative zeros and whether a negative zero
+      becomes a normal zero when stored in an object (<a href="#6.2.6.2">6.2.6.2</a>).
+    -- Whether two string literals result in distinct arrays (<a href="#6.4.5">6.4.5</a>).
+    -- The order in which subexpressions are evaluated and the order in which side effects
+      take place, except as specified for the function-call (), &amp;&amp;, ||, ? :, and comma
+
+[<a name="p550" href="#p550">page 550</a>] (<a href="#Contents">Contents</a>)
+
+   operators (<a href="#6.5">6.5</a>).
+-- The order in which the function designator, arguments, and subexpressions within the
+  arguments are evaluated in a function call (<a href="#6.5.2.2">6.5.2.2</a>).
+-- The order of side effects among compound literal initialization list expressions
+  (<a href="#6.5.2.5">6.5.2.5</a>).
+-- The order in which the operands of an assignment operator are evaluated (<a href="#6.5.16">6.5.16</a>).
+-- The alignment of the addressable storage unit allocated to hold a bit-field (<a href="#6.7.2.1">6.7.2.1</a>).
+-- Whether a call to an inline function uses the inline definition or the external definition
+  of the function (<a href="#6.7.4">6.7.4</a>).
+-- Whether or not a size expression is evaluated when it is part of the operand of a
+  sizeof operator and changing the value of the size expression would not affect the
+  result of the operator (<a href="#6.7.6.2">6.7.6.2</a>).
+-- The order in which any side effects occur among the initialization list expressions in
+  an initializer (<a href="#6.7.9">6.7.9</a>).
+-- The layout of storage for function parameters (<a href="#6.9.1">6.9.1</a>).
+-- When a fully expanded macro replacement list contains a function-like macro name
+  as its last preprocessing token and the next preprocessing token from the source file is
+  a (, and the fully expanded replacement of that macro ends with the name of the first
+  macro and the next preprocessing token from the source file is again a (, whether that
+  is considered a nested replacement (<a href="#6.10.3">6.10.3</a>).
+-- The order in which # and ## operations are evaluated during macro substitution
+  (<a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>).
+-- The state of the floating-point status flags when execution passes from a part of the *
+  program translated with FENV_ACCESS ''off'' to a part translated with
+  FENV_ACCESS ''on'' (<a href="#7.6.1">7.6.1</a>).
+-- The order in which feraiseexcept raises floating-point exceptions, except as
+  stated in <a href="#F.8.6">F.8.6</a> (<a href="#7.6.2.3">7.6.2.3</a>).
+-- Whether math_errhandling is a macro or an identifier with external linkage
+  (<a href="#7.12">7.12</a>).
+-- The results of the frexp functions when the specified value is not a floating-point
+  number (<a href="#7.12.6.4">7.12.6.4</a>).
+-- The numeric result of the ilogb functions when the correct value is outside the
+  range of the return type (<a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>).
+-- The result of rounding when the value is out of range (<a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.5">F.10.6.5</a>).
+
+[<a name="p551" href="#p551">page 551</a>] (<a href="#Contents">Contents</a>)
+
+-- The value stored by the remquo functions in the object pointed to by quo when y is
+  zero (<a href="#7.12.10.3">7.12.10.3</a>).
+-- Whether a comparison macro argument that is represented in a format wider than its
+  semantic type is converted to the semantic type (<a href="#7.12.14">7.12.14</a>).
+-- Whether setjmp is a macro or an identifier with external linkage (<a href="#7.13">7.13</a>).
+-- Whether va_copy and va_end are macros or identifiers with external linkage
+  (<a href="#7.16.1">7.16.1</a>).
+-- The hexadecimal digit before the decimal point when a non-normalized floating-point
+  number is printed with an a or A conversion specifier (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+-- The value of the file position indicator after a successful call to the ungetc function
+  for a text stream, or the ungetwc function for any stream, until all pushed-back
+  characters are read or discarded (<a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.28.3.10">7.28.3.10</a>).
+-- The details of the value stored by the fgetpos function (<a href="#7.21.9.1">7.21.9.1</a>).
+-- The details of the value returned by the ftell function for a text stream (<a href="#7.21.9.4">7.21.9.4</a>).
+-- Whether the strtod, strtof, strtold, wcstod, wcstof, and wcstold
+  functions convert a minus-signed sequence to a negative number directly or by
+  negating the value resulting from converting the corresponding unsigned sequence
+  (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
+-- The order and contiguity of storage allocated by successive calls to the calloc,
+  malloc, and realloc functions (<a href="#7.22.3">7.22.3</a>).
+-- The amount of storage allocated by a successful call to the calloc, malloc, or
+  realloc function when 0 bytes was requested (<a href="#7.22.3">7.22.3</a>).
+-- Which of two elements that compare as equal is matched by the bsearch function
+  (<a href="#7.22.5.1">7.22.5.1</a>).
+-- The order of two elements that compare as equal in an array sorted by the qsort
+  function (<a href="#7.22.5.2">7.22.5.2</a>).
+-- The encoding of the calendar time returned by the time function (<a href="#7.26.2.4">7.26.2.4</a>).
+-- The characters stored by the strftime or wcsftime function if any of the time
+  values being converted is outside the normal range (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+-- The conversion state after an encoding error occurs (<a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>,
+  <a href="#7.28.6.4.2">7.28.6.4.2</a>,
+-- The resulting value when the ''invalid'' floating-point exception is raised during
+  IEC 60559 floating to integer conversion (<a href="#F.4">F.4</a>).
+
+[<a name="p552" href="#p552">page 552</a>] (<a href="#Contents">Contents</a>)
+
+    -- Whether conversion of non-integer IEC 60559 floating values to integer raises the
+      ''inexact'' floating-point exception (<a href="#F.4">F.4</a>).
+    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise the ''inexact'' floating-point
+      exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
+    -- Whether or when library functions in <a href="#7.12">&lt;math.h&gt;</a> raise an undeserved ''underflow''
+      floating-point exception in an IEC 60559 conformant implementation (<a href="#F.10">F.10</a>).
+    -- The exponent value stored by frexp for a NaN or infinity (<a href="#F.10.3.4">F.10.3.4</a>).
+    -- The numeric result returned by the lrint, llrint, lround, and llround
+      functions if the rounded value is outside the range of the return type (<a href="#F.10.6.5">F.10.6.5</a>,
+      <a href="#F.10.6.7">F.10.6.7</a>).
+    -- The sign of one part of the complex result of several math functions for certain
+      special cases in IEC 60559 compatible implementations (<a href="#G.6.1.1">G.6.1.1</a>, <a href="#G.6.2.2">G.6.2.2</a>, <a href="#G.6.2.3">G.6.2.3</a>,
+      <a href="#G.6.2.4">G.6.2.4</a>, <a href="#G.6.2.5">G.6.2.5</a>, <a href="#G.6.2.6">G.6.2.6</a>, <a href="#G.6.3.1">G.6.3.1</a>, <a href="#G.6.4.2">G.6.4.2</a>).
+<a name="J.2" href="#J.2"><b>    J.2 Undefined behavior</b></a>
+1   The behavior is undefined in the following circumstances:
+    -- A ''shall'' or ''shall not'' requirement that appears outside of a constraint is violated
+      (clause 4).
+    -- A nonempty source file does not end in a new-line character which is not immediately
+      preceded by a backslash character or ends in a partial preprocessing token or
+      comment (<a href="#5.1.1.2">5.1.1.2</a>).
+    -- Token concatenation produces a character sequence matching the syntax of a
+      universal character name (<a href="#5.1.1.2">5.1.1.2</a>).
+    -- A program in a hosted environment does not define a function named main using one
+      of the specified forms (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+    -- The execution of a program contains a data race (<a href="#5.1.2.4">5.1.2.4</a>).
+    -- A character not in the basic source character set is encountered in a source file, except
+      in an identifier, a character constant, a string literal, a header name, a comment, or a
+      preprocessing token that is never converted to a token (<a href="#5.2.1">5.2.1</a>).
+    -- An identifier, comment, string literal, character constant, or header name contains an
+      invalid multibyte character or does not begin and end in the initial shift state (<a href="#5.2.1.2">5.2.1.2</a>).
+    -- The same identifier has both internal and external linkage in the same translation unit
+      (<a href="#6.2.2">6.2.2</a>).
+    -- An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
+
+[<a name="p553" href="#p553">page 553</a>] (<a href="#Contents">Contents</a>)
+
+-- The value of a pointer to an object whose lifetime has ended is used (<a href="#6.2.4">6.2.4</a>).
+-- The value of an object with automatic storage duration is used while it is
+  indeterminate (<a href="#6.2.4">6.2.4</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8">6.8</a>).
+-- A trap representation is read by an lvalue expression that does not have character type
+  (<a href="#6.2.6.1">6.2.6.1</a>).
+-- A trap representation is produced by a side effect that modifies any part of the object
+  using an lvalue expression that does not have character type (<a href="#6.2.6.1">6.2.6.1</a>).
+-- The operands to certain operators are such that they could produce a negative zero
+  result, but the implementation does not support negative zeros (<a href="#6.2.6.2">6.2.6.2</a>).
+-- Two declarations of the same object or function specify types that are not compatible
+  (<a href="#6.2.7">6.2.7</a>).
+-- A program requires the formation of a composite type from a variable length array
+  type whose size is specified by an expression that is not evaluated (<a href="#6.2.7">6.2.7</a>).
+-- Conversion to or from an integer type produces a value outside the range that can be
+  represented (<a href="#6.3.1.4">6.3.1.4</a>).
+-- Demotion of one real floating type to another produces a value outside the range that
+  can be represented (<a href="#6.3.1.5">6.3.1.5</a>).
+-- An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
+-- A non-array lvalue with an incomplete type is used in a context that requires the value
+  of the designated object (<a href="#6.3.2.1">6.3.2.1</a>).
+-- An lvalue designating an object of automatic storage duration that could have been
+  declared with the register storage class is used in a context that requires the value
+  of the designated object, but the object is uninitialized. (<a href="#6.3.2.1">6.3.2.1</a>).
+-- An lvalue having array type is converted to a pointer to the initial element of the
+  array, and the array object has register storage class (<a href="#6.3.2.1">6.3.2.1</a>).
+-- An attempt is made to use the value of a void expression, or an implicit or explicit
+  conversion (except to void) is applied to a void expression (<a href="#6.3.2.2">6.3.2.2</a>).
+-- Conversion of a pointer to an integer type produces a value outside the range that can
+  be represented (<a href="#6.3.2.3">6.3.2.3</a>).
+-- Conversion between two pointer types produces a result that is incorrectly aligned
+  (<a href="#6.3.2.3">6.3.2.3</a>).
+-- A pointer is used to call a function whose type is not compatible with the referenced
+  type (<a href="#6.3.2.3">6.3.2.3</a>).
+
+[<a name="p554" href="#p554">page 554</a>] (<a href="#Contents">Contents</a>)
+
+-- An unmatched ' or " character is encountered on a logical source line during
+  tokenization (<a href="#6.4">6.4</a>).
+-- A reserved keyword token is used in translation phase 7 or 8 for some purpose other
+  than as a keyword (<a href="#6.4.1">6.4.1</a>).
+-- A universal character name in an identifier does not designate a character whose
+  encoding falls into one of the specified ranges (<a href="#6.4.2.1">6.4.2.1</a>).
+-- The initial character of an identifier is a universal character name designating a digit
+  (<a href="#6.4.2.1">6.4.2.1</a>).
+-- Two identifiers differ only in nonsignificant characters (<a href="#6.4.2.1">6.4.2.1</a>).
+-- The identifier __func__ is explicitly declared (<a href="#6.4.2.2">6.4.2.2</a>).
+-- The program attempts to modify a string literal (<a href="#6.4.5">6.4.5</a>).
+-- The characters ', \, ", //, or /* occur in the sequence between the &lt; and &gt;
+  delimiters, or the characters ', \, //, or /* occur in the sequence between the "
+  delimiters, in a header name preprocessing token (<a href="#6.4.7">6.4.7</a>).
+-- A side effect on a scalar object is unsequenced relative to either a different side effect
+  on the same scalar object or a value computation using the value of the same scalar
+  object (<a href="#6.5">6.5</a>).
+-- An exceptional condition occurs during the evaluation of an expression (<a href="#6.5">6.5</a>).
+-- An object has its stored value accessed other than by an lvalue of an allowable type
+  (<a href="#6.5">6.5</a>).
+-- For a call to a function without a function prototype in scope, the number of *
+  arguments does not equal the number of parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+-- For call to a function without a function prototype in scope where the function is
+  defined with a function prototype, either the prototype ends with an ellipsis or the
+  types of the arguments after promotion are not compatible with the types of the
+  parameters (<a href="#6.5.2.2">6.5.2.2</a>).
+-- For a call to a function without a function prototype in scope where the function is not
+  defined with a function prototype, the types of the arguments after promotion are not
+  compatible with those of the parameters after promotion (with certain exceptions)
+  (<a href="#6.5.2.2">6.5.2.2</a>).
+-- A function is defined with a type that is not compatible with the type (of the
+  expression) pointed to by the expression that denotes the called function (<a href="#6.5.2.2">6.5.2.2</a>).
+-- A member of an atomic structure or union is accessed (<a href="#6.5.2.3">6.5.2.3</a>).
+-- The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
+
+[<a name="p555" href="#p555">page 555</a>] (<a href="#Contents">Contents</a>)
+
+-- A pointer is converted to other than an integer or pointer type (<a href="#6.5.4">6.5.4</a>).
+-- The value of the second operand of the / or % operator is zero (<a href="#6.5.5">6.5.5</a>).
+-- Addition or subtraction of a pointer into, or just beyond, an array object and an
+  integer type produces a result that does not point into, or just beyond, the same array
+  object (<a href="#6.5.6">6.5.6</a>).
+-- Addition or subtraction of a pointer into, or just beyond, an array object and an
+  integer type produces a result that points just beyond the array object and is used as
+  the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
+-- Pointers that do not point into, or just beyond, the same array object are subtracted
+  (<a href="#6.5.6">6.5.6</a>).
+-- An array subscript is out of range, even if an object is apparently accessible with the
+  given subscript (as in the lvalue expression a[1][7] given the declaration int
+  a[4][5]) (<a href="#6.5.6">6.5.6</a>).
+-- The result of subtracting two pointers is not representable in an object of type
+  ptrdiff_t (<a href="#6.5.6">6.5.6</a>).
+-- An expression is shifted by a negative number or by an amount greater than or equal
+  to the width of the promoted expression (<a href="#6.5.7">6.5.7</a>).
+-- An expression having signed promoted type is left-shifted and either the value of the
+  expression is negative or the result of shifting would be not be representable in the
+  promoted type (<a href="#6.5.7">6.5.7</a>).
+-- Pointers that do not point to the same aggregate or union (nor just beyond the same
+  array object) are compared using relational operators (<a href="#6.5.8">6.5.8</a>).
+-- An object is assigned to an inexactly overlapping object or to an exactly overlapping
+  object with incompatible type (<a href="#6.5.16.1">6.5.16.1</a>).
+-- An expression that is required to be an integer constant expression does not have an
+  integer type; has operands that are not integer constants, enumeration constants,
+  character constants, sizeof expressions whose results are integer constants, or
+  immediately-cast floating constants; or contains casts (outside operands to sizeof
+  operators) other than conversions of arithmetic types to integer types (<a href="#6.6">6.6</a>).
+-- A constant expression in an initializer is not, or does not evaluate to, one of the
+  following: an arithmetic constant expression, a null pointer constant, an address
+  constant, or an address constant for a complete object type plus or minus an integer
+  constant expression (<a href="#6.6">6.6</a>).
+-- An arithmetic constant expression does not have arithmetic type; has operands that
+  are not integer constants, floating constants, enumeration constants, character
+  constants, or sizeof expressions; or contains casts (outside operands to sizeof
+
+[<a name="p556" href="#p556">page 556</a>] (<a href="#Contents">Contents</a>)
+
+   operators) other than conversions of arithmetic types to arithmetic types (<a href="#6.6">6.6</a>).
+-- The value of an object is accessed by an array-subscript [], member-access . or -&gt;,
+  address &amp;, or indirection * operator or a pointer cast in creating an address constant
+  (<a href="#6.6">6.6</a>).
+-- An identifier for an object is declared with no linkage and the type of the object is
+  incomplete after its declarator, or after its init-declarator if it has an initializer (<a href="#6.7">6.7</a>).
+-- A function is declared at block scope with an explicit storage-class specifier other
+  than extern (<a href="#6.7.1">6.7.1</a>).
+-- A structure or union is defined as containing no named members, no anonymous
+  structures, and no anonymous unions (<a href="#6.7.2.1">6.7.2.1</a>).
+-- An attempt is made to access, or generate a pointer to just past, a flexible array
+  member of a structure when the referenced object provides no elements for that array
+  (<a href="#6.7.2.1">6.7.2.1</a>).
+-- When the complete type is needed, an incomplete structure or union type is not
+  completed in the same scope by another declaration of the tag that defines the content
+  (<a href="#6.7.2.3">6.7.2.3</a>).
+-- An attempt is made to modify an object defined with a const-qualified type through
+  use of an lvalue with non-const-qualified type (<a href="#6.7.3">6.7.3</a>).
+-- An attempt is made to refer to an object defined with a volatile-qualified type through
+  use of an lvalue with non-volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+-- The specification of a function type includes any type qualifiers (<a href="#6.7.3">6.7.3</a>).                        *
+-- Two qualified types that are required to be compatible do not have the identically
+  qualified version of a compatible type (<a href="#6.7.3">6.7.3</a>).
+-- An object which has been modified is accessed through a restrict-qualified pointer to
+  a const-qualified type, or through a restrict-qualified pointer and another pointer that
+  are not both based on the same object (<a href="#6.7.3.1">6.7.3.1</a>).
+-- A restrict-qualified pointer is assigned a value based on another restricted pointer
+  whose associated block neither began execution before the block associated with this
+  pointer, nor ended before the assignment (<a href="#6.7.3.1">6.7.3.1</a>).
+-- A function with external linkage is declared with an inline function specifier, but is
+  not also defined in the same translation unit (<a href="#6.7.4">6.7.4</a>).
+-- A function declared with a _Noreturn function specifier returns to its caller (<a href="#6.7.4">6.7.4</a>).
+-- The definition of an object has an alignment specifier and another declaration of that
+  object has a different alignment specifier (<a href="#6.7.5">6.7.5</a>).
+
+[<a name="p557" href="#p557">page 557</a>] (<a href="#Contents">Contents</a>)
+
+-- Declarations of an object in different translation units have different alignment
+  specifiers (<a href="#6.7.5">6.7.5</a>).
+-- Two pointer types that are required to be compatible are not identically qualified, or
+  are not pointers to compatible types (<a href="#6.7.6.1">6.7.6.1</a>).
+-- The size expression in an array declaration is not a constant expression and evaluates
+  at program execution time to a nonpositive value (<a href="#6.7.6.2">6.7.6.2</a>).
+-- In a context requiring two array types to be compatible, they do not have compatible
+  element types, or their size specifiers evaluate to unequal values (<a href="#6.7.6.2">6.7.6.2</a>).
+-- A declaration of an array parameter includes the keyword static within the [ and
+  ] and the corresponding argument does not provide access to the first element of an
+  array with at least the specified number of elements (<a href="#6.7.6.3">6.7.6.3</a>).
+-- A storage-class specifier or type qualifier modifies the keyword void as a function
+  parameter type list (<a href="#6.7.6.3">6.7.6.3</a>).
+-- In a context requiring two function types to be compatible, they do not have
+  compatible return types, or their parameters disagree in use of the ellipsis terminator
+  or the number and type of parameters (after default argument promotion, when there
+  is no parameter type list or when one type is specified by a function definition with an
+  identifier list) (<a href="#6.7.6.3">6.7.6.3</a>).
+-- The value of an unnamed member of a structure or union is used (<a href="#6.7.9">6.7.9</a>).
+-- The initializer for a scalar is neither a single expression nor a single expression
+  enclosed in braces (<a href="#6.7.9">6.7.9</a>).
+-- The initializer for a structure or union object that has automatic storage duration is
+  neither an initializer list nor a single expression that has compatible structure or union
+  type (<a href="#6.7.9">6.7.9</a>).
+-- The initializer for an aggregate or union, other than an array initialized by a string
+  literal, is not a brace-enclosed list of initializers for its elements or members (<a href="#6.7.9">6.7.9</a>).
+-- An identifier with external linkage is used, but in the program there does not exist
+  exactly one external definition for the identifier, or the identifier is not used and there
+  exist multiple external definitions for the identifier (<a href="#6.9">6.9</a>).
+-- A function definition includes an identifier list, but the types of the parameters are not
+  declared in a following declaration list (<a href="#6.9.1">6.9.1</a>).
+-- An adjusted parameter type in a function definition is not a complete object type
+  (<a href="#6.9.1">6.9.1</a>).
+-- A function that accepts a variable number of arguments is defined without a
+  parameter type list that ends with the ellipsis notation (<a href="#6.9.1">6.9.1</a>).
+
+[<a name="p558" href="#p558">page 558</a>] (<a href="#Contents">Contents</a>)
+
+-- The } that terminates a function is reached, and the value of the function call is used
+  by the caller (<a href="#6.9.1">6.9.1</a>).
+-- An identifier for an object with internal linkage and an incomplete type is declared
+  with a tentative definition (<a href="#6.9.2">6.9.2</a>).
+-- The token defined is generated during the expansion of a #if or #elif
+  preprocessing directive, or the use of the defined unary operator does not match
+  one of the two specified forms prior to macro replacement (<a href="#6.10.1">6.10.1</a>).
+-- The #include preprocessing directive that results after expansion does not match
+  one of the two header name forms (<a href="#6.10.2">6.10.2</a>).
+-- The character sequence in an #include preprocessing directive does not start with a
+  letter (<a href="#6.10.2">6.10.2</a>).
+-- There are sequences of preprocessing tokens within the list of macro arguments that
+  would otherwise act as preprocessing directives (<a href="#6.10.3">6.10.3</a>).
+-- The result of the preprocessing operator # is not a valid character string literal
+  (<a href="#6.10.3.2">6.10.3.2</a>).
+-- The result of the preprocessing operator ## is not a valid preprocessing token
+  (<a href="#6.10.3.3">6.10.3.3</a>).
+-- The #line preprocessing directive that results after expansion does not match one of
+  the two well-defined forms, or its digit sequence specifies zero or a number greater
+  than 2147483647 (<a href="#6.10.4">6.10.4</a>).
+-- A non-STDC #pragma preprocessing directive that is documented as causing
+  translation failure or some other form of undefined behavior is encountered (<a href="#6.10.6">6.10.6</a>).
+-- A #pragma STDC preprocessing directive does not match one of the well-defined
+  forms (<a href="#6.10.6">6.10.6</a>).
+-- The name of a predefined macro, or the identifier defined, is the subject of a
+  #define or #undef preprocessing directive (<a href="#6.10.8">6.10.8</a>).
+-- An attempt is made to copy an object to an overlapping object by use of a library
+  function, other than as explicitly allowed (e.g., memmove) (clause 7).
+-- A file with the same name as one of the standard headers, not provided as part of the
+  implementation, is placed in any of the standard places that are searched for included
+  source files (<a href="#7.1.2">7.1.2</a>).
+-- A header is included within an external declaration or definition (<a href="#7.1.2">7.1.2</a>).
+-- A function, object, type, or macro that is specified as being declared or defined by
+  some standard header is used before any header that declares or defines it is included
+  (<a href="#7.1.2">7.1.2</a>).
+
+[<a name="p559" href="#p559">page 559</a>] (<a href="#Contents">Contents</a>)
+
+-- A standard header is included while a macro is defined with the same name as a
+  keyword (<a href="#7.1.2">7.1.2</a>).
+-- The program attempts to declare a library function itself, rather than via a standard
+  header, but the declaration does not have external linkage (<a href="#7.1.2">7.1.2</a>).
+-- The program declares or defines a reserved identifier, other than as allowed by <a href="#7.1.4">7.1.4</a>
+  (<a href="#7.1.3">7.1.3</a>).
+-- The program removes the definition of a macro whose name begins with an
+  underscore and either an uppercase letter or another underscore (<a href="#7.1.3">7.1.3</a>).
+-- An argument to a library function has an invalid value or a type not expected by a
+  function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
+-- The pointer passed to a library function array parameter does not have a value such
+  that all address computations and object accesses are valid (<a href="#7.1.4">7.1.4</a>).
+-- The macro definition of assert is suppressed in order to access an actual function
+  (<a href="#7.2">7.2</a>).
+-- The argument to the assert macro does not have a scalar type (<a href="#7.2">7.2</a>).
+-- The CX_LIMITED_RANGE, FENV_ACCESS, or FP_CONTRACT pragma is used in
+  any context other than outside all external declarations or preceding all explicit
+  declarations and statements inside a compound statement (<a href="#7.3.4">7.3.4</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.12.2">7.12.2</a>).
+-- The value of an argument to a character handling function is neither equal to the value
+  of EOF nor representable as an unsigned char (<a href="#7.4">7.4</a>).
+-- A macro definition of errno is suppressed in order to access an actual object, or the
+  program defines an identifier with the name errno (<a href="#7.5">7.5</a>).
+-- Part of the program tests floating-point status flags, sets floating-point control modes,
+  or runs under non-default mode settings, but was translated with the state for the
+  FENV_ACCESS pragma ''off'' (<a href="#7.6.1">7.6.1</a>).
+-- The exception-mask argument for one of the functions that provide access to the
+  floating-point status flags has a nonzero value not obtained by bitwise OR of the
+  floating-point exception macros (<a href="#7.6.2">7.6.2</a>).
+-- The fesetexceptflag function is used to set floating-point status flags that were
+  not specified in the call to the fegetexceptflag function that provided the value
+  of the corresponding fexcept_t object (<a href="#7.6.2.4">7.6.2.4</a>).
+-- The argument to fesetenv or feupdateenv is neither an object set by a call to
+  fegetenv or feholdexcept, nor is it an environment macro (<a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>).
+-- The value of the result of an integer arithmetic or conversion function cannot be
+  represented (<a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.22.6.1">7.22.6.1</a>, <a href="#7.22.6.2">7.22.6.2</a>, <a href="#7.22.1">7.22.1</a>).
+
+[<a name="p560" href="#p560">page 560</a>] (<a href="#Contents">Contents</a>)
+
+-- The program modifies the string pointed to by the value returned by the setlocale
+  function (<a href="#7.11.1.1">7.11.1.1</a>).
+-- The program modifies the structure pointed to by the value returned by the
+  localeconv function (<a href="#7.11.2.1">7.11.2.1</a>).
+-- A macro definition of math_errhandling is suppressed or the program defines
+  an identifier with the name math_errhandling (<a href="#7.12">7.12</a>).
+-- An argument to a floating-point classification or comparison macro is not of real
+  floating type (<a href="#7.12.3">7.12.3</a>, <a href="#7.12.14">7.12.14</a>).
+-- A macro definition of setjmp is suppressed in order to access an actual function, or
+  the program defines an external identifier with the name setjmp (<a href="#7.13">7.13</a>).
+-- An invocation of the setjmp macro occurs other than in an allowed context
+  (<a href="#7.13.2.1">7.13.2.1</a>).
+-- The longjmp function is invoked to restore a nonexistent environment (<a href="#7.13.2.1">7.13.2.1</a>).
+-- After a longjmp, there is an attempt to access the value of an object of automatic
+  storage duration that does not have volatile-qualified type, local to the function
+  containing the invocation of the corresponding setjmp macro, that was changed
+  between the setjmp invocation and longjmp call (<a href="#7.13.2.1">7.13.2.1</a>).
+-- The program specifies an invalid pointer to a signal handler function (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal handler returns when the signal corresponded to a computational exception
+  (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal occurs as the result of calling the abort or raise function, and the signal
+  handler calls the raise function (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal occurs other than as the result of calling the abort or raise function, and
+  the signal handler refers to an object with static or thread storage duration that is not a
+  lock-free atomic object other than by assigning a value to an object declared as
+  volatile sig_atomic_t, or calls any function in the standard library other
+  than the abort function, the _Exit function, the quick_exit function, or the
+  signal function (for the same signal number) (<a href="#7.14.1.1">7.14.1.1</a>).
+-- The value of errno is referred to after a signal occurred other than as the result of
+  calling the abort or raise function and the corresponding signal handler obtained
+  a SIG_ERR return from a call to the signal function (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A signal is generated by an asynchronous signal handler (<a href="#7.14.1.1">7.14.1.1</a>).
+-- A function with a variable number of arguments attempts to access its varying
+  arguments other than through a properly declared and initialized va_list object, or
+  before the va_start macro is invoked (<a href="#7.16">7.16</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.4">7.16.1.4</a>).
+
+[<a name="p561" href="#p561">page 561</a>] (<a href="#Contents">Contents</a>)
+
+-- The macro va_arg is invoked using the parameter ap that was passed to a function
+  that invoked the macro va_arg with the same parameter (<a href="#7.16">7.16</a>).
+-- A macro definition of va_start, va_arg, va_copy, or va_end is suppressed in
+  order to access an actual function, or the program defines an external identifier with
+  the name va_copy or va_end (<a href="#7.16.1">7.16.1</a>).
+-- The va_start or va_copy macro is invoked without a corresponding invocation
+  of the va_end macro in the same function, or vice versa (<a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>,
+  <a href="#7.16.1.4">7.16.1.4</a>).
+-- The type parameter to the va_arg macro is not such that a pointer to an object of
+  that type can be obtained simply by postfixing a * (<a href="#7.16.1.1">7.16.1.1</a>).
+-- The va_arg macro is invoked when there is no actual next argument, or with a
+  specified type that is not compatible with the promoted type of the actual next
+  argument, with certain exceptions (<a href="#7.16.1.1">7.16.1.1</a>).
+-- The va_copy or va_start macro is called to initialize a va_list that was
+  previously initialized by either macro without an intervening invocation of the
+  va_end macro for the same va_list (<a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.4">7.16.1.4</a>).
+-- The parameter parmN of a va_start macro is declared with the register
+  storage class, with a function or array type, or with a type that is not compatible with
+  the type that results after application of the default argument promotions (<a href="#7.16.1.4">7.16.1.4</a>).
+-- The member designator parameter of an offsetof macro is an invalid right
+  operand of the . operator for the type parameter, or designates a bit-field (<a href="#7.19">7.19</a>).
+-- The argument in an instance of one of the integer-constant macros is not a decimal,
+  octal, or hexadecimal constant, or it has a value that exceeds the limits for the
+  corresponding type (<a href="#7.20.4">7.20.4</a>).
+-- A byte input/output function is applied to a wide-oriented stream, or a wide character
+  input/output function is applied to a byte-oriented stream (<a href="#7.21.2">7.21.2</a>).
+-- Use is made of any portion of a file beyond the most recent wide character written to
+  a wide-oriented stream (<a href="#7.21.2">7.21.2</a>).
+-- The value of a pointer to a FILE object is used after the associated file is closed
+  (<a href="#7.21.3">7.21.3</a>).
+-- The stream for the fflush function points to an input stream or to an update stream
+  in which the most recent operation was input (<a href="#7.21.5.2">7.21.5.2</a>).
+-- The string pointed to by the mode argument in a call to the fopen function does not
+  exactly match one of the specified character sequences (<a href="#7.21.5.3">7.21.5.3</a>).
+-- An output operation on an update stream is followed by an input operation without an
+    intervening call to the fflush function or a file positioning function, or an input
+
+[<a name="p562" href="#p562">page 562</a>] (<a href="#Contents">Contents</a>)
+
+   operation on an update stream is followed by an output operation with an intervening
+   call to a file positioning function (<a href="#7.21.5.3">7.21.5.3</a>).
+-- An attempt is made to use the contents of the array that was supplied in a call to the
+  setvbuf function (<a href="#7.21.5.6">7.21.5.6</a>).
+-- There are insufficient arguments for the format in a call to one of the formatted
+  input/output functions, or an argument does not have an appropriate type (<a href="#7.21.6.1">7.21.6.1</a>,
+  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- The format in a call to one of the formatted input/output functions or to the
+  strftime or wcsftime function is not a valid multibyte character sequence that
+  begins and ends in its initial shift state (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+  <a href="#7.28.5.1">7.28.5.1</a>).
+-- In a call to one of the formatted output functions, a precision appears with a
+  conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+-- A conversion specification for a formatted output function uses an asterisk to denote
+  an argument-supplied field width or precision, but the corresponding argument is not
+  provided (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+-- A conversion specification for a formatted output function uses a # or 0 flag with a
+  conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+-- A conversion specification for one of the formatted input/output functions uses a
+  length modifier with a conversion specifier other than those described (<a href="#7.21.6.1">7.21.6.1</a>,
+  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- An s conversion specifier is encountered by one of the formatted output functions,
+  and the argument is missing the null terminator (unless a precision is specified that
+  does not require null termination) (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+-- An n conversion specification for one of the formatted input/output functions includes
+  any flags, an assignment-suppressing character, a field width, or a precision (<a href="#7.21.6.1">7.21.6.1</a>,
+  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- A % conversion specifier is encountered by one of the formatted input/output
+  functions, but the complete conversion specification is not exactly %% (<a href="#7.21.6.1">7.21.6.1</a>,
+  <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- An invalid conversion specification is found in the format for one of the formatted
+  input/output functions, or the strftime or wcsftime function (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+  <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+-- The number of characters transmitted by a formatted output function is greater than
+  INT_MAX (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.10">7.21.6.10</a>).
+
+[<a name="p563" href="#p563">page 563</a>] (<a href="#Contents">Contents</a>)
+
+-- The result of a conversion by one of the formatted input functions cannot be
+  represented in the corresponding object, or the receiving object does not have an
+  appropriate type (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- A c, s, or [ conversion specifier is encountered by one of the formatted input
+  functions, and the array pointed to by the corresponding argument is not large enough
+  to accept the input sequence (and a null terminator if the conversion specifier is s or
+  [) (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- A c, s, or [ conversion specifier with an l qualifier is encountered by one of the
+  formatted input functions, but the input is not a valid multibyte character sequence
+  that begins in the initial shift state (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- The input item for a %p conversion by one of the formatted input functions is not a
+  value converted earlier during the same program execution (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- The vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf,
+  vsscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, or
+  vwscanf function is called with an improperly initialized va_list argument, or
+  the argument is used (other than in an invocation of va_end) after the function
+  returns (<a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
+  <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>).
+-- The contents of the array supplied in a call to the fgets or fgetws function are
+  used after a read error occurred (<a href="#7.21.7.2">7.21.7.2</a>, <a href="#7.28.3.2">7.28.3.2</a>).
+-- The file position indicator for a binary stream is used after a call to the ungetc
+  function where its value was zero before the call (<a href="#7.21.7.10">7.21.7.10</a>).
+-- The file position indicator for a stream is used after an error occurred during a call to
+  the fread or fwrite function (<a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>).
+-- A partial element read by a call to the fread function is used (<a href="#7.21.8.1">7.21.8.1</a>).
+-- The fseek function is called for a text stream with a nonzero offset and either the
+  offset was not returned by a previous successful call to the ftell function on a
+  stream associated with the same file or whence is not SEEK_SET (<a href="#7.21.9.2">7.21.9.2</a>).
+-- The fsetpos function is called to set a position that was not returned by a previous
+  successful call to the fgetpos function on a stream associated with the same file
+  (<a href="#7.21.9.3">7.21.9.3</a>).
+-- A non-null pointer returned by a call to the calloc, malloc, or realloc function
+  with a zero requested size is used to access an object (<a href="#7.22.3">7.22.3</a>).
+-- The value of a pointer that refers to space deallocated by a call to the free or
+  realloc function is used (<a href="#7.22.3">7.22.3</a>).
+
+[<a name="p564" href="#p564">page 564</a>] (<a href="#Contents">Contents</a>)
+
+-- The alignment requested of the aligned_alloc function is not valid or not
+  supported by the implementation, or the size requested is not an integral multiple of
+  the alignment (<a href="#7.22.3.1">7.22.3.1</a>).
+-- The pointer argument to the free or realloc function does not match a pointer
+  earlier returned by a memory management function, or the space has been deallocated
+  by a call to free or realloc (<a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>).
+-- The value of the object allocated by the malloc function is used (<a href="#7.22.3.4">7.22.3.4</a>).
+-- The value of any bytes in a new object allocated by the realloc function beyond
+  the size of the old object are used (<a href="#7.22.3.5">7.22.3.5</a>).
+-- The program calls the exit or quick_exit function more than once, or calls both
+  functions (<a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.7">7.22.4.7</a>).
+-- During the call to a function registered with the atexit or at_quick_exit
+  function, a call is made to the longjmp function that would terminate the call to the
+  registered function (<a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.7">7.22.4.7</a>).
+-- The string set up by the getenv or strerror function is modified by the program
+  (<a href="#7.22.4.6">7.22.4.6</a>, <a href="#7.23.6.2">7.23.6.2</a>).
+-- A command is executed through the system function in a way that is documented as
+  causing termination or some other form of undefined behavior (<a href="#7.22.4.8">7.22.4.8</a>).
+-- A searching or sorting utility function is called with an invalid pointer argument, even
+  if the number of elements is zero (<a href="#7.22.5">7.22.5</a>).
+-- The comparison function called by a searching or sorting utility function alters the
+  contents of the array being searched or sorted, or returns ordering values
+  inconsistently (<a href="#7.22.5">7.22.5</a>).
+-- The array being searched by the bsearch function does not have its elements in
+  proper order (<a href="#7.22.5.1">7.22.5.1</a>).
+-- The current conversion state is used by a multibyte/wide character conversion
+  function after changing the LC_CTYPE category (<a href="#7.22.7">7.22.7</a>).
+-- A string or wide string utility function is instructed to access an array beyond the end
+  of an object (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
+-- A string or wide string utility function is called with an invalid pointer argument, even
+  if the length is zero (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
+-- The contents of the destination array are used after a call to the strxfrm,
+  strftime, wcsxfrm, or wcsftime function in which the specified length was
+  too small to hold the entire null-terminated result (<a href="#7.23.4.5">7.23.4.5</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>,
+  <a href="#7.28.5.1">7.28.5.1</a>).
+
+[<a name="p565" href="#p565">page 565</a>] (<a href="#Contents">Contents</a>)
+
+    -- The first argument in the very first call to the strtok or wcstok is a null pointer
+      (<a href="#7.23.5.8">7.23.5.8</a>, <a href="#7.28.4.5.7">7.28.4.5.7</a>).
+    -- The type of an argument to a type-generic macro is not compatible with the type of
+      the corresponding parameter of the selected function (<a href="#7.24">7.24</a>).
+    -- A complex argument is supplied for a generic parameter of a type-generic macro that
+      has no corresponding complex function (<a href="#7.24">7.24</a>).
+    -- At least one field of the broken-down time passed to asctime contains a value
+      outside its normal range, or the calculated year exceeds four digits or is less than the
+      year 1000 (<a href="#7.26.3.1">7.26.3.1</a>).
+    -- The argument corresponding to an s specifier without an l qualifier in a call to the
+      fwprintf function does not point to a valid multibyte character sequence that
+      begins in the initial shift state (<a href="#7.28.2.11">7.28.2.11</a>).
+    -- In a call to the wcstok function, the object pointed to by ptr does not have the
+      value stored by the previous call for the same wide string (<a href="#7.28.4.5.7">7.28.4.5.7</a>).
+    -- An mbstate_t object is used inappropriately (<a href="#7.28.6">7.28.6</a>).
+    -- The value of an argument of type wint_t to a wide character classification or case
+      mapping function is neither equal to the value of WEOF nor representable as a
+      wchar_t (<a href="#7.29.1">7.29.1</a>).
+    -- The iswctype function is called using a different LC_CTYPE category from the
+      one in effect for the call to the wctype function that returned the description
+      (<a href="#7.29.2.2.1">7.29.2.2.1</a>).
+    -- The towctrans function is called using a different LC_CTYPE category from the
+      one in effect for the call to the wctrans function that returned the description
+      (<a href="#7.29.3.2.1">7.29.3.2.1</a>).
+<a name="J.3" href="#J.3"><b>    J.3 Implementation-defined behavior</b></a>
+1   A conforming implementation is required to document its choice of behavior in each of
+    the areas listed in this subclause. The following are implementation-defined:
+
+[<a name="p566" href="#p566">page 566</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3.1" href="#J.3.1"><b>    J.3.1 Translation</b></a>
+1   -- How a diagnostic is identified (<a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>).
+    -- Whether each nonempty sequence of white-space characters other than new-line is
+      retained or replaced by one space character in translation phase 3 (<a href="#5.1.1.2">5.1.1.2</a>).
+<a name="J.3.2" href="#J.3.2"><b>    J.3.2 Environment</b></a>
+1   -- The mapping between physical source file multibyte characters and the source
+      character set in translation phase 1 (<a href="#5.1.1.2">5.1.1.2</a>).
+    -- The name and type of the function called at program startup in a freestanding
+      environment (<a href="#5.1.2.1">5.1.2.1</a>).
+    -- The effect of program termination in a freestanding environment (<a href="#5.1.2.1">5.1.2.1</a>).
+    -- An alternative manner in which the main function may be defined (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+    -- The values given to the strings pointed to by the argv argument to main (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+    -- What constitutes an interactive device (<a href="#5.1.2.3">5.1.2.3</a>).
+    -- Whether a program can have more than one thread of execution in a freestanding
+      environment (<a href="#5.1.2.4">5.1.2.4</a>).
+    -- The set of signals, their semantics, and their default handling (<a href="#7.14">7.14</a>).
+    -- Signal values other than SIGFPE, SIGILL, and SIGSEGV that correspond to a
+      computational exception (<a href="#7.14.1.1">7.14.1.1</a>).
+    -- Signals for which the equivalent of signal(sig, SIG_IGN); is executed at
+      program startup (<a href="#7.14.1.1">7.14.1.1</a>).
+    -- The set of environment names and the method for altering the environment list used
+      by the getenv function (<a href="#7.22.4.6">7.22.4.6</a>).
+    -- The manner of execution of the string by the system function (<a href="#7.22.4.8">7.22.4.8</a>).
+<a name="J.3.3" href="#J.3.3"><b>    J.3.3 Identifiers</b></a>
+1   -- Which additional multibyte characters may appear in identifiers and their
+      correspondence to universal character names (<a href="#6.4.2">6.4.2</a>).
+    -- The number of significant initial characters in an identifier (<a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2">6.4.2</a>).
+
+[<a name="p567" href="#p567">page 567</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3.4" href="#J.3.4"><b>    J.3.4 Characters</b></a>
+1   -- The number of bits in a byte (<a href="#3.6">3.6</a>).
+    -- The values of the members of the execution character set (<a href="#5.2.1">5.2.1</a>).
+    -- The unique value of the member of the execution character set produced for each of
+      the standard alphabetic escape sequences (<a href="#5.2.2">5.2.2</a>).
+    -- The value of a char object into which has been stored any character other than a
+      member of the basic execution character set (<a href="#6.2.5">6.2.5</a>).
+    -- Which of signed char or unsigned char has the same range, representation,
+      and behavior as ''plain'' char (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>).
+    -- The mapping of members of the source character set (in character constants and string
+      literals) to members of the execution character set (<a href="#6.4.4.4">6.4.4.4</a>, <a href="#5.1.1.2">5.1.1.2</a>).
+    -- The value of an integer character constant containing more than one character or
+      containing a character or escape sequence that does not map to a single-byte
+      execution character (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- The value of a wide character constant containing more than one multibyte character
+      or a single multibyte character that maps to multiple members of the extended
+      execution character set, or containing a multibyte character or escape sequence not
+      represented in the extended execution character set (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- The current locale used to convert a wide character constant consisting of a single
+      multibyte character that maps to a member of the extended execution character set
+      into a corresponding wide character code (<a href="#6.4.4.4">6.4.4.4</a>).
+    -- Whether differently-prefixed wide string literal tokens can be concatenated and, if so,
+      the treatment of the resulting multibyte character sequence (<a href="#6.4.5">6.4.5</a>).
+    -- The current locale used to convert a wide string literal into corresponding wide
+      character codes (<a href="#6.4.5">6.4.5</a>).
+    -- The value of a string literal containing a multibyte character or escape sequence not
+      represented in the execution character set (<a href="#6.4.5">6.4.5</a>).
+    -- The encoding of any of wchar_t, char16_t, and char32_t where the
+      corresponding  standard   encoding macro      (__STDC_ISO_10646__,
+      __STDC_UTF_16__, or __STDC_UTF_32__) is not defined (<a href="#6.10.8.2">6.10.8.2</a>).
+
+[<a name="p568" href="#p568">page 568</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3.5" href="#J.3.5"><b>    J.3.5 Integers</b></a>
+1   -- Any extended integer types that exist in the implementation (<a href="#6.2.5">6.2.5</a>).
+    -- Whether signed integer types are represented using sign and magnitude, two's
+      complement, or ones' complement, and whether the extraordinary value is a trap
+      representation or an ordinary value (<a href="#6.2.6.2">6.2.6.2</a>).
+    -- The rank of any extended integer type relative to another extended integer type with
+      the same precision (<a href="#6.3.1.1">6.3.1.1</a>).
+    -- The result of, or the signal raised by, converting an integer to a signed integer type
+      when the value cannot be represented in an object of that type (<a href="#6.3.1.3">6.3.1.3</a>).
+    -- The results of some bitwise operations on signed integers (<a href="#6.5">6.5</a>).
+<a name="J.3.6" href="#J.3.6"><b>    J.3.6 Floating point</b></a>
+1   -- The accuracy of the floating-point operations and of the library functions in
+      <a href="#7.12">&lt;math.h&gt;</a> and <a href="#7.3">&lt;complex.h&gt;</a> that return floating-point results (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The accuracy of the conversions between floating-point internal representations and
+      string representations performed by the library functions in <a href="#7.21">&lt;stdio.h&gt;</a>,
+      <a href="#7.22">&lt;stdlib.h&gt;</a>, and <a href="#7.28">&lt;wchar.h&gt;</a> (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The rounding behaviors characterized by non-standard values of FLT_ROUNDS
+      (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The evaluation methods characterized by non-standard negative values of
+      FLT_EVAL_METHOD (<a href="#5.2.4.2.2">5.2.4.2.2</a>).
+    -- The direction of rounding when an integer is converted to a floating-point number that
+      cannot exactly represent the original value (<a href="#6.3.1.4">6.3.1.4</a>).
+    -- The direction of rounding when a floating-point number is converted to a narrower
+      floating-point number (<a href="#6.3.1.5">6.3.1.5</a>).
+    -- How the nearest representable value or the larger or smaller representable value
+      immediately adjacent to the nearest representable value is chosen for certain floating
+      constants (<a href="#6.4.4.2">6.4.4.2</a>).
+    -- Whether and how floating expressions are contracted when not disallowed by the
+      FP_CONTRACT pragma (<a href="#6.5">6.5</a>).
+    -- The default state for the FENV_ACCESS pragma (<a href="#7.6.1">7.6.1</a>).
+    -- Additional floating-point exceptions, rounding           modes,     environments,   and
+      classifications, and their macro names (<a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>).
+    -- The default state for the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>).
+
+[<a name="p569" href="#p569">page 569</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3.7" href="#J.3.7"><b>    J.3.7 Arrays and pointers</b></a>
+1   -- The result of converting a pointer to an integer or vice versa (<a href="#6.3.2.3">6.3.2.3</a>).
+    -- The size of the result of subtracting two pointers to elements of the same array
+      (<a href="#6.5.6">6.5.6</a>).
+<a name="J.3.8" href="#J.3.8"><b>    J.3.8 Hints</b></a>
+1   -- The extent to which suggestions made by using the register storage-class
+      specifier are effective (<a href="#6.7.1">6.7.1</a>).
+    -- The extent to which suggestions made by using the inline function specifier are
+      effective (<a href="#6.7.4">6.7.4</a>).
+<a name="J.3.9" href="#J.3.9"><b>    J.3.9 Structures, unions, enumerations, and bit-fields</b></a>
+1   -- Whether a ''plain'' int bit-field is treated as a signed int bit-field or as an
+      unsigned int bit-field (<a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.1">6.7.2.1</a>).
+    -- Allowable bit-field types other than _Bool, signed int, and unsigned int
+      (<a href="#6.7.2.1">6.7.2.1</a>).
+    -- Whether atomic types are permitted for bit-fields (<a href="#6.7.2.1">6.7.2.1</a>).
+    -- Whether a bit-field can straddle a storage-unit boundary (<a href="#6.7.2.1">6.7.2.1</a>).
+    -- The order of allocation of bit-fields within a unit (<a href="#6.7.2.1">6.7.2.1</a>).
+    -- The alignment of non-bit-field members of structures (<a href="#6.7.2.1">6.7.2.1</a>). This should present
+      no problem unless binary data written by one implementation is read by another.
+    -- The integer type compatible with each enumerated type (<a href="#6.7.2.2">6.7.2.2</a>).
+<a name="J.3.10" href="#J.3.10"><b>    J.3.10 Qualifiers</b></a>
+1   -- What constitutes an access to an object that has volatile-qualified type (<a href="#6.7.3">6.7.3</a>).
+<a name="J.3.11" href="#J.3.11"><b>    J.3.11 Preprocessing directives</b></a>
+1   -- The locations within #pragma directives where header name preprocessing tokens
+      are recognized (<a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>).
+    -- How sequences in both forms of header names are mapped to headers or external
+      source file names (<a href="#6.4.7">6.4.7</a>).
+    -- Whether the value of a character constant in a constant expression that controls
+      conditional inclusion matches the value of the same character constant in the
+      execution character set (<a href="#6.10.1">6.10.1</a>).
+    -- Whether the value of a single-character character constant in a constant expression
+      that controls conditional inclusion may have a negative value (<a href="#6.10.1">6.10.1</a>).
+
+[<a name="p570" href="#p570">page 570</a>] (<a href="#Contents">Contents</a>)
+
+    -- The places that are searched for an included &lt; &gt; delimited header, and how the places
+      are specified or the header is identified (<a href="#6.10.2">6.10.2</a>).
+    -- How the named source file is searched for in an included " " delimited header
+      (<a href="#6.10.2">6.10.2</a>).
+    -- The method by which preprocessing tokens (possibly resulting from macro
+      expansion) in a #include directive are combined into a header name (<a href="#6.10.2">6.10.2</a>).
+    -- The nesting limit for #include processing (<a href="#6.10.2">6.10.2</a>).
+    -- Whether the # operator inserts a \ character before the \ character that begins a
+      universal character name in a character constant or string literal (<a href="#6.10.3.2">6.10.3.2</a>).
+    -- The behavior on each recognized non-STDC #pragma directive (<a href="#6.10.6">6.10.6</a>).
+    -- The definitions for __DATE__ and __TIME__ when respectively, the date and
+      time of translation are not available (<a href="#6.10.8.1">6.10.8.1</a>).
+<a name="J.3.12" href="#J.3.12"><b>    J.3.12 Library functions</b></a>
+1   -- Any library facilities available to a freestanding program, other than the minimal set
+      required by clause 4 (<a href="#5.1.2.1">5.1.2.1</a>).
+    -- The format of the diagnostic printed by the assert macro (<a href="#7.2.1.1">7.2.1.1</a>).
+    -- The representation of the floating-point               status   flags   stored   by   the
+      fegetexceptflag function (<a href="#7.6.2.2">7.6.2.2</a>).
+    -- Whether the feraiseexcept function raises the ''inexact'' floating-point
+      exception in addition to the ''overflow'' or ''underflow'' floating-point exception
+      (<a href="#7.6.2.3">7.6.2.3</a>).
+    -- Strings other than "C" and "" that may be passed as the second argument to the
+      setlocale function (<a href="#7.11.1.1">7.11.1.1</a>).
+    -- The types defined for float_t and double_t when the value of the
+      FLT_EVAL_METHOD macro is less than 0 (<a href="#7.12">7.12</a>).
+    -- Domain errors for the mathematics functions, other than those required by this
+      International Standard (<a href="#7.12.1">7.12.1</a>).
+    -- The values returned by the mathematics functions on domain errors or pole errors
+      (<a href="#7.12.1">7.12.1</a>).
+    -- The values returned by the mathematics functions on underflow range errors, whether
+      errno is set to the value of the macro ERANGE when the integer expression
+      math_errhandling &amp; MATH_ERRNO is nonzero, and whether the ''underflow''
+      floating-point exception is raised when the integer expression math_errhandling
+      &amp; MATH_ERREXCEPT is nonzero. (<a href="#7.12.1">7.12.1</a>).
+
+[<a name="p571" href="#p571">page 571</a>] (<a href="#Contents">Contents</a>)
+
+-- Whether a domain error occurs or zero is returned when an fmod function has a
+  second argument of zero (<a href="#7.12.10.1">7.12.10.1</a>).
+-- Whether a domain error occurs or zero is returned when a remainder function has
+  a second argument of zero (<a href="#7.12.10.2">7.12.10.2</a>).
+-- The base-2 logarithm of the modulus used by the remquo functions in reducing the
+  quotient (<a href="#7.12.10.3">7.12.10.3</a>).
+-- Whether a domain error occurs or zero is returned when a remquo function has a
+  second argument of zero (<a href="#7.12.10.3">7.12.10.3</a>).
+-- Whether the equivalent of signal(sig, SIG_DFL); is executed prior to the call
+  of a signal handler, and, if not, the blocking of signals that is performed (<a href="#7.14.1.1">7.14.1.1</a>).
+-- The null pointer constant to which the macro NULL expands (<a href="#7.19">7.19</a>).
+-- Whether the last line of a text stream requires a terminating new-line character
+  (<a href="#7.21.2">7.21.2</a>).
+-- Whether space characters that are written out to a text stream immediately before a
+  new-line character appear when read in (<a href="#7.21.2">7.21.2</a>).
+-- The number of null characters that may be appended to data written to a binary
+  stream (<a href="#7.21.2">7.21.2</a>).
+-- Whether the file position indicator of an append-mode stream is initially positioned at
+  the beginning or end of the file (<a href="#7.21.3">7.21.3</a>).
+-- Whether a write on a text stream causes the associated file to be truncated beyond that
+  point (<a href="#7.21.3">7.21.3</a>).
+-- The characteristics of file buffering (<a href="#7.21.3">7.21.3</a>).
+-- Whether a zero-length file actually exists (<a href="#7.21.3">7.21.3</a>).
+-- The rules for composing valid file names (<a href="#7.21.3">7.21.3</a>).
+-- Whether the same file can be simultaneously open multiple times (<a href="#7.21.3">7.21.3</a>).
+-- The nature and choice of encodings used for multibyte characters in files (<a href="#7.21.3">7.21.3</a>).
+-- The effect of the remove function on an open file (<a href="#7.21.4.1">7.21.4.1</a>).
+-- The effect if a file with the new name exists prior to a call to the rename function
+  (<a href="#7.21.4.2">7.21.4.2</a>).
+-- Whether an open temporary file is removed upon abnormal program termination
+  (<a href="#7.21.4.3">7.21.4.3</a>).
+-- Which changes of mode are permitted (if any), and under what circumstances
+  (<a href="#7.21.5.4">7.21.5.4</a>).
+
+[<a name="p572" href="#p572">page 572</a>] (<a href="#Contents">Contents</a>)
+
+-- The style used to print an infinity or NaN, and the meaning of any n-char or n-wchar
+  sequence printed for a NaN (<a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+-- The output for %p conversion in the fprintf or fwprintf function (<a href="#7.21.6.1">7.21.6.1</a>,
+  <a href="#7.28.2.1">7.28.2.1</a>).
+-- The interpretation of a - character that is neither the first nor the last character, nor
+  the second where a ^ character is the first, in the scanlist for %[ conversion in the
+  fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>).
+-- The set of sequences matched by a %p conversion and the interpretation of the
+  corresponding input item in the fscanf or fwscanf function (<a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>).
+-- The value to which the macro errno is set by the fgetpos, fsetpos, or ftell
+  functions on failure (<a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>).
+-- The meaning of any n-char or n-wchar sequence in a string representing a NaN that is
+  converted by the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+  function (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
+-- Whether or not the strtod, strtof, strtold, wcstod, wcstof, or wcstold
+  function sets errno to ERANGE when underflow occurs (<a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>).
+-- Whether the calloc, malloc, and realloc functions return a null pointer or a
+  pointer to an allocated object when the size requested is zero (<a href="#7.22.3">7.22.3</a>).
+-- Whether open streams with unwritten buffered data are flushed, open streams are
+  closed, or temporary files are removed when the abort or _Exit function is called
+  (<a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.22.4.5">7.22.4.5</a>).
+-- The termination status returned to the host environment by the abort, exit,
+  _Exit, or quick_exit function (<a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>).
+-- The value returned by the system function when its argument is not a null pointer
+  (<a href="#7.22.4.8">7.22.4.8</a>).
+-- The local time zone and Daylight Saving Time (<a href="#7.26.1">7.26.1</a>).
+-- The range and precision of times representable in clock_t and time_t (<a href="#7.26">7.26</a>).
+-- The era for the clock function (<a href="#7.26.2.1">7.26.2.1</a>).
+-- The replacement string for the %Z specifier to the strftime, and wcsftime
+  functions in the "C" locale (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+-- Whether the functions in <a href="#7.12">&lt;math.h&gt;</a> honor the rounding direction mode in an
+  IEC 60559 conformant implementation, unless explicitly specified otherwise (<a href="#F.10">F.10</a>).
+
+[<a name="p573" href="#p573">page 573</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.3.13" href="#J.3.13"><b>    J.3.13 Architecture</b></a>
+1   -- The values or expressions assigned to the macros specified in the headers
+      <a href="#7.7">&lt;float.h&gt;</a>, <a href="#7.10">&lt;limits.h&gt;</a>, and <a href="#7.20">&lt;stdint.h&gt;</a> (<a href="#5.2.4.2">5.2.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>).
+    -- The result of attempting to indirectly access an object with automatic or thread
+      storage duration from a thread other than the one with which it is associated (<a href="#6.2.4">6.2.4</a>).
+    -- The number, order, and encoding of bytes in any object (when not explicitly specified
+      in this International Standard) (<a href="#6.2.6.1">6.2.6.1</a>).
+    -- Whether any extended alignments are supported and the contexts in which they are
+      supported (<a href="#6.2.8">6.2.8</a>).
+    -- Valid alignment values other than those returned by an alignof expression for
+      fundamental types, if any (<a href="#6.2.8">6.2.8</a>).
+    -- The value of the result of the sizeof and alignof operators (<a href="#6.5.3.4">6.5.3.4</a>).
+<a name="J.4" href="#J.4"><b>    J.4 Locale-specific behavior</b></a>
+1   The following characteristics of a hosted environment are locale-specific and are required
+    to be documented by the implementation:
+    -- Additional members of the source and execution character sets beyond the basic
+      character set (<a href="#5.2.1">5.2.1</a>).
+    -- The presence, meaning, and representation of additional multibyte characters in the
+      execution character set beyond the basic character set (<a href="#5.2.1.2">5.2.1.2</a>).
+    -- The shift states used for the encoding of multibyte characters (<a href="#5.2.1.2">5.2.1.2</a>).
+    -- The direction of writing of successive printing characters (<a href="#5.2.2">5.2.2</a>).
+    -- The decimal-point character (<a href="#7.1.1">7.1.1</a>).
+    -- The set of printing characters (<a href="#7.4">7.4</a>, <a href="#7.29.2">7.29.2</a>).
+    -- The set of control characters (<a href="#7.4">7.4</a>, <a href="#7.29.2">7.29.2</a>).
+    -- The sets of characters tested for by the isalpha, isblank, islower, ispunct,
+      isspace, isupper, iswalpha, iswblank, iswlower, iswpunct,
+      iswspace, or iswupper functions (<a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+      <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>).
+    -- The native environment (<a href="#7.11.1.1">7.11.1.1</a>).
+    -- Additional subject sequences accepted by the numeric conversion functions (<a href="#7.22.1">7.22.1</a>,
+      <a href="#7.28.4.1">7.28.4.1</a>).
+    -- The collation sequence of the execution character set (<a href="#7.23.4.3">7.23.4.3</a>, <a href="#7.28.4.4.2">7.28.4.4.2</a>).
+
+[<a name="p574" href="#p574">page 574</a>] (<a href="#Contents">Contents</a>)
+
+    -- The contents of the error message strings set up by the strerror function
+      (<a href="#7.23.6.2">7.23.6.2</a>).
+    -- The formats for time and date (<a href="#7.26.3.5">7.26.3.5</a>, <a href="#7.28.5.1">7.28.5.1</a>).
+    -- Character mappings that are supported by the towctrans function (<a href="#7.29.1">7.29.1</a>).
+    -- Character classifications that are supported by the iswctype function (<a href="#7.29.1">7.29.1</a>).
+<a name="J.5" href="#J.5"><b>    J.5 Common extensions</b></a>
+1   The following extensions are widely used in many systems, but are not portable to all
+    implementations. The inclusion of any extension that may cause a strictly conforming
+    program to become invalid renders an implementation nonconforming. Examples of such
+    extensions are new keywords, extra library functions declared in standard headers, or
+    predefined macros with names that do not begin with an underscore.
+<a name="J.5.1" href="#J.5.1"><b>    J.5.1 Environment arguments</b></a>
+1   In a hosted environment, the main function receives a third argument, char *envp[],
+    that points to a null-terminated array of pointers to char, each of which points to a string
+    that provides information about the environment for this execution of the program
+    (<a href="#5.1.2.2.1">5.1.2.2.1</a>).
+<a name="J.5.2" href="#J.5.2"><b>    J.5.2 Specialized identifiers</b></a>
+1   Characters other than the underscore _, letters, and digits, that are not part of the basic
+    source character set (such as the dollar sign $, or characters in national character sets)
+    may appear in an identifier (<a href="#6.4.2">6.4.2</a>).
+<a name="J.5.3" href="#J.5.3"><b>    J.5.3 Lengths and cases of identifiers</b></a>
+1   All characters in identifiers (with or without external linkage) are significant (<a href="#6.4.2">6.4.2</a>).
+<a name="J.5.4" href="#J.5.4"><b>    J.5.4 Scopes of identifiers</b></a>
+1   A function identifier, or the identifier of an object the declaration of which contains the
+    keyword extern, has file scope (<a href="#6.2.1">6.2.1</a>).
+<a name="J.5.5" href="#J.5.5"><b>    J.5.5 Writable string literals</b></a>
+1   String literals are modifiable (in which case, identical string literals should denote distinct
+    objects) (<a href="#6.4.5">6.4.5</a>).
+
+[<a name="p575" href="#p575">page 575</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.5.6" href="#J.5.6"><b>    J.5.6 Other arithmetic types</b></a>
+1   Additional arithmetic types, such as __int128 or double double, and their
+    appropriate conversions are defined (<a href="#6.2.5">6.2.5</a>, <a href="#6.3.1">6.3.1</a>). Additional floating types may have
+    more range or precision than long double, may be used for evaluating expressions of
+    other floating types, and may be used to define float_t or double_t.
+<a name="J.5.7" href="#J.5.7"><b>    J.5.7 Function pointer casts</b></a>
+1   A pointer to an object or to void may be cast to a pointer to a function, allowing data to
+    be invoked as a function (<a href="#6.5.4">6.5.4</a>).
+2   A pointer to a function may be cast to a pointer to an object or to void, allowing a
+    function to be inspected or modified (for example, by a debugger) (<a href="#6.5.4">6.5.4</a>).
+<a name="J.5.8" href="#J.5.8"><b>    J.5.8 Extended bit-field types</b></a>
+1   A bit-field may be declared with a type other than _Bool, unsigned int, or
+    signed int, with an appropriate maximum width (<a href="#6.7.2.1">6.7.2.1</a>).
+<a name="J.5.9" href="#J.5.9"><b>    J.5.9 The fortran keyword</b></a>
+1   The fortran function specifier may be used in a function declaration to indicate that
+    calls suitable for FORTRAN should be generated, or that a different representation for the
+    external name is to be generated (<a href="#6.7.4">6.7.4</a>).
+<a name="J.5.10" href="#J.5.10"><b>    J.5.10 The asm keyword</b></a>
+1   The asm keyword may be used to insert assembly language directly into the translator
+    output (<a href="#6.8">6.8</a>). The most common implementation is via a statement of the form:
+           asm ( character-string-literal );
+<a name="J.5.11" href="#J.5.11"><b>    J.5.11 Multiple external definitions</b></a>
+1   There may be more than one external definition for the identifier of an object, with or
+    without the explicit use of the keyword extern; if the definitions disagree, or more than
+    one is initialized, the behavior is undefined (<a href="#6.9.2">6.9.2</a>).
+<a name="J.5.12" href="#J.5.12"><b>    J.5.12 Predefined macro names</b></a>
+1   Macro names that do not begin with an underscore, describing the translation and
+    execution environments, are defined by the implementation before translation begins
+    (<a href="#6.10.8">6.10.8</a>).
+
+[<a name="p576" href="#p576">page 576</a>] (<a href="#Contents">Contents</a>)
+
+<a name="J.5.13" href="#J.5.13"><b>    J.5.13 Floating-point status flags</b></a>
+1   If any floating-point status flags are set on normal termination after all calls to functions
+    registered by the atexit function have been made (see <a href="#7.22.4.4">7.22.4.4</a>), the implementation
+    writes some diagnostics indicating the fact to the stderr stream, if it is still open,
+<a name="J.5.14" href="#J.5.14"><b>    J.5.14 Extra arguments for signal handlers</b></a>
+1   Handlers for specific signals are called with extra arguments in addition to the signal
+    number (<a href="#7.14.1.1">7.14.1.1</a>).
+<a name="J.5.15" href="#J.5.15"><b>    J.5.15 Additional stream types and file-opening modes</b></a>
+1   Additional mappings from files to streams are supported (<a href="#7.21.2">7.21.2</a>).
+2   Additional file-opening modes may be specified by characters appended to the mode
+    argument of the fopen function (<a href="#7.21.5.3">7.21.5.3</a>).
+<a name="J.5.16" href="#J.5.16"><b>    J.5.16 Defined file position indicator</b></a>
+1   The file position indicator is decremented by each successful call to the ungetc or
+    ungetwc function for a text stream, except if its value was zero before a call (<a href="#7.21.7.10">7.21.7.10</a>,
+<a name="7.28.3.10)" href="#7.28.3.10)"><b>    7.28.3.10).</b></a>
+<a name="J.5.17" href="#J.5.17"><b>    J.5.17 Math error reporting</b></a>
+1   Functions declared in <a href="#7.3">&lt;complex.h&gt;</a> and <a href="#7.12">&lt;math.h&gt;</a> raise SIGFPE to report errors
+    instead of, or in addition to, setting errno or raising floating-point exceptions (<a href="#7.3">7.3</a>,
+<a name="7.12)" href="#7.12)"><b>    7.12).</b></a>
+
+[<a name="p577" href="#p577">page 577</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K" href="#K"><b>                                           Annex K</b></a>
+                                          (normative)
+                              Bounds-checking interfaces
+<a name="K.1" href="#K.1"><b>    K.1 Background</b></a>
+1   Traditionally, the C Library has contained many functions that trust the programmer to
+    provide output character arrays big enough to hold the result being produced. Not only
+    do these functions not check that the arrays are big enough, they frequently lack the
+    information needed to perform such checks. While it is possible to write safe, robust, and
+    error-free code using the existing library, the library tends to promote programming styles
+    that lead to mysterious failures if a result is too big for the provided array.
+2   A common programming style is to declare character arrays large enough to handle most
+    practical cases. However, if these arrays are not large enough to handle the resulting
+    strings, data can be written past the end of the array overwriting other data and program
+    structures. The program never gets any indication that a problem exists, and so never has
+    a chance to recover or to fail gracefully.
+3   Worse, this style of programming has compromised the security of computers and
+    networks. Buffer overflows can often be exploited to run arbitrary code with the
+    permissions of the vulnerable (defective) program.
+4   If the programmer writes runtime checks to verify lengths before calling library
+    functions, then those runtime checks frequently duplicate work done inside the library
+    functions, which discover string lengths as a side effect of doing their job.
+5   This annex provides alternative library functions that promote safer, more secure
+    programming. The alternative functions verify that output buffers are large enough for
+    the intended result and return a failure indicator if they are not. Data is never written past
+    the end of an array. All string results are null terminated.
+6   This annex also addresses another problem that complicates writing robust code:
+    functions that are not reentrant because they return pointers to static objects owned by the
+    function. Such functions can be troublesome since a previously returned result can
+    change if the function is called again, perhaps by another thread.
+
+[<a name="p578" href="#p578">page 578</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.2" href="#K.2"><b>    K.2 Scope</b></a>
+1   This annex specifies a series of optional extensions that can be useful in the mitigation of
+    security vulnerabilities in programs, and comprise new functions, macros, and types
+    declared or defined in existing standard headers.
+2   An implementation that defines __STDC_LIB_EXT1__ shall conform to the
+    specifications in this annex.<sup><a href="#note367"><b>367)</b></a></sup>
+3   Subclause <a href="#K.3">K.3</a> should be read as if it were merged into the parallel structure of named
+    subclauses of clause 7.
+<a name="K.3" href="#K.3"><b>    K.3 Library</b></a>
+<a name="K.3.1" href="#K.3.1"><b>    K.3.1 Introduction</b></a>
+<a name="K.3.1.1" href="#K.3.1.1"><b>    K.3.1.1 Standard headers</b></a>
+1   The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are not
+    declared or defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
+    defined as a macro which expands to the integer constant 0 at the point in the source file
+    where the appropriate header is first included.
+2   The functions, macros, and types declared or defined in <a href="#K.3">K.3</a> and its subclauses are
+    declared and defined by their respective headers if __STDC_WANT_LIB_EXT1__ is
+    defined as a macro which expands to the integer constant 1 at the point in the source file
+    where the appropriate header is first included.<sup><a href="#note368"><b>368)</b></a></sup>
+3   It is implementation-defined whether the functions, macros, and types declared or defined
+    in <a href="#K.3">K.3</a> and its subclauses are declared or defined by their respective headers if
+    __STDC_WANT_LIB_EXT1__ is not defined as a macro at the point in the source file
+    where the appropriate header is first included.<sup><a href="#note369"><b>369)</b></a></sup>
+4   Within a preprocessing translation unit, __STDC_WANT_LIB_EXT1__ shall be
+    defined identically for all inclusions of any headers from subclause <a href="#K.3">K.3</a>. If
+    __STDC_WANT_LIB_EXT1__ is defined differently for any such inclusion, the
+    implementation shall issue a diagnostic as if a preprocessor error directive were used.
+
+
+    <sup><a name="note367" href="#note367"><b>367)</b></a></sup> Implementations that do not define __STDC_LIB_EXT1__ are not required to conform to these
+         specifications.
+    <sup><a name="note368" href="#note368"><b>368)</b></a></sup> Future revisions of this International Standard may define meanings for other values of
+         __STDC_WANT_LIB_EXT1__.
+    <sup><a name="note369" href="#note369"><b>369)</b></a></sup> Subclause <a href="#7.1.3">7.1.3</a> reserves certain names and patterns of names that an implementation may use in
+         headers. All other names are not reserved, and a conforming implementation is not permitted to use
+         them. While some of the names defined in <a href="#K.3">K.3</a> and its subclauses are reserved, others are not. If an
+         unreserved name is defined in a header when __STDC_WANT_LIB_EXT1__ is defined as 0, the
+         implementation is not conforming.
+
+[<a name="p579" href="#p579">page 579</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.1.2" href="#K.3.1.2"><b>    K.3.1.2 Reserved identifiers</b></a>
+1   Each macro name in any of the following subclauses is reserved for use as specified if it
+    is defined by any of its associated headers when included; unless explicitly stated
+    otherwise (see <a href="#7.1.4">7.1.4</a>).
+2   All identifiers with external linkage in any of the following subclauses are reserved for
+    use as identifiers with external linkage if any of them are used by the program. None of
+    them are reserved if none of them are used.
+3   Each identifier with file scope listed in any of the following subclauses is reserved for use
+    as a macro name and as an identifier with file scope in the same name space if it is
+    defined by any of its associated headers when included.
+<a name="K.3.1.3" href="#K.3.1.3"><b>    K.3.1.3 Use of errno</b></a>
+1   An implementation may set errno for the functions defined in this annex, but is not
+    required to.
+<a name="K.3.1.4" href="#K.3.1.4"><b>    K.3.1.4 Runtime-constraint violations</b></a>
+1   Most functions in this annex include as part of their specification a list of runtime-
+    constraints. These runtime-constraints are requirements on the program using the
+    library.<sup><a href="#note370"><b>370)</b></a></sup>
+2   Implementations shall verify that the runtime-constraints for a function are not violated
+    by the program. If a runtime-constraint is violated, the implementation shall call the
+    currently registered runtime-constraint handler (see set_constraint_handler_s
+    in <a href="#7.22">&lt;stdlib.h&gt;</a>). Multiple runtime-constraint violations in the same call to a library
+    function result in only one call to the runtime-constraint handler. It is unspecified which
+    one of the multiple runtime-constraint violations cause the handler to be called.
+3   If the runtime-constraints section for a function states an action to be performed when a
+    runtime-constraint violation occurs, the function shall perform the action before calling
+    the runtime-constraint handler. If the runtime-constraints section lists actions that are
+    prohibited when a runtime-constraint violation occurs, then such actions are prohibited to
+    the function both before calling the handler and after the handler returns.
+4   The runtime-constraint handler might not return. If the handler does return, the library
+    function whose runtime-constraint was violated shall return some indication of failure as
+    given by the returns section in the function's specification.
+
+
+
+    <sup><a name="note370" href="#note370"><b>370)</b></a></sup> Although runtime-constraints replace many cases of undefined behavior, undefined behavior still
+         exists in this annex. Implementations are free to detect any case of undefined behavior and treat it as a
+         runtime-constraint violation by calling the runtime-constraint handler. This license comes directly
+         from the definition of undefined behavior.
+
+[<a name="p580" href="#p580">page 580</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.2" href="#K.3.2"><b>    K.3.2 Errors &lt;errno.h&gt;</b></a>
+1   The header <a href="#7.5">&lt;errno.h&gt;</a> defines a type.
+2   The type is
+             errno_t
+    which is type int.<sup><a href="#note371"><b>371)</b></a></sup>
+<a name="K.3.3" href="#K.3.3"><b>    K.3.3 Common definitions &lt;stddef.h&gt;</b></a>
+1   The header <a href="#7.19">&lt;stddef.h&gt;</a> defines a type.
+2   The type is
+             rsize_t
+    which is the type size_t.<sup><a href="#note372"><b>372)</b></a></sup>
+<a name="K.3.4" href="#K.3.4"><b>    K.3.4 Integer types &lt;stdint.h&gt;</b></a>
+1   The header <a href="#7.20">&lt;stdint.h&gt;</a> defines a macro.
+2   The macro is
+             RSIZE_MAX
+    which expands to a value<sup><a href="#note373"><b>373)</b></a></sup> of type size_t. Functions that have parameters of type
+    rsize_t consider it a runtime-constraint violation if the values of those parameters are
+    greater than RSIZE_MAX.
+    Recommended practice
+3   Extremely large object sizes are frequently a sign that an object's size was calculated
+    incorrectly. For example, negative numbers appear as very large positive numbers when
+    converted to an unsigned type like size_t. Also, some implementations do not support
+    objects as large as the maximum value that can be represented by type size_t.
+4   For those reasons, it is sometimes beneficial to restrict the range of object sizes to detect
+    programming errors. For implementations targeting machines with large address spaces,
+    it is recommended that RSIZE_MAX be defined as the smaller of the size of the largest
+    object supported or (SIZE_MAX &gt;&gt; 1), even if this limit is smaller than the size of
+    some legitimate, but very large, objects. Implementations targeting machines with small
+    address spaces may wish to define RSIZE_MAX as SIZE_MAX, which means that there
+
+    <sup><a name="note371" href="#note371"><b>371)</b></a></sup> As a matter of programming style, errno_t may be used as the type of something that deals only
+         with the values that might be found in errno. For example, a function which returns the value of
+         errno might be declared as having the return type errno_t.
+    <sup><a name="note372" href="#note372"><b>372)</b></a></sup> See the description of the RSIZE_MAX macro in <a href="#7.20">&lt;stdint.h&gt;</a>.
+    <sup><a name="note373" href="#note373"><b>373)</b></a></sup> The macro RSIZE_MAX need not expand to a constant expression.
+
+[<a name="p581" href="#p581">page 581</a>] (<a href="#Contents">Contents</a>)
+
+    is no object size that is considered a runtime-constraint violation.
+<a name="K.3.5" href="#K.3.5"><b>    K.3.5 Input/output &lt;stdio.h&gt;</b></a>
+1   The header <a href="#7.21">&lt;stdio.h&gt;</a> defines several macros and two types.
+2   The macros are
+           L_tmpnam_s
+    which expands to an integer constant expression that is the size needed for an array of
+    char large enough to hold a temporary file name string generated by the tmpnam_s
+    function;
+           TMP_MAX_S
+    which expands to an integer constant expression that is the maximum number of unique
+    file names that can be generated by the tmpnam_s function.
+3   The types are
+           errno_t
+    which is type int; and
+           rsize_t
+    which is the type size_t.
+<a name="K.3.5.1" href="#K.3.5.1"><b>    K.3.5.1 Operations on files</b></a>
+<a name="K.3.5.1.1" href="#K.3.5.1.1"><b>    K.3.5.1.1 The tmpfile_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           errno_t tmpfile_s(FILE * restrict * restrict streamptr);
+    Runtime-constraints
+2   streamptr shall not be a null pointer.
+3   If there is a runtime-constraint violation, tmpfile_s does not attempt to create a file.
+<b>    Description</b>
+4   The tmpfile_s function creates a temporary binary file that is different from any other
+    existing file and that will automatically be removed when it is closed or at program
+    termination. If the program terminates abnormally, whether an open temporary file is
+    removed is implementation-defined. The file is opened for update with "wb+" mode
+    with the meaning that mode has in the fopen_s function (including the mode's effect
+    on exclusive access and file permissions).
+
+[<a name="p582" href="#p582">page 582</a>] (<a href="#Contents">Contents</a>)
+
+5   If the file was created successfully, then the pointer to FILE pointed to by streamptr
+    will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
+    to FILE pointed to by streamptr will be set to a null pointer.
+    Recommended practice
+    It should be possible to open at least TMP_MAX_S temporary files during the lifetime of
+    the program (this limit may be shared with tmpnam_s) and there should be no limit on
+    the number simultaneously open other than this limit and any limit on the number of open
+    files (FOPEN_MAX).
+<b>    Returns</b>
+6   The tmpfile_s function returns zero if it created the file. If it did not create the file or
+    there was a runtime-constraint violation, tmpfile_s returns a nonzero value.
+<a name="K.3.5.1.2" href="#K.3.5.1.2"><b>    K.3.5.1.2 The tmpnam_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            errno_t tmpnam_s(char *s, rsize_t maxsize);
+    Runtime-constraints
+2   s shall not be a null pointer. maxsize shall be less than or equal to RSIZE_MAX.
+    maxsize shall be greater than the length of the generated file name string.
+<b>    Description</b>
+3   The tmpnam_s function generates a string that is a valid file name and that is not the
+    same as the name of an existing file.<sup><a href="#note374"><b>374)</b></a></sup> The function is potentially capable of generating
+    TMP_MAX_S different strings, but any or all of them may already be in use by existing
+    files and thus not be suitable return values. The lengths of these strings shall be less than
+    the value of the L_tmpnam_s macro.
+4   The tmpnam_s function generates a different string each time it is called.
+5   It is assumed that s points to an array of at least maxsize characters. This array will be
+    set to generated string, as specified below.
+
+
+
+    <sup><a name="note374" href="#note374"><b>374)</b></a></sup> Files created using strings generated by the tmpnam_s function are temporary only in the sense that
+         their names should not collide with those generated by conventional naming rules for the
+         implementation. It is still necessary to use the remove function to remove such files when their use
+         is ended, and before program termination. Implementations should take care in choosing the patterns
+         used for names returned by tmpnam_s. For example, making a thread id part of the names avoids the
+         race condition and possible conflict when multiple programs run simultaneously by the same user
+         generate the same temporary file names.
+
+[<a name="p583" href="#p583">page 583</a>] (<a href="#Contents">Contents</a>)
+
+6    The implementation shall behave as if no library function except tmpnam calls the
+     tmpnam_s function.<sup><a href="#note375"><b>375)</b></a></sup>
+     Recommended practice
+7    After a program obtains a file name using the tmpnam_s function and before the
+     program creates a file with that name, the possibility exists that someone else may create
+     a file with that same name. To avoid this race condition, the tmpfile_s function
+     should be used instead of tmpnam_s when possible. One situation that requires the use
+     of the tmpnam_s function is when the program needs to create a temporary directory
+     rather than a temporary file.
+<b>     Returns</b>
+8    If no suitable string can be generated, or if there is a runtime-constraint violation, the
+     tmpnam_s function writes a null character to s[0] (only if s is not null and maxsize
+     is greater than zero) and returns a nonzero value.
+9    Otherwise, the tmpnam_s function writes the string in the array pointed to by s and
+     returns zero.
+     Environmental limits
+10   The value of the macro TMP_MAX_S shall be at least 25.
+<a name="K.3.5.2" href="#K.3.5.2"><b>     K.3.5.2 File access functions</b></a>
+<a name="K.3.5.2.1" href="#K.3.5.2.1"><b>     K.3.5.2.1 The fopen_s function</b></a>
+<b>     Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            errno_t fopen_s(FILE * restrict * restrict streamptr,
+                 const char * restrict filename,
+                 const char * restrict mode);
+     Runtime-constraints
+2    None of streamptr, filename, or mode shall be a null pointer.
+3    If there is a runtime-constraint violation, fopen_s does not attempt to open a file.
+     Furthermore, if streamptr is not a null pointer, fopen_s sets *streamptr to the
+     null pointer.
+
+
+
+
+     <sup><a name="note375" href="#note375"><b>375)</b></a></sup> An implementation may have tmpnam call tmpnam_s (perhaps so there is only one naming
+          convention for temporary files), but this is not required.
+
+[<a name="p584" href="#p584">page 584</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+4   The fopen_s function opens the file whose name is the string pointed to by
+    filename, and associates a stream with it.
+5   The mode string shall be as described for fopen, with the addition that modes starting
+    with the character 'w' or 'a' may be preceded by the character 'u', see below:
+    uw             truncate to zero length or create text file for writing, default
+                   permissions
+    uwx            create text file for writing, default permissions
+    ua             append; open or create text file for writing at end-of-file, default
+                   permissions
+    uwb            truncate to zero length or create binary file for writing, default
+                   permissions
+    uwbx           create binary file for writing, default permissions
+    uab            append; open or create binary file for writing at end-of-file, default
+                   permissions
+    uw+            truncate to zero length or create text file for update, default
+                   permissions
+    uw+x           create text file for update, default permissions
+    ua+            append; open or create text file for update, writing at end-of-file,
+                   default permissions
+    uw+b or uwb+   truncate to zero length or create binary file for update, default
+                   permissions
+    uw+bx or uwb+x create binary file for update, default permissions
+    ua+b or uab+   append; open or create binary file for update, writing at end-of-file,
+                   default permissions
+6   Opening a file with exclusive mode ('x' as the last character in the mode argument)
+    fails if the file already exists or cannot be created.
+7   To the extent that the underlying system supports the concepts, files opened for writing
+    shall be opened with exclusive (also known as non-shared) access. If the file is being
+    created, and the first character of the mode string is not 'u', to the extent that the
+    underlying system supports it, the file shall have a file permission that prevents other
+    users on the system from accessing the file. If the file is being created and first character
+    of the mode string is 'u', then by the time the file has been closed, it shall have the
+    system default file access permissions.<sup><a href="#note376"><b>376)</b></a></sup>
+8   If the file was opened successfully, then the pointer to FILE pointed to by streamptr
+    will be set to the pointer to the object controlling the opened file. Otherwise, the pointer
+
+
+    <sup><a name="note376" href="#note376"><b>376)</b></a></sup> These are the same permissions that the file would have been created with by fopen.
+
+[<a name="p585" href="#p585">page 585</a>] (<a href="#Contents">Contents</a>)
+
+    to FILE pointed to by streamptr will be set to a null pointer.
+<b>    Returns</b>
+9   The fopen_s function returns zero if it opened the file. If it did not open the file or if
+    there was a runtime-constraint violation, fopen_s returns a nonzero value.
+<a name="K.3.5.2.2" href="#K.3.5.2.2"><b>    K.3.5.2.2 The freopen_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           errno_t freopen_s(FILE * restrict * restrict newstreamptr,
+                const char * restrict filename,
+                const char * restrict mode,
+                FILE * restrict stream);
+    Runtime-constraints
+2   None of newstreamptr, mode, and stream shall be a null pointer.
+3   If there is a runtime-constraint violation, freopen_s neither attempts to close any file
+    associated with stream nor attempts to open a file. Furthermore, if newstreamptr is
+    not a null pointer, fopen_s sets *newstreamptr to the null pointer.
+<b>    Description</b>
+4   The freopen_s function opens the file whose name is the string pointed to by
+    filename and associates the stream pointed to by stream with it. The mode
+    argument has the same meaning as in the fopen_s function (including the mode's effect
+    on exclusive access and file permissions).
+5   If filename is a null pointer, the freopen_s function attempts to change the mode of
+    the stream to that specified by mode, as if the name of the file currently associated with
+    the stream had been used. It is implementation-defined which changes of mode are
+    permitted (if any), and under what circumstances.
+6   The freopen_s function first attempts to close any file that is associated with stream.
+    Failure to close the file is ignored. The error and end-of-file indicators for the stream are
+    cleared.
+7   If the file was opened successfully, then the pointer to FILE pointed to by
+    newstreamptr will be set to the value of stream. Otherwise, the pointer to FILE
+    pointed to by newstreamptr will be set to a null pointer.
+<b>    Returns</b>
+8   The freopen_s function returns zero if it opened the file. If it did not open the file or
+    there was a runtime-constraint violation, freopen_s returns a nonzero value.
+
+[<a name="p586" href="#p586">page 586</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.5.3" href="#K.3.5.3"><b>    K.3.5.3 Formatted input/output functions</b></a>
+1   Unless explicitly stated otherwise, if the execution of a function described in this
+    subclause causes copying to take place between objects that overlap, the objects take on
+    unspecified values.
+<a name="K.3.5.3.1" href="#K.3.5.3.1"><b>    K.3.5.3.1 The fprintf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int fprintf_s(FILE * restrict stream,
+                  const char * restrict format, ...);
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note377"><b>377)</b></a></sup> (modified or
+    not by flags, field width, or precision) shall not appear in the string pointed to by
+    format. Any argument to fprintf_s corresponding to a %s specifier shall not be a
+    null pointer.
+3   If there is a runtime-constraint violation,<sup><a href="#note378"><b>378)</b></a></sup> the fprintf_s function does not attempt
+    to produce further output, and it is unspecified to what extent fprintf_s produced
+    output before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The fprintf_s function is equivalent to the fprintf function except for the explicit
+    runtime-constraints listed above.
+<b>    Returns</b>
+5   The fprintf_s function returns the number of characters transmitted, or a negative
+    value if an output error, encoding error, or runtime-constraint violation occurred.
+
+
+
+
+    <sup><a name="note377" href="#note377"><b>377)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+    <sup><a name="note378" href="#note378"><b>378)</b></a></sup> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
+         implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
+         constraint violation.
+
+[<a name="p587" href="#p587">page 587</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.5.3.2" href="#K.3.5.3.2"><b>    K.3.5.3.2 The fscanf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int fscanf_s(FILE * restrict stream,
+                 const char * restrict format, ...);
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. Any argument indirected though in
+    order to store converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation,<sup><a href="#note379"><b>379)</b></a></sup> the fscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent fscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The fscanf_s function is equivalent to fscanf except that the c, s, and [ conversion
+    specifiers apply to a pair of arguments (unless assignment suppression is indicated by a
+    *). The first of these arguments is the same as for fscanf. That argument is
+    immediately followed in the argument list by the second argument, which has type
+    rsize_t and gives the number of elements in the array pointed to by the first argument
+    of the pair. If the first argument points to a scalar object, it is considered to be an array of
+    one element.<sup><a href="#note380"><b>380)</b></a></sup>
+5   A matching failure occurs if the number of elements in a receiving object is insufficient to
+    hold the converted input (including any trailing null character).
+<b>    Returns</b>
+6   The fscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+
+    <sup><a name="note379" href="#note379"><b>379)</b></a></sup> Because an implementation may treat any undefined behavior as a runtime-constraint violation, an
+         implementation may treat any unsupported specifiers in the string pointed to by format as a runtime-
+         constraint violation.
+    <sup><a name="note380" href="#note380"><b>380)</b></a></sup> If the format is known at translation time, an implementation may issue a diagnostic for any argument
+         used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
+         argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
+         the format is not known at translation time. For example, an implementation may issue a diagnostic
+         for each argument after format that has of type pointer to one of char, signed char,
+         unsigned char, or void that is not followed by an argument of a type compatible with
+         rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
+         using the hh length modifier, a length argument must follow the pointer argument. Another useful
+         diagnostic could flag any non-pointer argument following format that did not have a type
+         compatible with rsize_t.
+
+[<a name="p588" href="#p588">page 588</a>] (<a href="#Contents">Contents</a>)
+
+    fscanf_s function returns the number of input items assigned, which can be fewer than
+    provided for, or even zero, in the event of an early matching failure.
+7   EXAMPLE 1        The call:
+             #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             /* ... */
+             int n, i; float x; char name[50];
+             n = fscanf_s(stdin, "%d%f%s", &amp;i, &amp;x, name, (rsize_t) 50);
+    with the input line:
+             25 54.32E-1 thompson
+    will assign to n the value 3, to i the value 25, to x the value 5.432, and to name the sequence
+    thompson\0.
+
+8   EXAMPLE 2        The call:
+             #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             /* ... */
+             int n; char s[5];
+             n = fscanf_s(stdin, "%s", s, sizeof s);
+    with the input line:
+             hello
+    will assign to n the value 0 since a matching failure occurred because the sequence hello\0 requires an
+    array of six characters to store it.
+
+<a name="K.3.5.3.3" href="#K.3.5.3.3"><b>    K.3.5.3.3 The printf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int printf_s(const char * restrict format, ...);
+    Runtime-constraints
+2   format shall not be a null pointer. The %n specifier<sup><a href="#note381"><b>381)</b></a></sup> (modified or not by flags, field
+    width, or precision) shall not appear in the string pointed to by format. Any argument
+    to printf_s corresponding to a %s specifier shall not be a null pointer.
+3   If there is a runtime-constraint violation, the printf_s function does not attempt to
+    produce further output, and it is unspecified to what extent printf_s produced output
+    before discovering the runtime-constraint violation.
+
+
+    <sup><a name="note381" href="#note381"><b>381)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+
+[<a name="p589" href="#p589">page 589</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+4   The printf_s function is equivalent to the printf function except for the explicit
+    runtime-constraints listed above.
+<b>    Returns</b>
+5   The printf_s function returns the number of characters transmitted, or a negative
+    value if an output error, encoding error, or runtime-constraint violation occurred.
+<a name="K.3.5.3.4" href="#K.3.5.3.4"><b>    K.3.5.3.4 The scanf_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int scanf_s(const char * restrict format, ...);
+    Runtime-constraints
+2   format shall not be a null pointer. Any argument indirected though in order to store
+    converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the scanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent scanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The scanf_s function is equivalent to fscanf_s with the argument stdin
+    interposed before the arguments to scanf_s.
+<b>    Returns</b>
+5   The scanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    scanf_s function returns the number of input items assigned, which can be fewer than
+    provided for, or even zero, in the event of an early matching failure.
+<a name="K.3.5.3.5" href="#K.3.5.3.5"><b>    K.3.5.3.5 The snprintf_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int snprintf_s(char * restrict s, rsize_t n,
+                const char * restrict format, ...);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The %n specifier<sup><a href="#note382"><b>382)</b></a></sup> (modified or not by flags, field width, or
+    precision) shall not appear in the string pointed to by format. Any argument to
+
+[<a name="p590" href="#p590">page 590</a>] (<a href="#Contents">Contents</a>)
+
+    snprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
+    error shall occur.
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the snprintf_s function sets s[0] to the
+    null character.
+<b>    Description</b>
+4   The snprintf_s function is equivalent to the snprintf function except for the
+    explicit runtime-constraints listed above.
+5   The snprintf_s function, unlike sprintf_s, will truncate the result to fit within the
+    array pointed to by s.
+<b>    Returns</b>
+6   The snprintf_s function returns the number of characters that would have been
+    written had n been sufficiently large, not counting the terminating null character, or a
+    negative value if a runtime-constraint violation occurred. Thus, the null-terminated
+    output has been completely written if and only if the returned value is nonnegative and
+    less than n.
+<a name="K.3.5.3.6" href="#K.3.5.3.6"><b>    K.3.5.3.6 The sprintf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int sprintf_s(char * restrict s, rsize_t n,
+                  const char * restrict format, ...);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The number of characters (including the trailing null) required for the
+    result to be written to the array pointed to by s shall not be greater than n. The %n
+    specifier<sup><a href="#note383"><b>383)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+    string pointed to by format. Any argument to sprintf_s corresponding to a %s
+    specifier shall not be a null pointer. No encoding error shall occur.
+
+
+
+    <sup><a name="note382" href="#note382"><b>382)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+    <sup><a name="note383" href="#note383"><b>383)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+
+[<a name="p591" href="#p591">page 591</a>] (<a href="#Contents">Contents</a>)
+
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the sprintf_s function sets s[0] to the
+    null character.
+<b>    Description</b>
+4   The sprintf_s function is equivalent to the sprintf function except for the
+    parameter n and the explicit runtime-constraints listed above.
+5   The sprintf_s function, unlike snprintf_s, treats a result too big for the array
+    pointed to by s as a runtime-constraint violation.
+<b>    Returns</b>
+6   If no runtime-constraint violation occurred, the sprintf_s function returns the number
+    of characters written in the array, not counting the terminating null character. If an
+    encoding error occurred, sprintf_s returns a negative value. If any other runtime-
+    constraint violation occurred, sprintf_s returns zero.
+<a name="K.3.5.3.7" href="#K.3.5.3.7"><b>    K.3.5.3.7 The sscanf_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int sscanf_s(const char * restrict s,
+                const char * restrict format, ...);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. Any argument indirected though in order
+    to store converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the sscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent sscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The sscanf_s function is equivalent to fscanf_s, except that input is obtained from
+    a string (specified by the argument s) rather than from a stream. Reaching the end of the
+    string is equivalent to encountering end-of-file for the fscanf_s function. If copying
+    takes place between objects that overlap, the objects take on unspecified values.
+<b>    Returns</b>
+5   The sscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    sscanf_s function returns the number of input items assigned, which can be fewer than
+    provided for, or even zero, in the event of an early matching failure.
+
+[<a name="p592" href="#p592">page 592</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.5.3.8" href="#K.3.5.3.8"><b>    K.3.5.3.8 The vfprintf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int vfprintf_s(FILE * restrict stream,
+                  const char * restrict format,
+                  va_list arg);
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note384"><b>384)</b></a></sup> (modified or
+    not by flags, field width, or precision) shall not appear in the string pointed to by
+    format. Any argument to vfprintf_s corresponding to a %s specifier shall not be a
+    null pointer.
+3   If there is a runtime-constraint violation, the vfprintf_s function does not attempt to
+    produce further output, and it is unspecified to what extent vfprintf_s produced
+    output before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vfprintf_s function is equivalent to the vfprintf function except for the
+    explicit runtime-constraints listed above.
+<b>    Returns</b>
+5   The vfprintf_s function returns the number of characters transmitted, or a negative
+    value if an output error, encoding error, or runtime-constraint violation occurred.
+<a name="K.3.5.3.9" href="#K.3.5.3.9"><b>    K.3.5.3.9 The vfscanf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int vfscanf_s(FILE * restrict stream,
+                  const char * restrict format,
+                  va_list arg);
+
+
+
+
+    <sup><a name="note384" href="#note384"><b>384)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+
+[<a name="p593" href="#p593">page 593</a>] (<a href="#Contents">Contents</a>)
+
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. Any argument indirected though in
+    order to store converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vfscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent vfscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vfscanf_s function is equivalent to fscanf_s, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfscanf_s function does not invoke the
+    va_end macro.<sup><a href="#note385"><b>385)</b></a></sup>
+<b>    Returns</b>
+5   The vfscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    vfscanf_s function returns the number of input items assigned, which can be fewer
+    than provided for, or even zero, in the event of an early matching failure.
+<a name="K.3.5.3.10" href="#K.3.5.3.10"><b>    K.3.5.3.10 The vprintf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int vprintf_s(const char * restrict format,
+                  va_list arg);
+    Runtime-constraints
+2   format shall not be a null pointer. The %n specifier<sup><a href="#note386"><b>386)</b></a></sup> (modified or not by flags, field
+    width, or precision) shall not appear in the string pointed to by format. Any argument
+    to vprintf_s corresponding to a %s specifier shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vprintf_s function does not attempt to
+    produce further output, and it is unspecified to what extent vprintf_s produced output
+    before discovering the runtime-constraint violation.
+
+    <sup><a name="note385" href="#note385"><b>385)</b></a></sup> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+         vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
+         indeterminate.
+    <sup><a name="note386" href="#note386"><b>386)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+
+[<a name="p594" href="#p594">page 594</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+4   The vprintf_s function is equivalent to the vprintf function except for the explicit
+    runtime-constraints listed above.
+<b>    Returns</b>
+5   The vprintf_s function returns the number of characters transmitted, or a negative
+    value if an output error, encoding error, or runtime-constraint violation occurred.
+<a name="K.3.5.3.11" href="#K.3.5.3.11"><b>    K.3.5.3.11 The vscanf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            int vscanf_s(const char * restrict format,
+                 va_list arg);
+    Runtime-constraints
+2   format shall not be a null pointer. Any argument indirected though in order to store
+    converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent vscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vscanf_s function is equivalent to scanf_s, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vscanf_s function does not invoke the
+    va_end macro.<sup><a href="#note387"><b>387)</b></a></sup>
+<b>    Returns</b>
+5   The vscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    vscanf_s function returns the number of input items assigned, which can be fewer than
+    provided for, or even zero, in the event of an early matching failure.
+
+
+
+
+    <sup><a name="note387" href="#note387"><b>387)</b></a></sup> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+         vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
+         indeterminate.
+
+[<a name="p595" href="#p595">page 595</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.5.3.12" href="#K.3.5.3.12"><b>    K.3.5.3.12 The vsnprintf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int vsnprintf_s(char * restrict s, rsize_t n,
+                  const char * restrict format,
+                  va_list arg);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The %n specifier<sup><a href="#note388"><b>388)</b></a></sup> (modified or not by flags, field width, or
+    precision) shall not appear in the string pointed to by format. Any argument to
+    vsnprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
+    error shall occur.
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the vsnprintf_s function sets s[0] to the
+    null character.
+<b>    Description</b>
+4   The vsnprintf_s function is equivalent to the vsnprintf function except for the
+    explicit runtime-constraints listed above.
+5   The vsnprintf_s function, unlike vsprintf_s, will truncate the result to fit within
+    the array pointed to by s.
+<b>    Returns</b>
+6   The vsnprintf_s function returns the number of characters that would have been
+    written had n been sufficiently large, not counting the terminating null character, or a
+    negative value if a runtime-constraint violation occurred. Thus, the null-terminated
+    output has been completely written if and only if the returned value is nonnegative and
+    less than n.
+
+
+
+
+    <sup><a name="note388" href="#note388"><b>388)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+
+[<a name="p596" href="#p596">page 596</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.5.3.13" href="#K.3.5.3.13"><b>    K.3.5.3.13 The vsprintf_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+             #include <a href="#7.21">&lt;stdio.h&gt;</a>
+             int vsprintf_s(char * restrict s, rsize_t n,
+                  const char * restrict format,
+                  va_list arg);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The number of characters (including the trailing null) required for the
+    result to be written to the array pointed to by s shall not be greater than n. The %n
+    specifier<sup><a href="#note389"><b>389)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+    string pointed to by format. Any argument to vsprintf_s corresponding to a %s
+    specifier shall not be a null pointer. No encoding error shall occur.
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the vsprintf_s function sets s[0] to the
+    null character.
+<b>    Description</b>
+4   The vsprintf_s function is equivalent to the vsprintf function except for the
+    parameter n and the explicit runtime-constraints listed above.
+5   The vsprintf_s function, unlike vsnprintf_s, treats a result too big for the array
+    pointed to by s as a runtime-constraint violation.
+<b>    Returns</b>
+6   If no runtime-constraint violation occurred, the vsprintf_s function returns the
+    number of characters written in the array, not counting the terminating null character. If
+    an encoding error occurred, vsprintf_s returns a negative value. If any other
+    runtime-constraint violation occurred, vsprintf_s returns zero.
+
+
+
+
+    <sup><a name="note389" href="#note389"><b>389)</b></a></sup> It is not a runtime-constraint violation for the characters %n to appear in sequence in the string pointed
+         at by format when those characters are not a interpreted as a %n specifier. For example, if the entire
+         format string was %%n.
+
+[<a name="p597" href="#p597">page 597</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.5.3.14" href="#K.3.5.3.14"><b>    K.3.5.3.14 The vsscanf_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           int vsscanf_s(const char * restrict s,
+                const char * restrict format,
+                va_list arg);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. Any argument indirected though in order
+    to store converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vsscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent vsscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vsscanf_s function is equivalent to sscanf_s, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vsscanf_s function does not invoke the
+    va_end macro.<sup><a href="#note390"><b>390)</b></a></sup>
+<b>    Returns</b>
+5   The vsscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    vscanf_s function returns the number of input items assigned, which can be fewer than
+    provided for, or even zero, in the event of an early matching failure.
+<a name="K.3.5.4" href="#K.3.5.4"><b>    K.3.5.4 Character input/output functions</b></a>
+<a name="K.3.5.4.1" href="#K.3.5.4.1"><b>    K.3.5.4.1 The gets_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.21">&lt;stdio.h&gt;</a>
+           char *gets_s(char *s, rsize_t n);
+
+
+
+
+    <sup><a name="note390" href="#note390"><b>390)</b></a></sup> As the functions vfprintf_s, vfscanf_s, vprintf_s, vscanf_s, vsnprintf_s,
+         vsprintf_s, and vsscanf_s invoke the va_arg macro, the value of arg after the return is
+         indeterminate.
+
+[<a name="p598" href="#p598">page 598</a>] (<a href="#Contents">Contents</a>)
+
+    Runtime-constraints
+2   s shall not be a null pointer. n shall neither be equal to zero nor be greater than
+    RSIZE_MAX. A new-line character, end-of-file, or read error shall occur within reading
+    n-1 characters from stdin.<sup><a href="#note391"><b>391)</b></a></sup>
+3   If there is a runtime-constraint violation, s[0] is set to the null character, and characters
+    are read and discarded from stdin until a new-line character is read, or end-of-file or a
+    read error occurs.
+<b>    Description</b>
+4   The gets_s function reads at most one less than the number of characters specified by n
+    from the stream pointed to by stdin, into the array pointed to by s. No additional
+    characters are read after a new-line character (which is discarded) or after end-of-file.
+    The discarded new-line character does not count towards number of characters read. A
+    null character is written immediately after the last character read into the array.
+5   If end-of-file is encountered and no characters have been read into the array, or if a read
+    error occurs during the operation, then s[0] is set to the null character, and the other
+    elements of s take unspecified values.
+    Recommended practice
+6   The fgets function allows properly-written programs to safely process input lines too
+    long to store in the result array. In general this requires that callers of fgets pay
+    attention to the presence or absence of a new-line character in the result array. Consider
+    using fgets (along with any needed processing based on new-line characters) instead of
+    gets_s.
+<b>    Returns</b>
+7   The gets_s function returns s if successful. If there was a runtime-constraint violation,
+    or if end-of-file is encountered and no characters have been read into the array, or if a
+    read error occurs during the operation, then a null pointer is returned.
+
+
+
+
+    <sup><a name="note391" href="#note391"><b>391)</b></a></sup> The gets_s function, unlike the historical gets function, makes it a runtime-constraint violation for
+         a line of input to overflow the buffer to store it. Unlike the fgets function, gets_s maintains a
+         one-to-one relationship between input lines and successful calls to gets_s. Programs that use gets
+         expect such a relationship.
+
+[<a name="p599" href="#p599">page 599</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.6" href="#K.3.6"><b>    K.3.6 General utilities &lt;stdlib.h&gt;</b></a>
+1   The header <a href="#7.22">&lt;stdlib.h&gt;</a> defines three types.
+2   The types are
+            errno_t
+    which is type int; and
+            rsize_t
+    which is the type size_t; and
+            constraint_handler_t
+    which has the following definition
+            typedef void (*constraint_handler_t)(
+                 const char * restrict msg,
+                 void * restrict ptr,
+                 errno_t error);
+<a name="K.3.6.1" href="#K.3.6.1"><b>    K.3.6.1 Runtime-constraint handling</b></a>
+<a name="K.3.6.1.1" href="#K.3.6.1.1"><b>    K.3.6.1.1 The set_constraint_handler_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            constraint_handler_t set_constraint_handler_s(
+                 constraint_handler_t handler);
+<b>    Description</b>
+2   The set_constraint_handler_s function sets the runtime-constraint handler to
+    be handler. The runtime-constraint handler is the function to be called when a library
+    function detects a runtime-constraint violation. Only the most recent handler registered
+    with set_constraint_handler_s is called when a runtime-constraint violation
+    occurs.
+3   When the handler is called, it is passed the following arguments in the following order:
+       1.   A pointer to a character string describing the runtime-constraint violation.
+       2.   A null pointer or a pointer to an implementation defined object.
+       3.   If the function calling the handler has a return type declared as errno_t, the
+            return value of the function is passed. Otherwise, a positive value of type
+            errno_t is passed.
+
+[<a name="p600" href="#p600">page 600</a>] (<a href="#Contents">Contents</a>)
+
+4   The implementation has a default constraint handler that is used if no calls to the
+    set_constraint_handler_s function have been made. The behavior of the
+    default handler is implementation-defined, and it may cause the program to exit or abort.
+5   If the handler argument to set_constraint_handler_s is a null pointer, the
+    implementation default handler becomes the current constraint handler.
+<b>    Returns</b>
+6   The set_constraint_handler_s function returns a pointer to the previously
+    registered handler.<sup><a href="#note392"><b>392)</b></a></sup>
+<a name="K.3.6.1.2" href="#K.3.6.1.2"><b>    K.3.6.1.2 The abort_handler_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void abort_handler_s(
+                 const char * restrict msg,
+                 void * restrict ptr,
+                 errno_t error);
+<b>    Description</b>
+2   A pointer to the abort_handler_s function shall be a suitable argument to the
+    set_constraint_handler_s function.
+3   The abort_handler_s function writes a message on the standard error stream in an
+    implementation-defined format. The message shall include the string pointed to by msg.
+    The abort_handler_s function then calls the abort function.<sup><a href="#note393"><b>393)</b></a></sup>
+<b>    Returns</b>
+4   The abort_handler_s function does not return to its caller.
+
+
+
+
+    <sup><a name="note392" href="#note392"><b>392)</b></a></sup> If the previous handler was registered by calling set_constraint_handler_s with a null
+         pointer argument, a pointer to the implementation default handler is returned (not NULL).
+    <sup><a name="note393" href="#note393"><b>393)</b></a></sup> Many implementations invoke a debugger when the abort function is called.
+
+[<a name="p601" href="#p601">page 601</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.6.1.3" href="#K.3.6.1.3"><b>    K.3.6.1.3 The ignore_handler_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            void ignore_handler_s(
+                 const char * restrict msg,
+                 void * restrict ptr,
+                 errno_t error);
+<b>    Description</b>
+2   A pointer to the ignore_handler_s function shall be a suitable argument to the
+    set_constraint_handler_s function.
+3   The ignore_handler_s function simply returns to its caller.<sup><a href="#note394"><b>394)</b></a></sup>
+<b>    Returns</b>
+4   The ignore_handler_s function returns no value.
+<a name="K.3.6.2" href="#K.3.6.2"><b>    K.3.6.2 Communication with the environment</b></a>
+<a name="K.3.6.2.1" href="#K.3.6.2.1"><b>    K.3.6.2.1 The getenv_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            errno_t getenv_s(size_t * restrict len,
+                       char * restrict value, rsize_t maxsize,
+                       const char * restrict name);
+    Runtime-constraints
+2   name shall not be a null pointer. maxsize shall neither equal zero nor be greater than
+    RSIZE_MAX. If maxsize is not equal to zero, then value shall not be a null pointer.
+3   If there is a runtime-constraint violation, the integer pointed to by len is set to 0 (if len
+    is not null), and the environment list is not searched.
+<b>    Description</b>
+4   The getenv_s function searches an environment list, provided by the host environment,
+    for a string that matches the string pointed to by name.
+
+
+    <sup><a name="note394" href="#note394"><b>394)</b></a></sup> If the runtime-constraint handler is set to the ignore_handler_s function, any library function in
+         which a runtime-constraint violation occurs will return to its caller. The caller can determine whether
+         a runtime-constraint violation occurred based on the library function's specification (usually, the
+         library function returns a nonzero errno_t).
+
+[<a name="p602" href="#p602">page 602</a>] (<a href="#Contents">Contents</a>)
+
+5   If that name is found then getenv_s performs the following actions. If len is not a
+    null pointer, the length of the string associated with the matched list member is stored in
+    the integer pointed to by len. If the length of the associated string is less than maxsize,
+    then the associated string is copied to the array pointed to by value.
+6   If that name is not found then getenv_s performs the following actions. If len is not
+    a null pointer, zero is stored in the integer pointed to by len. If maxsize is greater than
+    zero, then value[0] is set to the null character.
+7   The set of environment names and the method for altering the environment list are
+    implementation-defined.
+<b>    Returns</b>
+8   The getenv_s function returns zero if the specified name is found and the associated
+    string was successfully stored in value. Otherwise, a nonzero value is returned.
+<a name="K.3.6.3" href="#K.3.6.3"><b>    K.3.6.3 Searching and sorting utilities</b></a>
+1   These utilities make use of a comparison function to search or sort arrays of unspecified
+    type. Where an argument declared as size_t nmemb specifies the length of the array
+    for a function, if nmemb has the value zero on a call to that function, then the comparison
+    function is not called, a search finds no matching element, sorting performs no
+    rearrangement, and the pointer to the array may be null.
+2   The implementation shall ensure that the second argument of the comparison function
+    (when called from bsearch_s), or both arguments (when called from qsort_s), are
+    pointers to elements of the array.<sup><a href="#note395"><b>395)</b></a></sup> The first argument when called from bsearch_s
+    shall equal key.
+3   The comparison function shall not alter the contents of either the array or search key. The
+    implementation may reorder elements of the array between calls to the comparison
+    function, but shall not otherwise alter the contents of any individual element.
+4   When the same objects (consisting of size bytes, irrespective of their current positions
+    in the array) are passed more than once to the comparison function, the results shall be
+    consistent with one another. That is, for qsort_s they shall define a total ordering on
+    the array, and for bsearch_s the same object shall always compare the same way with
+    the key.
+
+
+
+
+    <sup><a name="note395" href="#note395"><b>395)</b></a></sup> That is, if the value passed is p, then the following expressions are always valid and nonzero:
+                  ((char *)p - (char *)base) % size == 0
+                  (char *)p &gt;= (char *)base
+                  (char *)p &lt; (char *)base + nmemb * size
+
+[<a name="p603" href="#p603">page 603</a>] (<a href="#Contents">Contents</a>)
+
+5   A sequence point occurs immediately before and immediately after each call to the
+    comparison function, and also between any call to the comparison function and any
+    movement of the objects passed as arguments to that call.
+<a name="K.3.6.3.1" href="#K.3.6.3.1"><b>    K.3.6.3.1 The bsearch_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             void *bsearch_s(const void *key, const void *base,
+                  rsize_t nmemb, rsize_t size,
+                  int (*compar)(const void *k, const void *y,
+                                  void *context),
+                  void *context);
+    Runtime-constraints
+2   Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
+    zero, then none of key, base, or compar shall be a null pointer.
+3   If there is a runtime-constraint violation, the bsearch_s function does not search the
+    array.
+<b>    Description</b>
+4   The bsearch_s function searches an array of nmemb objects, the initial element of
+    which is pointed to by base, for an element that matches the object pointed to by key.
+    The size of each element of the array is specified by size.
+5   The comparison function pointed to by compar is called with three arguments. The first
+    two point to the key object and to an array element, in that order. The function shall
+    return an integer less than, equal to, or greater than zero if the key object is considered,
+    respectively, to be less than, to match, or to be greater than the array element. The array
+    shall consist of: all the elements that compare less than, all the elements that compare
+    equal to, and all the elements that compare greater than the key object, in that order.<sup><a href="#note396"><b>396)</b></a></sup>
+    The third argument to the comparison function is the context argument passed to
+    bsearch_s. The sole use of context by bsearch_s is to pass it to the comparison
+    function.<sup><a href="#note397"><b>397)</b></a></sup>
+
+
+
+
+    <sup><a name="note396" href="#note396"><b>396)</b></a></sup> In practice, this means that the entire array has been sorted according to the comparison function.
+    <sup><a name="note397" href="#note397"><b>397)</b></a></sup> The context argument is for the use of the comparison function in performing its duties. For
+         example, it might specify a collating sequence used by the comparison function.
+
+[<a name="p604" href="#p604">page 604</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+6   The bsearch_s function returns a pointer to a matching element of the array, or a null
+    pointer if no match is found or there is a runtime-constraint violation. If two elements
+    compare as equal, which element is matched is unspecified.
+<a name="K.3.6.3.2" href="#K.3.6.3.2"><b>    K.3.6.3.2 The qsort_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size,
+                 int (*compar)(const void *x, const void *y,
+                                 void *context),
+                 void *context);
+    Runtime-constraints
+2   Neither nmemb nor size shall be greater than RSIZE_MAX. If nmemb is not equal to
+    zero, then neither base nor compar shall be a null pointer.
+3   If there is a runtime-constraint violation, the qsort_s function does not sort the array.
+<b>    Description</b>
+4   The qsort_s function sorts an array of nmemb objects, the initial element of which is
+    pointed to by base. The size of each object is specified by size.
+5   The contents of the array are sorted into ascending order according to a comparison
+    function pointed to by compar, which is called with three arguments. The first two
+    point to the objects being compared. The function shall return an integer less than, equal
+    to, or greater than zero if the first argument is considered to be respectively less than,
+    equal to, or greater than the second. The third argument to the comparison function is the
+    context argument passed to qsort_s. The sole use of context by qsort_s is to
+    pass it to the comparison function.<sup><a href="#note398"><b>398)</b></a></sup>
+6   If two elements compare as equal, their relative order in the resulting sorted array is
+    unspecified.
+<b>    Returns</b>
+7   The qsort_s function returns zero if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+
+
+
+
+    <sup><a name="note398" href="#note398"><b>398)</b></a></sup> The context argument is for the use of the comparison function in performing its duties. For
+         example, it might specify a collating sequence used by the comparison function.
+
+[<a name="p605" href="#p605">page 605</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.6.4" href="#K.3.6.4"><b>    K.3.6.4 Multibyte/wide character conversion functions</b></a>
+1   The behavior of the multibyte character functions is affected by the LC_CTYPE category
+    of the current locale. For a state-dependent encoding, each function is placed into its
+    initial conversion state by a call for which its character pointer argument, s, is a null
+    pointer. Subsequent calls with s as other than a null pointer cause the internal conversion
+    state of the function to be altered as necessary. A call with s as a null pointer causes
+    these functions to set the int pointed to by their status argument to a nonzero value if
+    encodings have state dependency, and zero otherwise.<sup><a href="#note399"><b>399)</b></a></sup> Changing the LC_CTYPE
+    category causes the conversion state of these functions to be indeterminate.
+<a name="K.3.6.4.1" href="#K.3.6.4.1"><b>    K.3.6.4.1 The wctomb_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+            errno_t wctomb_s(int * restrict status,
+                 char * restrict s,
+                 rsize_t smax,
+                 wchar_t wc);
+    Runtime-constraints
+2   Let n denote the number of bytes needed to represent the multibyte character
+    corresponding to the wide character given by wc (including any shift sequences).
+3   If s is not a null pointer, then smax shall not be less than n, and smax shall not be
+    greater than RSIZE_MAX. If s is a null pointer, then smax shall equal zero.
+4   If there is a runtime-constraint violation, wctomb_s does not modify the int pointed to
+    by status, and if s is not a null pointer, no more than smax elements in the array
+    pointed to by s will be accessed.
+<b>    Description</b>
+5   The wctomb_s function determines n and stores the multibyte character representation
+    of wc in the array whose first element is pointed to by s (if s is not a null pointer). The
+    number of characters stored never exceeds MB_CUR_MAX or smax. If wc is a null wide
+    character, a null byte is stored, preceded by any shift sequence needed to restore the
+    initial shift state, and the function is left in the initial conversion state.
+6   The implementation shall behave as if no library function calls the wctomb_s function.
+
+
+
+
+    <sup><a name="note399" href="#note399"><b>399)</b></a></sup> If the locale employs special bytes to change the shift state, these bytes do not produce separate wide
+         character codes, but are grouped with an adjacent multibyte character.
+
+[<a name="p606" href="#p606">page 606</a>] (<a href="#Contents">Contents</a>)
+
+7    If s is a null pointer, the wctomb_s function stores into the int pointed to by status a
+     nonzero or zero value, if multibyte character encodings, respectively, do or do not have
+     state-dependent encodings.
+8    If s is not a null pointer, the wctomb_s function stores into the int pointed to by
+     status either n or -1 if wc, respectively, does or does not correspond to a valid
+     multibyte character.
+9    In no case will the int pointed to by status be set to a value greater than the
+     MB_CUR_MAX macro.
+<b>     Returns</b>
+10   The wctomb_s function returns zero if successful, and a nonzero value if there was a
+     runtime-constraint violation or wc did not correspond to a valid multibyte character.
+<a name="K.3.6.5" href="#K.3.6.5"><b>     K.3.6.5 Multibyte/wide string conversion functions</b></a>
+1    The behavior of the multibyte string functions is affected by the LC_CTYPE category of
+     the current locale.
+<a name="K.3.6.5.1" href="#K.3.6.5.1"><b>     K.3.6.5.1 The mbstowcs_s function</b></a>
+<b>     Synopsis</b>
+1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             errno_t mbstowcs_s(size_t * restrict retval,
+                  wchar_t * restrict dst, rsize_t dstmax,
+                  const char * restrict src, rsize_t len);
+     Runtime-constraints
+2    Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
+     neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
+     then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
+     zero. If dst is not a null pointer and len is not less than dstmax, then a null character
+     shall occur within the first dstmax multibyte characters of the array pointed to by src.
+3    If there is a runtime-constraint violation, then mbstowcs_s does the following. If
+     retval is not a null pointer, then mbstowcs_s sets *retval to (size_t)(-1). If
+     dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+     then mbstowcs_s sets dst[0] to the null wide character.
+<b>     Description</b>
+4    The mbstowcs_s function converts a sequence of multibyte characters that begins in
+     the initial shift state from the array pointed to by src into a sequence of corresponding
+     wide characters. If dst is not a null pointer, the converted characters are stored into the
+     array pointed to by dst. Conversion continues up to and including a terminating null
+     character, which is also stored. Conversion stops earlier in two cases: when a sequence of
+
+[<a name="p607" href="#p607">page 607</a>] (<a href="#Contents">Contents</a>)
+
+    bytes is encountered that does not form a valid multibyte character, or (if dst is not a
+    null pointer) when len wide characters have been stored into the array pointed to by
+    dst.<sup><a href="#note400"><b>400)</b></a></sup> If dst is not a null pointer and no null wide character was stored into the array
+    pointed to by dst, then dst[len] is set to the null wide character. Each conversion
+    takes place as if by a call to the mbrtowc function.
+5   Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+    sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
+    the mbstowcs_s function stores the value (size_t)(-1) into *retval.
+    Otherwise, the mbstowcs_s function stores into *retval the number of multibyte
+    characters successfully converted, not including the terminating null character (if any).
+6   All elements following the terminating null wide character (if any) written by
+    mbstowcs_s in the array of dstmax wide characters pointed to by dst take
+    unspecified values when mbstowcs_s returns.<sup><a href="#note401"><b>401)</b></a></sup>
+7   If copying takes place between objects that overlap, the objects take on unspecified
+    values.
+<b>    Returns</b>
+8   The mbstowcs_s function returns zero if no runtime-constraint violation and no
+    encoding error occurred. Otherwise, a nonzero value is returned.
+<a name="K.3.6.5.2" href="#K.3.6.5.2"><b>    K.3.6.5.2 The wcstombs_s function</b></a>
+<b>    Synopsis</b>
+1            #include <a href="#7.22">&lt;stdlib.h&gt;</a>
+             errno_t wcstombs_s(size_t * restrict retval,
+                  char * restrict dst, rsize_t dstmax,
+                  const wchar_t * restrict src, rsize_t len);
+    Runtime-constraints
+2   Neither retval nor src shall be a null pointer. If dst is not a null pointer, then
+    neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null pointer,
+    then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall not equal
+    zero. If dst is not a null pointer and len is not less than dstmax, then the conversion
+    shall have been stopped (see below) because a terminating null wide character was
+    reached or because an encoding error occurred.
+
+
+
+
+    <sup><a name="note400" href="#note400"><b>400)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
+    <sup><a name="note401" href="#note401"><b>401)</b></a></sup> This allows an implementation to attempt converting the multibyte string before discovering a
+         terminating null character did not occur where required.
+
+[<a name="p608" href="#p608">page 608</a>] (<a href="#Contents">Contents</a>)
+
+3   If there is a runtime-constraint violation, then wcstombs_s does the following. If
+    retval is not a null pointer, then wcstombs_s sets *retval to (size_t)(-1). If
+    dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+    then wcstombs_s sets dst[0] to the null character.
+<b>    Description</b>
+4   The wcstombs_s function converts a sequence of wide characters from the array
+    pointed to by src into a sequence of corresponding multibyte characters that begins in
+    the initial shift state. If dst is not a null pointer, the converted characters are then stored
+    into the array pointed to by dst. Conversion continues up to and including a terminating
+    null wide character, which is also stored. Conversion stops earlier in two cases:
+    -- when a wide character is reached that does not correspond to a valid multibyte
+      character;
+    -- (if dst is not a null pointer) when the next multibyte character would exceed the
+        limit of n total bytes to be stored into the array pointed to by dst. If the wide
+        character being converted is the null wide character, then n is the lesser of len or
+        dstmax. Otherwise, n is the lesser of len or dstmax-1.
+    If the conversion stops without converting a null wide character and dst is not a null
+    pointer, then a null character is stored into the array pointed to by dst immediately
+    following any multibyte characters already stored. Each conversion takes place as if by a
+    call to the wcrtomb function.<sup><a href="#note402"><b>402)</b></a></sup>
+5   Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+    wide character that does not correspond to a valid multibyte character, an encoding error
+    occurs: the wcstombs_s function stores the value (size_t)(-1) into *retval.
+    Otherwise, the wcstombs_s function stores into *retval the number of bytes in the
+    resulting multibyte character sequence, not including the terminating null character (if
+    any).
+6   All elements following the terminating null character (if any) written by wcstombs_s
+    in the array of dstmax elements pointed to by dst take unspecified values when
+    wcstombs_s returns.<sup><a href="#note403"><b>403)</b></a></sup>
+7   If copying takes place between objects that overlap, the objects take on unspecified
+    values.
+
+
+    <sup><a name="note402" href="#note402"><b>402)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
+         include those necessary to reach the initial shift state immediately before the null byte. However, if
+         the conversion stops before a terminating null wide character has been reached, the result will be null
+         terminated, but might not end in the initial shift state.
+    <sup><a name="note403" href="#note403"><b>403)</b></a></sup> When len is not less than dstmax, the implementation might fill the array before discovering a
+         runtime-constraint violation.
+
+[<a name="p609" href="#p609">page 609</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+8   The wcstombs_s function returns zero if no runtime-constraint violation and no
+    encoding error occurred. Otherwise, a nonzero value is returned.
+<a name="K.3.7" href="#K.3.7"><b>    K.3.7 String handling &lt;string.h&gt;</b></a>
+1   The header <a href="#7.23">&lt;string.h&gt;</a> defines two types.
+2   The types are
+           errno_t
+    which is type int; and
+           rsize_t
+    which is the type size_t.
+<a name="K.3.7.1" href="#K.3.7.1"><b>    K.3.7.1 Copying functions</b></a>
+<a name="K.3.7.1.1" href="#K.3.7.1.1"><b>    K.3.7.1.1 The memcpy_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.23">&lt;string.h&gt;</a>
+           errno_t memcpy_s(void * restrict s1, rsize_t s1max,
+                const void * restrict s2, rsize_t n);
+    Runtime-constraints
+2   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+    RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
+    objects that overlap.
+3   If there is a runtime-constraint violation, the memcpy_s function stores zeros in the first
+    s1max characters of the object pointed to by s1 if s1 is not a null pointer and s1max is
+    not greater than RSIZE_MAX.
+<b>    Description</b>
+4   The memcpy_s function copies n characters from the object pointed to by s2 into the
+    object pointed to by s1.
+<b>    Returns</b>
+5   The memcpy_s function returns zero if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+
+[<a name="p610" href="#p610">page 610</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.7.1.2" href="#K.3.7.1.2"><b>    K.3.7.1.2 The memmove_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            errno_t memmove_s(void *s1, rsize_t s1max,
+                 const void *s2, rsize_t n);
+    Runtime-constraints
+2   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+    RSIZE_MAX. n shall not be greater than s1max.
+3   If there is a runtime-constraint violation, the memmove_s function stores zeros in the
+    first s1max characters of the object pointed to by s1 if s1 is not a null pointer and
+    s1max is not greater than RSIZE_MAX.
+<b>    Description</b>
+4   The memmove_s function copies n characters from the object pointed to by s2 into the
+    object pointed to by s1. This copying takes place as if the n characters from the object
+    pointed to by s2 are first copied into a temporary array of n characters that does not
+    overlap the objects pointed to by s1 or s2, and then the n characters from the temporary
+    array are copied into the object pointed to by s1.
+<b>    Returns</b>
+5   The memmove_s function returns zero if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+<a name="K.3.7.1.3" href="#K.3.7.1.3"><b>    K.3.7.1.3 The strcpy_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            errno_t strcpy_s(char * restrict s1,
+                 rsize_t s1max,
+                 const char * restrict s2);
+    Runtime-constraints
+2   Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+    s1max shall not equal zero. s1max shall be greater than strnlen_s(s2, s1max).
+    Copying shall not take place between objects that overlap.
+3   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+    greater than zero and not greater than RSIZE_MAX, then strcpy_s sets s1[0] to the
+    null character.
+
+[<a name="p611" href="#p611">page 611</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+4   The strcpy_s function copies the string pointed to by s2 (including the terminating
+    null character) into the array pointed to by s1.
+5   All elements following the terminating null character (if any) written by strcpy_s in
+    the array of s1max characters pointed to by s1 take unspecified values when
+    strcpy_s returns.<sup><a href="#note404"><b>404)</b></a></sup>
+<b>    Returns</b>
+6   The strcpy_s function returns zero<sup><a href="#note405"><b>405)</b></a></sup> if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+<a name="K.3.7.1.4" href="#K.3.7.1.4"><b>    K.3.7.1.4 The strncpy_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            errno_t strncpy_s(char * restrict s1,
+                 rsize_t s1max,
+                 const char * restrict s2,
+                 rsize_t n);
+    Runtime-constraints
+2   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+    RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
+    shall be greater than strnlen_s(s2, s1max). Copying shall not take place between
+    objects that overlap.
+3   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+    greater than zero and not greater than RSIZE_MAX, then strncpy_s sets s1[0] to the
+    null character.
+<b>    Description</b>
+4   The strncpy_s function copies not more than n successive characters (characters that
+    follow a null character are not copied) from the array pointed to by s2 to the array
+    pointed to by s1. If no null character was copied from s2, then s1[n] is set to a null
+    character.
+
+
+    <sup><a name="note404" href="#note404"><b>404)</b></a></sup> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
+         any of those characters are null. Such an approach might write a character to every element of s1
+         before discovering that the first element should be set to the null character.
+    <sup><a name="note405" href="#note405"><b>405)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
+         within the array pointed to by s1 and that the result in s1 is null terminated.
+
+[<a name="p612" href="#p612">page 612</a>] (<a href="#Contents">Contents</a>)
+
+5   All elements following the terminating null character (if any) written by strncpy_s in
+    the array of s1max characters pointed to by s1 take unspecified values when
+    strncpy_s returns.<sup><a href="#note406"><b>406)</b></a></sup>
+<b>    Returns</b>
+6   The strncpy_s function returns zero<sup><a href="#note407"><b>407)</b></a></sup> if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+7   EXAMPLE 1 The strncpy_s function can be used to copy a string without the danger that the result
+    will not be null terminated or that characters will be written past the end of the destination array.
+            #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            /* ... */
+            char src1[100] = "hello";
+            char src2[7] = {'g', 'o', 'o', 'd', 'b', 'y', 'e'};
+            char dst1[6], dst2[5], dst3[5];
+            int r1, r2, r3;
+            r1 = strncpy_s(dst1, 6, src1, 100);
+            r2 = strncpy_s(dst2, 5, src2, 7);
+            r3 = strncpy_s(dst3, 5, src2, 4);
+    The first call will assign to r1 the value zero and to dst1 the sequence hello\0.
+    The second call will assign to r2 a nonzero value and to dst2 the sequence \0.
+    The third call will assign to r3 the value zero and to dst3 the sequence good\0.
+
+<a name="K.3.7.2" href="#K.3.7.2"><b>    K.3.7.2 Concatenation functions</b></a>
+<a name="K.3.7.2.1" href="#K.3.7.2.1"><b>    K.3.7.2.1 The strcat_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            errno_t strcat_s(char * restrict s1,
+                 rsize_t s1max,
+                 const char * restrict s2);
+    Runtime-constraints
+2   Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
+    strcat_s.
+
+
+
+
+    <sup><a name="note406" href="#note406"><b>406)</b></a></sup> This allows an implementation to copy characters from s2 to s1 while simultaneously checking if
+         any of those characters are null. Such an approach might write a character to every element of s1
+         before discovering that the first element should be set to the null character.
+    <sup><a name="note407" href="#note407"><b>407)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 fit
+         within the array pointed to by s1 and that the result in s1 is null terminated.
+
+[<a name="p613" href="#p613">page 613</a>] (<a href="#Contents">Contents</a>)
+
+3   Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+    s1max shall not equal zero. m shall not equal zero.<sup><a href="#note408"><b>408)</b></a></sup> m shall be greater than
+    strnlen_s(s2, m). Copying shall not take place between objects that overlap.
+4   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+    greater than zero and not greater than RSIZE_MAX, then strcat_s sets s1[0] to the
+    null character.
+<b>    Description</b>
+5   The strcat_s function appends a copy of the string pointed to by s2 (including the
+    terminating null character) to the end of the string pointed to by s1. The initial character
+    from s2 overwrites the null character at the end of s1.
+6   All elements following the terminating null character (if any) written by strcat_s in
+    the array of s1max characters pointed to by s1 take unspecified values when
+    strcat_s returns.<sup><a href="#note409"><b>409)</b></a></sup>
+<b>    Returns</b>
+7   The strcat_s function returns zero<sup><a href="#note410"><b>410)</b></a></sup> if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+<a name="K.3.7.2.2" href="#K.3.7.2.2"><b>    K.3.7.2.2 The strncat_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            errno_t strncat_s(char * restrict s1,
+                 rsize_t s1max,
+                 const char * restrict s2,
+                 rsize_t n);
+    Runtime-constraints
+2   Let m denote the value s1max - strnlen_s(s1, s1max) upon entry to
+    strncat_s.
+3   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+    RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note411"><b>411)</b></a></sup> If n is not less
+
+
+    <sup><a name="note408" href="#note408"><b>408)</b></a></sup> Zero means that s1 was not null terminated upon entry to strcat_s.
+    <sup><a name="note409" href="#note409"><b>409)</b></a></sup> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
+         any of those characters are null. Such an approach might write a character to every element of s1
+         before discovering that the first element should be set to the null character.
+    <sup><a name="note410" href="#note410"><b>410)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 were
+         appended to the string pointed to by s1 and that the result in s1 is null terminated.
+
+[<a name="p614" href="#p614">page 614</a>] (<a href="#Contents">Contents</a>)
+
+    than m, then m shall be greater than strnlen_s(s2, m). Copying shall not take
+    place between objects that overlap.
+4   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+    greater than zero and not greater than RSIZE_MAX, then strncat_s sets s1[0] to the
+    null character.
+<b>    Description</b>
+5   The strncat_s function appends not more than n successive characters (characters
+    that follow a null character are not copied) from the array pointed to by s2 to the end of
+    the string pointed to by s1. The initial character from s2 overwrites the null character at
+    the end of s1. If no null character was copied from s2, then s1[s1max-m+n] is set to
+    a null character.
+6   All elements following the terminating null character (if any) written by strncat_s in
+    the array of s1max characters pointed to by s1 take unspecified values when
+    strncat_s returns.<sup><a href="#note412"><b>412)</b></a></sup>
+<b>    Returns</b>
+7   The strncat_s function returns zero<sup><a href="#note413"><b>413)</b></a></sup> if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+8   EXAMPLE 1 The strncat_s function can be used to copy a string without the danger that the result
+    will not be null terminated or that characters will be written past the end of the destination array.
+            #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            /* ... */
+            char s1[100] = "good";
+            char s2[6] = "hello";
+            char s3[6] = "hello";
+            char s4[7] = "abc";
+            char s5[1000] = "bye";
+            int r1, r2, r3, r4;
+            r1 = strncat_s(s1, 100, s5, 1000);
+            r2 = strncat_s(s2, 6, "", 1);
+            r3 = strncat_s(s3, 6, "X", 2);
+            r4 = strncat_s(s4, 7, "defghijklmn", 3);
+    After the first call r1 will have the value zero and s1 will contain the sequence goodbye\0.
+
+
+
+    <sup><a name="note411" href="#note411"><b>411)</b></a></sup> Zero means that s1 was not null terminated upon entry to strncat_s.
+    <sup><a name="note412" href="#note412"><b>412)</b></a></sup> This allows an implementation to append characters from s2 to s1 while simultaneously checking if
+         any of those characters are null. Such an approach might write a character to every element of s1
+         before discovering that the first element should be set to the null character.
+    <sup><a name="note413" href="#note413"><b>413)</b></a></sup> A zero return value implies that all of the requested characters from the string pointed to by s2 were
+         appended to the string pointed to by s1 and that the result in s1 is null terminated.
+
+[<a name="p615" href="#p615">page 615</a>] (<a href="#Contents">Contents</a>)
+
+    After the second call r2 will have the value zero and s2 will contain the sequence hello\0.
+    After the third call r3 will have a nonzero value and s3 will contain the sequence \0.
+    After the fourth call r4 will have the value zero and s4 will contain the sequence abcdef\0.
+
+<a name="K.3.7.3" href="#K.3.7.3"><b>    K.3.7.3 Search functions</b></a>
+<a name="K.3.7.3.1" href="#K.3.7.3.1"><b>    K.3.7.3.1 The strtok_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            char *strtok_s(char * restrict s1,
+                 rsize_t * restrict s1max,
+                 const char * restrict s2,
+                 char ** restrict ptr);
+    Runtime-constraints
+2   None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
+    shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
+    The end of the token found shall occur within the first *s1max characters of s1 for the
+    first call, and shall occur within the first *s1max characters of where searching resumes
+    on subsequent calls.
+3   If there is a runtime-constraint violation, the strtok_s function does not indirect
+    through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
+<b>    Description</b>
+4   A sequence of calls to the strtok_s function breaks the string pointed to by s1 into a
+    sequence of tokens, each of which is delimited by a character from the string pointed to
+    by s2. The fourth argument points to a caller-provided char pointer into which the
+    strtok_s function stores information necessary for it to continue scanning the same
+    string.
+5   The first call in a sequence has a non-null first argument and s1max points to an object
+    whose value is the number of elements in the character array pointed to by the first
+    argument. The first call stores an initial value in the object pointed to by ptr and
+    updates the value pointed to by s1max to reflect the number of elements that remain in
+    relation to ptr. Subsequent calls in the sequence have a null first argument and the
+    objects pointed to by s1max and ptr are required to have the values stored by the
+    previous call in the sequence, which are then updated. The separator string pointed to by
+    s2 may be different from call to call.
+6   The first call in the sequence searches the string pointed to by s1 for the first character
+    that is not contained in the current separator string pointed to by s2. If no such character
+    is found, then there are no tokens in the string pointed to by s1 and the strtok_s
+    function returns a null pointer. If such a character is found, it is the start of the first token.
+
+[<a name="p616" href="#p616">page 616</a>] (<a href="#Contents">Contents</a>)
+
+7    The strtok_s function then searches from there for the first character in s1 that is
+     contained in the current separator string. If no such character is found, the current token
+     extends to the end of the string pointed to by s1, and subsequent searches in the same
+     string for a token return a null pointer. If such a character is found, it is overwritten by a
+     null character, which terminates the current token.
+8    In all cases, the strtok_s function stores sufficient information in the pointer pointed
+     to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+     value for ptr, shall start searching just past the element overwritten by a null character
+     (if any).
+<b>     Returns</b>
+9    The strtok_s function returns a pointer to the first character of a token, or a null
+     pointer if there is no token or there is a runtime-constraint violation.
+10   EXAMPLE
+             #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.23">&lt;string.h&gt;</a>
+             static char str1[] = "?a???b,,,#c";
+             static char str2[] = "\t \t";
+             char *t, *ptr1, *ptr2;
+             rsize_t max1 = sizeof(str1);
+             rsize_t max2 = sizeof(str2);
+             t   =   strtok_s(str1,   &amp;max1,   "?", &amp;ptr1);        //   t   points to the token "a"
+             t   =   strtok_s(NULL,   &amp;max1,   ",", &amp;ptr1);        //   t   points to the token "??b"
+             t   =   strtok_s(str2,   &amp;max2,   " \t", &amp;ptr2);      //   t   is a null pointer
+             t   =   strtok_s(NULL,   &amp;max1,   "#,", &amp;ptr1);       //   t   points to the token "c"
+             t   =   strtok_s(NULL,   &amp;max1,   "?", &amp;ptr1);        //   t   is a null pointer
+
+<a name="K.3.7.4" href="#K.3.7.4"><b>     K.3.7.4 Miscellaneous functions</b></a>
+<a name="K.3.7.4.1" href="#K.3.7.4.1"><b>     K.3.7.4.1 The memset_s function</b></a>
+<b>     Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.23">&lt;string.h&gt;</a>
+             errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n)
+     Runtime-constraints
+2    s shall not be a null pointer. Neither smax nor n shall be greater than RSIZE_MAX. n
+     shall not be greater than smax.
+3    If there is a runtime-constraint violation, then if s is not a null pointer and smax is not
+     greater than RSIZE_MAX, the memset_s function stores the value of c (converted to an
+     unsigned char) into each of the first smax characters of the object pointed to by s.
+
+[<a name="p617" href="#p617">page 617</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+4   The memset_s function copies the value of c (converted to an unsigned char) into
+    each of the first n characters of the object pointed to by s. Unlike memset, any call to
+    the memset_s function shall be evaluated strictly according to the rules of the abstract
+    machine as described in (<a href="#5.1.2.3">5.1.2.3</a>). That is, any call to the memset_s function shall
+    assume that the memory indicated by s and n may be accessible in the future and thus
+    must contain the values indicated by c.
+<b>    Returns</b>
+5   The memset_s function returns zero if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+<a name="K.3.7.4.2" href="#K.3.7.4.2"><b>    K.3.7.4.2 The strerror_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.23">&lt;string.h&gt;</a>
+           errno_t strerror_s(char *s, rsize_t maxsize,
+                errno_t errnum);
+    Runtime-constraints
+2   s shall not be a null pointer. maxsize shall not be greater than RSIZE_MAX.
+    maxsize shall not equal zero.
+3   If there is a runtime-constraint violation, then the array (if any) pointed to by s is not
+    modified.
+<b>    Description</b>
+4   The strerror_s function maps the number in errnum to a locale-specific message
+    string. Typically, the values for errnum come from errno, but strerror_s shall
+    map any value of type int to a message.
+5   If the length of the desired string is less than maxsize, then the string is copied to the
+    array pointed to by s.
+6   Otherwise, if maxsize is greater than zero, then maxsize-1 characters are copied
+    from the string to the array pointed to by s and then s[maxsize-1] is set to the null
+    character. Then, if maxsize is greater than 3, then s[maxsize-2],
+    s[maxsize-3], and s[maxsize-4] are set to the character period (.).
+<b>    Returns</b>
+7   The strerror_s function returns zero if the length of the desired string was less than
+    maxsize and there was no runtime-constraint violation. Otherwise, the strerror_s
+    function returns a nonzero value.
+
+[<a name="p618" href="#p618">page 618</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.7.4.3" href="#K.3.7.4.3"><b>    K.3.7.4.3 The strerrorlen_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            size_t strerrorlen_s(errno_t errnum);
+<b>    Description</b>
+2   The strerrorlen_s function calculates the length of the (untruncated) locale-specific
+    message string that the strerror_s function maps to errnum.
+<b>    Returns</b>
+3   The strerrorlen_s function returns the number of characters (not including the null
+    character) in the full message string.
+<a name="K.3.7.4.4" href="#K.3.7.4.4"><b>    K.3.7.4.4 The strnlen_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.23">&lt;string.h&gt;</a>
+            size_t strnlen_s(const char *s, size_t maxsize);
+<b>    Description</b>
+2   The strnlen_s function computes the length of the string pointed to by s.
+<b>    Returns</b>
+3   If s is a null pointer,<sup><a href="#note414"><b>414)</b></a></sup> then the strnlen_s function returns zero.
+4   Otherwise, the strnlen_s function returns the number of characters that precede the
+    terminating null character. If there is no null character in the first maxsize characters of
+    s then strnlen_s returns maxsize. At most the first maxsize characters of s shall
+    be accessed by strnlen_s.
+
+
+
+
+    <sup><a name="note414" href="#note414"><b>414)</b></a></sup> Note that the strnlen_s function has no runtime-constraints. This lack of runtime-constraints
+         along with the values returned for a null pointer or an unterminated string argument make
+         strnlen_s useful in algorithms that gracefully handle such exceptional data.
+
+[<a name="p619" href="#p619">page 619</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.8" href="#K.3.8"><b>    K.3.8 Date and time &lt;time.h&gt;</b></a>
+1   The header <a href="#7.26">&lt;time.h&gt;</a> defines two types.
+2   The types are
+            errno_t
+    which is type int; and
+            rsize_t
+    which is the type size_t.
+<a name="K.3.8.1" href="#K.3.8.1"><b>    K.3.8.1 Components of time</b></a>
+1   A broken-down time is normalized if the values of the members of the tm structure are in
+    their normal rages.<sup><a href="#note415"><b>415)</b></a></sup>
+<a name="K.3.8.2" href="#K.3.8.2"><b>    K.3.8.2 Time conversion functions</b></a>
+1   Like the strftime function, the asctime_s and ctime_s functions do not return a
+    pointer to a static object, and other library functions are permitted to call them.
+<a name="K.3.8.2.1" href="#K.3.8.2.1"><b>    K.3.8.2.1 The asctime_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.26">&lt;time.h&gt;</a>
+            errno_t asctime_s(char *s, rsize_t maxsize,
+                 const struct tm *timeptr);
+    Runtime-constraints
+2   Neither s nor timeptr shall be a null pointer. maxsize shall not be less than 26 and
+    shall not be greater than RSIZE_MAX. The broken-down time pointed to by timeptr
+    shall be normalized. The calendar year represented by the broken-down time pointed to
+    by timeptr shall not be less than calendar year 0 and shall not be greater than calendar
+    year 9999.
+3   If there is a runtime-constraint violation, there is no attempt to convert the time, and
+    s[0] is set to a null character if s is not a null pointer and maxsize is not zero and is
+    not greater than RSIZE_MAX.
+<b>    Description</b>
+4   The asctime_s function converts the normalized broken-down time in the structure
+    pointed to by timeptr into a 26 character (including the null character) string in the
+
+
+    <sup><a name="note415" href="#note415"><b>415)</b></a></sup> The normal ranges are defined in <a href="#7.26.1">7.26.1</a>.
+
+[<a name="p620" href="#p620">page 620</a>] (<a href="#Contents">Contents</a>)
+
+    form
+            Sun Sep 16 01:03:52 1973\n\0
+    The fields making up this string are (in order):
+       1.   The name of the day of the week represented by timeptr-&gt;tm_wday using the
+            following three character weekday names: Sun, Mon, Tue, Wed, Thu, Fri, and Sat.
+       2.   The character space.
+       3. The name of the month represented by timeptr-&gt;tm_mon using the following
+          three character month names: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct,
+          Nov, and Dec.
+       4.   The character space.
+       5.   The value of timeptr-&gt;tm_mday as if printed using the fprintf format
+            "%2d".
+       6.   The character space.
+       7.   The value of timeptr-&gt;tm_hour as if printed using the fprintf format
+            "%.2d".
+       8.   The character colon.
+       9.   The value of timeptr-&gt;tm_min as if printed using the fprintf format
+            "%.2d".
+     10.    The character colon.
+     11.    The value of timeptr-&gt;tm_sec as if printed using the fprintf format
+            "%.2d".
+     12.    The character space.
+     13.    The value of timeptr-&gt;tm_year + 1900 as if printed using the fprintf
+            format "%4d".
+     14.    The character new line.
+     15.    The null character.
+    Recommended practice
+    The strftime function allows more flexible formatting and supports locale-specific
+    behavior. If you do not require the exact form of the result string produced by the
+    asctime_s function, consider using the strftime function instead.
+<b>    Returns</b>
+5   The asctime_s function returns zero if the time was successfully converted and stored
+    into the array pointed to by s. Otherwise, it returns a nonzero value.
+
+[<a name="p621" href="#p621">page 621</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.8.2.2" href="#K.3.8.2.2"><b>    K.3.8.2.2 The ctime_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.26">&lt;time.h&gt;</a>
+           errno_t ctime_s(char *s, rsize_t maxsize,
+                const time_t *timer);
+    Runtime-constraints
+2   Neither s nor timer shall be a null pointer. maxsize shall not be less than 26 and
+    shall not be greater than RSIZE_MAX.
+3   If there is a runtime-constraint violation, s[0] is set to a null character if s is not a null
+    pointer and maxsize is not equal zero and is not greater than RSIZE_MAX.
+<b>    Description</b>
+4   The ctime_s function converts the calendar time pointed to by timer to local time in
+    the form of a string. It is equivalent to
+           asctime_s(s, maxsize, localtime_s(timer))
+    Recommended practice
+    The strftime function allows more flexible formatting and supports locale-specific
+    behavior. If you do not require the exact form of the result string produced by the
+    ctime_s function, consider using the strftime function instead.
+<b>    Returns</b>
+5   The ctime_s function returns zero if the time was successfully converted and stored
+    into the array pointed to by s. Otherwise, it returns a nonzero value.
+<a name="K.3.8.2.3" href="#K.3.8.2.3"><b>    K.3.8.2.3 The gmtime_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.26">&lt;time.h&gt;</a>
+           struct tm *gmtime_s(const time_t * restrict timer,
+                struct tm * restrict result);
+    Runtime-constraints
+2   Neither timer nor result shall be a null pointer.
+3   If there is a runtime-constraint violation, there is no attempt to convert the time.
+<b>    Description</b>
+4   The gmtime_s function converts the calendar time pointed to by timer into a broken-
+    down time, expressed as UTC. The broken-down time is stored in the structure pointed
+
+[<a name="p622" href="#p622">page 622</a>] (<a href="#Contents">Contents</a>)
+
+    to by result.
+<b>    Returns</b>
+5   The gmtime_s function returns result, or a null pointer if the specified time cannot
+    be converted to UTC or there is a runtime-constraint violation.
+<a name="K.3.8.2.4" href="#K.3.8.2.4"><b>    K.3.8.2.4 The localtime_s function</b></a>
+<b>    Synopsis</b>
+1            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.26">&lt;time.h&gt;</a>
+             struct tm *localtime_s(const time_t * restrict timer,
+                  struct tm * restrict result);
+    Runtime-constraints
+2   Neither timer nor result shall be a null pointer.
+3   If there is a runtime-constraint violation, there is no attempt to convert the time.
+<b>    Description</b>
+4   The localtime_s function converts the calendar time pointed to by timer into a
+    broken-down time, expressed as local time. The broken-down time is stored in the
+    structure pointed to by result.
+<b>    Returns</b>
+5   The localtime_s function returns result, or a null pointer if the specified time
+    cannot be converted to local time or there is a runtime-constraint violation.
+<a name="K.3.9" href="#K.3.9"><b>    K.3.9 Extended multibyte and wide character utilities &lt;wchar.h&gt;</b></a>
+1   The header <a href="#7.28">&lt;wchar.h&gt;</a> defines two types.
+2   The types are
+             errno_t
+    which is type int; and
+             rsize_t
+    which is the type size_t.
+3   Unless explicitly stated otherwise, if the execution of a function described in this
+    subclause causes copying to take place between objects that overlap, the objects take on
+    unspecified values.
+
+[<a name="p623" href="#p623">page 623</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.9.1" href="#K.3.9.1"><b>    K.3.9.1 Formatted wide character input/output functions</b></a>
+<a name="K.3.9.1.1" href="#K.3.9.1.1"><b>    K.3.9.1.1 The fwprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int fwprintf_s(FILE * restrict stream,
+                 const wchar_t * restrict format, ...);
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note416"><b>416)</b></a></sup> (modified or
+    not by flags, field width, or precision) shall not appear in the wide string pointed to by
+    format. Any argument to fwprintf_s corresponding to a %s specifier shall not be a
+    null pointer.
+3   If there is a runtime-constraint violation, the fwprintf_s function does not attempt to
+    produce further output, and it is unspecified to what extent fwprintf_s produced
+    output before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The fwprintf_s function is equivalent to the fwprintf function except for the
+    explicit runtime-constraints listed above.
+<b>    Returns</b>
+5   The fwprintf_s function returns the number of wide characters transmitted, or a
+    negative value if an output error, encoding error, or runtime-constraint violation occurred.
+<a name="K.3.9.1.2" href="#K.3.9.1.2"><b>    K.3.9.1.2 The fwscanf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int fwscanf_s(FILE * restrict stream,
+                 const wchar_t * restrict format, ...);
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. Any argument indirected though in
+    order to store converted input shall not be a null pointer.
+
+
+    <sup><a name="note416" href="#note416"><b>416)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+
+[<a name="p624" href="#p624">page 624</a>] (<a href="#Contents">Contents</a>)
+
+3   If there is a runtime-constraint violation, the fwscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent fwscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The fwscanf_s function is equivalent to fwscanf except that the c, s, and [
+    conversion specifiers apply to a pair of arguments (unless assignment suppression is
+    indicated by a *). The first of these arguments is the same as for fwscanf. That
+    argument is immediately followed in the argument list by the second argument, which has
+    type size_t and gives the number of elements in the array pointed to by the first
+    argument of the pair. If the first argument points to a scalar object, it is considered to be
+    an array of one element.<sup><a href="#note417"><b>417)</b></a></sup>
+5   A matching failure occurs if the number of elements in a receiving object is insufficient to
+    hold the converted input (including any trailing null character).
+<b>    Returns</b>
+6   The fwscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    fwscanf_s function returns the number of input items assigned, which can be fewer
+    than provided for, or even zero, in the event of an early matching failure.
+<a name="K.3.9.1.3" href="#K.3.9.1.3"><b>    K.3.9.1.3 The snwprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int snwprintf_s(wchar_t * restrict s,
+                 rsize_t n,
+                 const wchar_t * restrict format, ...);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The %n specifier<sup><a href="#note418"><b>418)</b></a></sup> (modified or not by flags, field width, or
+
+    <sup><a name="note417" href="#note417"><b>417)</b></a></sup> If the format is known at translation time, an implementation may issue a diagnostic for any argument
+         used to store the result from a c, s, or [ conversion specifier if that argument is not followed by an
+         argument of a type compatible with rsize_t. A limited amount of checking may be done if even if
+         the format is not known at translation time. For example, an implementation may issue a diagnostic
+         for each argument after format that has of type pointer to one of char, signed char,
+         unsigned char, or void that is not followed by an argument of a type compatible with
+         rsize_t. The diagnostic could warn that unless the pointer is being used with a conversion specifier
+         using the hh length modifier, a length argument must follow the pointer argument. Another useful
+         diagnostic could flag any non-pointer argument following format that did not have a type
+         compatible with rsize_t.
+
+[<a name="p625" href="#p625">page 625</a>] (<a href="#Contents">Contents</a>)
+
+    precision) shall not appear in the wide string pointed to by format. Any argument to
+    snwprintf_s corresponding to a %s specifier shall not be a null pointer. No encoding
+    error shall occur.
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the snwprintf_s function sets s[0] to the
+    null wide character.
+<b>    Description</b>
+4   The snwprintf_s function is equivalent to the swprintf function except for the
+    explicit runtime-constraints listed above.
+5   The snwprintf_s function, unlike swprintf_s, will truncate the result to fit within
+    the array pointed to by s.
+<b>    Returns</b>
+6   The snwprintf_s function returns the number of wide characters that would have
+    been written had n been sufficiently large, not counting the terminating wide null
+    character, or a negative value if a runtime-constraint violation occurred. Thus, the null-
+    terminated output has been completely written if and only if the returned value is
+    nonnegative and less than n.
+<a name="K.3.9.1.4" href="#K.3.9.1.4"><b>    K.3.9.1.4 The swprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int swprintf_s(wchar_t * restrict s, rsize_t n,
+                 const wchar_t * restrict format, ...);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The number of wide characters (including the trailing null) required
+    for the result to be written to the array pointed to by s shall not be greater than n. The %n
+    specifier<sup><a href="#note419"><b>419)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+    wide string pointed to by format. Any argument to swprintf_s corresponding to a
+    %s specifier shall not be a null pointer. No encoding error shall occur.
+
+
+    <sup><a name="note418" href="#note418"><b>418)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+    <sup><a name="note419" href="#note419"><b>419)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+
+[<a name="p626" href="#p626">page 626</a>] (<a href="#Contents">Contents</a>)
+
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the swprintf_s function sets s[0] to the
+    null wide character.
+<b>    Description</b>
+4   The swprintf_s function is equivalent to the swprintf function except for the
+    explicit runtime-constraints listed above.
+5   The swprintf_s function, unlike snwprintf_s, treats a result too big for the array
+    pointed to by s as a runtime-constraint violation.
+<b>    Returns</b>
+6   If no runtime-constraint violation occurred, the swprintf_s function returns the
+    number of wide characters written in the array, not counting the terminating null wide
+    character. If an encoding error occurred or if n or more wide characters are requested to
+    be written, swprintf_s returns a negative value. If any other runtime-constraint
+    violation occurred, swprintf_s returns zero.
+<a name="K.3.9.1.5" href="#K.3.9.1.5"><b>    K.3.9.1.5 The swscanf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int swscanf_s(const wchar_t * restrict s,
+                 const wchar_t * restrict format, ...);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. Any argument indirected though in order
+    to store converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the swscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent swscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The swscanf_s function is equivalent to fwscanf_s, except that the argument s
+    specifies a wide string from which the input is to be obtained, rather than from a stream.
+    Reaching the end of the wide string is equivalent to encountering end-of-file for the
+    fwscanf_s function.
+<b>    Returns</b>
+5   The swscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    swscanf_s function returns the number of input items assigned, which can be fewer
+    than provided for, or even zero, in the event of an early matching failure.
+
+[<a name="p627" href="#p627">page 627</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.9.1.6" href="#K.3.9.1.6"><b>    K.3.9.1.6 The vfwprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vfwprintf_s(FILE * restrict stream,
+                 const wchar_t * restrict format,
+                 va_list arg);
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. The %n specifier<sup><a href="#note420"><b>420)</b></a></sup> (modified or
+    not by flags, field width, or precision) shall not appear in the wide string pointed to by
+    format. Any argument to vfwprintf_s corresponding to a %s specifier shall not be
+    a null pointer.
+3   If there is a runtime-constraint violation, the vfwprintf_s function does not attempt
+    to produce further output, and it is unspecified to what extent vfwprintf_s produced
+    output before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vfwprintf_s function is equivalent to the vfwprintf function except for the
+    explicit runtime-constraints listed above.
+<b>    Returns</b>
+5   The vfwprintf_s function returns the number of wide characters transmitted, or a
+    negative value if an output error, encoding error, or runtime-constraint violation occurred.
+<a name="K.3.9.1.7" href="#K.3.9.1.7"><b>    K.3.9.1.7 The vfwscanf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.21">&lt;stdio.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vfwscanf_s(FILE * restrict stream,
+                 const wchar_t * restrict format, va_list arg);
+
+
+
+    <sup><a name="note420" href="#note420"><b>420)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+
+[<a name="p628" href="#p628">page 628</a>] (<a href="#Contents">Contents</a>)
+
+    Runtime-constraints
+2   Neither stream nor format shall be a null pointer. Any argument indirected though in
+    order to store converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vfwscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent vfwscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vfwscanf_s function is equivalent to fwscanf_s, with the variable argument
+    list replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vfwscanf_s function does not invoke the
+    va_end macro.<sup><a href="#note421"><b>421)</b></a></sup>
+<b>    Returns</b>
+5   The vfwscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    vfwscanf_s function returns the number of input items assigned, which can be fewer
+    than provided for, or even zero, in the event of an early matching failure.
+<a name="K.3.9.1.8" href="#K.3.9.1.8"><b>    K.3.9.1.8 The vsnwprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vsnwprintf_s(wchar_t * restrict s,
+                 rsize_t n,
+                 const wchar_t * restrict format,
+                 va_list arg);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The %n specifier<sup><a href="#note422"><b>422)</b></a></sup> (modified or not by flags, field width, or
+    precision) shall not appear in the wide string pointed to by format. Any argument to
+    vsnwprintf_s corresponding to a %s specifier shall not be a null pointer. No
+    encoding error shall occur.
+
+    <sup><a name="note421" href="#note421"><b>421)</b></a></sup> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+         value of arg after the return is indeterminate.
+    <sup><a name="note422" href="#note422"><b>422)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+
+[<a name="p629" href="#p629">page 629</a>] (<a href="#Contents">Contents</a>)
+
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the vsnwprintf_s function sets s[0] to
+    the null wide character.
+<b>    Description</b>
+4   The vsnwprintf_s function is equivalent to the vswprintf function except for the
+    explicit runtime-constraints listed above.
+5   The vsnwprintf_s function, unlike vswprintf_s, will truncate the result to fit
+    within the array pointed to by s.
+<b>    Returns</b>
+6   The vsnwprintf_s function returns the number of wide characters that would have
+    been written had n been sufficiently large, not counting the terminating null character, or
+    a negative value if a runtime-constraint violation occurred. Thus, the null-terminated
+    output has been completely written if and only if the returned value is nonnegative and
+    less than n.
+<a name="K.3.9.1.9" href="#K.3.9.1.9"><b>    K.3.9.1.9 The vswprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vswprintf_s(wchar_t * restrict s,
+                 rsize_t n,
+                 const wchar_t * restrict format,
+                 va_list arg);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. n shall neither equal zero nor be greater
+    than RSIZE_MAX. The number of wide characters (including the trailing null) required
+    for the result to be written to the array pointed to by s shall not be greater than n. The %n
+    specifier<sup><a href="#note423"><b>423)</b></a></sup> (modified or not by flags, field width, or precision) shall not appear in the
+    wide string pointed to by format. Any argument to vswprintf_s corresponding to a
+    %s specifier shall not be a null pointer. No encoding error shall occur.
+3   If there is a runtime-constraint violation, then if s is not a null pointer and n is greater
+    than zero and less than RSIZE_MAX, then the vswprintf_s function sets s[0] to the
+    null wide character.
+
+    <sup><a name="note423" href="#note423"><b>423)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+
+[<a name="p630" href="#p630">page 630</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Description</b>
+4   The vswprintf_s function is equivalent to the vswprintf function except for the
+    explicit runtime-constraints listed above.
+5   The vswprintf_s function, unlike vsnwprintf_s, treats a result too big for the
+    array pointed to by s as a runtime-constraint violation.
+<b>    Returns</b>
+6   If no runtime-constraint violation occurred, the vswprintf_s function returns the
+    number of wide characters written in the array, not counting the terminating null wide
+    character. If an encoding error occurred or if n or more wide characters are requested to
+    be written, vswprintf_s returns a negative value. If any other runtime-constraint
+    violation occurred, vswprintf_s returns zero.
+<a name="K.3.9.1.10" href="#K.3.9.1.10"><b>    K.3.9.1.10 The vswscanf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vswscanf_s(const wchar_t * restrict s,
+                 const wchar_t * restrict format,
+                 va_list arg);
+    Runtime-constraints
+2   Neither s nor format shall be a null pointer. Any argument indirected though in order
+    to store converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vswscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent vswscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vswscanf_s function is equivalent to swscanf_s, with the variable argument
+    list replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vswscanf_s function does not invoke the
+    va_end macro.<sup><a href="#note424"><b>424)</b></a></sup>
+
+
+
+
+    <sup><a name="note424" href="#note424"><b>424)</b></a></sup> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+         value of arg after the return is indeterminate.
+
+[<a name="p631" href="#p631">page 631</a>] (<a href="#Contents">Contents</a>)
+
+<b>    Returns</b>
+5   The vswscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    vswscanf_s function returns the number of input items assigned, which can be fewer
+    than provided for, or even zero, in the event of an early matching failure.
+<a name="K.3.9.1.11" href="#K.3.9.1.11"><b>    K.3.9.1.11 The vwprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vwprintf_s(const wchar_t * restrict format,
+                 va_list arg);
+    Runtime-constraints
+2   format shall not be a null pointer. The %n specifier<sup><a href="#note425"><b>425)</b></a></sup> (modified or not by flags, field
+    width, or precision) shall not appear in the wide string pointed to by format. Any
+    argument to vwprintf_s corresponding to a %s specifier shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vwprintf_s function does not attempt to
+    produce further output, and it is unspecified to what extent vwprintf_s produced
+    output before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vwprintf_s function is equivalent to the vwprintf function except for the
+    explicit runtime-constraints listed above.
+<b>    Returns</b>
+5   The vwprintf_s function returns the number of wide characters transmitted, or a
+    negative value if an output error, encoding error, or runtime-constraint violation occurred.
+
+
+
+
+    <sup><a name="note425" href="#note425"><b>425)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+
+[<a name="p632" href="#p632">page 632</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.9.1.12" href="#K.3.9.1.12"><b>    K.3.9.1.12 The vwscanf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.16">&lt;stdarg.h&gt;</a>
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int vwscanf_s(const wchar_t * restrict format,
+                 va_list arg);
+    Runtime-constraints
+2   format shall not be a null pointer. Any argument indirected though in order to store
+    converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the vwscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent vwscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The vwscanf_s function is equivalent to wscanf_s, with the variable argument list
+    replaced by arg, which shall have been initialized by the va_start macro (and
+    possibly subsequent va_arg calls). The vwscanf_s function does not invoke the
+    va_end macro.<sup><a href="#note426"><b>426)</b></a></sup>
+<b>    Returns</b>
+5   The vwscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    vwscanf_s function returns the number of input items assigned, which can be fewer
+    than provided for, or even zero, in the event of an early matching failure.
+<a name="K.3.9.1.13" href="#K.3.9.1.13"><b>    K.3.9.1.13 The wprintf_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            int wprintf_s(const wchar_t * restrict format, ...);
+    Runtime-constraints
+2   format shall not be a null pointer. The %n specifier<sup><a href="#note427"><b>427)</b></a></sup> (modified or not by flags, field
+
+    <sup><a name="note426" href="#note426"><b>426)</b></a></sup> As the functions vfwscanf_s, vwscanf_s, and vswscanf_s invoke the va_arg macro, the
+         value of arg after the return is indeterminate.
+    <sup><a name="note427" href="#note427"><b>427)</b></a></sup> It is not a runtime-constraint violation for the wide characters %n to appear in sequence in the wide
+         string pointed at by format when those wide characters are not a interpreted as a %n specifier. For
+         example, if the entire format string was L"%%n".
+
+[<a name="p633" href="#p633">page 633</a>] (<a href="#Contents">Contents</a>)
+
+    width, or precision) shall not appear in the wide string pointed to by format. Any
+    argument to wprintf_s corresponding to a %s specifier shall not be a null pointer.
+3   If there is a runtime-constraint violation, the wprintf_s function does not attempt to
+    produce further output, and it is unspecified to what extent wprintf_s produced output
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The wprintf_s function is equivalent to the wprintf function except for the explicit
+    runtime-constraints listed above.
+<b>    Returns</b>
+5   The wprintf_s function returns the number of wide characters transmitted, or a
+    negative value if an output error, encoding error, or runtime-constraint violation occurred.
+<a name="K.3.9.1.14" href="#K.3.9.1.14"><b>    K.3.9.1.14 The wscanf_s function</b></a>
+<b>    Synopsis</b>
+1          #define __STDC_WANT_LIB_EXT1__ 1
+           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           int wscanf_s(const wchar_t * restrict format, ...);
+    Runtime-constraints
+2   format shall not be a null pointer. Any argument indirected though in order to store
+    converted input shall not be a null pointer.
+3   If there is a runtime-constraint violation, the wscanf_s function does not attempt to
+    perform further input, and it is unspecified to what extent wscanf_s performed input
+    before discovering the runtime-constraint violation.
+<b>    Description</b>
+4   The wscanf_s function is equivalent to fwscanf_s with the argument stdin
+    interposed before the arguments to wscanf_s.
+<b>    Returns</b>
+5   The wscanf_s function returns the value of the macro EOF if an input failure occurs
+    before any conversion or if there is a runtime-constraint violation. Otherwise, the
+    wscanf_s function returns the number of input items assigned, which can be fewer than
+    provided for, or even zero, in the event of an early matching failure.
+
+[<a name="p634" href="#p634">page 634</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.9.2" href="#K.3.9.2"><b>    K.3.9.2 General wide string utilities</b></a>
+<a name="K.3.9.2.1" href="#K.3.9.2.1"><b>    K.3.9.2.1 Wide string copying functions</b></a>
+<a name="K.3.9.2.1.1" href="#K.3.9.2.1.1"><b>    K.3.9.2.1.1 The wcscpy_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            errno_t wcscpy_s(wchar_t * restrict s1,
+                 rsize_t s1max,
+                 const wchar_t * restrict s2);
+    Runtime-constraints
+2   Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+    s1max shall not equal zero. s1max shall be greater than wcsnlen_s(s2, s1max).
+    Copying shall not take place between objects that overlap.
+3   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+    greater than zero and not greater than RSIZE_MAX, then wcscpy_s sets s1[0] to the
+    null wide character.
+<b>    Description</b>
+4   The wcscpy_s function copies the wide string pointed to by s2 (including the
+    terminating null wide character) into the array pointed to by s1.
+5   All elements following the terminating null wide character (if any) written by
+    wcscpy_s in the array of s1max wide characters pointed to by s1 take unspecified
+    values when wcscpy_s returns.<sup><a href="#note428"><b>428)</b></a></sup>
+<b>    Returns</b>
+6   The wcscpy_s function returns zero<sup><a href="#note429"><b>429)</b></a></sup> if there was no runtime-constraint violation.
+    Otherwise, a nonzero value is returned.
+
+
+
+
+    <sup><a name="note428" href="#note428"><b>428)</b></a></sup> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
+         if any of those wide characters are null. Such an approach might write a wide character to every
+         element of s1 before discovering that the first element should be set to the null wide character.
+    <sup><a name="note429" href="#note429"><b>429)</b></a></sup> A zero return value implies that all of the requested wide characters from the string pointed to by s2
+         fit within the array pointed to by s1 and that the result in s1 is null terminated.
+
+[<a name="p635" href="#p635">page 635</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.9.2.1.2" href="#K.3.9.2.1.2"><b>     K.3.9.2.1.2 The wcsncpy_s function</b></a>
+<b>     Synopsis</b>
+7            #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             errno_t wcsncpy_s(wchar_t * restrict s1,
+                  rsize_t s1max,
+                  const wchar_t * restrict s2,
+                  rsize_t n);
+     Runtime-constraints
+8    Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+     RSIZE_MAX. s1max shall not equal zero. If n is not less than s1max, then s1max
+     shall be greater than wcsnlen_s(s2, s1max). Copying shall not take place between
+     objects that overlap.
+9    If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+     greater than zero and not greater than RSIZE_MAX, then wcsncpy_s sets s1[0] to the
+     null wide character.
+<b>     Description</b>
+10   The wcsncpy_s function copies not more than n successive wide characters (wide
+     characters that follow a null wide character are not copied) from the array pointed to by
+     s2 to the array pointed to by s1. If no null wide character was copied from s2, then
+     s1[n] is set to a null wide character.
+11   All elements following the terminating null wide character (if any) written by
+     wcsncpy_s in the array of s1max wide characters pointed to by s1 take unspecified
+     values when wcsncpy_s returns.<sup><a href="#note430"><b>430)</b></a></sup>
+<b>     Returns</b>
+12   The wcsncpy_s function returns zero<sup><a href="#note431"><b>431)</b></a></sup> if there was no runtime-constraint violation.
+     Otherwise, a nonzero value is returned.
+13   EXAMPLE 1 The wcsncpy_s function can be used to copy a wide string without the danger that the
+     result will not be null terminated or that wide characters will be written past the end of the destination
+     array.
+
+
+
+
+     <sup><a name="note430" href="#note430"><b>430)</b></a></sup> This allows an implementation to copy wide characters from s2 to s1 while simultaneously checking
+          if any of those wide characters are null. Such an approach might write a wide character to every
+          element of s1 before discovering that the first element should be set to the null wide character.
+     <sup><a name="note431" href="#note431"><b>431)</b></a></sup> A zero return value implies that all of the requested wide characters from the string pointed to by s2
+          fit within the array pointed to by s1 and that the result in s1 is null terminated.
+
+[<a name="p636" href="#p636">page 636</a>] (<a href="#Contents">Contents</a>)
+
+             #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             /* ... */
+             wchar_t src1[100] = L"hello";
+             wchar_t src2[7] = {L'g', L'o', L'o', L'd', L'b', L'y', L'e'};
+             wchar_t dst1[6], dst2[5], dst3[5];
+             int r1, r2, r3;
+             r1 = wcsncpy_s(dst1, 6, src1, 100);
+             r2 = wcsncpy_s(dst2, 5, src2, 7);
+             r3 = wcsncpy_s(dst3, 5, src2, 4);
+     The first call will assign to r1 the value zero and to dst1 the sequence of wide characters hello\0.
+     The second call will assign to r2 a nonzero value and to dst2 the sequence of wide characters \0.
+     The third call will assign to r3 the value zero and to dst3 the sequence of wide characters good\0.
+
+<a name="K.3.9.2.1.3" href="#K.3.9.2.1.3"><b>     K.3.9.2.1.3 The wmemcpy_s function</b></a>
+<b>     Synopsis</b>
+14           #define __STDC_WANT_LIB_EXT1__ 1
+             #include <a href="#7.28">&lt;wchar.h&gt;</a>
+             errno_t wmemcpy_s(wchar_t * restrict s1,
+                  rsize_t s1max,
+                  const wchar_t * restrict s2,
+                  rsize_t n);
+     Runtime-constraints
+15   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+     RSIZE_MAX. n shall not be greater than s1max. Copying shall not take place between
+     objects that overlap.
+16   If there is a runtime-constraint violation, the wmemcpy_s function stores zeros in the
+     first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
+     s1max is not greater than RSIZE_MAX.
+<b>     Description</b>
+17   The wmemcpy_s function copies n successive wide characters from the object pointed
+     to by s2 into the object pointed to by s1.
+<b>     Returns</b>
+18   The wmemcpy_s function returns zero if there was no runtime-constraint violation.
+     Otherwise, a nonzero value is returned.
+
+[<a name="p637" href="#p637">page 637</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.9.2.1.4" href="#K.3.9.2.1.4"><b>     K.3.9.2.1.4 The wmemmove_s function</b></a>
+<b>     Synopsis</b>
+19          #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            errno_t wmemmove_s(wchar_t *s1, rsize_t s1max,
+                 const wchar_t *s2, rsize_t n);
+     Runtime-constraints
+20   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+     RSIZE_MAX. n shall not be greater than s1max.
+21   If there is a runtime-constraint violation, the wmemmove_s function stores zeros in the
+     first s1max wide characters of the object pointed to by s1 if s1 is not a null pointer and
+     s1max is not greater than RSIZE_MAX.
+<b>     Description</b>
+22   The wmemmove_s function copies n successive wide characters from the object pointed
+     to by s2 into the object pointed to by s1. This copying takes place as if the n wide
+     characters from the object pointed to by s2 are first copied into a temporary array of n
+     wide characters that does not overlap the objects pointed to by s1 or s2, and then the n
+     wide characters from the temporary array are copied into the object pointed to by s1.
+<b>     Returns</b>
+23   The wmemmove_s function returns zero if there was no runtime-constraint violation.
+     Otherwise, a nonzero value is returned.
+<a name="K.3.9.2.2" href="#K.3.9.2.2"><b>     K.3.9.2.2 Wide string concatenation functions</b></a>
+<a name="K.3.9.2.2.1" href="#K.3.9.2.2.1"><b>     K.3.9.2.2.1 The wcscat_s function</b></a>
+<b>     Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            errno_t wcscat_s(wchar_t * restrict s1,
+                 rsize_t s1max,
+                 const wchar_t * restrict s2);
+     Runtime-constraints
+2    Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
+     wcscat_s.
+3    Neither s1 nor s2 shall be a null pointer. s1max shall not be greater than RSIZE_MAX.
+     s1max shall not equal zero. m shall not equal zero.<sup><a href="#note432"><b>432)</b></a></sup> m shall be greater than
+     wcsnlen_s(s2, m). Copying shall not take place between objects that overlap.
+
+[<a name="p638" href="#p638">page 638</a>] (<a href="#Contents">Contents</a>)
+
+4    If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+     greater than zero and not greater than RSIZE_MAX, then wcscat_s sets s1[0] to the
+     null wide character.
+<b>     Description</b>
+5    The wcscat_s function appends a copy of the wide string pointed to by s2 (including
+     the terminating null wide character) to the end of the wide string pointed to by s1. The
+     initial wide character from s2 overwrites the null wide character at the end of s1.
+6    All elements following the terminating null wide character (if any) written by
+     wcscat_s in the array of s1max wide characters pointed to by s1 take unspecified
+     values when wcscat_s returns.<sup><a href="#note433"><b>433)</b></a></sup>
+<b>     Returns</b>
+7    The wcscat_s function returns zero<sup><a href="#note434"><b>434)</b></a></sup> if there was no runtime-constraint violation.
+     Otherwise, a nonzero value is returned.
+<a name="K.3.9.2.2.2" href="#K.3.9.2.2.2"><b>     K.3.9.2.2.2 The wcsncat_s function</b></a>
+<b>     Synopsis</b>
+8             #define __STDC_WANT_LIB_EXT1__ 1
+              #include <a href="#7.28">&lt;wchar.h&gt;</a>
+              errno_t wcsncat_s(wchar_t * restrict s1,
+                   rsize_t s1max,
+                   const wchar_t * restrict s2,
+                   rsize_t n);
+     Runtime-constraints
+9    Let m denote the value s1max - wcsnlen_s(s1, s1max) upon entry to
+     wcsncat_s.
+10   Neither s1 nor s2 shall be a null pointer. Neither s1max nor n shall be greater than
+     RSIZE_MAX. s1max shall not equal zero. m shall not equal zero.<sup><a href="#note435"><b>435)</b></a></sup> If n is not less
+     than m, then m shall be greater than wcsnlen_s(s2, m). Copying shall not take
+     place between objects that overlap.
+
+
+     <sup><a name="note432" href="#note432"><b>432)</b></a></sup> Zero means that s1 was not null terminated upon entry to wcscat_s.
+     <sup><a name="note433" href="#note433"><b>433)</b></a></sup> This allows an implementation to append wide characters from s2 to s1 while simultaneously
+          checking if any of those wide characters are null. Such an approach might write a wide character to
+          every element of s1 before discovering that the first element should be set to the null wide character.
+     <sup><a name="note434" href="#note434"><b>434)</b></a></sup> A zero return value implies that all of the requested wide characters from the wide string pointed to by
+          s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
+     <sup><a name="note435" href="#note435"><b>435)</b></a></sup> Zero means that s1 was not null terminated upon entry to wcsncat_s.
+
+[<a name="p639" href="#p639">page 639</a>] (<a href="#Contents">Contents</a>)
+
+11   If there is a runtime-constraint violation, then if s1 is not a null pointer and s1max is
+     greater than zero and not greater than RSIZE_MAX, then wcsncat_s sets s1[0] to the
+     null wide character.
+<b>     Description</b>
+12   The wcsncat_s function appends not more than n successive wide characters (wide
+     characters that follow a null wide character are not copied) from the array pointed to by
+     s2 to the end of the wide string pointed to by s1. The initial wide character from s2
+     overwrites the null wide character at the end of s1. If no null wide character was copied
+     from s2, then s1[s1max-m+n] is set to a null wide character.
+13   All elements following the terminating null wide character (if any) written by
+     wcsncat_s in the array of s1max wide characters pointed to by s1 take unspecified
+     values when wcsncat_s returns.<sup><a href="#note436"><b>436)</b></a></sup>
+<b>     Returns</b>
+14   The wcsncat_s function returns zero<sup><a href="#note437"><b>437)</b></a></sup> if there was no runtime-constraint violation.
+     Otherwise, a nonzero value is returned.
+15   EXAMPLE 1 The wcsncat_s function can be used to copy a wide string without the danger that the
+     result will not be null terminated or that wide characters will be written past the end of the destination
+     array.
+              #define __STDC_WANT_LIB_EXT1__ 1
+              #include <a href="#7.28">&lt;wchar.h&gt;</a>
+              /* ... */
+              wchar_t s1[100] = L"good";
+              wchar_t s2[6] = L"hello";
+              wchar_t s3[6] = L"hello";
+              wchar_t s4[7] = L"abc";
+              wchar_t s5[1000] = L"bye";
+              int r1, r2, r3, r4;
+              r1 = wcsncat_s(s1, 100, s5, 1000);
+              r2 = wcsncat_s(s2, 6, L"", 1);
+              r3 = wcsncat_s(s3, 6, L"X", 2);
+              r4 = wcsncat_s(s4, 7, L"defghijklmn", 3);
+     After the first call r1 will have the value zero and s1 will be the wide character sequence goodbye\0.
+     After the second call r2 will have the value zero and s2 will be the wide character sequence hello\0.
+     After the third call r3 will have a nonzero value and s3 will be the wide character sequence \0.
+     After the fourth call r4 will have the value zero and s4 will be the wide character sequence abcdef\0.
+
+
+
+
+     <sup><a name="note436" href="#note436"><b>436)</b></a></sup> This allows an implementation to append wide characters from s2 to s1 while simultaneously
+          checking if any of those wide characters are null. Such an approach might write a wide character to
+          every element of s1 before discovering that the first element should be set to the null wide character.
+     <sup><a name="note437" href="#note437"><b>437)</b></a></sup> A zero return value implies that all of the requested wide characters from the wide string pointed to by
+          s2 were appended to the wide string pointed to by s1 and that the result in s1 is null terminated.
+
+[<a name="p640" href="#p640">page 640</a>] (<a href="#Contents">Contents</a>)
+
+<a name="K.3.9.2.3" href="#K.3.9.2.3"><b>    K.3.9.2.3 Wide string search functions</b></a>
+<a name="K.3.9.2.3.1" href="#K.3.9.2.3.1"><b>    K.3.9.2.3.1 The wcstok_s function</b></a>
+<b>    Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            wchar_t *wcstok_s(wchar_t * restrict s1,
+                 rsize_t * restrict s1max,
+                 const wchar_t * restrict s2,
+                 wchar_t ** restrict ptr);
+    Runtime-constraints
+2   None of s1max, s2, or ptr shall be a null pointer. If s1 is a null pointer, then *ptr
+    shall not be a null pointer. The value of *s1max shall not be greater than RSIZE_MAX.
+    The end of the token found shall occur within the first *s1max wide characters of s1 for
+    the first call, and shall occur within the first *s1max wide characters of where searching
+    resumes on subsequent calls.
+3   If there is a runtime-constraint violation, the wcstok_s function does not indirect
+    through the s1 or s2 pointers, and does not store a value in the object pointed to by ptr.
+<b>    Description</b>
+4   A sequence of calls to the wcstok_s function breaks the wide string pointed to by s1
+    into a sequence of tokens, each of which is delimited by a wide character from the wide
+    string pointed to by s2. The fourth argument points to a caller-provided wchar_t
+    pointer into which the wcstok_s function stores information necessary for it to
+    continue scanning the same wide string.
+5   The first call in a sequence has a non-null first argument and s1max points to an object
+    whose value is the number of elements in the wide character array pointed to by the first
+    argument. The first call stores an initial value in the object pointed to by ptr and
+    updates the value pointed to by s1max to reflect the number of elements that remain in
+    relation to ptr. Subsequent calls in the sequence have a null first argument and the
+    objects pointed to by s1max and ptr are required to have the values stored by the
+    previous call in the sequence, which are then updated. The separator wide string pointed
+    to by s2 may be different from call to call.
+6   The first call in the sequence searches the wide string pointed to by s1 for the first wide
+    character that is not contained in the current separator wide string pointed to by s2. If no
+    such wide character is found, then there are no tokens in the wide string pointed to by s1
+    and the wcstok_s function returns a null pointer. If such a wide character is found, it is
+    the start of the first token.
+
+[<a name="p641" href="#p641">page 641</a>] (<a href="#Contents">Contents</a>)
+
+7    The wcstok_s function then searches from there for the first wide character in s1 that
+     is contained in the current separator wide string. If no such wide character is found, the
+     current token extends to the end of the wide string pointed to by s1, and subsequent
+     searches in the same wide string for a token return a null pointer. If such a wide character
+     is found, it is overwritten by a null wide character, which terminates the current token.
+8    In all cases, the wcstok_s function stores sufficient information in the pointer pointed
+     to by ptr so that subsequent calls, with a null pointer for s1 and the unmodified pointer
+     value for ptr, shall start searching just past the element overwritten by a null wide
+     character (if any).
+<b>     Returns</b>
+9    The wcstok_s function returns a pointer to the first wide character of a token, or a null
+     pointer if there is no token or there is a runtime-constraint violation.
+10   EXAMPLE
+            #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            static wchar_t str1[] = L"?a???b,,,#c";
+            static wchar_t str2[] = L"\t \t";
+            wchar_t *t, *ptr1, *ptr2;
+            rsize_t max1 = wcslen(str1)+1;
+            rsize_t max2 = wcslen(str2)+1;
+            t   =   wcstok_s(str1,   &amp;max1,   "?", &amp;ptr1);        //   t   points to the token "a"
+            t   =   wcstok_s(NULL,   &amp;max1,   ",", &amp;ptr1);        //   t   points to the token "??b"
+            t   =   wcstok_s(str2,   &amp;max2,   " \t", &amp;ptr2);      //   t   is a null pointer
+            t   =   wcstok_s(NULL,   &amp;max1,   "#,", &amp;ptr1);       //   t   points to the token "c"
+            t   =   wcstok_s(NULL,   &amp;max1,   "?", &amp;ptr1);        //   t   is a null pointer
+
+<a name="K.3.9.2.4" href="#K.3.9.2.4"><b>     K.3.9.2.4 Miscellaneous functions</b></a>
+<a name="K.3.9.2.4.1" href="#K.3.9.2.4.1"><b>     K.3.9.2.4.1 The wcsnlen_s function</b></a>
+<b>     Synopsis</b>
+1           #define __STDC_WANT_LIB_EXT1__ 1
+            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            size_t wcsnlen_s(const wchar_t *s, size_t maxsize);
+<b>     Description</b>
+2    The wcsnlen_s function computes the length of the wide string pointed to by s.
+<b>     Returns</b>
+3    If s is a null pointer,<sup><a href="#note438"><b>438)</b></a></sup> then the wcsnlen_s function returns zero.
+4    Otherwise, the wcsnlen_s function returns the number of wide characters that precede
+     the terminating null wide character. If there is no null wide character in the first
+     maxsize wide characters of s then wcsnlen_s returns maxsize. At most the first
+
+[<a name="p642" href="#p642">page 642</a>] (<a href="#Contents">Contents</a>)
+
+    maxsize wide characters of s shall be accessed by wcsnlen_s.
+<a name="K.3.9.3" href="#K.3.9.3"><b>    K.3.9.3 Extended multibyte/wide character conversion utilities</b></a>
+<a name="K.3.9.3.1" href="#K.3.9.3.1"><b>    K.3.9.3.1 Restartable multibyte/wide character conversion functions</b></a>
+1   Unlike wcrtomb, wcrtomb_s does not permit the ps parameter (the pointer to the
+    conversion state) to be a null pointer.
+<a name="K.3.9.3.1.1" href="#K.3.9.3.1.1"><b>    K.3.9.3.1.1 The wcrtomb_s function</b></a>
+<b>    Synopsis</b>
+2           #include <a href="#7.28">&lt;wchar.h&gt;</a>
+            errno_t wcrtomb_s(size_t * restrict retval,
+                 char * restrict s, rsize_t smax,
+                 wchar_t wc, mbstate_t * restrict ps);
+    Runtime-constraints
+3   Neither retval nor ps shall be a null pointer. If s is not a null pointer, then smax
+    shall not equal zero and shall not be greater than RSIZE_MAX. If s is not a null pointer,
+    then smax shall be not be less than the number of bytes to be stored in the array pointed
+    to by s. If s is a null pointer, then smax shall equal zero.
+4   If there is a runtime-constraint violation, then wcrtomb_s does the following. If s is
+    not a null pointer and smax is greater than zero and not greater than RSIZE_MAX, then
+    wcrtomb_s sets s[0] to the null character. If retval is not a null pointer, then
+    wcrtomb_s sets *retval to (size_t)(-1).
+<b>    Description</b>
+5   If s is a null pointer, the wcrtomb_s function is equivalent to the call
+                    wcrtomb_s(&amp;retval, buf, sizeof buf, L'\0', ps)
+    where retval and buf are internal variables of the appropriate types, and the size of
+    buf is greater than MB_CUR_MAX.
+6   If s is not a null pointer, the wcrtomb_s function determines the number of bytes
+    needed to represent the multibyte character that corresponds to the wide character given
+    by wc (including any shift sequences), and stores the multibyte character representation
+    in the array whose first element is pointed to by s. At most MB_CUR_MAX bytes are
+    stored. If wc is a null wide character, a null byte is stored, preceded by any shift
+    sequence needed to restore the initial shift state; the resulting state described is the initial
+    conversion state.
+
+    <sup><a name="note438" href="#note438"><b>438)</b></a></sup> Note that the wcsnlen_s function has no runtime-constraints. This lack of runtime-constraints
+         along with the values returned for a null pointer or an unterminated wide string argument make
+         wcsnlen_s useful in algorithms that gracefully handle such exceptional data.
+
+[<a name="p643" href="#p643">page 643</a>] (<a href="#Contents">Contents</a>)
+
+7   If wc does not correspond to a valid multibyte character, an encoding error occurs: the
+    wcrtomb_s function stores the value (size_t)(-1) into *retval and the
+    conversion state is unspecified. Otherwise, the wcrtomb_s function stores into
+    *retval the number of bytes (including any shift sequences) stored in the array pointed
+    to by s.
+<b>    Returns</b>
+8   The wcrtomb_s function returns zero if no runtime-constraint violation and no
+    encoding error occurred. Otherwise, a nonzero value is returned.
+<a name="K.3.9.3.2" href="#K.3.9.3.2"><b>    K.3.9.3.2 Restartable multibyte/wide string conversion functions</b></a>
+1   Unlike mbsrtowcs and wcsrtombs, mbsrtowcs_s and wcsrtombs_s do not
+    permit the ps parameter (the pointer to the conversion state) to be a null pointer.
+<a name="K.3.9.3.2.1" href="#K.3.9.3.2.1"><b>    K.3.9.3.2.1 The mbsrtowcs_s function</b></a>
+<b>    Synopsis</b>
+2          #include <a href="#7.28">&lt;wchar.h&gt;</a>
+           errno_t mbsrtowcs_s(size_t * restrict retval,
+                wchar_t * restrict dst, rsize_t dstmax,
+                const char ** restrict src, rsize_t len,
+                mbstate_t * restrict ps);
+    Runtime-constraints
+3   None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
+    then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
+    pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
+    not equal zero. If dst is not a null pointer and len is not less than dstmax, then a null
+    character shall occur within the first dstmax multibyte characters of the array pointed to
+    by *src.
+4   If there is a runtime-constraint violation, then mbsrtowcs_s does the following. If
+    retval is not a null pointer, then mbsrtowcs_s sets *retval to (size_t)(-1).
+    If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+    then mbsrtowcs_s sets dst[0] to the null wide character.
+<b>    Description</b>
+5   The mbsrtowcs_s function converts a sequence of multibyte characters that begins in
+    the conversion state described by the object pointed to by ps, from the array indirectly
+    pointed to by src into a sequence of corresponding wide characters. If dst is not a null
+    pointer, the converted characters are stored into the array pointed to by dst. Conversion
+    continues up to and including a terminating null character, which is also stored.
+    Conversion stops earlier in two cases: when a sequence of bytes is encountered that does
+    not form a valid multibyte character, or (if dst is not a null pointer) when len wide
+
+[<a name="p644" href="#p644">page 644</a>] (<a href="#Contents">Contents</a>)
+
+     characters have been stored into the array pointed to by dst.<sup><a href="#note439"><b>439)</b></a></sup> If dst is not a null
+     pointer and no null wide character was stored into the array pointed to by dst, then
+     dst[len] is set to the null wide character. Each conversion takes place as if by a call
+     to the mbrtowc function.
+6    If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+     pointer (if conversion stopped due to reaching a terminating null character) or the address
+     just past the last multibyte character converted (if any). If conversion stopped due to
+     reaching a terminating null character and if dst is not a null pointer, the resulting state
+     described is the initial conversion state.
+7    Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+     sequence of bytes that do not form a valid multibyte character, an encoding error occurs:
+     the mbsrtowcs_s function stores the value (size_t)(-1) into *retval and the
+     conversion state is unspecified. Otherwise, the mbsrtowcs_s function stores into
+     *retval the number of multibyte characters successfully converted, not including the
+     terminating null character (if any).
+8    All elements following the terminating null wide character (if any) written by
+     mbsrtowcs_s in the array of dstmax wide characters pointed to by dst take
+     unspecified values when mbsrtowcs_s returns.<sup><a href="#note440"><b>440)</b></a></sup>
+9    If copying takes place between objects that overlap, the objects take on unspecified
+     values.
+<b>     Returns</b>
+10   The mbsrtowcs_s function returns zero if no runtime-constraint violation and no
+     encoding error occurred. Otherwise, a nonzero value is returned.
+<a name="K.3.9.3.2.2" href="#K.3.9.3.2.2"><b>     K.3.9.3.2.2 The wcsrtombs_s function</b></a>
+<b>     Synopsis</b>
+11            #include <a href="#7.28">&lt;wchar.h&gt;</a>
+              errno_t wcsrtombs_s(size_t * restrict retval,
+                   char * restrict dst, rsize_t dstmax,
+                   const wchar_t ** restrict src, rsize_t len,
+                   mbstate_t * restrict ps);
+
+
+
+
+     <sup><a name="note439" href="#note439"><b>439)</b></a></sup> Thus, the value of len is ignored if dst is a null pointer.
+     <sup><a name="note440" href="#note440"><b>440)</b></a></sup> This allows an implementation to attempt converting the multibyte string before discovering a
+          terminating null character did not occur where required.
+
+[<a name="p645" href="#p645">page 645</a>] (<a href="#Contents">Contents</a>)
+
+     Runtime-constraints
+12   None of retval, src, *src, or ps shall be null pointers. If dst is not a null pointer,
+     then neither len nor dstmax shall be greater than RSIZE_MAX. If dst is a null
+     pointer, then dstmax shall equal zero. If dst is not a null pointer, then dstmax shall
+     not equal zero. If dst is not a null pointer and len is not less than dstmax, then the
+     conversion shall have been stopped (see below) because a terminating null wide character
+     was reached or because an encoding error occurred.
+13   If there is a runtime-constraint violation, then wcsrtombs_s does the following. If
+     retval is not a null pointer, then wcsrtombs_s sets *retval to (size_t)(-1).
+     If dst is not a null pointer and dstmax is greater than zero and less than RSIZE_MAX,
+     then wcsrtombs_s sets dst[0] to the null character.
+<b>     Description</b>
+14   The wcsrtombs_s function converts a sequence of wide characters from the array
+     indirectly pointed to by src into a sequence of corresponding multibyte characters that
+     begins in the conversion state described by the object pointed to by ps. If dst is not a
+     null pointer, the converted characters are then stored into the array pointed to by dst.
+     Conversion continues up to and including a terminating null wide character, which is also
+     stored. Conversion stops earlier in two cases:
+     -- when a wide character is reached that does not correspond to a valid multibyte
+       character;
+     -- (if dst is not a null pointer) when the next multibyte character would exceed the
+         limit of n total bytes to be stored into the array pointed to by dst. If the wide
+         character being converted is the null wide character, then n is the lesser of len or
+         dstmax. Otherwise, n is the lesser of len or dstmax-1.
+     If the conversion stops without converting a null wide character and dst is not a null
+     pointer, then a null character is stored into the array pointed to by dst immediately
+     following any multibyte characters already stored. Each conversion takes place as if by a
+     call to the wcrtomb function.<sup><a href="#note441"><b>441)</b></a></sup>
+15   If dst is not a null pointer, the pointer object pointed to by src is assigned either a null
+     pointer (if conversion stopped due to reaching a terminating null wide character) or the
+     address just past the last wide character converted (if any). If conversion stopped due to
+     reaching a terminating null wide character, the resulting state described is the initial
+     conversion state.
+
+
+     <sup><a name="note441" href="#note441"><b>441)</b></a></sup> If conversion stops because a terminating null wide character has been reached, the bytes stored
+          include those necessary to reach the initial shift state immediately before the null byte. However, if
+          the conversion stops before a terminating null wide character has been reached, the result will be null
+          terminated, but might not end in the initial shift state.
+
+[<a name="p646" href="#p646">page 646</a>] (<a href="#Contents">Contents</a>)
+
+16   Regardless of whether dst is or is not a null pointer, if the input conversion encounters a
+     wide character that does not correspond to a valid multibyte character, an encoding error
+     occurs: the wcsrtombs_s function stores the value (size_t)(-1) into *retval
+     and the conversion state is unspecified. Otherwise, the wcsrtombs_s function stores
+     into *retval the number of bytes in the resulting multibyte character sequence, not
+     including the terminating null character (if any).
+17   All elements following the terminating null character (if any) written by wcsrtombs_s
+     in the array of dstmax elements pointed to by dst take unspecified values when
+     wcsrtombs_s returns.<sup><a href="#note442"><b>442)</b></a></sup>
+18   If copying takes place between objects that overlap, the objects take on unspecified
+     values.
+<b>     Returns</b>
+19   The wcsrtombs_s function returns zero if no runtime-constraint violation and no
+     encoding error occurred. Otherwise, a nonzero value is returned.
+
+
+
+
+     <sup><a name="note442" href="#note442"><b>442)</b></a></sup> When len is not less than dstmax, the implementation might fill the array before discovering a
+          runtime-constraint violation.
+
+[<a name="p647" href="#p647">page 647</a>] (<a href="#Contents">Contents</a>)
+
+<a name="L" href="#L"><b>                                                Annex L</b></a>
+                                               (normative)
+                                            Analyzability
+<a name="L.1" href="#L.1"><b>    L.1 Scope</b></a>
+1   This annex specifies optional behavior that can aid in the analyzability of C programs.
+2   An implementation that defines __STDC_ANALYZABLE__ shall conform to the
+    specifications in this annex.<sup><a href="#note443"><b>443)</b></a></sup>
+<a name="L.2" href="#L.2"><b>    L.2 Definitions</b></a>
+<a name="L.2.1" href="#L.2.1"><b>    L.2.1</b></a>
+1   out-of-bounds store
+    an (attempted) access (<a href="#3.1">3.1</a>) that, at run time, for a given computational state, would
+    modify (or, for an object declared volatile, fetch) one or more bytes that lie outside
+    the bounds permitted by this Standard.
+<a name="L.2.2" href="#L.2.2"><b>    L.2.2</b></a>
+1   bounded undefined behavior
+    undefined behavior (<a href="#3.4.3">3.4.3</a>) that does not perform an out-of-bounds store.
+2   NOTE 1    The behavior might perform a trap.
+
+3   NOTE 2    Any values produced or stored might be indeterminate values.
+
+<a name="L.2.3" href="#L.2.3"><b>    L.2.3</b></a>
+1   critical undefined behavior
+    undefined behavior that is not bounded undefined behavior.
+2   NOTE     The behavior might perform an out-of-bounds store or perform a trap.
+
+
+
+
+    <sup><a name="note443" href="#note443"><b>443)</b></a></sup> Implementations that do not define __STDC_ANALYZABLE__ are not required to conform to these
+         specifications.
+
+[<a name="p648" href="#p648">page 648</a>] (<a href="#Contents">Contents</a>)
+
+<a name="L.3" href="#L.3"><b>    L.3 Requirements</b></a>
+1   If the program performs a trap (<a href="#3.19.5">3.19.5</a>), the implementation is permitted to invoke a
+    runtime-constraint handler. Any such semantics are implementation-defined.
+2   All undefined behavior shall be limited to bounded undefined behavior, except for the
+    following which are permitted to result in critical undefined behavior:
+    -- An object is referred to outside of its lifetime (<a href="#6.2.4">6.2.4</a>).
+    -- An lvalue does not designate an object when evaluated (<a href="#6.3.2.1">6.3.2.1</a>).
+    -- A pointer is used to call a function whose type is not compatible with the referenced
+      type (<a href="#6.3.2.3">6.3.2.3</a>).
+    -- The operand of the unary * operator has an invalid value (<a href="#6.5.3.2">6.5.3.2</a>).
+    -- Addition or subtraction of a pointer into, or just beyond, an array object and an
+      integer type produces a result that points just beyond the array object and is used as
+      the operand of a unary * operator that is evaluated (<a href="#6.5.6">6.5.6</a>).
+    -- An argument to a library function has an invalid value or a type not expected by a
+      function with variable number of arguments (<a href="#7.1.4">7.1.4</a>).
+    -- The value of a pointer that refers to space deallocated by a call to the free or realloc
+      function is used (<a href="#7.22.3">7.22.3</a>).
+    -- A string or wide string utility function is instructed to access an array beyond the end
+      of an object (<a href="#7.23.1">7.23.1</a>, <a href="#7.28.4">7.28.4</a>).
+
+[<a name="p649" href="#p649">page 649</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="Bibliography" href="#Bibliography"><b>                                  Bibliography</b></a>
+  1.   ''The C Reference Manual'' by Dennis M. Ritchie, a version of which was
+       published in The C Programming Language by Brian W. Kernighan and Dennis
+       M. Ritchie, Prentice-Hall, Inc., (1978). Copyright owned by AT&amp;T.
+  2.   1984 /usr/group Standard by the /usr/group Standards Committee, Santa Clara,
+       California, USA, November 1984.
+  3.   ANSI X3/TR-1-82 (1982), American National Dictionary for Information
+       Processing Systems, Information Processing Systems Technical Report.
+  4.   ANSI/IEEE 754-1985, American National Standard for Binary Floating-Point
+       Arithmetic.
+  5.   ANSI/IEEE 854-1988, American National Standard for Radix-Independent
+       Floating-Point Arithmetic.
+  6.   IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems,
+       second edition (previously designated IEC 559:1989).
+  7.   ISO 31-11:1992, Quantities and units -- Part 11: Mathematical signs and
+       symbols for use in the physical sciences and technology.
+  8.   ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character set for
+       information interchange.
+  9.   ISO/IEC 2382-1:1993, Information technology -- Vocabulary -- Part 1:
+       Fundamental terms.
+ 10.   ISO 4217:1995, Codes for the representation of currencies and funds.
+ 11.   ISO 8601:1988, Data elements and interchange formats -- Information
+       interchange -- Representation of dates and times.
+ 12.   ISO/IEC 9899:1990, Programming languages -- C.
+ 13.   ISO/IEC 9899/COR1:1994, Technical Corrigendum 1.
+ 14.   ISO/IEC 9899/COR2:1996, Technical Corrigendum 2.
+ 15.   ISO/IEC 9899/AMD1:1995, Amendment 1 to ISO/IEC 9899:1990 C Integrity.
+ 16.   ISO/IEC 9899:1999, Programming languages -- C.
+ 17.   ISO/IEC 9899:1999/Cor.1:2001, Technical Corrigendum 1.
+ 18.   ISO/IEC 9899:1999/Cor.2:2004, Technical Corrigendum 2.
+ 19.   ISO/IEC 9899:1999/Cor.3:2007, Technical Corrigendum 3.
+
+[<a name="p650" href="#p650">page 650</a>] (<a href="#Contents">Contents</a>)
+
+ 20.    ISO/IEC 9945-2:1993, Information technology -- Portable Operating System
+        Interface (POSIX) -- Part 2: Shell and Utilities.
+ 21.    ISO/IEC TR 10176:1998, Information technology -- Guidelines for the
+        preparation of programming language standards.
+ 22.    ISO/IEC 10646-1:1993, Information technology -- Universal Multiple-Octet
+        Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane.
+ 23.    ISO/IEC 10646-1/COR1:1996,         Technical       Corrigendum       1      to
+        ISO/IEC 10646-1:1993.
+ 24.    ISO/IEC 10646-1/COR2:1998,         Technical       Corrigendum       2      to
+        ISO/IEC 10646-1:1993.
+ 25.    ISO/IEC 10646-1/AMD1:1996, Amendment 1 to ISO/IEC 10646-1:1993
+        Transformation Format for 16 planes of group 00 (UTF-16).
+ 26.    ISO/IEC 10646-1/AMD2:1996, Amendment 2 to ISO/IEC 10646-1:1993 UCS
+        Transformation Format 8 (UTF-8).
+ 27.    ISO/IEC 10646-1/AMD3:1996, Amendment 3 to ISO/IEC 10646-1:1993.
+ 28.    ISO/IEC 10646-1/AMD4:1996, Amendment 4 to ISO/IEC 10646-1:1993.
+ 29.    ISO/IEC 10646-1/AMD5:1998, Amendment 5 to ISO/IEC 10646-1:1993 Hangul
+        syllables.
+ 30.    ISO/IEC 10646-1/AMD6:1997,       Amendment     6   to   ISO/IEC 10646-1:1993
+        Tibetan.
+ 31.    ISO/IEC 10646-1/AMD7:1997, Amendment 7 to ISO/IEC 10646-1:1993 33
+        additional characters.
+ 32.    ISO/IEC 10646-1/AMD8:1997, Amendment 8 to ISO/IEC 10646-1:1993.
+ 33.    ISO/IEC 10646-1/AMD9:1997,       Amendment     9   to   ISO/IEC 10646-1:1993
+        Identifiers for characters.
+ 34.    ISO/IEC 10646-1/AMD10:1998, Amendment 10 to ISO/IEC 10646-1:1993
+        Ethiopic.
+ 35.    ISO/IEC 10646-1/AMD11:1998, Amendment 11 to ISO/IEC 10646-1:1993
+        Unified Canadian Aboriginal Syllabics.
+ 36.    ISO/IEC 10646-1/AMD12:1998, Amendment 12 to ISO/IEC 10646-1:1993
+        Cherokee.
+ 37.    ISO/IEC 10967-1:1994, Information technology -- Language independent
+        arithmetic -- Part 1: Integer and floating point arithmetic.
+
+[<a name="p651" href="#p651">page 651</a>] (<a href="#Contents">Contents</a>)
+
+ 38.   ISO/IEC TR 19769:2004, Information technology -- Programming languages,
+       their environments and system software interfaces -- Extensions for the
+       programming language C to support new character data types.
+ 39.   ISO/IEC TR 24731-1:2007, Information technology -- Programming languages,
+       their environments and system software interfaces -- Extensions to the C library
+       -- Part 1: Bounds-checking interfaces.
+
+[<a name="p652" href="#p652">page 652</a>] (<a href="#Contents">Contents</a>)
+
+
+<a name="Index" href="#Index"><b>Index</b></a>
+[^ x ^], <a href="#3.20">3.20</a>                                                    , (comma operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a>
+                                                               , (comma punctuator), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,
+[_ x _], <a href="#3.21">3.21</a>                                                         <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>
+! (logical negation operator), <a href="#6.5.3.3">6.5.3.3</a>                         - (subtraction operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
+!= (inequality operator), <a href="#6.5.9">6.5.9</a>                                - (unary minus operator), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>
+# operator, <a href="#6.10.3.2">6.10.3.2</a>                                           -- (postfix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>
+# preprocessing directive, <a href="#6.10.7">6.10.7</a>                              -- (prefix decrement operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
+# punctuator, <a href="#6.10">6.10</a>                                             -= (subtraction assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+## operator, <a href="#6.10.3.3">6.10.3.3</a>                                          -&gt; (structure/union pointer operator), <a href="#6.5.2.3">6.5.2.3</a>
+#define preprocessing directive, <a href="#6.10.3">6.10.3</a>                        . (structure/union member operator), <a href="#6.3.2.1">6.3.2.1</a>,
+#elif preprocessing directive, <a href="#6.10.1">6.10.1</a>                               <a href="#6.5.2.3">6.5.2.3</a>
+#else preprocessing directive, <a href="#6.10.1">6.10.1</a>                          . punctuator, <a href="#6.7.9">6.7.9</a>
+#endif preprocessing directive, <a href="#6.10.1">6.10.1</a>                         ... (ellipsis punctuator), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
+#error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                      / (division operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>
+#if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,             /* */ (comment delimiters), <a href="#6.4.9">6.4.9</a>
+     <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>                                             // (comment delimiter), <a href="#6.4.9">6.4.9</a>
+#ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>                         /= (division assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+#ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>                        : (colon punctuator), <a href="#6.7.2.1">6.7.2.1</a>
+#include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>,                     :&gt; (alternative spelling of ]), <a href="#6.4.6">6.4.6</a>
+     <a href="#6.10.2">6.10.2</a>                                                    ; (semicolon punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,
+#line preprocessing directive, <a href="#6.10.4">6.10.4</a>                               <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>
+#pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>                        &lt; (less-than operator), <a href="#6.5.8">6.5.8</a>
+#undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,               &lt;% (alternative spelling of {), <a href="#6.4.6">6.4.6</a>
+     <a href="#7.1.4">7.1.4</a>                                                     &lt;: (alternative spelling of [), <a href="#6.4.6">6.4.6</a>
+% (remainder operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>                         &lt;&lt; (left-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+%: (alternative spelling of #), <a href="#6.4.6">6.4.6</a>                          &lt;&lt;= (left-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+%:%: (alternative spelling of ##), <a href="#6.4.6">6.4.6</a>                       &lt;= (less-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>
+%= (remainder assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                   <a href="#7.2">&lt;assert.h&gt;</a> header, <a href="#7.2">7.2</a>
+%&gt; (alternative spelling of }), <a href="#6.4.6">6.4.6</a>                          <a href="#7.3">&lt;complex.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,
+&amp; (address operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                              <a href="#7.3">7.3</a>, <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>
+&amp; (bitwise AND operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>                      <a href="#7.4">&lt;ctype.h&gt;</a> header, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>
+&amp;&amp; (logical AND operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>                     <a href="#7.5">&lt;errno.h&gt;</a> header, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>
+&amp;= (bitwise AND assignment operator), <a href="#6.5.16.2">6.5.16.2</a>                 <a href="#7.6">&lt;fenv.h&gt;</a> header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>,
+' ' (space character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,                <a href="#H">H</a>
+     <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>                                      <a href="#7.7">&lt;float.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
+( ) (cast operator), <a href="#6.5.4">6.5.4</a>                                          <a href="#7.28.4.1.1">7.28.4.1.1</a>
+( ) (function-call operator), <a href="#6.5.2.2">6.5.2.2</a>                          <a href="#7.8">&lt;inttypes.h&gt;</a> header, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>
+( ) (parentheses punctuator), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>            <a href="#7.9">&lt;iso646.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.9">7.9</a>
+( ){ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                    <a href="#7.10">&lt;limits.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>
+* (asterisk punctuator), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a>                      <a href="#7.11">&lt;locale.h&gt;</a> header, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>
+* (indirection operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                     <a href="#7.12">&lt;math.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>,
+* (multiplication operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>,                   <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a>
+     <a href="#G.5.1">G.5.1</a>                                                     <a href="#7.13">&lt;setjmp.h&gt;</a> header, <a href="#7.13">7.13</a>
+*= (multiplication assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              <a href="#7.14">&lt;signal.h&gt;</a> header, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>
++ (addition operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>,              <a href="#7.15">&lt;stdalign.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
+     <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                                         <a href="#7.16">&lt;stdarg.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
++ (unary plus operator), <a href="#6.5.3.3">6.5.3.3</a>                               <a href="#7.17">&lt;stdatomic.h&gt;</a> header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>
+++ (postfix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>               <a href="#7.18">&lt;stdbool.h&gt;</a> header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>
+++ (prefix increment operator), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>                <a href="#7.19">&lt;stddef.h&gt;</a> header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
++= (addition assignment operator), <a href="#6.5.16.2">6.5.16.2</a>
+
+[<a name="p653" href="#p653">page 653</a>] (<a href="#Contents">Contents</a>)
+
+     <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>                      \x hexadecimal digits (hexadecimal-character
+<a href="#7.20">&lt;stdint.h&gt;</a> header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>,                       escape sequence), <a href="#6.4.4.4">6.4.4.4</a>
+     <a href="#7.20">7.20</a>, <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>                              ^ (bitwise exclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
+<a href="#7.21">&lt;stdio.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>,                ^= (bitwise exclusive OR assignment operator),
+     <a href="#K.3.5">K.3.5</a>                                                        <a href="#6.5.16.2">6.5.16.2</a>
+<a href="#7.22">&lt;stdlib.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,              __alignas_is_defined macro, <a href="#7.15">7.15</a>
+     <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>                                          __bool_true_false_are_defined
+<a href="#7.23">&lt;string.h&gt;</a> header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                           macro, <a href="#7.18">7.18</a>
+<a href="#7.24">&lt;tgmath.h&gt;</a> header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                 __cplusplus macro, <a href="#6.10.8">6.10.8</a>
+<a href="#7.25">&lt;threads.h&gt;</a> header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                    __DATE__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+<a href="#7.26">&lt;time.h&gt;</a> header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                 __FILE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
+<a href="#7.27">&lt;uchar.h&gt;</a> header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                       __func__ identifier, <a href="#6.4.2.2">6.4.2.2</a>, <a href="#7.2.1.1">7.2.1.1</a>
+<a href="#7.28">&lt;wchar.h&gt;</a> header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>,                   __LINE__ macro, <a href="#6.10.8.1">6.10.8.1</a>, <a href="#7.2.1.1">7.2.1.1</a>
+     <a href="#7.30.12">7.30.12</a>, <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>                                       __STDC_, <a href="#6.11.9">6.11.9</a>
+<a href="#7.29">&lt;wctype.h&gt;</a> header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                             __STDC__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+= (equal-sign punctuator), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a>               __STDC_ANALYZABLE__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#L.1">L.1</a>
+= (simple assignment operator), <a href="#6.5.16.1">6.5.16.1</a>                     __STDC_HOSTED__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+== (equality operator), <a href="#6.5.9">6.5.9</a>                                __STDC_IEC_559__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#F.1">F.1</a>
+&gt; (greater-than operator), <a href="#6.5.8">6.5.8</a>                             __STDC_IEC_559_COMPLEX__ macro,
+&gt;= (greater-than-or-equal-to operator), <a href="#6.5.8">6.5.8</a>                     <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G.1">G.1</a>
+&gt;&gt; (right-shift operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>                    __STDC_ISO_10646__ macro, <a href="#6.10.8.2">6.10.8.2</a>
+&gt;&gt;= (right-shift assignment operator), <a href="#6.5.16.2">6.5.16.2</a>              __STDC_LIB_EXT1__ macro, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#K.2">K.2</a>
+? : (conditional operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a>                  __STDC_MB_MIGHT_NEQ_WC__ macro,
+?? (trigraph sequences), <a href="#5.2.1.1">5.2.1.1</a>                                  <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>
+[ ] (array subscript operator), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>             __STDC_NO_COMPLEX__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
+[ ] (brackets punctuator), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>                         <a href="#7.3.1">7.3.1</a>
+\ (backslash character), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>             __STDC_NO_THREADS__ macro, <a href="#6.10.8.3">6.10.8.3</a>,
+\ (escape character), <a href="#6.4.4.4">6.4.4.4</a>                                     <a href="#7.17.1">7.17.1</a>, <a href="#7.25.1">7.25.1</a>
+\" (double-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>,                  __STDC_NO_VLA__ macro, <a href="#6.10.8.3">6.10.8.3</a>
+     <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                           __STDC_UTF_16__ macro, <a href="#6.10.8.2">6.10.8.2</a>
+\\ (backslash escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>              __STDC_UTF_32__ macro, <a href="#6.10.8.2">6.10.8.2</a>
+\' (single-quote escape sequence), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>            __STDC_VERSION__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+\0 (null character), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                   __STDC_WANT_LIB_EXT1__ macro, <a href="#K.3.1.1">K.3.1.1</a>
+  padding of binary stream, <a href="#7.21.2">7.21.2</a>                           __TIME__ macro, <a href="#6.10.8.1">6.10.8.1</a>
+\? (question-mark escape sequence), <a href="#6.4.4.4">6.4.4.4</a>                  __VA_ARGS__ identifier, <a href="#6.10.3">6.10.3</a>, <a href="#6.10.3.1">6.10.3.1</a>
+\a (alert escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                   _Alignas, <a href="#6.7.5">6.7.5</a>
+\b (backspace escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>               _Atomic type qualifier, <a href="#6.7.3">6.7.3</a>
+\f (form-feed escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,              _Bool type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.17.1">7.17.1</a>,
+     <a href="#7.4.1.10">7.4.1.10</a>                                                     <a href="#F.4">F.4</a>
+\n (new-line escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               _Bool type conversions, <a href="#6.3.1.2">6.3.1.2</a>
+     <a href="#7.4.1.10">7.4.1.10</a>                                                _Complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+\octal digits (octal-character escape sequence),             _Complex_I macro, <a href="#7.3.1">7.3.1</a>
+     <a href="#6.4.4.4">6.4.4.4</a>                                                 _Exit function, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
+\r (carriage-return escape sequence), <a href="#5.2.2">5.2.2</a>,                 _Imaginary keyword, <a href="#G.2">G.2</a>
+     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                       _Imaginary types, <a href="#7.3.1">7.3.1</a>, <a href="#G">G</a>
+\t (horizontal-tab escape sequence), <a href="#5.2.2">5.2.2</a>,                  _Imaginary_I macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
+     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>                  _IOFBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>
+\U (universal character names), <a href="#6.4.3">6.4.3</a>                        _IOLBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.6">7.21.5.6</a>
+\u (universal character names), <a href="#6.4.3">6.4.3</a>                        _IONBF macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>
+\v (vertical-tab escape sequence), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           _Noreturn, <a href="#6.7.4">6.7.4</a>
+     <a href="#7.4.1.10">7.4.1.10</a>                                                _Pragma operator, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>
+
+[<a name="p654" href="#p654">page 654</a>] (<a href="#Contents">Contents</a>)
+
+_Static_assert, <a href="#6.7.10">6.7.10</a>, <a href="#7.2">7.2</a>                                  allocated storage, order and contiguity, <a href="#7.22.3">7.22.3</a>
+_Thread_local storage-class specifier, <a href="#6.2.4">6.2.4</a>,                 and macro, <a href="#7.9">7.9</a>
+     <a href="#6.7.1">6.7.1</a>                                                   AND operators
+{ } (braces punctuator), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>,               bitwise (&amp;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
+     <a href="#6.8.2">6.8.2</a>                                                      bitwise assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>
+{ } (compound-literal operator), <a href="#6.5.2.5">6.5.2.5</a>                        logical (&amp;&amp;), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>
+| (bitwise inclusive OR operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>           and_eq macro, <a href="#7.9">7.9</a>
+|= (bitwise inclusive OR assignment operator),               anonymous structure, <a href="#6.7.2.1">6.7.2.1</a>
+     <a href="#6.5.16.2">6.5.16.2</a>                                                anonymous union, <a href="#6.7.2.1">6.7.2.1</a>
+|| (logical OR operator), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>                    ANSI/IEEE 754, <a href="#F.1">F.1</a>
+~ (bitwise complement operator), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>            ANSI/IEEE 854, <a href="#F.1">F.1</a>
+                                                             argc (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+abort function, <a href="#7.2.1.1">7.2.1.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>,                   argument, <a href="#3.3">3.3</a>
+      <a href="#7.22.4.1">7.22.4.1</a>, <a href="#7.25.3.6">7.25.3.6</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a>                             array, <a href="#6.9.1">6.9.1</a>
+abort_handler_s function, <a href="#K.3.6.1.2">K.3.6.1.2</a>                             default promotions, <a href="#6.5.2.2">6.5.2.2</a>
+abs function, <a href="#7.22.6.1">7.22.6.1</a>                                          function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+absolute-value functions                                        macro, substitution, <a href="#6.10.3.1">6.10.3.1</a>
+   complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                     argument, complex, <a href="#7.3.9.1">7.3.9.1</a>
+   integer, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.22.6.1">7.22.6.1</a>                                argv (main function parameter), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+   real, <a href="#7.12.7">7.12.7</a>, <a href="#F.10.4">F.10.4</a>                                      arithmetic constant expression, <a href="#6.6">6.6</a>
+abstract declarator, <a href="#6.7.7">6.7.7</a>                                   arithmetic conversions, usual, see usual arithmetic
+abstract machine, <a href="#5.1.2.3">5.1.2.3</a>                                          conversions
+access, <a href="#3.1">3.1</a>, <a href="#6.7.3">6.7.3</a>, <a href="#L.2.1">L.2.1</a>                                    arithmetic operators
+accuracy, see floating-point accuracy                            additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>
+acos functions, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#F.10.1.1">F.10.1.1</a>                              bitwise, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>
+acos type-generic macro, <a href="#7.24">7.24</a>                                   increment and decrement, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>
+acosh functions, <a href="#7.12.5.1">7.12.5.1</a>, <a href="#F.10.2.1">F.10.2.1</a>                             multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+acosh type-generic macro, <a href="#7.24">7.24</a>                                  shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+acquire fence, <a href="#7.17.4">7.17.4</a>                                           unary, <a href="#6.5.3.3">6.5.3.3</a>
+acquire operation, <a href="#5.1.2.4">5.1.2.4</a>                                   arithmetic types, <a href="#6.2.5">6.2.5</a>
+active position, <a href="#5.2.2">5.2.2</a>                                       arithmetic, pointer, <a href="#6.5.6">6.5.6</a>
+actual argument, <a href="#3.3">3.3</a>                                         array
+actual parameter (deprecated), <a href="#3.3">3.3</a>                              argument, <a href="#6.9.1">6.9.1</a>
+addition assignment operator (+=), <a href="#6.5.16.2">6.5.16.2</a>                     declarator, <a href="#6.7.6.2">6.7.6.2</a>
+addition operator (+), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>,               initialization, <a href="#6.7.9">6.7.9</a>
+      <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>                                         multidimensional, <a href="#6.5.2.1">6.5.2.1</a>
+additive expressions, <a href="#6.5.6">6.5.6</a>, <a href="#G.5.2">G.5.2</a>                              parameter, <a href="#6.9.1">6.9.1</a>
+address constant, <a href="#6.6">6.6</a>                                           storage order, <a href="#6.5.2.1">6.5.2.1</a>
+address operator (&amp;), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>                          subscript operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+address-free, <a href="#7.17.5">7.17.5</a>                                            subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+aggregate initialization, <a href="#6.7.9">6.7.9</a>                                 type, <a href="#6.2.5">6.2.5</a>
+aggregate types, <a href="#6.2.5">6.2.5</a>                                          type conversion, <a href="#6.3.2.1">6.3.2.1</a>
+alert escape sequence (\a), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                      variable length, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>
+aliasing, <a href="#6.5">6.5</a>                                                arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+alignas macro, <a href="#7.15">7.15</a>                                          as-if rule, <a href="#5.1.2.3">5.1.2.3</a>
+aligned_alloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.1">7.22.3.1</a>                     ASCII code set, <a href="#5.2.1.1">5.2.1.1</a>
+alignment, <a href="#3.2">3.2</a>, <a href="#6.2.8">6.2.8</a>, <a href="#7.22.3.1">7.22.3.1</a>                              asctime function, <a href="#7.26.3.1">7.26.3.1</a>
+   pointer, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.3">6.3.2.3</a>                                   asctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>
+   structure/union member, <a href="#6.7.2.1">6.7.2.1</a>                           asin functions, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#F.10.1.2">F.10.1.2</a>
+alignment specifier, <a href="#6.7.5">6.7.5</a>                                    asin type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+alignof operator, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>                             asinh functions, <a href="#7.12.5.2">7.12.5.2</a>, <a href="#F.10.2.2">F.10.2.2</a>
+
+[<a name="p655" href="#p655">page 655</a>] (<a href="#Contents">Contents</a>)
+
+asinh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                           atomic_is_lock_free generic function,
+asm keyword, <a href="#J.5.10">J.5.10</a>                                               <a href="#7.17.5.1">7.17.5.1</a>
+assert macro, <a href="#7.2.1.1">7.2.1.1</a>                                         ATOMIC_LLONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+assert.h header, <a href="#7.2">7.2</a>                                          atomic_load generic functions, <a href="#7.17.7.2">7.17.7.2</a>
+assignment                                                    ATOMIC_LONG_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+   compound, <a href="#6.5.16.2">6.5.16.2</a>                                         ATOMIC_SHORT_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+   conversion, <a href="#6.5.16.1">6.5.16.1</a>                                       atomic_signal_fence function, <a href="#7.17.4.2">7.17.4.2</a>
+   expression, <a href="#6.5.16">6.5.16</a>                                         atomic_store generic functions, <a href="#7.17.7.1">7.17.7.1</a>
+   operators, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>                                 atomic_thread_fence function, <a href="#7.17.4.1">7.17.4.1</a>
+   simple, <a href="#6.5.16.1">6.5.16.1</a>                                           ATOMIC_VAR_INIT macro, <a href="#7.17.2.1">7.17.2.1</a>
+associativity of operators, <a href="#6.5">6.5</a>                               ATOMIC_WCHAR_T_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>
+asterisk punctuator (*), <a href="#6.7.6.1">6.7.6.1</a>, <a href="#6.7.6.2">6.7.6.2</a>                     atomics header, <a href="#7.17">7.17</a>
+at_quick_exit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>,                   auto storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>
+     <a href="#7.22.4.4">7.22.4.4</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>                             automatic storage duration, <a href="#5.2.3">5.2.3</a>, <a href="#6.2.4">6.2.4</a>
+atan functions, <a href="#7.12.4.3">7.12.4.3</a>, <a href="#F.10.1.3">F.10.1.3</a>
+atan type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                            backslash character (\), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+atan2 functions, <a href="#7.12.4.4">7.12.4.4</a>, <a href="#F.10.1.4">F.10.1.4</a>                           backslash escape sequence (\\), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.10.9">6.10.9</a>
+atan2 type-generic macro, <a href="#7.24">7.24</a>                                backspace escape sequence (\b), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+atanh functions, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#F.10.2.3">F.10.2.3</a>                           basic character set, <a href="#3.6">3.6</a>, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>
+atanh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                           basic types, <a href="#6.2.5">6.2.5</a>
+atexit function, <a href="#7.22.4.2">7.22.4.2</a>, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>,                behavior, <a href="#3.4">3.4</a>
+     <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>, <a href="#J.5.13">J.5.13</a>                               binary streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
+atof function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.1">7.22.1.1</a>                                     <a href="#7.21.9.4">7.21.9.4</a>
+atoi function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                               bit, <a href="#3.5">3.5</a>
+atol function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                                  high order, <a href="#3.6">3.6</a>
+atoll function, <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.2">7.22.1.2</a>                                 low order, <a href="#3.6">3.6</a>
+atomic lock-free macros, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.5">7.17.5</a>                       bit-field, <a href="#6.7.2.1">6.7.2.1</a>
+atomic operations, <a href="#5.1.2.4">5.1.2.4</a>                                    bitand macro, <a href="#7.9">7.9</a>
+atomic types, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>,               bitor macro, <a href="#7.9">7.9</a>
+     <a href="#6.5.2.3">6.5.2.3</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>,           bitwise operators, <a href="#6.5">6.5</a>
+     <a href="#7.17.6">7.17.6</a>                                                      AND, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.10">6.5.10</a>
+atomic_address type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.6">7.17.6</a>                              AND assignment (&amp;=), <a href="#6.5.16.2">6.5.16.2</a>
+ATOMIC_ADDRESS_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                           complement (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>
+atomic_bool type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.6">7.17.6</a>                                 exclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
+ATOMIC_CHAR16_T_LOCK_FREE macro,                                 exclusive OR assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
+     <a href="#7.17.1">7.17.1</a>                                                      inclusive OR, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
+ATOMIC_CHAR32_T_LOCK_FREE macro,                                 inclusive OR assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+     <a href="#7.17.1">7.17.1</a>                                                      shift, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+ATOMIC_CHAR_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                           blank character, <a href="#7.4.1.3">7.4.1.3</a>
+atomic_compare_exchange generic                               block, <a href="#6.8">6.8</a>, <a href="#6.8.2">6.8.2</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
+     functions, <a href="#7.17.7.4">7.17.7.4</a>                                      block scope, <a href="#6.2.1">6.2.1</a>
+atomic_exchange generic functions, <a href="#7.17.7.3">7.17.7.3</a>                   block structure, <a href="#6.2.1">6.2.1</a>
+atomic_fetch and modify generic functions,                    bold type convention, <a href="#6.1">6.1</a>
+     <a href="#7.17.7.5">7.17.7.5</a>                                                 bool macro, <a href="#7.18">7.18</a>
+atomic_flag type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>                              boolean type, <a href="#6.3.1.2">6.3.1.2</a>
+atomic_flag_clear functions, <a href="#7.17.8.2">7.17.8.2</a>                         boolean type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.2">6.3.1.2</a>
+ATOMIC_FLAG_INIT macro, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.8">7.17.8</a>                        bounded undefined behavior, <a href="#L.2.2">L.2.2</a>
+atomic_flag_test_and_set functions,                           braces punctuator ({ }), <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>,
+     <a href="#7.17.8.1">7.17.8.1</a>                                                       <a href="#6.8.2">6.8.2</a>
+atomic_init generic function, <a href="#7.17.2.2">7.17.2.2</a>                        brackets operator ([ ]), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+ATOMIC_INT_LOCK_FREE macro, <a href="#7.17.1">7.17.1</a>                            brackets punctuator ([ ]), <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>
+
+[<a name="p656" href="#p656">page 656</a>] (<a href="#Contents">Contents</a>)
+
+branch cuts, <a href="#7.3.3">7.3.3</a>                                                type-generic macro for, <a href="#7.24">7.24</a>
+break statement, <a href="#6.8.6.3">6.8.6.3</a>                                       ccosh functions, <a href="#7.3.6.4">7.3.6.4</a>, <a href="#G.6.2.4">G.6.2.4</a>
+broken-down time, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.3">7.26.3</a>,                       type-generic macro for, <a href="#7.24">7.24</a>
+     <a href="#7.26.3.1">7.26.3.1</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#7.26.3.5">7.26.3.5</a>,                   ceil functions, <a href="#7.12.9.1">7.12.9.1</a>, <a href="#F.10.6.1">F.10.6.1</a>
+     <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                           ceil type-generic macro, <a href="#7.24">7.24</a>
+bsearch function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a>                             cerf function, <a href="#7.30.1">7.30.1</a>
+bsearch_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>                         cerfc function, <a href="#7.30.1">7.30.1</a>
+btowc function, <a href="#7.28.6.1.1">7.28.6.1.1</a>                                     cexp functions, <a href="#7.3.7.1">7.3.7.1</a>, <a href="#G.6.3.1">G.6.3.1</a>
+BUFSIZ macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.5">7.21.5.5</a>                            type-generic macro for, <a href="#7.24">7.24</a>
+byte, <a href="#3.6">3.6</a>, <a href="#6.5.3.4">6.5.3.4</a>                                             cexp2 function, <a href="#7.30.1">7.30.1</a>
+byte input/output functions, <a href="#7.21.1">7.21.1</a>                            cexpm1 function, <a href="#7.30.1">7.30.1</a>
+byte-oriented stream, <a href="#7.21.2">7.21.2</a>                                   char type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
+                                                                     <a href="#K.3.9.1.2">K.3.9.1.2</a>
+C program, <a href="#5.1.1.1">5.1.1.1</a>                                             char type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+c16rtomb function, <a href="#7.27.1.2">7.27.1.2</a>                                          <a href="#6.3.1.8">6.3.1.8</a>
+c32rtomb function, <a href="#7.27.1.4">7.27.1.4</a>                                    char16_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.27">7.27</a>
+cabs functions, <a href="#7.3.8.1">7.3.8.1</a>, <a href="#G.6">G.6</a>                                   char32_t type, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.27">7.27</a>
+  type-generic macro for, <a href="#7.24">7.24</a>                                 CHAR_BIT macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+cacos functions, <a href="#7.3.5.1">7.3.5.1</a>, <a href="#G.6.1.1">G.6.1.1</a>                              CHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+  type-generic macro for, <a href="#7.24">7.24</a>                                 CHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+cacosh functions, <a href="#7.3.6.1">7.3.6.1</a>, <a href="#G.6.2.1">G.6.2.1</a>                             character, <a href="#3.7">3.7</a>, <a href="#3.7.1">3.7.1</a>
+  type-generic macro for, <a href="#7.24">7.24</a>                                 character array initialization, <a href="#6.7.9">6.7.9</a>
+calendar time, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.2">7.26.2.2</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.2.4">7.26.2.4</a>,           character case mapping functions, <a href="#7.4.2">7.4.2</a>
+      <a href="#7.26.3.2">7.26.3.2</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>,                    wide character, <a href="#7.29.3.1">7.29.3.1</a>
+      <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                           extensible, <a href="#7.29.3.2">7.29.3.2</a>
+call by value, <a href="#6.5.2.2">6.5.2.2</a>                                         character classification functions, <a href="#7.4.1">7.4.1</a>
+call_once function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.2.1">7.25.2.1</a>                              wide character, <a href="#7.29.2.1">7.29.2.1</a>
+calloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.2">7.22.3.2</a>                                    extensible, <a href="#7.29.2.2">7.29.2.2</a>
+carg functions, <a href="#7.3.9.1">7.3.9.1</a>, <a href="#G.6">G.6</a>                                   character constant, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>
+carg type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                             character display semantics, <a href="#5.2.2">5.2.2</a>
+carriage-return escape sequence (\r), <a href="#5.2.2">5.2.2</a>,                   character handling header, <a href="#7.4">7.4</a>, <a href="#7.11.1.1">7.11.1.1</a>
+      <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.10">7.4.1.10</a>                                        character input/output functions, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a>
+carries a dependency, <a href="#5.1.2.4">5.1.2.4</a>                                     wide character, <a href="#7.28.3">7.28.3</a>
+case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                                     character sets, <a href="#5.2.1">5.2.1</a>
+case mapping functions                                         character string literal, see string literal
+  character, <a href="#7.4.2">7.4.2</a>                                             character type conversion, <a href="#6.3.1.1">6.3.1.1</a>
+  wide character, <a href="#7.29.3.1">7.29.3.1</a>                                     character types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.9">6.7.9</a>
+      extensible, <a href="#7.29.3.2">7.29.3.2</a>                                     cimag functions, <a href="#7.3.9.2">7.3.9.2</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>
+casin functions, <a href="#7.3.5.2">7.3.5.2</a>, <a href="#G.6">G.6</a>                                  cimag type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+  type-generic macro for, <a href="#7.24">7.24</a>                                 cis function, <a href="#G.6">G.6</a>
+casinh functions, <a href="#7.3.6.2">7.3.6.2</a>, <a href="#G.6.2.2">G.6.2.2</a>                             classification functions
+  type-generic macro for, <a href="#7.24">7.24</a>                                    character, <a href="#7.4.1">7.4.1</a>
+cast expression, <a href="#6.5.4">6.5.4</a>                                            floating-point, <a href="#7.12.3">7.12.3</a>
+cast operator (( )), <a href="#6.5.4">6.5.4</a>                                        wide character, <a href="#7.29.2.1">7.29.2.1</a>
+catan functions, <a href="#7.3.5.3">7.3.5.3</a>, <a href="#G.6">G.6</a>                                        extensible, <a href="#7.29.2.2">7.29.2.2</a>
+  type-generic macro for, <a href="#7.24">7.24</a>                                 clearerr function, <a href="#7.21.10.1">7.21.10.1</a>
+catanh functions, <a href="#7.3.6.3">7.3.6.3</a>, <a href="#G.6.2.3">G.6.2.3</a>                             clgamma function, <a href="#7.30.1">7.30.1</a>
+  type-generic macro for, <a href="#7.24">7.24</a>                                 clock function, <a href="#7.26.2.1">7.26.2.1</a>
+cbrt functions, <a href="#7.12.7.1">7.12.7.1</a>, <a href="#F.10.4.1">F.10.4.1</a>                             clock_t type, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.1">7.26.2.1</a>
+cbrt type-generic macro, <a href="#7.24">7.24</a>                                  CLOCKS_PER_SEC macro, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.1">7.26.2.1</a>
+ccos functions, <a href="#7.3.5.4">7.3.5.4</a>, <a href="#G.6">G.6</a>                                   clog functions, <a href="#7.3.7.2">7.3.7.2</a>, <a href="#G.6.3.2">G.6.3.2</a>
+
+[<a name="p657" href="#p657">page 657</a>] (<a href="#Contents">Contents</a>)
+
+  type-generic macro for, <a href="#7.24">7.24</a>                                  string, <a href="#7.23.3">7.23.3</a>, <a href="#K.3.7.2">K.3.7.2</a>
+clog10 function, <a href="#7.30.1">7.30.1</a>                                         wide string, <a href="#7.28.4.3">7.28.4.3</a>, <a href="#K.3.9.2.2">K.3.9.2.2</a>
+clog1p function, <a href="#7.30.1">7.30.1</a>                                       concatenation, preprocessing, see preprocessing
+clog2 function, <a href="#7.30.1">7.30.1</a>                                             concatenation
+CMPLX macros, <a href="#7.3.9.3">7.3.9.3</a>                                         conceptual models, <a href="#5.1">5.1</a>
+cnd_broadcast function, <a href="#7.25.3.1">7.25.3.1</a>, <a href="#7.25.3.5">7.25.3.5</a>,                   conditional features, <a href="#4">4</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>,
+     <a href="#7.25.3.6">7.25.3.6</a>                                                      <a href="#7.1.2">7.1.2</a>, <a href="#F.1">F.1</a>, <a href="#G.1">G.1</a>, <a href="#K.2">K.2</a>, <a href="#L.1">L.1</a>
+cnd_destroy function, <a href="#7.25.3.2">7.25.3.2</a>                                conditional inclusion, <a href="#6.10.1">6.10.1</a>
+cnd_init function, <a href="#7.25.3.3">7.25.3.3</a>                                   conditional operator (? :), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.15">6.5.15</a>
+cnd_signal function, <a href="#7.25.3.4">7.25.3.4</a>, <a href="#7.25.3.5">7.25.3.5</a>,                      conflict, <a href="#5.1.2.4">5.1.2.4</a>
+     <a href="#7.25.3.6">7.25.3.6</a>                                                 conformance, <a href="#4">4</a>
+cnd_t type, <a href="#7.25.1">7.25.1</a>                                            conj functions, <a href="#7.3.9.4">7.3.9.4</a>, <a href="#G.6">G.6</a>
+cnd_timedwait function, <a href="#7.25.3.5">7.25.3.5</a>                              conj type-generic macro, <a href="#7.24">7.24</a>
+cnd_wait function, <a href="#7.25.3.3">7.25.3.3</a>, <a href="#7.25.3.6">7.25.3.6</a>                         const type qualifier, <a href="#6.7.3">6.7.3</a>
+collating sequences, <a href="#5.2.1">5.2.1</a>                                    const-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.7.3">6.7.3</a>
+colon punctuator (:), <a href="#6.7.2.1">6.7.2.1</a>                                 constant expression, <a href="#6.6">6.6</a>, <a href="#F.8.4">F.8.4</a>
+comma operator (,), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.17">6.5.17</a>                           constants, <a href="#6.4.4">6.4.4</a>
+comma punctuator (,), <a href="#6.5.2">6.5.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.7.2.2">6.7.2.2</a>,             as primary expression, <a href="#6.5.1">6.5.1</a>
+     <a href="#6.7.2.3">6.7.2.3</a>, <a href="#6.7.9">6.7.9</a>                                             character, <a href="#6.4.4.4">6.4.4.4</a>
+command processor, <a href="#7.22.4.8">7.22.4.8</a>                                     enumeration, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+comment delimiters (/* */ and //), <a href="#6.4.9">6.4.9</a>                        floating, <a href="#6.4.4.2">6.4.4.2</a>
+comments, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.4.9">6.4.9</a>                                   hexadecimal, <a href="#6.4.4.1">6.4.4.1</a>
+common extensions, <a href="#J.5">J.5</a>                                          integer, <a href="#6.4.4.1">6.4.4.1</a>
+common initial sequence, <a href="#6.5.2.3">6.5.2.3</a>                                octal, <a href="#6.4.4.1">6.4.4.1</a>
+common real type, <a href="#6.3.1.8">6.3.1.8</a>                                     constraint, <a href="#3.8">3.8</a>, <a href="#4">4</a>
+common warnings, <a href="#I">I</a>                                            constraint_handler_t type, <a href="#K.3.6">K.3.6</a>
+comparison functions, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.1">7.22.5.1</a>, <a href="#7.22.5.2">7.22.5.2</a>,             consume operation, <a href="#5.1.2.4">5.1.2.4</a>
+     <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>                            content of structure/union/enumeration, <a href="#6.7.2.3">6.7.2.3</a>
+  string, <a href="#7.23.4">7.23.4</a>                                              contiguity of allocated storage, <a href="#7.22.3">7.22.3</a>
+  wide string, <a href="#7.28.4.4">7.28.4.4</a>                                       continue statement, <a href="#6.8.6.2">6.8.6.2</a>
+comparison macros, <a href="#7.12.14">7.12.14</a>                                    contracted expression, <a href="#6.5">6.5</a>, <a href="#7.12.2">7.12.2</a>, <a href="#F.7">F.7</a>
+comparison, pointer, <a href="#6.5.8">6.5.8</a>                                    control character, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
+compatible type, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a>                   control wide character, <a href="#7.29.2">7.29.2</a>
+compl macro, <a href="#7.9">7.9</a>                                              conversion, <a href="#6.3">6.3</a>
+complement operator (~), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.3.3">6.5.3.3</a>                       arithmetic operands, <a href="#6.3.1">6.3.1</a>
+complete type, <a href="#6.2.5">6.2.5</a>                                            array argument, <a href="#6.9.1">6.9.1</a>
+complex macro, <a href="#7.3.1">7.3.1</a>                                            array parameter, <a href="#6.9.1">6.9.1</a>
+complex numbers, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>                                       arrays, <a href="#6.3.2.1">6.3.2.1</a>
+complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>                       boolean, <a href="#6.3.1.2">6.3.1.2</a>
+complex type domain, <a href="#6.2.5">6.2.5</a>                                      boolean, characters, and integers, <a href="#6.3.1.1">6.3.1.1</a>
+complex types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#G">G</a>                        by assignment, <a href="#6.5.16.1">6.5.16.1</a>
+complex.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>,                   by return statement, <a href="#6.8.6.4">6.8.6.4</a>
+     <a href="#7.3">7.3</a>, <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>                             complex types, <a href="#6.3.1.6">6.3.1.6</a>
+compliance, see conformance                                     explicit, <a href="#6.3">6.3</a>
+components of time, <a href="#7.26.1">7.26.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                             function, <a href="#6.3.2.1">6.3.2.1</a>
+composite type, <a href="#6.2.7">6.2.7</a>                                           function argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+compound assignment, <a href="#6.5.16.2">6.5.16.2</a>                                   function designators, <a href="#6.3.2.1">6.3.2.1</a>
+compound literals, <a href="#6.5.2.5">6.5.2.5</a>                                      function parameter, <a href="#6.9.1">6.9.1</a>
+compound statement, <a href="#6.8.2">6.8.2</a>                                       imaginary, <a href="#G.4.1">G.4.1</a>
+compound-literal operator (( ){ }), <a href="#6.5.2.5">6.5.2.5</a>                     imaginary and complex, <a href="#G.4.3">G.4.3</a>
+concatenation functions                                         implicit, <a href="#6.3">6.3</a>
+
+[<a name="p658" href="#p658">page 658</a>] (<a href="#Contents">Contents</a>)
+
+   lvalues, <a href="#6.3.2.1">6.3.2.1</a>                                             csinh functions, <a href="#7.3.6.5">7.3.6.5</a>, <a href="#G.6.2.5">G.6.2.5</a>
+   pointer, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                                      type-generic macro for, <a href="#7.24">7.24</a>
+   real and complex, <a href="#6.3.1.7">6.3.1.7</a>                                    csqrt functions, <a href="#7.3.8.3">7.3.8.3</a>, <a href="#G.6.4.2">G.6.4.2</a>
+   real and imaginary, <a href="#G.4.2">G.4.2</a>                                      type-generic macro for, <a href="#7.24">7.24</a>
+   real floating and integer, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                  ctan functions, <a href="#7.3.5.6">7.3.5.6</a>, <a href="#G.6">G.6</a>
+   real floating types, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#F.3">F.3</a>                               type-generic macro for, <a href="#7.24">7.24</a>
+   signed and unsigned integers, <a href="#6.3.1.3">6.3.1.3</a>                        ctanh functions, <a href="#7.3.6.6">7.3.6.6</a>, <a href="#G.6.2.6">G.6.2.6</a>
+   usual arithmetic, see usual arithmetic                         type-generic macro for, <a href="#7.24">7.24</a>
+         conversions                                            ctgamma function, <a href="#7.30.1">7.30.1</a>
+   void type, <a href="#6.3.2.2">6.3.2.2</a>                                           ctime function, <a href="#7.26.3.2">7.26.3.2</a>
+conversion functions                                            ctime_s function, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>
+   multibyte/wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>                    ctype.h header, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>
+      extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>                                 current object, <a href="#6.7.9">6.7.9</a>
+      restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>                  CX_LIMITED_RANGE pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.3.4">7.3.4</a>
+   multibyte/wide string, <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
+      restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                          data race, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.4.6">7.22.4.6</a>,
+   numeric, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                                          <a href="#7.23.5.8">7.23.5.8</a>, <a href="#7.23.6.2">7.23.6.2</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>,
+      wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1">7.28.4.1</a>                                 <a href="#7.28.6.4">7.28.6.4</a>
+   single byte/wide character, <a href="#7.28.6.1">7.28.6.1</a>                         data stream, see streams
+   time, <a href="#7.26.3">7.26.3</a>, <a href="#K.3.8.2">K.3.8.2</a>                                        date and time header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>
+      wide character, <a href="#7.28.5">7.28.5</a>                                    Daylight Saving Time, <a href="#7.26.1">7.26.1</a>
+conversion specifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>,              DBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.28.2.2">7.28.2.2</a>                                                  DBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+conversion state, <a href="#7.22.7">7.22.7</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.27.1.1">7.27.1.1</a>,                     DBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.6">7.28.6</a>,                     DBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.28.6.2.1">7.28.6.2.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>,             DBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.28.6.4">7.28.6.4</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.6.4">K.3.6.4</a>,                DBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>,           DBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>                                               DBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+conversion state functions, <a href="#7.28.6.2">7.28.6.2</a>                            DBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+copying functions                                               DBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   string, <a href="#7.23.2">7.23.2</a>, <a href="#K.3.7.1">K.3.7.1</a>                                      DBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   wide string, <a href="#7.28.4.2">7.28.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a>                             DBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+copysign functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12.11.1">7.12.11.1</a>, <a href="#F.3">F.3</a>,                    decimal constant, <a href="#6.4.4.1">6.4.4.1</a>
+      <a href="#F.10.8.1">F.10.8.1</a>                                                  decimal digit, <a href="#5.2.1">5.2.1</a>
+copysign type-generic macro, <a href="#7.24">7.24</a>                               decimal-point character, <a href="#7.1.1">7.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+correctly rounded result, <a href="#3.9">3.9</a>                                   DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
+corresponding real type, <a href="#6.2.5">6.2.5</a>                                       <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.5">F.5</a>
+cos functions, <a href="#7.12.4.5">7.12.4.5</a>, <a href="#F.10.1.5">F.10.1.5</a>                               declaration specifiers, <a href="#6.7">6.7</a>
+cos type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                               declarations, <a href="#6.7">6.7</a>
+cosh functions, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#F.10.2.4">F.10.2.4</a>                                function, <a href="#6.7.6.3">6.7.6.3</a>
+cosh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                pointer, <a href="#6.7.6.1">6.7.6.1</a>
+cpow functions, <a href="#7.3.8.2">7.3.8.2</a>, <a href="#G.6.4.1">G.6.4.1</a>                                  structure/union, <a href="#6.7.2.1">6.7.2.1</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                   typedef, <a href="#6.7.8">6.7.8</a>
+cproj functions, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                   declarator, <a href="#6.7.6">6.7.6</a>
+cproj type-generic macro, <a href="#7.24">7.24</a>                                    abstract, <a href="#6.7.7">6.7.7</a>
+creal functions, <a href="#7.3.9.6">7.3.9.6</a>, <a href="#G.6">G.6</a>                                   declarator type derivation, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.6">6.7.6</a>
+creal type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                             decrement operators, see arithmetic operators,
+critical undefined behavior, <a href="#L.2.3">L.2.3</a>                                    increment and decrement
+csin functions, <a href="#7.3.5.5">7.3.5.5</a>, <a href="#G.6">G.6</a>                                    default argument promotions, <a href="#6.5.2.2">6.5.2.2</a>
+   type-generic macro for, <a href="#7.24">7.24</a>                                 default initialization, <a href="#6.7.9">6.7.9</a>
+
+[<a name="p659" href="#p659">page 659</a>] (<a href="#Contents">Contents</a>)
+
+default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>                                  elif preprocessing directive, <a href="#6.10.1">6.10.1</a>
+define preprocessing directive, <a href="#6.10.3">6.10.3</a>                         ellipsis punctuator (...), <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
+defined operator, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.8">6.10.8</a>                               else preprocessing directive, <a href="#6.10.1">6.10.1</a>
+definition, <a href="#6.7">6.7</a>                                                 else statement, <a href="#6.8.4.1">6.8.4.1</a>
+   function, <a href="#6.9.1">6.9.1</a>                                             empty statement, <a href="#6.8.3">6.8.3</a>
+dependency-ordered before, <a href="#5.1.2.4">5.1.2.4</a>                             encoding error, <a href="#7.21.3">7.21.3</a>, <a href="#7.27.1.1">7.27.1.1</a>, <a href="#7.27.1.2">7.27.1.2</a>,
+derived declarator types, <a href="#6.2.5">6.2.5</a>                                      <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>,
+derived types, <a href="#6.2.5">6.2.5</a>                                                 <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>,
+designated initializer, <a href="#6.7.9">6.7.9</a>                                        <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>,
+destringizing, <a href="#6.10.9">6.10.9</a>                                                <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+device input/output, <a href="#5.1.2.3">5.1.2.3</a>                                   end-of-file, <a href="#7.28.1">7.28.1</a>
+diagnostic message, <a href="#3.10">3.10</a>, <a href="#5.1.1.3">5.1.1.3</a>                              end-of-file indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,
+diagnostics, <a href="#5.1.1.3">5.1.1.3</a>                                                 <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,
+diagnostics header, <a href="#7.2">7.2</a>                                              <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.2">7.21.10.2</a>, <a href="#7.28.3.1">7.28.3.1</a>,
+difftime function, <a href="#7.26.2.2">7.26.2.2</a>                                          <a href="#7.28.3.10">7.28.3.10</a>
+digit, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>                                              end-of-file macro, see EOF macro
+digraphs, <a href="#6.4.6">6.4.6</a>                                                end-of-line indicator, <a href="#5.2.1">5.2.1</a>
+direct input/output functions, <a href="#7.21.8">7.21.8</a>                          endif preprocessing directive, <a href="#6.10.1">6.10.1</a>
+display device, <a href="#5.2.2">5.2.2</a>                                          enum type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.2.2">6.7.2.2</a>
+div function, <a href="#7.22.6.2">7.22.6.2</a>                                         enumerated type, <a href="#6.2.5">6.2.5</a>
+div_t type, <a href="#7.22">7.22</a>                                               enumeration, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.2">6.7.2.2</a>
+division assignment operator (/=), <a href="#6.5.16.2">6.5.16.2</a>                    enumeration constant, <a href="#6.2.1">6.2.1</a>, <a href="#6.4.4.3">6.4.4.3</a>
+division operator (/), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>, <a href="#G.5.1">G.5.1</a>              enumeration content, <a href="#6.7.2.3">6.7.2.3</a>
+do statement, <a href="#6.8.5.2">6.8.5.2</a>                                          enumeration members, <a href="#6.7.2.2">6.7.2.2</a>
+documentation of implementation, <a href="#4">4</a>                             enumeration specifiers, <a href="#6.7.2.2">6.7.2.2</a>
+domain error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.4.1">7.12.4.1</a>, <a href="#7.12.4.2">7.12.4.2</a>, <a href="#7.12.4.4">7.12.4.4</a>,            enumeration tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+      <a href="#7.12.5.1">7.12.5.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.7">7.12.6.7</a>,                  enumerator, <a href="#6.7.2.2">6.7.2.2</a>
+      <a href="#7.12.6.8">7.12.6.8</a>, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>,                environment, <a href="#5">5</a>
+      <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>,                  environment functions, <a href="#7.22.4">7.22.4</a>, <a href="#K.3.6.2">K.3.6.2</a>
+      <a href="#7.12.9.7">7.12.9.7</a>, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>                environment list, <a href="#7.22.4.6">7.22.4.6</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>
+dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                                      environmental considerations, <a href="#5.2">5.2</a>
+double _Complex type, <a href="#6.2.5">6.2.5</a>                                    environmental limits, <a href="#5.2.4">5.2.4</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.21.2">7.21.2</a>,
+double _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,                            <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.4.2">7.22.4.2</a>,
+      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>                                               <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>
+double _Imaginary type, <a href="#G.2">G.2</a>                                    EOF macro, <a href="#7.4">7.4</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.2">7.21.5.2</a>,
+double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.2">7.21.6.2</a>,                        <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.11">7.21.6.11</a>,
+      <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.2">F.2</a>                                                  <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.4">7.21.7.4</a>,
+double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,                   <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>,
+      <a href="#6.3.1.8">6.3.1.8</a>                                                        <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.2.4">7.28.2.4</a>,
+double-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>                                 <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.2.12">7.28.2.12</a>,
+double-quote escape sequence (\"), <a href="#6.4.4.4">6.4.4.4</a>,                          <a href="#7.28.3.4">7.28.3.4</a>, <a href="#7.28.6.1.1">7.28.6.1.1</a>, <a href="#7.28.6.1.2">7.28.6.1.2</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>,
+      <a href="#6.4.5">6.4.5</a>, <a href="#6.10.9">6.10.9</a>                                                  <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>,
+double_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>                                           <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>,
+                                                                     <a href="#K.3.9.1.14">K.3.9.1.14</a>
+EDOM macro, <a href="#7.5">7.5</a>, <a href="#7.12.1">7.12.1</a>, see also domain error                 equal-sign punctuator (=), <a href="#6.7">6.7</a>, <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.9">6.7.9</a>
+effective type, <a href="#6.5">6.5</a>                                            equal-to operator, see equality operator
+EILSEQ macro, <a href="#7.5">7.5</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.27.1.1">7.27.1.1</a>, <a href="#7.27.1.2">7.27.1.2</a>,                 equality expressions, <a href="#6.5.9">6.5.9</a>
+     <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>,                   equality operator (==), <a href="#6.5.9">6.5.9</a>
+     <a href="#7.28.6.3.2">7.28.6.3.2</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>,           ERANGE macro, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.12.1">7.12.1</a>,
+     see also encoding error                                         <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, see
+element type, <a href="#6.2.5">6.2.5</a>                                                  also range error, pole error
+
+[<a name="p660" href="#p660">page 660</a>] (<a href="#Contents">Contents</a>)
+
+erf functions, <a href="#7.12.8.1">7.12.8.1</a>, <a href="#F.10.5.1">F.10.5.1</a>                               exp2 functions, <a href="#7.12.6.2">7.12.6.2</a>, <a href="#F.10.3.2">F.10.3.2</a>
+erf type-generic macro, <a href="#7.24">7.24</a>                                    exp2 type-generic macro, <a href="#7.24">7.24</a>
+erfc functions, <a href="#7.12.8.2">7.12.8.2</a>, <a href="#F.10.5.2">F.10.5.2</a>                              explicit conversion, <a href="#6.3">6.3</a>
+erfc type-generic macro, <a href="#7.24">7.24</a>                                   expm1 functions, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#F.10.3.3">F.10.3.3</a>
+errno macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.3.2">7.3.2</a>, <a href="#7.5">7.5</a>, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>,               expm1 type-generic macro, <a href="#7.24">7.24</a>
+      <a href="#7.12.1">7.12.1</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.10.4">7.21.10.4</a>,            exponent part, <a href="#6.4.4.2">6.4.4.2</a>
+      <a href="#7.22.1">7.22.1</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.23.6.2">7.23.6.2</a>, <a href="#7.27.1.1">7.27.1.1</a>,           exponential functions
+      <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.3">7.27.1.3</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.3.1">7.28.3.1</a>,                     complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>
+      <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>,               real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>
+      <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#J.5.17">J.5.17</a>,               expression, <a href="#6.5">6.5</a>
+      <a href="#K.3.1.3">K.3.1.3</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a>                                          assignment, <a href="#6.5.16">6.5.16</a>
+errno.h header, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>                                cast, <a href="#6.5.4">6.5.4</a>
+errno_t type, <a href="#K.3.2">K.3.2</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>,                     constant, <a href="#6.6">6.6</a>
+      <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>                                         evaluation, <a href="#5.1.2.3">5.1.2.3</a>
+error                                                             full, <a href="#6.8">6.8</a>
+   domain, see domain error                                       order of evaluation, see order of evaluation
+   encoding, see encoding error                                   parenthesized, <a href="#6.5.1">6.5.1</a>
+   pole, see pole error                                           primary, <a href="#6.5.1">6.5.1</a>
+   range, see range error                                         unary, <a href="#6.5.3">6.5.3</a>
+error conditions, <a href="#7.12.1">7.12.1</a>                                        expression statement, <a href="#6.8.3">6.8.3</a>
+error functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a>                                 extended alignment, <a href="#6.2.8">6.2.8</a>
+error indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,                    extended character set, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.1.2">5.2.1.2</a>
+      <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.21.7.7">7.21.7.7</a>,                   extended characters, <a href="#5.2.1">5.2.1</a>
+      <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.10.1">7.21.10.1</a>, <a href="#7.21.10.3">7.21.10.3</a>,                 extended integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>,
+      <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>                                             <a href="#7.20">7.20</a>
+error preprocessing directive, <a href="#4">4</a>, <a href="#6.10.5">6.10.5</a>                        extended multibyte/wide character conversion
+error-handling functions, <a href="#7.21.10">7.21.10</a>, <a href="#7.23.6.2">7.23.6.2</a>,                         utilities, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
+      <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a>                                      extensible wide character case mapping functions,
+escape character (\), <a href="#6.4.4.4">6.4.4.4</a>                                        <a href="#7.29.3.2">7.29.3.2</a>
+escape sequences, <a href="#5.2.1">5.2.1</a>, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.11.4">6.11.4</a>                 extensible wide character classification functions,
+evaluation format, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#7.12">7.12</a>                          <a href="#7.29.2.2">7.29.2.2</a>
+evaluation method, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#F.8.5">F.8.5</a>                        extern storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.7.1">6.7.1</a>
+evaluation of expression, <a href="#5.1.2.3">5.1.2.3</a>                               external definition, <a href="#6.9">6.9</a>
+evaluation order, see order of evaluation                       external identifiers, underscore, <a href="#7.1.3">7.1.3</a>
+exceptional condition, <a href="#6.5">6.5</a>                                      external linkage, <a href="#6.2.2">6.2.2</a>
+excess precision, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                   external name, <a href="#6.4.2.1">6.4.2.1</a>
+excess range, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                       external object definitions, <a href="#6.9.2">6.9.2</a>
+exclusive OR operators
+   bitwise (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>                                 fabs functions, <a href="#7.12.7.2">7.12.7.2</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.2">F.10.4.2</a>
+   bitwise assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>                            fabs type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+executable program, <a href="#5.1.1.1">5.1.1.1</a>                                     false macro, <a href="#7.18">7.18</a>
+execution character set, <a href="#5.2.1">5.2.1</a>                                  fclose function, <a href="#7.21.5.1">7.21.5.1</a>
+execution environment, <a href="#5">5</a>, <a href="#5.1.2">5.1.2</a>, see also                       fdim functions, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#F.10.9.1">F.10.9.1</a>
+      environmental limits                                      fdim type-generic macro, <a href="#7.24">7.24</a>
+execution sequence, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.8">6.8</a>                                FE_ALL_EXCEPT macro, <a href="#7.6">7.6</a>
+exit function, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>,               FE_DFL_ENV macro, <a href="#7.6">7.6</a>
+      <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>                                        FE_DIVBYZERO macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+EXIT_FAILURE macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>                              FE_DOWNWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+EXIT_SUCCESS macro, <a href="#7.22">7.22</a>, <a href="#7.22.4.4">7.22.4.4</a>                              FE_INEXACT macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+exp functions, <a href="#7.12.6.1">7.12.6.1</a>, <a href="#F.10.3.1">F.10.3.1</a>                               FE_INVALID macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+exp type-generic macro, <a href="#7.24">7.24</a>                                    FE_OVERFLOW macro, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>
+
+[<a name="p661" href="#p661">page 661</a>] (<a href="#Contents">Contents</a>)
+
+FE_TONEAREST macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                 float _Complex type conversion, <a href="#6.3.1.6">6.3.1.6</a>,
+FE_TOWARDZERO macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                     <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+FE_UNDERFLOW macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                 float _Imaginary type, <a href="#G.2">G.2</a>
+FE_UPWARD macro, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                    float type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#F.2">F.2</a>
+feclearexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.1">7.6.2.1</a>, <a href="#F.3">F.3</a>                  float type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
+fegetenv function, <a href="#7.6.4.1">7.6.4.1</a>, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                 <a href="#6.3.1.8">6.3.1.8</a>
+fegetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.2">7.6.2.2</a>, <a href="#F.3">F.3</a>                float.h header, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,
+fegetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.1">7.6.3.1</a>, <a href="#F.3">F.3</a>                            <a href="#7.28.4.1.1">7.28.4.1.1</a>
+feholdexcept function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.3">7.6.4.3</a>,                     float_t type, <a href="#7.12">7.12</a>, <a href="#J.5.6">J.5.6</a>
+     <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                                            floating constant, <a href="#6.4.4.2">6.4.4.2</a>
+fence, <a href="#5.1.2.4">5.1.2.4</a>                                               floating suffix, f or <a href="#F">F</a>, <a href="#6.4.4.2">6.4.4.2</a>
+fences, <a href="#7.17.4">7.17.4</a>                                               floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>, <a href="#6.3.1.7">6.3.1.7</a>,
+fenv.h header, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>                <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>
+FENV_ACCESS pragma, <a href="#6.10.6">6.10.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#F.8">F.8</a>, <a href="#F.9">F.9</a>,                 floating types, <a href="#6.2.5">6.2.5</a>, <a href="#6.11.1">6.11.1</a>
+     <a href="#F.10">F.10</a>                                                    floating-point accuracy, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.5">6.5</a>,
+fenv_t type, <a href="#7.6">7.6</a>                                                  <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.5">F.5</a>, see also contracted expression
+feof function, <a href="#7.21.10.2">7.21.10.2</a>                                     floating-point arithmetic functions, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>
+feraiseexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.3">7.6.2.3</a>, <a href="#F.3">F.3</a>                  floating-point classification functions, <a href="#7.12.3">7.12.3</a>
+ferror function, <a href="#7.21.10.3">7.21.10.3</a>                                   floating-point control mode, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
+fesetenv function, <a href="#7.6.4.3">7.6.4.3</a>, <a href="#F.3">F.3</a>                              floating-point environment, <a href="#7.6">7.6</a>, <a href="#F.8">F.8</a>, <a href="#F.8.6">F.8.6</a>
+fesetexceptflag function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.4">7.6.2.4</a>, <a href="#F.3">F.3</a>                floating-point exception, <a href="#7.6">7.6</a>, <a href="#7.6.2">7.6.2</a>, <a href="#F.10">F.10</a>
+fesetround function, <a href="#7.6">7.6</a>, <a href="#7.6.3.2">7.6.3.2</a>, <a href="#F.3">F.3</a>                       floating-point number, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.2.5">6.2.5</a>
+fetestexcept function, <a href="#7.6.2">7.6.2</a>, <a href="#7.6.2.5">7.6.2.5</a>, <a href="#F.3">F.3</a>                   floating-point rounding mode, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+feupdateenv function, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.6.4.4">7.6.4.4</a>, <a href="#F.3">F.3</a>                  floating-point status flag, <a href="#7.6">7.6</a>, <a href="#F.8.6">F.8.6</a>
+fexcept_t type, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>                                     floor functions, <a href="#7.12.9.2">7.12.9.2</a>, <a href="#F.10.6.2">F.10.6.2</a>
+fflush function, <a href="#7.21.5.2">7.21.5.2</a>, <a href="#7.21.5.3">7.21.5.3</a>                          floor type-generic macro, <a href="#7.24">7.24</a>
+fgetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.1">7.21.7.1</a>,                    FLT_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+     <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.8.1">7.21.8.1</a>                                      FLT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+fgetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>                 FLT_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+fgets function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.2">7.21.7.2</a>, <a href="#K.3.5.4.1">K.3.5.4.1</a>                  FLT_EVAL_METHOD macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.6">6.6</a>, <a href="#7.12">7.12</a>,
+fgetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.28.3.1">7.28.3.1</a>,                        <a href="#F.10.11">F.10.11</a>
+     <a href="#7.28.3.6">7.28.3.6</a>                                                FLT_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+fgetws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.2">7.28.3.2</a>                            FLT_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+field width, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>                               FLT_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+file, <a href="#7.21.3">7.21.3</a>                                                  FLT_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  access functions, <a href="#7.21.5">7.21.5</a>, <a href="#K.3.5.2">K.3.5.2</a>                          FLT_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  name, <a href="#7.21.3">7.21.3</a>                                               FLT_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  operations, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>                                FLT_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  position indicator, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>,                FLT_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+        <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.1">7.21.7.1</a>, <a href="#7.21.7.3">7.21.7.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,             FLT_RADIX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,
+        <a href="#7.21.8.1">7.21.8.1</a>, <a href="#7.21.8.2">7.21.8.2</a>, <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.2">7.21.9.2</a>,                   <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+        <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.28.3.1">7.28.3.1</a>,              FLT_ROUNDS macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#F.3">F.3</a>
+        <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.3.10">7.28.3.10</a>                                  FLT_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  positioning functions, <a href="#7.21.9">7.21.9</a>                              fma functions, <a href="#7.12">7.12</a>, <a href="#7.12.13.1">7.12.13.1</a>, <a href="#F.10.10.1">F.10.10.1</a>
+file scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.9">6.9</a>                                        fma type-generic macro, <a href="#7.24">7.24</a>
+FILE type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                    fmax functions, <a href="#7.12.12.2">7.12.12.2</a>, <a href="#F.10.9.2">F.10.9.2</a>
+FILENAME_MAX macro, <a href="#7.21.1">7.21.1</a>                                   fmax type-generic macro, <a href="#7.24">7.24</a>
+flags, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>, see also floating-point             fmin functions, <a href="#7.12.12.3">7.12.12.3</a>, <a href="#F.10.9.3">F.10.9.3</a>
+     status flag                                              fmin type-generic macro, <a href="#7.24">7.24</a>
+flexible array member, <a href="#6.7.2.1">6.7.2.1</a>                                fmod functions, <a href="#7.12.10.1">7.12.10.1</a>, <a href="#F.10.7.1">F.10.7.1</a>
+float _Complex type, <a href="#6.2.5">6.2.5</a>                                   fmod type-generic macro, <a href="#7.24">7.24</a>
+
+[<a name="p662" href="#p662">page 662</a>] (<a href="#Contents">Contents</a>)
+
+fopen function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.5.4">7.21.5.4</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a>                       <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>
+FOPEN_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.4.3">7.21.4.3</a>,                    fseek function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
+     <a href="#K.3.5.1.1">K.3.5.1.1</a>                                                      <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>, <a href="#7.21.9.5">7.21.9.5</a>, <a href="#7.28.3.10">7.28.3.10</a>
+fopen_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.2.1">K.3.5.2.1</a>,                       fsetpos function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>,
+     <a href="#K.3.5.2.2">K.3.5.2.2</a>                                                      <a href="#7.21.9.1">7.21.9.1</a>, <a href="#7.21.9.3">7.21.9.3</a>, <a href="#7.28.3.10">7.28.3.10</a>
+for statement, <a href="#6.8.5">6.8.5</a>, <a href="#6.8.5.3">6.8.5.3</a>                                 ftell function, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>
+form-feed character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                               full declarator, <a href="#6.7.6">6.7.6</a>
+form-feed escape sequence (\f), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,               full expression, <a href="#6.8">6.8</a>
+     <a href="#7.4.1.10">7.4.1.10</a>                                                 fully buffered stream, <a href="#7.21.3">7.21.3</a>
+formal argument (deprecated), <a href="#3.16">3.16</a>                            function
+formal parameter, <a href="#3.16">3.16</a>                                           argument, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.9.1">6.9.1</a>
+formatted input/output functions, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.21.6">7.21.6</a>,              body, <a href="#6.9.1">6.9.1</a>
+     <a href="#K.3.5.3">K.3.5.3</a>                                                     call, <a href="#6.5.2.2">6.5.2.2</a>
+   wide character, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                                  library, <a href="#7.1.4">7.1.4</a>
+fortran keyword, <a href="#J.5.9">J.5.9</a>                                           declarator, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.11.6">6.11.6</a>
+forward reference, <a href="#3.11">3.11</a>                                          definition, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.7">6.11.7</a>
+FP_CONTRACT pragma, <a href="#6.5">6.5</a>, <a href="#6.10.6">6.10.6</a>, <a href="#7.12.2">7.12.2</a>, see                     designator, <a href="#6.3.2.1">6.3.2.1</a>
+     also contracted expression                                  image, <a href="#5.2.3">5.2.3</a>
+FP_FAST_FMA macro, <a href="#7.12">7.12</a>                                          inline, <a href="#6.7.4">6.7.4</a>
+FP_FAST_FMAF macro, <a href="#7.12">7.12</a>                                         library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.4">7.1.4</a>
+FP_FAST_FMAL macro, <a href="#7.12">7.12</a>                                         name length, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+FP_ILOGB0 macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                                  no-return, <a href="#6.7.4">6.7.4</a>
+FP_ILOGBNAN macro, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                                parameter, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
+FP_INFINITE macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                     prototype, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.7">6.2.7</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>,
+FP_NAN macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                                <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.9.1">6.9.1</a>, <a href="#6.11.6">6.11.6</a>, <a href="#6.11.7">6.11.7</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.12">7.12</a>
+FP_NORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                       prototype scope, <a href="#6.2.1">6.2.1</a>, <a href="#6.7.6.2">6.7.6.2</a>
+FP_SUBNORMAL macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                    recursive call, <a href="#6.5.2.2">6.5.2.2</a>
+FP_ZERO macro, <a href="#7.12">7.12</a>, <a href="#F.3">F.3</a>                                         return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
+fpclassify macro, <a href="#7.12.3.1">7.12.3.1</a>, <a href="#F.3">F.3</a>                                  scope, <a href="#6.2.1">6.2.1</a>
+fpos_t type, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>                                      type, <a href="#6.2.5">6.2.5</a>
+fprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.1">7.21.6.1</a>,                       type conversion, <a href="#6.3.2.1">6.3.2.1</a>
+     <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.6">7.21.6.6</a>,                  function specifiers, <a href="#6.7.4">6.7.4</a>
+     <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.1">K.3.5.3.1</a>                       function type, <a href="#6.2.5">6.2.5</a>
+fprintf_s function, <a href="#K.3.5.3.1">K.3.5.3.1</a>                                 function-call operator (( )), <a href="#6.5.2.2">6.5.2.2</a>
+fputc function, <a href="#5.2.2">5.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.7.3">7.21.7.3</a>,              function-like macro, <a href="#6.10.3">6.10.3</a>
+     <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.8.2">7.21.8.2</a>                                       fundamental alignment, <a href="#6.2.8">6.2.8</a>
+fputs function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.4">7.21.7.4</a>                              future directions
+fputwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.28.3.3">7.28.3.3</a>,                       language, <a href="#6.11">6.11</a>
+     <a href="#7.28.3.8">7.28.3.8</a>                                                    library, <a href="#7.30">7.30</a>
+fputws function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.4">7.28.3.4</a>                             fwide function, <a href="#7.21.2">7.21.2</a>, <a href="#7.28.3.5">7.28.3.5</a>
+fread function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.1">7.21.8.1</a>                              fwprintf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+free function, <a href="#7.22.3.3">7.22.3.3</a>, <a href="#7.22.3.5">7.22.3.5</a>                                   <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.2.3">7.28.2.3</a>, <a href="#7.28.2.5">7.28.2.5</a>,
+freestanding execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>,                       <a href="#7.28.2.11">7.28.2.11</a>, <a href="#K.3.9.1.1">K.3.9.1.1</a>
+     <a href="#5.1.2.1">5.1.2.1</a>                                                  fwprintf_s function, <a href="#K.3.9.1.1">K.3.9.1.1</a>
+freopen function, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.5.4">7.21.5.4</a>                            fwrite function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.8.2">7.21.8.2</a>
+freopen_s function, <a href="#K.3.5.2.2">K.3.5.2.2</a>                                 fwscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+frexp functions, <a href="#7.12.6.4">7.12.6.4</a>, <a href="#F.10.3.4">F.10.3.4</a>                                 <a href="#7.28.2.4">7.28.2.4</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.12">7.28.2.12</a>, <a href="#7.28.3.10">7.28.3.10</a>,
+frexp type-generic macro, <a href="#7.24">7.24</a>                                      <a href="#K.3.9.1.2">K.3.9.1.2</a>
+fscanf function, <a href="#7.8.1">7.8.1</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                     fwscanf_s function, <a href="#K.3.9.1.2">K.3.9.1.2</a>, <a href="#K.3.9.1.5">K.3.9.1.5</a>,
+     <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#F.3">F.3</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>                   <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
+fscanf_s function, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
+
+[<a name="p663" href="#p663">page 663</a>] (<a href="#Contents">Contents</a>)
+
+gamma functions, <a href="#7.12.8">7.12.8</a>, <a href="#F.10.5">F.10.5</a>                               name spaces, <a href="#6.2.3">6.2.3</a>
+general utilities, <a href="#7.22">7.22</a>, <a href="#K.3.6">K.3.6</a>                                reserved, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>
+  wide string, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>                                 scope, <a href="#6.2.1">6.2.1</a>
+general wide string utilities, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>                 type, <a href="#6.2.5">6.2.5</a>
+generic parameters, <a href="#7.24">7.24</a>                                    identifier list, <a href="#6.7.6">6.7.6</a>
+generic selection, <a href="#6.5.1.1">6.5.1.1</a>                                  identifier nondigit, <a href="#6.4.2.1">6.4.2.1</a>
+getc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.5">7.21.7.5</a>, <a href="#7.21.7.6">7.21.7.6</a>                   IEC 559, <a href="#F.1">F.1</a>
+getchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.6">7.21.7.6</a>                          IEC 60559, <a href="#2">2</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.3.3">7.3.3</a>,
+getenv function, <a href="#7.22.4.6">7.22.4.6</a>                                         <a href="#7.6">7.6</a>, <a href="#7.6.4.2">7.6.4.2</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.14">7.12.14</a>, <a href="#F">F</a>, <a href="#G">G</a>,
+getenv_s function, <a href="#K.3.6.2.1">K.3.6.2.1</a>                                      <a href="#H.1">H.1</a>
+gets function, <a href="#K.3.5.4.1">K.3.5.4.1</a>                                    IEEE 754, <a href="#F.1">F.1</a>
+gets_s function, <a href="#K.3.5.4.1">K.3.5.4.1</a>                                  IEEE 854, <a href="#F.1">F.1</a>
+getwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.6">7.28.3.6</a>, <a href="#7.28.3.7">7.28.3.7</a>                  IEEE floating-point arithmetic standard, see
+getwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.7">7.28.3.7</a>                               IEC 60559, ANSI/IEEE 754,
+gmtime function, <a href="#7.26.3.3">7.26.3.3</a>                                         ANSI/IEEE 854
+gmtime_s function, <a href="#K.3.8.2.3">K.3.8.2.3</a>                                if preprocessing directive, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>,
+goto statement, <a href="#6.2.1">6.2.1</a>, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.6.1">6.8.6.1</a>                             <a href="#6.10.1">6.10.1</a>, <a href="#7.1.4">7.1.4</a>
+graphic characters, <a href="#5.2.1">5.2.1</a>                                   if statement, <a href="#6.8.4.1">6.8.4.1</a>
+greater-than operator (&gt;), <a href="#6.5.8">6.5.8</a>                            ifdef preprocessing directive, <a href="#6.10.1">6.10.1</a>
+greater-than-or-equal-to operator (&gt;=), <a href="#6.5.8">6.5.8</a>               ifndef preprocessing directive, <a href="#6.10.1">6.10.1</a>
+                                                            ignore_handler_s function, <a href="#K.3.6.1.3">K.3.6.1.3</a>
+happens before, <a href="#5.1.2.4">5.1.2.4</a>                                     ilogb functions, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#F.10.3.5">F.10.3.5</a>
+header, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7.1.2">7.1.2</a>, see also standard headers           ilogb type-generic macro, <a href="#7.24">7.24</a>
+header names, <a href="#6.4">6.4</a>, <a href="#6.4.7">6.4.7</a>, <a href="#6.10.2">6.10.2</a>                            imaginary macro, <a href="#7.3.1">7.3.1</a>, <a href="#G.6">G.6</a>
+hexadecimal constant, <a href="#6.4.4.1">6.4.4.1</a>                               imaginary numbers, <a href="#G">G</a>
+hexadecimal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                imaginary type domain, <a href="#G.2">G.2</a>
+hexadecimal prefix, <a href="#6.4.4.1">6.4.4.1</a>                                  imaginary types, <a href="#G">G</a>
+hexadecimal-character escape sequence                       imaxabs function, <a href="#7.8.2.1">7.8.2.1</a>
+     (\x hexadecimal digits), <a href="#6.4.4.4">6.4.4.4</a>                       imaxdiv function, <a href="#7.8">7.8</a>, <a href="#7.8.2.2">7.8.2.2</a>
+high-order bit, <a href="#3.6">3.6</a>                                         imaxdiv_t type, <a href="#7.8">7.8</a>
+horizontal-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                        implementation, <a href="#3.12">3.12</a>
+horizontal-tab escape sequence (\r), <a href="#7.29.2.1.3">7.29.2.1.3</a>             implementation limit, <a href="#3.13">3.13</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.4.2.1">6.4.2.1</a>,
+horizontal-tab escape sequence (\t), <a href="#5.2.2">5.2.2</a>,                       <a href="#6.7.6">6.7.6</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#E">E</a>, see also environmental
+     <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.4.1.3">7.4.1.3</a>, <a href="#7.4.1.10">7.4.1.10</a>                                   limits
+hosted execution environment, <a href="#4">4</a>, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.2">5.1.2.2</a>             implementation-defined behavior, <a href="#3.4.1">3.4.1</a>, <a href="#4">4</a>, <a href="#J.3">J.3</a>
+HUGE_VAL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                     implementation-defined value, <a href="#3.19.1">3.19.1</a>
+     <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                       implicit conversion, <a href="#6.3">6.3</a>
+HUGE_VALF macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    implicit initialization, <a href="#6.7.9">6.7.9</a>
+     <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                       include preprocessing directive, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.2">6.10.2</a>
+HUGE_VALL macro, <a href="#7.12">7.12</a>, <a href="#7.12.1">7.12.1</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    inclusive OR operators
+     <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#F.10">F.10</a>                                         bitwise (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
+hyperbolic functions                                           bitwise assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+  complex, <a href="#7.3.6">7.3.6</a>, <a href="#G.6.2">G.6.2</a>                                     incomplete type, <a href="#6.2.5">6.2.5</a>
+  real, <a href="#7.12.5">7.12.5</a>, <a href="#F.10.2">F.10.2</a>                                      increment operators, see arithmetic operators,
+hypot functions, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#F.10.4.3">F.10.4.3</a>                               increment and decrement
+hypot type-generic macro, <a href="#7.24">7.24</a>                              indeterminate value, <a href="#3.19.2">3.19.2</a>
+                                                            indeterminately sequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>,
+I macro, <a href="#7.3.1">7.3.1</a>, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#G.6">G.6</a>                                      <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, see also sequenced before,
+identifier, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.5.1">6.5.1</a>                                         unsequenced
+   linkage, see linkage                                     indirection operator (*), <a href="#6.5.2.1">6.5.2.1</a>, <a href="#6.5.3.2">6.5.3.2</a>
+   maximum length, <a href="#6.4.2.1">6.4.2.1</a>                                  inequality operator (!=), <a href="#6.5.9">6.5.9</a>
+
+[<a name="p664" href="#p664">page 664</a>] (<a href="#Contents">Contents</a>)
+
+infinitary, <a href="#7.12.1">7.12.1</a>                                                    extended, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#7.20">7.20</a>
+INFINITY macro, <a href="#7.3.9.5">7.3.9.5</a>, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>                              inter-thread happens before, <a href="#5.1.2.4">5.1.2.4</a>
+initial position, <a href="#5.2.2">5.2.2</a>                                           interactive device, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a>
+initial shift state, <a href="#5.2.1.2">5.2.1.2</a>                                      internal linkage, <a href="#6.2.2">6.2.2</a>
+initialization, <a href="#5.1.2">5.1.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.5">6.5.2.5</a>, <a href="#6.7.9">6.7.9</a>,            internal name, <a href="#6.4.2.1">6.4.2.1</a>
+      <a href="#F.8.5">F.8.5</a>                                                       interrupt, <a href="#5.2.3">5.2.3</a>
+   in blocks, <a href="#6.8">6.8</a>                                                 INTMAX_C macro, <a href="#7.20.4.2">7.20.4.2</a>
+initializer, <a href="#6.7.9">6.7.9</a>                                                INTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
+   permitted form, <a href="#6.6">6.6</a>                                            INTMAX_MIN macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>
+   string literal, <a href="#6.3.2.1">6.3.2.1</a>                                        intmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+inline, <a href="#6.7.4">6.7.4</a>                                                           <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+inner scope, <a href="#6.2.1">6.2.1</a>                                                INTN_C macros, <a href="#7.20.4.1">7.20.4.1</a>
+input failure, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>,                     INTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>
+      <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>,                 INTN_MIN macros, <a href="#7.20.2.1">7.20.2.1</a>
+      <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>, <a href="#K.3.9.1.5">K.3.9.1.5</a>,               intN_t types, <a href="#7.20.1.1">7.20.1.1</a>
+      <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>               INTPTR_MAX macro, <a href="#7.20.2.4">7.20.2.4</a>
+input/output functions                                            INTPTR_MIN macro, <a href="#7.20.2.4">7.20.2.4</a>
+   character, <a href="#7.21.7">7.21.7</a>, <a href="#K.3.5.4">K.3.5.4</a>                                     intptr_t type, <a href="#7.20.1.4">7.20.1.4</a>
+   direct, <a href="#7.21.8">7.21.8</a>                                                 inttypes.h header, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>
+   formatted, <a href="#7.21.6">7.21.6</a>, <a href="#K.3.5.3">K.3.5.3</a>                                     isalnum function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.9">7.4.1.9</a>, <a href="#7.4.1.10">7.4.1.10</a>
+      wide character, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                             isalpha function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>
+   wide character, <a href="#7.28.3">7.28.3</a>                                         isblank function, <a href="#7.4.1.3">7.4.1.3</a>
+      formatted, <a href="#7.28.2">7.28.2</a>, <a href="#K.3.9.1">K.3.9.1</a>                                  iscntrl function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.4">7.4.1.4</a>, <a href="#7.4.1.7">7.4.1.7</a>,
+input/output header, <a href="#7.21">7.21</a>, <a href="#K.3.5">K.3.5</a>                                        <a href="#7.4.1.11">7.4.1.11</a>
+input/output, device, <a href="#5.1.2.3">5.1.2.3</a>                                     isdigit function, <a href="#7.4.1.1">7.4.1.1</a>, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.5">7.4.1.5</a>,
+int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.7.2">6.7.2</a>                       <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.11.1.1">7.11.1.1</a>
+int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,                   isfinite macro, <a href="#7.12.3.2">7.12.3.2</a>, <a href="#F.3">F.3</a>
+      <a href="#6.3.1.8">6.3.1.8</a>                                                     isgraph function, <a href="#7.4.1.6">7.4.1.6</a>
+INT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>                                    isgreater macro, <a href="#7.12.14.1">7.12.14.1</a>, <a href="#F.3">F.3</a>
+INT_FASTN_MIN macros, <a href="#7.20.2.3">7.20.2.3</a>                                    isgreaterequal macro, <a href="#7.12.14.2">7.12.14.2</a>, <a href="#F.3">F.3</a>
+int_fastN_t types, <a href="#7.20.1.3">7.20.1.3</a>                                       isinf macro, <a href="#7.12.3.3">7.12.3.3</a>
+INT_LEASTN_MAX macros, <a href="#7.20.2.2">7.20.2.2</a>                                   isless macro, <a href="#7.12.14.3">7.12.14.3</a>, <a href="#F.3">F.3</a>
+INT_LEASTN_MIN macros, <a href="#7.20.2.2">7.20.2.2</a>                                   islessequal macro, <a href="#7.12.14.4">7.12.14.4</a>, <a href="#F.3">F.3</a>
+int_leastN_t types, <a href="#7.20.1.2">7.20.1.2</a>                                      islessgreater macro, <a href="#7.12.14.5">7.12.14.5</a>, <a href="#F.3">F.3</a>
+INT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>, <a href="#7.12.6.5">7.12.6.5</a>                          islower function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.2.1">7.4.2.1</a>,
+INT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.12">7.12</a>                                          <a href="#7.4.2.2">7.4.2.2</a>
+integer arithmetic functions, <a href="#7.8.2.1">7.8.2.1</a>, <a href="#7.8.2.2">7.8.2.2</a>,                   isnan macro, <a href="#7.12.3.4">7.12.3.4</a>, <a href="#F.3">F.3</a>
+      <a href="#7.22.6">7.22.6</a>                                                      isnormal macro, <a href="#7.12.3.5">7.12.3.5</a>
+integer character constant, <a href="#6.4.4.4">6.4.4.4</a>                               ISO 31-11, <a href="#2">2</a>, <a href="#3">3</a>
+integer constant, <a href="#6.4.4.1">6.4.4.1</a>                                         ISO 4217, <a href="#2">2</a>, <a href="#7.11.2.1">7.11.2.1</a>
+integer constant expression, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.6">6.6</a>, <a href="#6.7.2.1">6.7.2.1</a>,               ISO 8601, <a href="#2">2</a>, <a href="#7.26.3.5">7.26.3.5</a>
+      <a href="#6.7.2.2">6.7.2.2</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.7.10">6.7.10</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#6.10.1">6.10.1</a>,           ISO/IEC 10646, <a href="#2">2</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.4.3">6.4.3</a>, <a href="#6.10.8.2">6.10.8.2</a>
+      <a href="#7.1.4">7.1.4</a>                                                       ISO/IEC 10976-1, <a href="#H.1">H.1</a>
+integer conversion rank, <a href="#6.3.1.1">6.3.1.1</a>                                  ISO/IEC 2382-1, <a href="#2">2</a>, <a href="#3">3</a>
+integer promotions, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.3.1.1">6.3.1.1</a>,                  ISO/IEC 646, <a href="#2">2</a>, <a href="#5.2.1.1">5.2.1.1</a>
+      <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.3.3">6.5.3.3</a>, <a href="#6.5.7">6.5.7</a>, <a href="#6.8.4.2">6.8.4.2</a>, <a href="#7.20.2">7.20.2</a>, <a href="#7.20.3">7.20.3</a>,           ISO/IEC 9945-2, <a href="#7.11">7.11</a>
+      <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>                                          iso646.h header, <a href="#4">4</a>, <a href="#7.9">7.9</a>                          *
+integer suffix, <a href="#6.4.4.1">6.4.4.1</a>                                            isprint function, <a href="#5.2.2">5.2.2</a>, <a href="#7.4.1.8">7.4.1.8</a>
+integer type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,               ispunct function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,
+      <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                                          <a href="#7.4.1.11">7.4.1.11</a>
+integer types, <a href="#6.2.5">6.2.5</a>, <a href="#7.20">7.20</a>                                        isspace function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.7">7.4.1.7</a>, <a href="#7.4.1.9">7.4.1.9</a>,
+
+[<a name="p665" href="#p665">page 665</a>] (<a href="#Contents">Contents</a>)
+
+      <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>,                   LC_ALL macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+      <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>                                        LC_COLLATE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.3">7.23.4.3</a>,
+isunordered macro, <a href="#7.12.14.6">7.12.14.6</a>, <a href="#F.3">F.3</a>                                     <a href="#7.28.4.4.2">7.28.4.4.2</a>
+isupper function, <a href="#7.4.1.2">7.4.1.2</a>, <a href="#7.4.1.11">7.4.1.11</a>, <a href="#7.4.2.1">7.4.2.1</a>,                   LC_CTYPE macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7">7.22.7</a>,
+      <a href="#7.4.2.2">7.4.2.2</a>                                                         <a href="#7.22.8">7.22.8</a>, <a href="#7.28.6">7.28.6</a>, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>,
+iswalnum function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>,                            <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>, <a href="#K.3.6.4">K.3.6.4</a>, <a href="#K.3.6.5">K.3.6.5</a>
+      <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   LC_MONETARY macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+iswalpha function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                      LC_NUMERIC macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>
+      <a href="#7.29.2.2.1">7.29.2.2.1</a>                                                LC_TIME macro, <a href="#7.11">7.11</a>, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.26.3.5">7.26.3.5</a>
+iswblank function, <a href="#7.29.2.1.3">7.29.2.1.3</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                       lconv structure type, <a href="#7.11">7.11</a>
+iswcntrl function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.4">7.29.2.1.4</a>,                      LDBL_DECIMAL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                       LDBL_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+iswctype function, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>                       LDBL_EPSILON macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+iswdigit function, <a href="#7.29.2.1.1">7.29.2.1.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                      LDBL_HAS_SUBNORM macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.29.2.1.5">7.29.2.1.5</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>           LDBL_MANT_DIG macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+iswgraph function, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.1.6">7.29.2.1.6</a>,                        LDBL_MAX macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.29.2.1.10">7.29.2.1.10</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   LDBL_MAX_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+iswlower function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.7">7.29.2.1.7</a>,                      LDBL_MAX_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.1.2">7.29.3.1.2</a>                        LDBL_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+iswprint function, <a href="#7.29.2.1.6">7.29.2.1.6</a>, <a href="#7.29.2.1.8">7.29.2.1.8</a>,                      LDBL_MIN_10_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.29.2.2.1">7.29.2.2.1</a>                                                LDBL_MIN_EXP macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+iswpunct function, <a href="#7.29.2.1">7.29.2.1</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>,                        LDBL_TRUE_MIN macro, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>,                      ldexp functions, <a href="#7.12.6.6">7.12.6.6</a>, <a href="#F.10.3.6">F.10.3.6</a>
+      <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   ldexp type-generic macro, <a href="#7.24">7.24</a>
+iswspace function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,                          ldiv function, <a href="#7.22.6.2">7.22.6.2</a>
+      <a href="#7.28.4.1.1">7.28.4.1.1</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.6">7.29.2.1.6</a>,           ldiv_t type, <a href="#7.22">7.22</a>
+      <a href="#7.29.2.1.7">7.29.2.1.7</a>, <a href="#7.29.2.1.9">7.29.2.1.9</a>, <a href="#7.29.2.1.10">7.29.2.1.10</a>,                      leading underscore in identifiers, <a href="#7.1.3">7.1.3</a>
+      <a href="#7.29.2.1.11">7.29.2.1.11</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                                   left-shift assignment operator (&lt;&lt;=), <a href="#6.5.16.2">6.5.16.2</a>
+iswupper function, <a href="#7.29.2.1.2">7.29.2.1.2</a>, <a href="#7.29.2.1.11">7.29.2.1.11</a>,                     left-shift operator (&lt;&lt;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+      <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.1.2">7.29.3.1.2</a>                        length
+iswxdigit function, <a href="#7.29.2.1.12">7.29.2.1.12</a>, <a href="#7.29.2.2.1">7.29.2.2.1</a>                        external name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+isxdigit function, <a href="#7.4.1.12">7.4.1.12</a>, <a href="#7.11.1.1">7.11.1.1</a>                              function name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+italic type convention, <a href="#3">3</a>, <a href="#6.1">6.1</a>                                     identifier, <a href="#6.4.2.1">6.4.2.1</a>
+iteration statements, <a href="#6.8.5">6.8.5</a>                                        internal name, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+                                                                length function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.23.6.3">7.23.6.3</a>, <a href="#7.28.4.6.1">7.28.4.6.1</a>,
+jmp_buf type, <a href="#7.13">7.13</a>                                                    <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#K.3.7.4.4">K.3.7.4.4</a>, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a>
+jump statements, <a href="#6.8.6">6.8.6</a>                                          length modifier, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>,
+                                                                      <a href="#7.28.2.2">7.28.2.2</a>
+keywords, <a href="#6.4.1">6.4.1</a>, <a href="#G.2">G.2</a>, <a href="#J.5.9">J.5.9</a>, <a href="#J.5.10">J.5.10</a>                             less-than operator (&lt;), <a href="#6.5.8">6.5.8</a>
+kill_dependency macro, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.17.3.1">7.17.3.1</a>                        less-than-or-equal-to operator (&lt;=), <a href="#6.5.8">6.5.8</a>
+known constant size, <a href="#6.2.5">6.2.5</a>                                      letter, <a href="#5.2.1">5.2.1</a>, <a href="#7.4">7.4</a>
+                                                                lexical elements, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>
+L_tmpnam macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.4">7.21.4.4</a>                                lgamma functions, <a href="#7.12.8.3">7.12.8.3</a>, <a href="#F.10.5.3">F.10.5.3</a>
+L_tmpnam_s macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                              lgamma type-generic macro, <a href="#7.24">7.24</a>
+label name, <a href="#6.2.1">6.2.1</a>, <a href="#6.2.3">6.2.3</a>                                        library, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#7">7</a>, <a href="#K.3">K.3</a>
+labeled statement, <a href="#6.8.1">6.8.1</a>                                           future directions, <a href="#7.30">7.30</a>
+labs function, <a href="#7.22.6.1">7.22.6.1</a>                                            summary, <a href="#B">B</a>
+language, <a href="#6">6</a>                                                        terms, <a href="#7.1.1">7.1.1</a>
+   future directions, <a href="#6.11">6.11</a>                                         use of functions, <a href="#7.1.4">7.1.4</a>
+   syntax summary, <a href="#A">A</a>                                            lifetime, <a href="#6.2.4">6.2.4</a>
+Latin alphabet, <a href="#5.2.1">5.2.1</a>, <a href="#6.4.2.1">6.4.2.1</a>                                  limits
+
+[<a name="p666" href="#p666">page 666</a>] (<a href="#Contents">Contents</a>)
+
+   environmental, see environmental limits                      <a href="#6.3.1.6">6.3.1.6</a>, <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+   implementation, see implementation limits               long double _Imaginary type, <a href="#G.2">G.2</a>
+   numerical, see numerical limits                         long double suffix, l or <a href="#L">L</a>, <a href="#6.4.4.2">6.4.4.2</a>
+   translation, see translation limits                     long double type, <a href="#6.2.5">6.2.5</a>, <a href="#6.4.4.2">6.4.4.2</a>, <a href="#6.7.2">6.7.2</a>,
+limits.h header, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                      <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.2">F.2</a>
+line buffered stream, <a href="#7.21.3">7.21.3</a>                               long double type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,
+line number, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a>                                   <a href="#6.3.1.7">6.3.1.7</a>, <a href="#6.3.1.8">6.3.1.8</a>
+line preprocessing directive, <a href="#6.10.4">6.10.4</a>                       long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,
+lines, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#7.21.2">7.21.2</a>                                          <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+   preprocessing directive, <a href="#6.10">6.10</a>                           long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+linkage, <a href="#6.2.2">6.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.7.4">6.7.4</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.9">6.9</a>, <a href="#6.9.2">6.9.2</a>,                <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+      <a href="#6.11.2">6.11.2</a>                                               long integer suffix, l or <a href="#L">L</a>, <a href="#6.4.4.1">6.4.4.1</a>
+llabs function, <a href="#7.22.6.1">7.22.6.1</a>                                   long long int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>,
+lldiv function, <a href="#7.22.6.2">7.22.6.2</a>                                        <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+lldiv_t type, <a href="#7.22">7.22</a>                                         long long int type conversion, <a href="#6.3.1.1">6.3.1.1</a>,
+LLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                           <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+      <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           long long integer suffix, ll or LL, <a href="#6.4.4.1">6.4.4.1</a>
+LLONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                      LONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
+      <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           LONG_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
+llrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a>                  longjmp function, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>, <a href="#7.22.4.4">7.22.4.4</a>,
+llrint type-generic macro, <a href="#7.24">7.24</a>                                 <a href="#7.22.4.7">7.22.4.7</a>
+llround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a>                      loop body, <a href="#6.8.5">6.8.5</a>
+llround type-generic macro, <a href="#7.24">7.24</a>                           low-order bit, <a href="#3.6">3.6</a>
+local time, <a href="#7.26.1">7.26.1</a>                                         lowercase letter, <a href="#5.2.1">5.2.1</a>
+locale, <a href="#3.4.2">3.4.2</a>                                              lrint functions, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.5">F.10.6.5</a>
+locale-specific behavior, <a href="#3.4.2">3.4.2</a>, <a href="#J.4">J.4</a>                        lrint type-generic macro, <a href="#7.24">7.24</a>
+locale.h header, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>                              lround functions, <a href="#7.12.9.7">7.12.9.7</a>, <a href="#F.10.6.7">F.10.6.7</a>
+localeconv function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>                    lround type-generic macro, <a href="#7.24">7.24</a>
+localization, <a href="#7.11">7.11</a>                                         lvalue, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.3.1">6.5.3.1</a>, <a href="#6.5.16">6.5.16</a>,
+localtime function, <a href="#7.26.3.4">7.26.3.4</a>                                    <a href="#6.7.2.4">6.7.2.4</a>
+localtime_s function, <a href="#K.3.8.2.4">K.3.8.2.4</a>                            lvalue conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.5.16.1">6.5.16.1</a>,
+log functions, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#F.10.3.7">F.10.3.7</a>                               <a href="#6.5.16.2">6.5.16.2</a>
+log type-generic macro, <a href="#7.24">7.24</a>
+log10 functions, <a href="#7.12.6.8">7.12.6.8</a>, <a href="#F.10.3.8">F.10.3.8</a>                        macro argument substitution, <a href="#6.10.3.1">6.10.3.1</a>
+log10 type-generic macro, <a href="#7.24">7.24</a>                             macro definition
+log1p functions, <a href="#7.12.6.9">7.12.6.9</a>, <a href="#F.10.3.9">F.10.3.9</a>                          library function, <a href="#7.1.4">7.1.4</a>
+log1p type-generic macro, <a href="#7.24">7.24</a>                             macro invocation, <a href="#6.10.3">6.10.3</a>
+log2 functions, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#F.10.3.10">F.10.3.10</a>                       macro name, <a href="#6.10.3">6.10.3</a>
+log2 type-generic macro, <a href="#7.24">7.24</a>                                length, <a href="#5.2.4.1">5.2.4.1</a>
+logarithmic functions                                        predefined, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>
+   complex, <a href="#7.3.7">7.3.7</a>, <a href="#G.6.3">G.6.3</a>                                     redefinition, <a href="#6.10.3">6.10.3</a>
+   real, <a href="#7.12.6">7.12.6</a>, <a href="#F.10.3">F.10.3</a>                                      scope, <a href="#6.10.3.5">6.10.3.5</a>
+logb functions, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.11">F.10.3.11</a>                  macro parameter, <a href="#6.10.3">6.10.3</a>
+logb type-generic macro, <a href="#7.24">7.24</a>                              macro preprocessor, <a href="#6.10">6.10</a>
+logical operators                                          macro replacement, <a href="#6.10.3">6.10.3</a>
+   AND (&amp;&amp;), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.13">6.5.13</a>                               magnitude, complex, <a href="#7.3.8.1">7.3.8.1</a>
+   negation (!), <a href="#6.5.3.3">6.5.3.3</a>                                   main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.4">6.7.4</a>,
+   OR (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>                                     <a href="#7.21.3">7.21.3</a>
+logical source lines, <a href="#5.1.1.2">5.1.1.2</a>                              malloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.4">7.22.3.4</a>, <a href="#7.22.3.5">7.22.3.5</a>
+long double _Complex type, <a href="#6.2.5">6.2.5</a>                           manipulation functions
+long double _Complex type conversion,                        complex, <a href="#7.3.9">7.3.9</a>
+
+[<a name="p667" href="#p667">page 667</a>] (<a href="#Contents">Contents</a>)
+
+  real, <a href="#7.12.11">7.12.11</a>, <a href="#F.10.8">F.10.8</a>                                    modf functions, <a href="#7.12.6.12">7.12.6.12</a>, <a href="#F.10.3.12">F.10.3.12</a>
+matching failure, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.10">7.28.2.10</a>,           modifiable lvalue, <a href="#6.3.2.1">6.3.2.1</a>
+     <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>                     modification order, <a href="#5.1.2.4">5.1.2.4</a>
+math.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>,              modulus functions, <a href="#7.12.6.12">7.12.6.12</a>
+     <a href="#F.10">F.10</a>, <a href="#J.5.17">J.5.17</a>                                          modulus, complex, <a href="#7.3.8.1">7.3.8.1</a>
+MATH_ERREXCEPT macro, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>                           mtx_destroy function, <a href="#7.25.4.1">7.25.4.1</a>
+math_errhandling macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.12">7.12</a>, <a href="#F.10">F.10</a>                  mtx_init function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.4.2">7.25.4.2</a>
+MATH_ERRNO macro, <a href="#7.12">7.12</a>                                     mtx_lock function, <a href="#7.25.4.3">7.25.4.3</a>
+max_align_t type, <a href="#7.19">7.19</a>                                     mtx_t type, <a href="#7.25.1">7.25.1</a>
+maximum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                         mtx_timedlock function, <a href="#7.25.4.4">7.25.4.4</a>
+MB_CUR_MAX macro, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a>, <a href="#7.22.7.2">7.22.7.2</a>,                   mtx_trylock function, <a href="#7.25.4.5">7.25.4.5</a>
+     <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.27.1.2">7.27.1.2</a>, <a href="#7.27.1.4">7.27.1.4</a>, <a href="#7.28.6.3.3">7.28.6.3.3</a>,             mtx_unlock function, <a href="#7.25.4.3">7.25.4.3</a>, <a href="#7.25.4.4">7.25.4.4</a>,
+     <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>                                     <a href="#7.25.4.5">7.25.4.5</a>, <a href="#7.25.4.6">7.25.4.6</a>
+MB_LEN_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.1.1">7.1.1</a>, <a href="#7.22">7.22</a>                   multibyte character, <a href="#3.7.2">3.7.2</a>, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#6.4.4.4">6.4.4.4</a>
+mblen function, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.28.6.3">7.28.6.3</a>                         multibyte conversion functions
+mbrlen function, <a href="#7.28.6.3.1">7.28.6.3.1</a>                                  wide character, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
+mbrtoc16 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27.1.1">7.27.1.1</a>                     extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
+mbrtoc32 function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27.1.3">7.27.1.3</a>                     restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
+mbrtowc function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                wide string, <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
+     <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#7.28.6.3.2">7.28.6.3.2</a>,                restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
+     <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>                    multibyte string, <a href="#7.1.1">7.1.1</a>
+mbsinit function, <a href="#7.28.6.2.1">7.28.6.2.1</a>                               multibyte/wide character conversion functions,
+mbsrtowcs function, <a href="#7.28.6.4.1">7.28.6.4.1</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                       <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>
+mbsrtowcs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>                 extended, <a href="#7.28.6">7.28.6</a>, <a href="#K.3.9.3">K.3.9.3</a>
+mbstate_t type, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.1">7.21.6.1</a>,                    restartable, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>
+     <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.27">7.27</a>, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>,             multibyte/wide string conversion functions,
+     <a href="#7.28.2.2">7.28.2.2</a>, <a href="#7.28.6">7.28.6</a>, <a href="#7.28.6.2.1">7.28.6.2.1</a>, <a href="#7.28.6.3">7.28.6.3</a>,                    <a href="#7.22.8">7.22.8</a>, <a href="#K.3.6.5">K.3.6.5</a>
+     <a href="#7.28.6.3.1">7.28.6.3.1</a>, <a href="#7.28.6.4">7.28.6.4</a>                                    restartable, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
+mbstowcs function, <a href="#6.4.5">6.4.5</a>, <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.28.6.4">7.28.6.4</a>               multidimensional array, <a href="#6.5.2.1">6.5.2.1</a>
+mbstowcs_s function, <a href="#K.3.6.5.1">K.3.6.5.1</a>                             multiplication assignment operator (*=), <a href="#6.5.16.2">6.5.16.2</a>
+mbtowc function, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#7.22.7.1">7.22.7.1</a>, <a href="#7.22.7.2">7.22.7.2</a>,              multiplication operator (*), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#F.3">F.3</a>,
+     <a href="#7.22.8.1">7.22.8.1</a>, <a href="#7.28.6.3">7.28.6.3</a>                                         <a href="#G.5.1">G.5.1</a>
+member access operators (. and -&gt;), <a href="#6.5.2.3">6.5.2.3</a>                multiplicative expressions, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+memchr function, <a href="#7.23.5.1">7.23.5.1</a>                                  n-char sequence, <a href="#7.22.1.3">7.22.1.3</a>
+memcmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.1">7.23.4.1</a>                          n-wchar sequence, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+memcpy function, <a href="#7.23.2.1">7.23.2.1</a>                                  name
+memcpy_s function, <a href="#K.3.7.1.1">K.3.7.1.1</a>                                 external, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>, <a href="#6.11.3">6.11.3</a>
+memmove function, <a href="#7.23.2.2">7.23.2.2</a>                                   file, <a href="#7.21.3">7.21.3</a>
+memmove_s function, <a href="#K.3.7.1.2">K.3.7.1.2</a>                                internal, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.2.1">6.4.2.1</a>
+memory location, <a href="#3.14">3.14</a>                                        label, <a href="#6.2.3">6.2.3</a>
+memory management functions, <a href="#7.22.3">7.22.3</a>                          structure/union member, <a href="#6.2.3">6.2.3</a>
+memory_order type, <a href="#7.17.1">7.17.1</a>, <a href="#7.17.3">7.17.3</a>                          name spaces, <a href="#6.2.3">6.2.3</a>
+memset function, <a href="#7.23.6.1">7.23.6.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>                       named label, <a href="#6.8.1">6.8.1</a>
+memset_s function, <a href="#K.3.7.4.1">K.3.7.4.1</a>                               NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+minimum functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                         nan functions, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#F.2.1">F.2.1</a>, <a href="#F.10.8.2">F.10.8.2</a>
+minus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                             NAN macro, <a href="#7.12">7.12</a>, <a href="#F.2.1">F.2.1</a>
+miscellaneous functions                                    NDEBUG macro, <a href="#7.2">7.2</a>
+  string, <a href="#7.23.6">7.23.6</a>, <a href="#K.3.7.4">K.3.7.4</a>                                  nearbyint functions, <a href="#7.12.9.3">7.12.9.3</a>, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>,
+  wide string, <a href="#7.28.4.6">7.28.4.6</a>, <a href="#K.3.9.2.4">K.3.9.2.4</a>                              <a href="#F.10.6.3">F.10.6.3</a>
+mktime function, <a href="#7.26.2.3">7.26.2.3</a>                                  nearbyint type-generic macro, <a href="#7.24">7.24</a>
+
+[<a name="p668" href="#p668">page 668</a>] (<a href="#Contents">Contents</a>)
+
+nearest integer functions, <a href="#7.12.9">7.12.9</a>, <a href="#F.10.6">F.10.6</a>                       operating system, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#7.22.4.8">7.22.4.8</a>
+negation operator (!), <a href="#6.5.3.3">6.5.3.3</a>                                  operations on files, <a href="#7.21.4">7.21.4</a>, <a href="#K.3.5.1">K.3.5.1</a>
+negative zero, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.12.11.1">7.12.11.1</a>                               operator, <a href="#6.4.6">6.4.6</a>
+new-line character, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#6.10.4">6.10.4</a>           operators, <a href="#6.5">6.5</a>
+new-line escape sequence (\n), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,                     additive, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>
+     <a href="#7.4.1.10">7.4.1.10</a>                                                      alignof, <a href="#6.5.3.4">6.5.3.4</a>
+nextafter functions, <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>,                    assignment, <a href="#6.5.16">6.5.16</a>
+     <a href="#F.10.8.3">F.10.8.3</a>                                                      associativity, <a href="#6.5">6.5</a>
+nextafter type-generic macro, <a href="#7.24">7.24</a>                                 equality, <a href="#6.5.9">6.5.9</a>
+nexttoward functions, <a href="#7.12.11.4">7.12.11.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.8.4">F.10.8.4</a>                     multiplicative, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>, <a href="#G.5.1">G.5.1</a>
+nexttoward type-generic macro, <a href="#7.24">7.24</a>                                postfix, <a href="#6.5.2">6.5.2</a>
+no linkage, <a href="#6.2.2">6.2.2</a>                                                  precedence, <a href="#6.5">6.5</a>
+no-return function, <a href="#6.7.4">6.7.4</a>                                          preprocessing, <a href="#6.10.1">6.10.1</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>, <a href="#6.10.9">6.10.9</a>
+non-stop floating-point control mode, <a href="#7.6.4.2">7.6.4.2</a>                       relational, <a href="#6.5.8">6.5.8</a>
+nongraphic characters, <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>                              shift, <a href="#6.5.7">6.5.7</a>
+nonlocal jumps header, <a href="#7.13">7.13</a>                                        sizeof, <a href="#6.5.3.4">6.5.3.4</a>
+norm, complex, <a href="#7.3.8.1">7.3.8.1</a>                                             unary, <a href="#6.5.3">6.5.3</a>
+normalized broken-down time, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>                    unary arithmetic, <a href="#6.5.3.3">6.5.3.3</a>
+not macro, <a href="#7.9">7.9</a>                                                  optional features, see conditional features
+not-equal-to operator, see inequality operator                  or macro, <a href="#7.9">7.9</a>
+not_eq macro, <a href="#7.9">7.9</a>                                               OR operators
+null character (\0), <a href="#5.2.1">5.2.1</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>                         bitwise exclusive (^), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.11">6.5.11</a>
+  padding of binary stream, <a href="#7.21.2">7.21.2</a>                                 bitwise exclusive assignment (^=), <a href="#6.5.16.2">6.5.16.2</a>
+NULL macro, <a href="#7.11">7.11</a>, <a href="#7.19">7.19</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.22">7.22</a>, <a href="#7.23.1">7.23.1</a>,                      bitwise inclusive (|), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.12">6.5.12</a>
+     <a href="#7.26.1">7.26.1</a>, <a href="#7.28.1">7.28.1</a>                                                bitwise inclusive assignment (|=), <a href="#6.5.16.2">6.5.16.2</a>
+null pointer, <a href="#6.3.2.3">6.3.2.3</a>                                              logical (||), <a href="#5.1.2.4">5.1.2.4</a>, <a href="#6.5.14">6.5.14</a>
+null pointer constant, <a href="#6.3.2.3">6.3.2.3</a>                                  or_eq macro, <a href="#7.9">7.9</a>
+null preprocessing directive, <a href="#6.10.7">6.10.7</a>                            order of allocated storage, <a href="#7.22.3">7.22.3</a>
+null statement, <a href="#6.8.3">6.8.3</a>                                           order of evaluation, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.3.3">6.10.3.3</a>,
+null wide character, <a href="#7.1.1">7.1.1</a>                                            see also sequence points
+number classification macros, <a href="#7.12">7.12</a>, <a href="#7.12.3.1">7.12.3.1</a>                     ordinary identifier name space, <a href="#6.2.3">6.2.3</a>
+numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                   orientation of stream, <a href="#7.21.2">7.21.2</a>, <a href="#7.28.3.5">7.28.3.5</a>
+  wide string, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1">7.28.4.1</a>                                out-of-bounds store, <a href="#L.2.1">L.2.1</a>
+numerical limits, <a href="#5.2.4.2">5.2.4.2</a>                                       outer scope, <a href="#6.2.1">6.2.1</a>
+                                                                over-aligned, <a href="#6.2.8">6.2.8</a>
+object, <a href="#3.15">3.15</a>
+object representation, <a href="#6.2.6.1">6.2.6.1</a>                                  padding
+object type, <a href="#6.2.5">6.2.5</a>                                                binary stream, <a href="#7.21.2">7.21.2</a>
+object-like macro, <a href="#6.10.3">6.10.3</a>                                         bits, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a>
+observable behavior, <a href="#5.1.2.3">5.1.2.3</a>                                      structure/union, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+obsolescence, <a href="#6.11">6.11</a>, <a href="#7.30">7.30</a>                                        parameter, <a href="#3.16">3.16</a>
+octal constant, <a href="#6.4.4.1">6.4.4.1</a>                                           array, <a href="#6.9.1">6.9.1</a>
+octal digit, <a href="#6.4.4.1">6.4.4.1</a>, <a href="#6.4.4.4">6.4.4.4</a>                                     ellipsis, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.10.3">6.10.3</a>
+octal-character escape sequence (\octal digits),                  function, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.7">6.7</a>, <a href="#6.9.1">6.9.1</a>
+     <a href="#6.4.4.4">6.4.4.4</a>                                                      macro, <a href="#6.10.3">6.10.3</a>
+offsetof macro, <a href="#7.19">7.19</a>                                              main function, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+on-off switch, <a href="#6.10.6">6.10.6</a>                                             program, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+once_flag type, <a href="#7.25.1">7.25.1</a>                                          parameter type list, <a href="#6.7.6.3">6.7.6.3</a>
+ONCE_FLAG_INIT macro, <a href="#7.25.1">7.25.1</a>                                    parentheses punctuator (( )), <a href="#6.7.6.3">6.7.6.3</a>, <a href="#6.8.4">6.8.4</a>, <a href="#6.8.5">6.8.5</a>
+ones' complement, <a href="#6.2.6.2">6.2.6.2</a>                                       parenthesized expression, <a href="#6.5.1">6.5.1</a>
+operand, <a href="#6.4.6">6.4.6</a>, <a href="#6.5">6.5</a>                                             parse state, <a href="#7.21.2">7.21.2</a>
+
+[<a name="p669" href="#p669">page 669</a>] (<a href="#Contents">Contents</a>)
+
+perform a trap, <a href="#3.19.5">3.19.5</a>                                        preprocessor, <a href="#6.10">6.10</a>
+permitted form of initializer, <a href="#6.6">6.6</a>                            PRIcFASTN macros, <a href="#7.8.1">7.8.1</a>
+perror function, <a href="#7.21.10.4">7.21.10.4</a>                                    PRIcLEASTN macros, <a href="#7.8.1">7.8.1</a>
+phase angle, complex, <a href="#7.3.9.1">7.3.9.1</a>                                 PRIcMAX macros, <a href="#7.8.1">7.8.1</a>
+physical source lines, <a href="#5.1.1.2">5.1.1.2</a>                                PRIcN macros, <a href="#7.8.1">7.8.1</a>
+placemarker, <a href="#6.10.3.3">6.10.3.3</a>                                         PRIcPTR macros, <a href="#7.8.1">7.8.1</a>
+plus operator, unary, <a href="#6.5.3.3">6.5.3.3</a>                                 primary expression, <a href="#6.5.1">6.5.1</a>
+pointer arithmetic, <a href="#6.5.6">6.5.6</a>                                     printf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.3">7.21.6.3</a>, <a href="#7.21.6.10">7.21.6.10</a>,
+pointer comparison, <a href="#6.5.8">6.5.8</a>                                           <a href="#K.3.5.3.3">K.3.5.3.3</a>
+pointer declarator, <a href="#6.7.6.1">6.7.6.1</a>                                   printf_s function, <a href="#K.3.5.3.3">K.3.5.3.3</a>
+pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                printing character, <a href="#5.2.2">5.2.2</a>, <a href="#7.4">7.4</a>, <a href="#7.4.1.8">7.4.1.8</a>
+pointer to function, <a href="#6.5.2.2">6.5.2.2</a>                                  printing wide character, <a href="#7.29.2">7.29.2</a>
+pointer type, <a href="#6.2.5">6.2.5</a>                                           program diagnostics, <a href="#7.2.1">7.2.1</a>
+pointer type conversion, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>                     program execution, <a href="#5.1.2.2.2">5.1.2.2.2</a>, <a href="#5.1.2.3">5.1.2.3</a>
+pointer, null, <a href="#6.3.2.3">6.3.2.3</a>                                        program file, <a href="#5.1.1.1">5.1.1.1</a>
+pole error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.3">7.12.5.3</a>, <a href="#7.12.6.7">7.12.6.7</a>, <a href="#7.12.6.8">7.12.6.8</a>,             program image, <a href="#5.1.1.2">5.1.1.2</a>
+     <a href="#7.12.6.9">7.12.6.9</a>, <a href="#7.12.6.10">7.12.6.10</a>, <a href="#7.12.6.11">7.12.6.11</a>, <a href="#7.12.7.4">7.12.7.4</a>,                program name (argv[0]), <a href="#5.1.2.2.1">5.1.2.2.1</a>
+     <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>                                       program parameters, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+portability, <a href="#4">4</a>, <a href="#J">J</a>                                             program startup, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.1">5.1.2.2.1</a>
+position indicator, file, see file position indicator           program structure, <a href="#5.1.1.1">5.1.1.1</a>
+positive difference, <a href="#7.12.12.1">7.12.12.1</a>                                program termination, <a href="#5.1.2">5.1.2</a>, <a href="#5.1.2.1">5.1.2.1</a>, <a href="#5.1.2.2.3">5.1.2.2.3</a>,
+positive difference functions, <a href="#7.12.12">7.12.12</a>, <a href="#F.10.9">F.10.9</a>                      <a href="#5.1.2.3">5.1.2.3</a>
+postfix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              program, conforming, <a href="#4">4</a>
+postfix expressions, <a href="#6.5.2">6.5.2</a>                                     program, strictly conforming, <a href="#4">4</a>
+postfix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.4">6.5.2.4</a>              promotions
+pow functions, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#F.10.4.4">F.10.4.4</a>                                default argument, <a href="#6.5.2.2">6.5.2.2</a>
+pow type-generic macro, <a href="#7.24">7.24</a>                                     integer, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.3.1.1">6.3.1.1</a>
+power functions                                               prototype, see function prototype
+  complex, <a href="#7.3.8">7.3.8</a>, <a href="#G.6.4">G.6.4</a>                                       pseudo-random sequence functions, <a href="#7.22.2">7.22.2</a>
+  real, <a href="#7.12.7">7.12.7</a>, <a href="#F.10.4">F.10.4</a>                                        PTRDIFF_MAX macro, <a href="#7.20.3">7.20.3</a>
+pp-number, <a href="#6.4.8">6.4.8</a>                                              PTRDIFF_MIN macro, <a href="#7.20.3">7.20.3</a>
+pragma operator, <a href="#6.10.9">6.10.9</a>                                       ptrdiff_t type, <a href="#7.17.1">7.17.1</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>,
+pragma preprocessing directive, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>                      <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+precedence of operators, <a href="#6.5">6.5</a>                                  punctuators, <a href="#6.4.6">6.4.6</a>
+precedence of syntax rules, <a href="#5.1.1.2">5.1.1.2</a>                           putc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.21.7.8">7.21.7.8</a>
+precision, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.2.1">7.28.2.1</a>               putchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.8">7.21.7.8</a>
+  excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                         puts function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.9">7.21.7.9</a>
+predefined macro names, <a href="#6.10.8">6.10.8</a>, <a href="#6.11.9">6.11.9</a>                         putwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#7.28.3.9">7.28.3.9</a>
+prefix decrement operator (--), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>               putwchar function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.9">7.28.3.9</a>
+prefix increment operator (++), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3.1">6.5.3.1</a>
+preprocessing concatenation, <a href="#6.10.3.3">6.10.3.3</a>                         qsort function, <a href="#7.22.5">7.22.5</a>, <a href="#7.22.5.2">7.22.5.2</a>
+preprocessing directives, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10">6.10</a>                       qsort_s function, <a href="#K.3.6.3">K.3.6.3</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>
+preprocessing file, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.10">6.10</a>                              qualified types, <a href="#6.2.5">6.2.5</a>
+preprocessing numbers, <a href="#6.4">6.4</a>, <a href="#6.4.8">6.4.8</a>                             qualified version of type, <a href="#6.2.5">6.2.5</a>
+preprocessing operators                                       question-mark escape sequence (\?), <a href="#6.4.4.4">6.4.4.4</a>
+  #, <a href="#6.10.3.2">6.10.3.2</a>                                                 quick_exit function, <a href="#7.22.4.3">7.22.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>,
+  ##, <a href="#6.10.3.3">6.10.3.3</a>                                                     <a href="#7.22.4.7">7.22.4.7</a>
+  _Pragma, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.10.9">6.10.9</a>                                    quiet NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+  defined, <a href="#6.10.1">6.10.1</a>
+preprocessing tokens, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>                      raise function, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>, <a href="#7.22.4.1">7.22.4.1</a>
+preprocessing translation unit, <a href="#5.1.1.1">5.1.1.1</a>                       rand function, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a>, <a href="#7.22.2.2">7.22.2.2</a>
+
+[<a name="p670" href="#p670">page 670</a>] (<a href="#Contents">Contents</a>)
+
+RAND_MAX macro, <a href="#7.22">7.22</a>, <a href="#7.22.2.1">7.22.2.1</a>                               restrict-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>
+range                                                        return statement, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
+   excess, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.8.6.4">6.8.6.4</a>                       rewind function, <a href="#7.21.5.3">7.21.5.3</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.5">7.21.9.5</a>,
+range error, <a href="#7.12.1">7.12.1</a>, <a href="#7.12.5.4">7.12.5.4</a>, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#7.12.6.1">7.12.6.1</a>,                 <a href="#7.28.3.10">7.28.3.10</a>
+      <a href="#7.12.6.2">7.12.6.2</a>, <a href="#7.12.6.3">7.12.6.3</a>, <a href="#7.12.6.5">7.12.6.5</a>, <a href="#7.12.6.6">7.12.6.6</a>,                right-shift assignment operator (&gt;&gt;=), <a href="#6.5.16.2">6.5.16.2</a>
+      <a href="#7.12.6.13">7.12.6.13</a>, <a href="#7.12.7.3">7.12.7.3</a>, <a href="#7.12.7.4">7.12.7.4</a>, <a href="#7.12.8.2">7.12.8.2</a>,               right-shift operator (&gt;&gt;), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.7">6.5.7</a>
+      <a href="#7.12.8.3">7.12.8.3</a>, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#7.12.9.5">7.12.9.5</a>, <a href="#7.12.9.7">7.12.9.7</a>,                rint functions, <a href="#7.12.9.4">7.12.9.4</a>, <a href="#F.3">F.3</a>, <a href="#F.10.6.4">F.10.6.4</a>
+      <a href="#7.12.11.3">7.12.11.3</a>, <a href="#7.12.12.1">7.12.12.1</a>, <a href="#7.12.13.1">7.12.13.1</a>                        rint type-generic macro, <a href="#7.24">7.24</a>
+rank, see integer conversion rank                            round functions, <a href="#7.12.9.6">7.12.9.6</a>, <a href="#F.10.6.6">F.10.6.6</a>
+read-modify-write operations, <a href="#5.1.2.4">5.1.2.4</a>                        round type-generic macro, <a href="#7.24">7.24</a>
+real floating type conversion, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.5">6.3.1.5</a>,              rounding mode, floating point, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+      <a href="#6.3.1.7">6.3.1.7</a>, <a href="#F.3">F.3</a>, <a href="#F.4">F.4</a>                                      RSIZE_MAX macro, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>,
+real floating types, <a href="#6.2.5">6.2.5</a>                                          <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>, <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>,
+real type domain, <a href="#6.2.5">6.2.5</a>                                            <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.6.2.1">K.3.6.2.1</a>, <a href="#K.3.6.3.1">K.3.6.3.1</a>, <a href="#K.3.6.3.2">K.3.6.3.2</a>,
+real types, <a href="#6.2.5">6.2.5</a>                                                  <a href="#K.3.6.4.1">K.3.6.4.1</a>, <a href="#K.3.6.5.1">K.3.6.5.1</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.7.1.1">K.3.7.1.1</a>,
+real-floating, <a href="#7.12.3">7.12.3</a>                                               <a href="#K.3.7.1.2">K.3.7.1.2</a>, <a href="#K.3.7.1.3">K.3.7.1.3</a>, <a href="#K.3.7.1.4">K.3.7.1.4</a>, <a href="#K.3.7.2.1">K.3.7.2.1</a>,
+realloc function, <a href="#7.22.3">7.22.3</a>, <a href="#7.22.3.5">7.22.3.5</a>                                 <a href="#K.3.7.2.2">K.3.7.2.2</a>, <a href="#K.3.7.3.1">K.3.7.3.1</a>, <a href="#K.3.7.4.1">K.3.7.4.1</a>, <a href="#K.3.7.4.2">K.3.7.4.2</a>,
+recommended practice, <a href="#3.17">3.17</a>                                         <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>,
+recursion, <a href="#6.5.2.2">6.5.2.2</a>                                                 <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a>, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a>,
+recursive function call, <a href="#6.5.2.2">6.5.2.2</a>                                   <a href="#K.3.9.2.1.3">K.3.9.2.1.3</a>, <a href="#K.3.9.2.1.4">K.3.9.2.1.4</a>, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a>,
+redefinition of macro, <a href="#6.10.3">6.10.3</a>                                       <a href="#K.3.9.2.2.2">K.3.9.2.2.2</a>, <a href="#K.3.9.2.3.1">K.3.9.2.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>,
+reentrancy, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>                                         <a href="#K.3.9.3.2.1">K.3.9.3.2.1</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+   library functions, <a href="#7.1.4">7.1.4</a>                                  rsize_t type, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,
+referenced type, <a href="#6.2.5">6.2.5</a>                                             <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+register storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.9">6.9</a>                  runtime-constraint, <a href="#3.18">3.18</a>
+relational expressions, <a href="#6.5.8">6.5.8</a>                                Runtime-constraint handling functions, <a href="#K.3.6.1">K.3.6.1</a>
+relaxed atomic operations, <a href="#5.1.2.4">5.1.2.4</a>                           rvalue, <a href="#6.3.2.1">6.3.2.1</a>
+release fence, <a href="#7.17.4">7.17.4</a>
+release operation, <a href="#5.1.2.4">5.1.2.4</a>                                   same scope, <a href="#6.2.1">6.2.1</a>
+release sequence, <a href="#5.1.2.4">5.1.2.4</a>                                    save calling environment function, <a href="#7.13.1">7.13.1</a>
+reliability of data, interrupted, <a href="#5.1.2.3">5.1.2.3</a>                    scalar types, <a href="#6.2.5">6.2.5</a>
+remainder assignment operator (%=), <a href="#6.5.16.2">6.5.16.2</a>                 scalbln function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a>
+remainder functions, <a href="#7.12.10">7.12.10</a>, <a href="#F.10.7">F.10.7</a>                         scalbln type-generic macro, <a href="#7.24">7.24</a>
+remainder functions, <a href="#7.12.10.2">7.12.10.2</a>, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>,              scalbn function, <a href="#7.12.6.13">7.12.6.13</a>, <a href="#F.3">F.3</a>, <a href="#F.10.3.13">F.10.3.13</a>
+      <a href="#F.10.7.2">F.10.7.2</a>                                               scalbn type-generic macro, <a href="#7.24">7.24</a>
+remainder operator (%), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.5">6.5.5</a>                       scanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.4">7.21.6.4</a>, <a href="#7.21.6.11">7.21.6.11</a>
+remainder type-generic macro, <a href="#7.24">7.24</a>                           scanf_s function, <a href="#K.3.5.3.4">K.3.5.3.4</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>
+remove function, <a href="#7.21.4.1">7.21.4.1</a>, <a href="#7.21.4.4">7.21.4.4</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>               scanlist, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
+remquo functions, <a href="#7.12.10.3">7.12.10.3</a>, <a href="#F.3">F.3</a>, <a href="#F.10.7.3">F.10.7.3</a>                   scanset, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
+remquo type-generic macro, <a href="#7.24">7.24</a>                              SCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+rename function, <a href="#7.21.4.2">7.21.4.2</a>                                    SCHAR_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+representations of types, <a href="#6.2.6">6.2.6</a>                              SCNcFASTN macros, <a href="#7.8.1">7.8.1</a>
+   pointer, <a href="#6.2.5">6.2.5</a>                                            SCNcLEASTN macros, <a href="#7.8.1">7.8.1</a>
+rescanning and replacement, <a href="#6.10.3.4">6.10.3.4</a>                         SCNcMAX macros, <a href="#7.8.1">7.8.1</a>
+reserved identifiers, <a href="#6.4.1">6.4.1</a>, <a href="#7.1.3">7.1.3</a>, <a href="#K.3.1.2">K.3.1.2</a>                   SCNcN macros, <a href="#7.8.1">7.8.1</a>
+restartable multibyte/wide character conversion              SCNcPTR macros, <a href="#7.8.1">7.8.1</a>
+      functions, <a href="#7.27.1">7.27.1</a>, <a href="#7.28.6.3">7.28.6.3</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>                 scope of identifier, <a href="#6.2.1">6.2.1</a>, <a href="#6.9.2">6.9.2</a>
+restartable multibyte/wide string conversion                 search functions
+      functions, <a href="#7.28.6.4">7.28.6.4</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>                           string, <a href="#7.23.5">7.23.5</a>, <a href="#K.3.7.3">K.3.7.3</a>
+restore calling environment function, <a href="#7.13.2">7.13.2</a>                   utility, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a>
+restrict type qualifier, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>                         wide string, <a href="#7.28.4.5">7.28.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a>
+
+[<a name="p671" href="#p671">page 671</a>] (<a href="#Contents">Contents</a>)
+
+SEEK_CUR macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 sign and magnitude, <a href="#6.2.6.2">6.2.6.2</a>
+SEEK_END macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 sign bit, <a href="#6.2.6.2">6.2.6.2</a>
+SEEK_SET macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.9.2">7.21.9.2</a>                                 signal function, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.22.4.5">7.22.4.5</a>, <a href="#7.22.4.7">7.22.4.7</a>
+selection statements, <a href="#6.8.4">6.8.4</a>                                      signal handler, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#7.14.2.1">7.14.2.1</a>
+self-referential structure, <a href="#6.7.2.3">6.7.2.3</a>                              signal handling functions, <a href="#7.14.1">7.14.1</a>
+semicolon punctuator (;), <a href="#6.7">6.7</a>, <a href="#6.7.2.1">6.7.2.1</a>, <a href="#6.8.3">6.8.3</a>,                   signal.h header, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>
+      <a href="#6.8.5">6.8.5</a>, <a href="#6.8.6">6.8.6</a>                                               signaling NaN, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#F.2.1">F.2.1</a>
+separate compilation, <a href="#5.1.1.1">5.1.1.1</a>                                    signals, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.3">5.2.3</a>, <a href="#7.14.1">7.14.1</a>
+separate translation, <a href="#5.1.1.1">5.1.1.1</a>                                    signbit macro, <a href="#7.12.3.6">7.12.3.6</a>, <a href="#F.3">F.3</a>
+sequence points, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.13">6.5.13</a>, <a href="#6.5.14">6.5.14</a>,               signed char type, <a href="#6.2.5">6.2.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+      <a href="#6.5.15">6.5.15</a>, <a href="#6.5.17">6.5.17</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.3.1">6.7.3.1</a>, <a href="#6.7.6">6.7.6</a>, <a href="#6.8">6.8</a>,                     <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+      <a href="#7.1.4">7.1.4</a>, <a href="#7.21.6">7.21.6</a>, <a href="#7.22.5">7.22.5</a>, <a href="#7.28.2">7.28.2</a>, <a href="#C">C</a>, <a href="#K.3.6.3">K.3.6.3</a>                  signed character, <a href="#6.3.1.1">6.3.1.1</a>
+sequenced after, see sequenced before                            signed integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>
+sequenced before, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.2">6.5.2.2</a>, <a href="#6.5.2.4">6.5.2.4</a>,                signed type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.3.1.4">6.3.1.4</a>,
+      <a href="#6.5.16">6.5.16</a>, see also indeterminately sequenced,                     <a href="#6.3.1.8">6.3.1.8</a>
+      unsequenced                                                signed types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>
+sequencing of statements, <a href="#6.8">6.8</a>                                    significand part, <a href="#6.4.4.2">6.4.4.2</a>
+set_constraint_handler_s function,                               SIGSEGV macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>
+      <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6.1.1">K.3.6.1.1</a>, <a href="#K.3.6.1.2">K.3.6.1.2</a>, <a href="#K.3.6.1.3">K.3.6.1.3</a>                   SIGTERM macro, <a href="#7.14">7.14</a>
+setbuf function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>, <a href="#7.21.5.5">7.21.5.5</a>                      simple assignment operator (=), <a href="#6.5.16.1">6.5.16.1</a>
+setjmp macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.13.1.1">7.13.1.1</a>, <a href="#7.13.2.1">7.13.2.1</a>                          sin functions, <a href="#7.12.4.6">7.12.4.6</a>, <a href="#F.10.1.6">F.10.1.6</a>
+setjmp.h header, <a href="#7.13">7.13</a>                                            sin type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+setlocale function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.11.2.1">7.11.2.1</a>                           single-byte character, <a href="#3.7.1">3.7.1</a>, <a href="#5.2.1.2">5.2.1.2</a>
+setvbuf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.1">7.21.5.1</a>,                      single-byte/wide character conversion functions,
+      <a href="#7.21.5.5">7.21.5.5</a>, <a href="#7.21.5.6">7.21.5.6</a>                                              <a href="#7.28.6.1">7.28.6.1</a>
+shall, <a href="#4">4</a>                                                         single-precision arithmetic, <a href="#5.1.2.3">5.1.2.3</a>
+shift expressions, <a href="#6.5.7">6.5.7</a>                                         single-quote escape sequence (\'), <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>
+shift sequence, <a href="#7.1.1">7.1.1</a>                                            singularity, <a href="#7.12.1">7.12.1</a>
+shift states, <a href="#5.2.1.2">5.2.1.2</a>                                            sinh functions, <a href="#7.12.5.5">7.12.5.5</a>, <a href="#F.10.2.5">F.10.2.5</a>
+short identifier, character, <a href="#5.2.4.1">5.2.4.1</a>, <a href="#6.4.3">6.4.3</a>                       sinh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+short int type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>,                 SIZE_MAX macro, <a href="#7.20.3">7.20.3</a>
+      <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>                               size_t type, <a href="#6.2.8">6.2.8</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#7.19">7.19</a>, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.1">7.21.1</a>,
+short int type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,                          <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.23.1">7.23.1</a>, <a href="#7.26.1">7.26.1</a>, <a href="#7.27">7.27</a>,
+      <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>                                                <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>,
+SHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                             <a href="#K.3.5">K.3.5</a>, <a href="#K.3.6">K.3.6</a>, <a href="#K.3.7">K.3.7</a>, <a href="#K.3.8">K.3.8</a>, <a href="#K.3.9">K.3.9</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+SHRT_MIN macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                        sizeof operator, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.3">6.5.3</a>, <a href="#6.5.3.4">6.5.3.4</a>
+side effects, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.5">6.5</a>, <a href="#6.5.2.4">6.5.2.4</a>,           snprintf function, <a href="#7.21.6.5">7.21.6.5</a>, <a href="#7.21.6.12">7.21.6.12</a>,
+      <a href="#6.5.16">6.5.16</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.8.3">6.8.3</a>, <a href="#7.6">7.6</a>, <a href="#7.6.1">7.6.1</a>, <a href="#7.21.7.5">7.21.7.5</a>,                     <a href="#K.3.5.3.5">K.3.5.3.5</a>
+      <a href="#7.21.7.7">7.21.7.7</a>, <a href="#7.28.3.6">7.28.3.6</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#F.8.1">F.8.1</a>, <a href="#F.9.1">F.9.1</a>,                snprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
+      <a href="#F.9.3">F.9.3</a>                                                      snwprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
+SIG_ATOMIC_MAX macro, <a href="#7.20.3">7.20.3</a>                                     sorting utility functions, <a href="#7.22.5">7.22.5</a>, <a href="#K.3.6.3">K.3.6.3</a>
+SIG_ATOMIC_MIN macro, <a href="#7.20.3">7.20.3</a>                                     source character set, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>
+sig_atomic_t type, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>,                      source file, <a href="#5.1.1.1">5.1.1.1</a>
+      <a href="#7.20.3">7.20.3</a>                                                        name, <a href="#6.10.4">6.10.4</a>, <a href="#6.10.8.1">6.10.8.1</a>
+SIG_DFL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source file inclusion, <a href="#6.10.2">6.10.2</a>
+SIG_ERR macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source lines, <a href="#5.1.1.2">5.1.1.2</a>
+SIG_IGN macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                    source text, <a href="#5.1.1.2">5.1.1.2</a>
+SIGABRT macro, <a href="#7.14">7.14</a>, <a href="#7.22.4.1">7.22.4.1</a>                                    space character (' '), <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>, <a href="#7.4.1.3">7.4.1.3</a>,
+SIGFPE macro, <a href="#7.12.1">7.12.1</a>, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>, <a href="#J.5.17">J.5.17</a>                          <a href="#7.4.1.10">7.4.1.10</a>, <a href="#7.29.2.1.3">7.29.2.1.3</a>
+SIGILL macro, <a href="#7.14">7.14</a>, <a href="#7.14.1.1">7.14.1.1</a>                                     sprintf function, <a href="#7.21.6.6">7.21.6.6</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
+SIGINT macro, <a href="#7.14">7.14</a>                                               sprintf_s function, <a href="#K.3.5.3.5">K.3.5.3.5</a>, <a href="#K.3.5.3.6">K.3.5.3.6</a>
+
+[<a name="p672" href="#p672">page 672</a>] (<a href="#Contents">Contents</a>)
+
+sqrt functions, <a href="#7.12.7.5">7.12.7.5</a>, <a href="#F.3">F.3</a>, <a href="#F.10.4.5">F.10.4.5</a>                         do, <a href="#6.8.5.2">6.8.5.2</a>
+sqrt type-generic macro, <a href="#7.24">7.24</a>                                   else, <a href="#6.8.4.1">6.8.4.1</a>
+srand function, <a href="#7.22.2.2">7.22.2.2</a>                                        expression, <a href="#6.8.3">6.8.3</a>
+sscanf function, <a href="#7.21.6.7">7.21.6.7</a>, <a href="#7.21.6.14">7.21.6.14</a>                            for, <a href="#6.8.5.3">6.8.5.3</a>
+sscanf_s function, <a href="#K.3.5.3.7">K.3.5.3.7</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                        goto, <a href="#6.8.6.1">6.8.6.1</a>
+standard error stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.10.4">7.21.10.4</a>                if, <a href="#6.8.4.1">6.8.4.1</a>
+standard headers, <a href="#4">4</a>, <a href="#7.1.2">7.1.2</a>                                      iteration, <a href="#6.8.5">6.8.5</a>
+   <a href="#7.2">&lt;assert.h&gt;</a>, <a href="#7.2">7.2</a>                                              jump, <a href="#6.8.6">6.8.6</a>
+   <a href="#7.3">&lt;complex.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.3">7.3</a>,                labeled, <a href="#6.8.1">6.8.1</a>
+        <a href="#7.24">7.24</a>, <a href="#7.30.1">7.30.1</a>, <a href="#G.6">G.6</a>, <a href="#J.5.17">J.5.17</a>                               null, <a href="#6.8.3">6.8.3</a>
+   <a href="#7.4">&lt;ctype.h&gt;</a>, <a href="#7.4">7.4</a>, <a href="#7.30.2">7.30.2</a>                                       return, <a href="#6.8.6.4">6.8.6.4</a>, <a href="#F.6">F.6</a>
+   <a href="#7.5">&lt;errno.h&gt;</a>, <a href="#7.5">7.5</a>, <a href="#7.30.3">7.30.3</a>, <a href="#K.3.2">K.3.2</a>                                selection, <a href="#6.8.4">6.8.4</a>
+   <a href="#7.6">&lt;fenv.h&gt;</a>, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.6">7.6</a>, <a href="#7.12">7.12</a>, <a href="#F">F</a>, <a href="#H">H</a>                sequencing, <a href="#6.8">6.8</a>
+   <a href="#7.7">&lt;float.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.7">7.7</a>, <a href="#7.22.1.3">7.22.1.3</a>,                      switch, <a href="#6.8.4.2">6.8.4.2</a>
+        <a href="#7.28.4.1.1">7.28.4.1.1</a>                                              while, <a href="#6.8.5.1">6.8.5.1</a>
+   <a href="#7.8">&lt;inttypes.h&gt;</a>, <a href="#7.8">7.8</a>, <a href="#7.30.4">7.30.4</a>                                 static assertions, <a href="#6.7.10">6.7.10</a>
+   <a href="#7.9">&lt;iso646.h&gt;</a>, <a href="#4">4</a>, <a href="#7.9">7.9</a>                                        static storage duration, <a href="#6.2.4">6.2.4</a>
+   <a href="#7.10">&lt;limits.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#6.2.5">6.2.5</a>, <a href="#7.10">7.10</a>                     static storage-class specifier, <a href="#6.2.2">6.2.2</a>, <a href="#6.2.4">6.2.4</a>, <a href="#6.7.1">6.7.1</a>
+   <a href="#7.11">&lt;locale.h&gt;</a>, <a href="#7.11">7.11</a>, <a href="#7.30.5">7.30.5</a>                                  static, in array declarators, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.7.6.3">6.7.6.3</a>
+   <a href="#7.12">&lt;math.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#6.5">6.5</a>, <a href="#7.12">7.12</a>, <a href="#7.24">7.24</a>, <a href="#F">F</a>, <a href="#F.10">F.10</a>,            static_assert declaration, <a href="#6.7.10">6.7.10</a>
+        <a href="#J.5.17">J.5.17</a>                                               static_assert macro, <a href="#7.2">7.2</a>
+   <a href="#7.13">&lt;setjmp.h&gt;</a>, <a href="#7.13">7.13</a>                                          stdalign.h header, <a href="#4">4</a>, <a href="#7.15">7.15</a>
+   <a href="#7.14">&lt;signal.h&gt;</a>, <a href="#7.14">7.14</a>, <a href="#7.30.6">7.30.6</a>                                  stdarg.h header, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>
+   <a href="#7.15">&lt;stdalign.h&gt;</a>, <a href="#4">4</a>, <a href="#7.15">7.15</a>                                     stdatomic.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>
+   <a href="#7.16">&lt;stdarg.h&gt;</a>, <a href="#4">4</a>, <a href="#6.7.6.3">6.7.6.3</a>, <a href="#7.16">7.16</a>                              stdbool.h header, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>
+   <a href="#7.17">&lt;stdatomic.h&gt;</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.17">7.17</a>                      STDC, <a href="#6.10.6">6.10.6</a>, <a href="#6.11.8">6.11.8</a>
+   <a href="#7.18">&lt;stdbool.h&gt;</a>, <a href="#4">4</a>, <a href="#7.18">7.18</a>, <a href="#7.30.7">7.30.7</a>, <a href="#H">H</a>                           stddef.h header, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,
+   <a href="#7.19">&lt;stddef.h&gt;</a>, <a href="#4">4</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.4.4.4">6.4.4.4</a>,                       <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>
+        <a href="#6.4.5">6.4.5</a>, <a href="#6.5.3.4">6.5.3.4</a>, <a href="#6.5.6">6.5.6</a>, <a href="#7.19">7.19</a>, <a href="#K.3.3">K.3.3</a>                   stderr macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>
+   <a href="#7.20">&lt;stdint.h&gt;</a>, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>,                stdin macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.4">7.21.6.4</a>,
+        <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>                                       <a href="#7.21.7.6">7.21.7.6</a>, <a href="#7.28.2.12">7.28.2.12</a>, <a href="#7.28.3.7">7.28.3.7</a>, <a href="#K.3.5.3.4">K.3.5.3.4</a>,
+   <a href="#7.21">&lt;stdio.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>                    <a href="#K.3.5.4.1">K.3.5.4.1</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
+   <a href="#7.22">&lt;stdlib.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,                  stdint.h header, <a href="#4">4</a>, <a href="#5.2.4.2">5.2.4.2</a>, <a href="#6.10.1">6.10.1</a>, <a href="#7.8">7.8</a>, <a href="#7.20">7.20</a>,
+        <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>                                             <a href="#7.30.8">7.30.8</a>, <a href="#K.3.3">K.3.3</a>, <a href="#K.3.4">K.3.4</a>
+   <a href="#7.23">&lt;string.h&gt;</a>, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                          stdio.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21">7.21</a>, <a href="#7.30.9">7.30.9</a>, <a href="#F">F</a>, <a href="#K.3.5">K.3.5</a>
+   <a href="#7.24">&lt;tgmath.h&gt;</a>, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                     stdlib.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.22">7.22</a>, <a href="#7.30.10">7.30.10</a>, <a href="#F">F</a>,
+   <a href="#7.25">&lt;threads.h&gt;</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                              <a href="#K.3.1.4">K.3.1.4</a>, <a href="#K.3.6">K.3.6</a>
+   <a href="#7.26">&lt;time.h&gt;</a>, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                     stdout macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.3">7.21.6.3</a>,
+   <a href="#7.27">&lt;uchar.h&gt;</a>, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                                 <a href="#7.21.7.8">7.21.7.8</a>, <a href="#7.21.7.9">7.21.7.9</a>, <a href="#7.28.2.11">7.28.2.11</a>, <a href="#7.28.3.9">7.28.3.9</a>
+   <a href="#7.28">&lt;wchar.h&gt;</a>, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>, <a href="#7.30.12">7.30.12</a>,              storage duration, <a href="#6.2.4">6.2.4</a>
+        <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>                                             storage order of array, <a href="#6.5.2.1">6.5.2.1</a>
+   <a href="#7.29">&lt;wctype.h&gt;</a>, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                                 storage unit (bit-field), <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.7.2.1">6.7.2.1</a>
+standard input stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                        storage-class specifiers, <a href="#6.7.1">6.7.1</a>, <a href="#6.11.5">6.11.5</a>
+standard integer types, <a href="#6.2.5">6.2.5</a>                                strcat function, <a href="#7.23.3.1">7.23.3.1</a>
+standard output stream, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                       strcat_s function, <a href="#K.3.7.2.1">K.3.7.2.1</a>
+standard signed integer types, <a href="#6.2.5">6.2.5</a>                         strchr function, <a href="#7.23.5.2">7.23.5.2</a>
+state-dependent encoding, <a href="#5.2.1.2">5.2.1.2</a>, <a href="#7.22.7">7.22.7</a>, <a href="#K.3.6.4">K.3.6.4</a>           strcmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.2">7.23.4.2</a>
+statements, <a href="#6.8">6.8</a>                                              strcoll function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.3">7.23.4.3</a>, <a href="#7.23.4.5">7.23.4.5</a>
+   break, <a href="#6.8.6.3">6.8.6.3</a>                                            strcpy function, <a href="#7.23.2.3">7.23.2.3</a>
+   compound, <a href="#6.8.2">6.8.2</a>                                           strcpy_s function, <a href="#K.3.7.1.3">K.3.7.1.3</a>
+   continue, <a href="#6.8.6.2">6.8.6.2</a>                                         strcspn function, <a href="#7.23.5.3">7.23.5.3</a>
+
+[<a name="p673" href="#p673">page 673</a>] (<a href="#Contents">Contents</a>)
+
+streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.22.4.4">7.22.4.4</a>                                                <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>
+   fully buffered, <a href="#7.21.3">7.21.3</a>                                          strtoull function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>
+   line buffered, <a href="#7.21.3">7.21.3</a>                                           strtoumax function, <a href="#7.8.2.3">7.8.2.3</a>
+   orientation, <a href="#7.21.2">7.21.2</a>                                             struct hack, see flexible array member
+   standard error, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                  struct lconv, <a href="#7.11">7.11</a>
+   standard input, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                  struct tm, <a href="#7.26.1">7.26.1</a>
+   standard output, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.3">7.21.3</a>                                 structure
+   unbuffered, <a href="#7.21.3">7.21.3</a>                                                 arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+strerror function, <a href="#7.21.10.4">7.21.10.4</a>, <a href="#7.23.6.2">7.23.6.2</a>                                content, <a href="#6.7.2.3">6.7.2.3</a>
+strerror_s function, <a href="#K.3.7.4.2">K.3.7.4.2</a>, <a href="#K.3.7.4.3">K.3.7.4.3</a>                             dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>
+strerrorlen_s function, <a href="#K.3.7.4.3">K.3.7.4.3</a>                                     initialization, <a href="#6.7.9">6.7.9</a>
+strftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.26.3.5">7.26.3.5</a>,                        member alignment, <a href="#6.7.2.1">6.7.2.1</a>
+      <a href="#7.28.5.1">7.28.5.1</a>, <a href="#K.3.8.2">K.3.8.2</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>                         member name space, <a href="#6.2.3">6.2.3</a>
+stricter, <a href="#6.2.8">6.2.8</a>                                                       member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>
+strictly conforming program, <a href="#4">4</a>                                        pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>
+string, <a href="#7.1.1">7.1.1</a>                                                         specifier, <a href="#6.7.2.1">6.7.2.1</a>
+   comparison functions, <a href="#7.23.4">7.23.4</a>                                       tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>
+   concatenation functions, <a href="#7.23.3">7.23.3</a>, <a href="#K.3.7.2">K.3.7.2</a>                           type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>
+   conversion functions, <a href="#7.11.1.1">7.11.1.1</a>                                  strxfrm function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.23.4.5">7.23.4.5</a>
+   copying functions, <a href="#7.23.2">7.23.2</a>, <a href="#K.3.7.1">K.3.7.1</a>                              subnormal floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+   library function conventions, <a href="#7.23.1">7.23.1</a>                            subscripting, <a href="#6.5.2.1">6.5.2.1</a>
+   literal, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1">5.2.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.5.1">6.5.1</a>, <a href="#6.7.9">6.7.9</a>           subtraction assignment operator (-=), <a href="#6.5.16.2">6.5.16.2</a>
+   miscellaneous functions, <a href="#7.23.6">7.23.6</a>, <a href="#K.3.7.4">K.3.7.4</a>                        subtraction operator (-), <a href="#6.2.6.2">6.2.6.2</a>, <a href="#6.5.6">6.5.6</a>, <a href="#F.3">F.3</a>, <a href="#G.5.2">G.5.2</a>
+   numeric conversion functions, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1">7.22.1</a>                   suffix
+   search functions, <a href="#7.23.5">7.23.5</a>, <a href="#K.3.7.3">K.3.7.3</a>                                  floating constant, <a href="#6.4.4.2">6.4.4.2</a>
+string handling header, <a href="#7.23">7.23</a>, <a href="#K.3.7">K.3.7</a>                                   integer constant, <a href="#6.4.4.1">6.4.4.1</a>
+string.h header, <a href="#7.23">7.23</a>, <a href="#7.30.11">7.30.11</a>, <a href="#K.3.7">K.3.7</a>                              switch body, <a href="#6.8.4.2">6.8.4.2</a>
+stringizing, <a href="#6.10.3.2">6.10.3.2</a>, <a href="#6.10.9">6.10.9</a>                                      switch case label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+strlen function, <a href="#7.23.6.3">7.23.6.3</a>                                          switch default label, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+strncat function, <a href="#7.23.3.2">7.23.3.2</a>                                         switch statement, <a href="#6.8.1">6.8.1</a>, <a href="#6.8.4.2">6.8.4.2</a>
+strncat_s function, <a href="#K.3.7.2.2">K.3.7.2.2</a>                                      swprintf function, <a href="#7.28.2.3">7.28.2.3</a>, <a href="#7.28.2.7">7.28.2.7</a>,
+strncmp function, <a href="#7.23.4">7.23.4</a>, <a href="#7.23.4.4">7.23.4.4</a>                                       <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
+strncpy function, <a href="#7.23.2.4">7.23.2.4</a>                                         swprintf_s function, <a href="#K.3.9.1.3">K.3.9.1.3</a>, <a href="#K.3.9.1.4">K.3.9.1.4</a>
+strncpy_s function, <a href="#K.3.7.1.4">K.3.7.1.4</a>                                      swscanf function, <a href="#7.28.2.4">7.28.2.4</a>, <a href="#7.28.2.8">7.28.2.8</a>
+strnlen_s function, <a href="#K.3.7.4.4">K.3.7.4.4</a>                                      swscanf_s function, <a href="#K.3.9.1.5">K.3.9.1.5</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>
+stronger, <a href="#6.2.8">6.2.8</a>                                                    symbols, <a href="#3">3</a>
+strpbrk function, <a href="#7.23.5.4">7.23.5.4</a>                                         synchronization operation, <a href="#5.1.2.4">5.1.2.4</a>
+strrchr function, <a href="#7.23.5.5">7.23.5.5</a>                                         synchronize with, <a href="#5.1.2.4">5.1.2.4</a>
+strspn function, <a href="#7.23.5.6">7.23.5.6</a>                                          syntactic categories, <a href="#6.1">6.1</a>
+strstr function, <a href="#7.23.5.7">7.23.5.7</a>                                          syntax notation, <a href="#6.1">6.1</a>
+strtod function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.3">7.22.1.3</a>,                    syntax rule precedence, <a href="#5.1.1.2">5.1.1.2</a>
+      <a href="#7.28.2.2">7.28.2.2</a>, <a href="#F.3">F.3</a>                                                syntax summary, language, <a href="#A">A</a>
+strtof function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>                          system function, <a href="#7.22.4.8">7.22.4.8</a>
+strtoimax function, <a href="#7.8.2.3">7.8.2.3</a>
+strtok function, <a href="#7.23.5.8">7.23.5.8</a>                                          tab characters, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>
+strtok_s function, <a href="#K.3.7.3.1">K.3.7.3.1</a>                                       tag compatibility, <a href="#6.2.7">6.2.7</a>
+strtol function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,                      tag name space, <a href="#6.2.3">6.2.3</a>
+      <a href="#7.22.1.4">7.22.1.4</a>, <a href="#7.28.2.2">7.28.2.2</a>                                           tags, <a href="#6.7.2.3">6.7.2.3</a>
+strtold function, <a href="#7.12.11.2">7.12.11.2</a>, <a href="#7.22.1.3">7.22.1.3</a>, <a href="#F.3">F.3</a>                         tan functions, <a href="#7.12.4.7">7.12.4.7</a>, <a href="#F.10.1.7">F.10.1.7</a>
+strtoll function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.22.1.2">7.22.1.2</a>, <a href="#7.22.1.4">7.22.1.4</a>                      tan type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+strtoul function, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22.1.2">7.22.1.2</a>,                     tanh functions, <a href="#7.12.5.6">7.12.5.6</a>, <a href="#F.10.2.6">F.10.2.6</a>
+
+[<a name="p674" href="#p674">page 674</a>] (<a href="#Contents">Contents</a>)
+
+tanh type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                            toupper function, <a href="#7.4.2.2">7.4.2.2</a>
+temporary lifetime, <a href="#6.2.4">6.2.4</a>                                     towctrans function, <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>
+tentative definition, <a href="#6.9.2">6.9.2</a>                                    towlower function, <a href="#7.29.3.1.1">7.29.3.1.1</a>, <a href="#7.29.3.2.1">7.29.3.2.1</a>
+terms, <a href="#3">3</a>                                                      towupper function, <a href="#7.29.3.1.2">7.29.3.1.2</a>, <a href="#7.29.3.2.1">7.29.3.2.1</a>
+text streams, <a href="#7.21.2">7.21.2</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>, <a href="#7.21.9.4">7.21.9.4</a>           translation environment, <a href="#5">5</a>, <a href="#5.1.1">5.1.1</a>
+tgamma functions, <a href="#7.12.8.4">7.12.8.4</a>, <a href="#F.10.5.4">F.10.5.4</a>                          translation limits, <a href="#5.2.4.1">5.2.4.1</a>
+tgamma type-generic macro, <a href="#7.24">7.24</a>                               translation phases, <a href="#5.1.1.2">5.1.1.2</a>
+tgmath.h header, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>                                    translation unit, <a href="#5.1.1.1">5.1.1.1</a>, <a href="#6.9">6.9</a>
+thrd_create function, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.5.1">7.25.5.1</a>                        trap, see perform a trap
+thrd_current function, <a href="#7.25.5.2">7.25.5.2</a>                               trap representation, <a href="#3.19.4">3.19.4</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.2.6.2">6.2.6.2</a>,
+thrd_detach function, <a href="#7.25.5.3">7.25.5.3</a>                                      <a href="#6.3.2.3">6.3.2.3</a>, <a href="#6.5.2.3">6.5.2.3</a>
+thrd_equal function, <a href="#7.25.5.4">7.25.5.4</a>                                 trigonometric functions
+thrd_exit function, <a href="#7.25.5.5">7.25.5.5</a>                                     complex, <a href="#7.3.5">7.3.5</a>, <a href="#G.6.1">G.6.1</a>
+thrd_join function, <a href="#7.25.5.6">7.25.5.6</a>                                     real, <a href="#7.12.4">7.12.4</a>, <a href="#F.10.1">F.10.1</a>
+thrd_sleep function, <a href="#7.25.5.7">7.25.5.7</a>                                 trigraph sequences, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#5.2.1.1">5.2.1.1</a>
+thrd_start_t type, <a href="#7.25.1">7.25.1</a>                                     true macro, <a href="#7.18">7.18</a>
+thrd_t type, <a href="#7.25.1">7.25.1</a>                                           trunc functions, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#F.10.6.8">F.10.6.8</a>
+thrd_yield function, <a href="#7.25.5.8">7.25.5.8</a>                                 trunc type-generic macro, <a href="#7.24">7.24</a>
+thread of execution, <a href="#5.1.2.4">5.1.2.4</a>, <a href="#7.1.4">7.1.4</a>, <a href="#7.6">7.6</a>, <a href="#7.22.4.6">7.22.4.6</a>            truncation, <a href="#6.3.1.4">6.3.1.4</a>, <a href="#7.12.9.8">7.12.9.8</a>, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.5.3">7.21.5.3</a>
+thread storage duration, <a href="#6.2.4">6.2.4</a>, <a href="#7.6">7.6</a>                           truncation toward zero, <a href="#6.5.5">6.5.5</a>
+threads header, <a href="#7.25">7.25</a>                                          tss_create function, <a href="#7.25.6.1">7.25.6.1</a>
+threads.h header, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.1.2">7.1.2</a>, <a href="#7.25">7.25</a>                       tss_delete function, <a href="#7.25.6.2">7.25.6.2</a>
+time                                                          TSS_DTOR_ITERATIONS macro, <a href="#7.25.1">7.25.1</a>
+   broken down, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.3">7.26.3</a>, <a href="#7.26.3.1">7.26.3.1</a>,           tss_dtor_t type, <a href="#7.25.1">7.25.1</a>
+         <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#7.26.3.5">7.26.3.5</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>,             tss_get function, <a href="#7.25.6.3">7.25.6.3</a>
+         <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                 tss_set function, <a href="#7.25.6.4">7.25.6.4</a>
+   calendar, <a href="#7.26.1">7.26.1</a>, <a href="#7.26.2.2">7.26.2.2</a>, <a href="#7.26.2.3">7.26.2.3</a>, <a href="#7.26.2.4">7.26.2.4</a>,            tss_t type, <a href="#7.25.1">7.25.1</a>
+         <a href="#7.26.3.2">7.26.3.2</a>, <a href="#7.26.3.3">7.26.3.3</a>, <a href="#7.26.3.4">7.26.3.4</a>, <a href="#K.3.8.2.2">K.3.8.2.2</a>,             two's complement, <a href="#6.2.6.2">6.2.6.2</a>, <a href="#7.20.1.1">7.20.1.1</a>
+         <a href="#K.3.8.2.3">K.3.8.2.3</a>, <a href="#K.3.8.2.4">K.3.8.2.4</a>                                 type category, <a href="#6.2.5">6.2.5</a>
+   components, <a href="#7.26.1">7.26.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                                type conversion, <a href="#6.3">6.3</a>
+   conversion functions, <a href="#7.26.3">7.26.3</a>, <a href="#K.3.8.2">K.3.8.2</a>                      type definitions, <a href="#6.7.8">6.7.8</a>
+      wide character, <a href="#7.28.5">7.28.5</a>                                  type domain, <a href="#6.2.5">6.2.5</a>, <a href="#G.2">G.2</a>
+   local, <a href="#7.26.1">7.26.1</a>                                              type names, <a href="#6.7.7">6.7.7</a>
+   manipulation functions, <a href="#7.26.2">7.26.2</a>                             type punning, <a href="#6.5.2.3">6.5.2.3</a>
+   normalized broken down, <a href="#K.3.8.1">K.3.8.1</a>, <a href="#K.3.8.2.1">K.3.8.2.1</a>                 type qualifiers, <a href="#6.7.3">6.7.3</a>
+time function, <a href="#7.26.2.4">7.26.2.4</a>                                       type specifiers, <a href="#6.7.2">6.7.2</a>
+time.h header, <a href="#7.26">7.26</a>, <a href="#K.3.8">K.3.8</a>                                    type-generic macro, <a href="#7.24">7.24</a>, <a href="#G.7">G.7</a>
+time_t type, <a href="#7.26.1">7.26.1</a>                                           typedef declaration, <a href="#6.7.8">6.7.8</a>
+TIME_UTC macro, <a href="#7.25.7.1">7.25.7.1</a>                                      typedef storage-class specifier, <a href="#6.7.1">6.7.1</a>, <a href="#6.7.8">6.7.8</a>
+tm structure type, <a href="#7.26.1">7.26.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#K.3.8.1">K.3.8.1</a>                    types, <a href="#6.2.5">6.2.5</a>
+TMP_MAX macro, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>                        atomic, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.2.5">6.2.5</a>, <a href="#6.2.6.1">6.2.6.1</a>, <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>,
+TMP_MAX_S macro, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                           <a href="#6.5.2.4">6.5.2.4</a>, <a href="#6.5.16.2">6.5.16.2</a>, <a href="#6.7.2.4">6.7.2.4</a>, <a href="#6.10.8.3">6.10.8.3</a>, <a href="#7.17.6">7.17.6</a>
+tmpfile function, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.22.4.4">7.22.4.4</a>                             character, <a href="#6.7.9">6.7.9</a>
+tmpfile_s function, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                         compatible, <a href="#6.2.7">6.2.7</a>, <a href="#6.7.2">6.7.2</a>, <a href="#6.7.3">6.7.3</a>, <a href="#6.7.6">6.7.6</a>
+tmpnam function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.4.3">7.21.4.3</a>, <a href="#7.21.4.4">7.21.4.4</a>,                     complex, <a href="#6.2.5">6.2.5</a>, <a href="#G">G</a>
+      <a href="#K.3.5.1.2">K.3.5.1.2</a>                                                  composite, <a href="#6.2.7">6.2.7</a>
+tmpnam_s function, <a href="#K.3.5">K.3.5</a>, <a href="#K.3.5.1.1">K.3.5.1.1</a>, <a href="#K.3.5.1.2">K.3.5.1.2</a>                   const qualified, <a href="#6.7.3">6.7.3</a>
+token, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, see also preprocessing tokens               conversions, <a href="#6.3">6.3</a>
+token concatenation, <a href="#6.10.3.3">6.10.3.3</a>                                    imaginary, <a href="#G">G</a>
+token pasting, <a href="#6.10.3.3">6.10.3.3</a>                                          restrict qualified, <a href="#6.7.3">6.7.3</a>
+tolower function, <a href="#7.4.2.1">7.4.2.1</a>                                        volatile qualified, <a href="#6.7.3">6.7.3</a>
+
+[<a name="p675" href="#p675">page 675</a>] (<a href="#Contents">Contents</a>)
+
+uchar.h header, <a href="#6.4.4.4">6.4.4.4</a>, <a href="#6.4.5">6.4.5</a>, <a href="#7.27">7.27</a>                      universal character name, <a href="#6.4.3">6.4.3</a>
+UCHAR_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                unnormalized floating-point numbers, <a href="#5.2.4.2.2">5.2.4.2.2</a>
+UINT_FASTN_MAX macros, <a href="#7.20.2.3">7.20.2.3</a>                           unqualified type, <a href="#6.2.5">6.2.5</a>
+uint_fastN_t types, <a href="#7.20.1.3">7.20.1.3</a>                              unqualified version of type, <a href="#6.2.5">6.2.5</a>
+uint_least16_t type, <a href="#7.27">7.27</a>                                 unsequenced, <a href="#5.1.2.3">5.1.2.3</a>, <a href="#6.5">6.5</a>, <a href="#6.5.16">6.5.16</a>, see also
+uint_least32_t type, <a href="#7.27">7.27</a>                                       indeterminately sequenced, sequenced
+UINT_LEASTN_MAX macros, <a href="#7.20.2.2">7.20.2.2</a>                                before
+uint_leastN_t types, <a href="#7.20.1.2">7.20.1.2</a>                             unsigned char type, <a href="#K.3.5.3.2">K.3.5.3.2</a>, <a href="#K.3.9.1.2">K.3.9.1.2</a>
+UINT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>                                 unsigned integer suffix, u or <a href="#U">U</a>, <a href="#6.4.4.1">6.4.4.1</a>
+UINTMAX_C macro, <a href="#7.20.4.2">7.20.4.2</a>                                 unsigned integer types, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.1.3">6.3.1.3</a>, <a href="#6.4.4.1">6.4.4.1</a>
+UINTMAX_MAX macro, <a href="#7.8.2.3">7.8.2.3</a>, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.20.2.5">7.20.2.5</a>             unsigned type conversion, <a href="#6.3.1.1">6.3.1.1</a>, <a href="#6.3.1.3">6.3.1.3</a>,
+uintmax_t type, <a href="#7.20.1.5">7.20.1.5</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,                   <a href="#6.3.1.4">6.3.1.4</a>, <a href="#6.3.1.8">6.3.1.8</a>
+     <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>                                   unsigned types, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2">6.7.2</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>,
+UINTN_C macros, <a href="#7.20.4.1">7.20.4.1</a>                                        <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+UINTN_MAX macros, <a href="#7.20.2.1">7.20.2.1</a>                                unspecified behavior, <a href="#3.4.4">3.4.4</a>, <a href="#4">4</a>, <a href="#J.1">J.1</a>
+uintN_t types, <a href="#7.20.1.1">7.20.1.1</a>                                   unspecified value, <a href="#3.19.3">3.19.3</a>
+UINTPTR_MAX macro, <a href="#7.20.2.4">7.20.2.4</a>                               uppercase letter, <a href="#5.2.1">5.2.1</a>
+uintptr_t type, <a href="#7.20.1.4">7.20.1.4</a>                                  use of library functions, <a href="#7.1.4">7.1.4</a>
+ULLONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                    USHRT_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>
+     <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           usual arithmetic conversions, <a href="#6.3.1.8">6.3.1.8</a>, <a href="#6.5.5">6.5.5</a>, <a href="#6.5.6">6.5.6</a>,
+ULONG_MAX macro, <a href="#5.2.4.2.1">5.2.4.2.1</a>, <a href="#7.22.1.4">7.22.1.4</a>,                           <a href="#6.5.8">6.5.8</a>, <a href="#6.5.9">6.5.9</a>, <a href="#6.5.10">6.5.10</a>, <a href="#6.5.11">6.5.11</a>, <a href="#6.5.12">6.5.12</a>, <a href="#6.5.15">6.5.15</a>
+     <a href="#7.28.4.1.2">7.28.4.1.2</a>                                           UTF-16, <a href="#6.10.8.2">6.10.8.2</a>
+unary arithmetic operators, <a href="#6.5.3.3">6.5.3.3</a>                       UTF-32, <a href="#6.10.8.2">6.10.8.2</a>
+unary expression, <a href="#6.5.3">6.5.3</a>                                   UTF-8 string literal, see string literal
+unary minus operator (-), <a href="#6.5.3.3">6.5.3.3</a>, <a href="#F.3">F.3</a>                    utilities, general, <a href="#7.22">7.22</a>, <a href="#K.3.6">K.3.6</a>
+unary operators, <a href="#6.5.3">6.5.3</a>                                       wide string, <a href="#7.28.4">7.28.4</a>, <a href="#K.3.9.2">K.3.9.2</a>
+unary plus operator (+), <a href="#6.5.3.3">6.5.3.3</a>
+unbuffered stream, <a href="#7.21.3">7.21.3</a>                                 va_arg macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>, <a href="#7.16.1.2">7.16.1.2</a>,
+undef preprocessing directive, <a href="#6.10.3.5">6.10.3.5</a>, <a href="#7.1.3">7.1.3</a>,                <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>,
+     <a href="#7.1.4">7.1.4</a>                                                     <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
+undefined behavior, <a href="#3.4.3">3.4.3</a>, <a href="#4">4</a>, <a href="#J.2">J.2</a>                               <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>,
+underscore character, <a href="#6.4.2.1">6.4.2.1</a>                                  <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
+underscore, leading, in identifier, <a href="#7.1.3">7.1.3</a>                       <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+ungetc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.7.10">7.21.7.10</a>, <a href="#7.21.9.2">7.21.9.2</a>,             va_copy macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>,
+     <a href="#7.21.9.3">7.21.9.3</a>                                                  <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>
+ungetwc function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3.10">7.28.3.10</a>                       va_end macro, <a href="#7.1.3">7.1.3</a>, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.3">7.16.1.3</a>,
+Unicode, <a href="#7.27">7.27</a>, see also char16_t type,                         <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>,
+     char32_t type, wchar_t type                               <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>, <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>,
+Unicode required set, <a href="#6.10.8.2">6.10.8.2</a>                                 <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>,
+union                                                          <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,
+  arrow operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                                 <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>, <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+  content, <a href="#6.7.2.3">6.7.2.3</a>                                        va_list type, <a href="#7.16">7.16</a>, <a href="#7.16.1.3">7.16.1.3</a>
+  dot operator (.), <a href="#6.5.2.3">6.5.2.3</a>                               va_start macro, <a href="#7.16">7.16</a>, <a href="#7.16.1">7.16.1</a>, <a href="#7.16.1.1">7.16.1.1</a>,
+  initialization, <a href="#6.7.9">6.7.9</a>                                        <a href="#7.16.1.2">7.16.1.2</a>, <a href="#7.16.1.3">7.16.1.3</a>, <a href="#7.16.1.4">7.16.1.4</a>, <a href="#7.21.6.8">7.21.6.8</a>,
+  member alignment, <a href="#6.7.2.1">6.7.2.1</a>                                    <a href="#7.21.6.9">7.21.6.9</a>, <a href="#7.21.6.10">7.21.6.10</a>, <a href="#7.21.6.11">7.21.6.11</a>, <a href="#7.21.6.12">7.21.6.12</a>,
+  member name space, <a href="#6.2.3">6.2.3</a>                                     <a href="#7.21.6.13">7.21.6.13</a>, <a href="#7.21.6.14">7.21.6.14</a>, <a href="#7.28.2.5">7.28.2.5</a>, <a href="#7.28.2.6">7.28.2.6</a>,
+  member operator (.), <a href="#6.3.2.1">6.3.2.1</a>, <a href="#6.5.2.3">6.5.2.3</a>                        <a href="#7.28.2.7">7.28.2.7</a>, <a href="#7.28.2.8">7.28.2.8</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.10">7.28.2.10</a>,
+  pointer operator (-&gt;), <a href="#6.5.2.3">6.5.2.3</a>                               <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>, <a href="#K.3.9.1.7">K.3.9.1.7</a>,
+  specifier, <a href="#6.7.2.1">6.7.2.1</a>                                            <a href="#K.3.9.1.10">K.3.9.1.10</a>, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+  tag, <a href="#6.2.3">6.2.3</a>, <a href="#6.7.2.3">6.7.2.3</a>                                     value, <a href="#3.19">3.19</a>
+  type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.2.1">6.7.2.1</a>                                    value bits, <a href="#6.2.6.2">6.2.6.2</a>
+
+[<a name="p676" href="#p676">page 676</a>] (<a href="#Contents">Contents</a>)
+
+variable arguments, <a href="#6.10.3">6.10.3</a>, <a href="#7.16">7.16</a>                             vswscanf function, <a href="#7.28.2.8">7.28.2.8</a>
+variable arguments header, <a href="#7.16">7.16</a>                              vswscanf_s function, <a href="#K.3.9.1.10">K.3.9.1.10</a>
+variable length array, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>              vwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#K.3.9.1.11">K.3.9.1.11</a>
+variably modified type, <a href="#6.7.6">6.7.6</a>, <a href="#6.7.6.2">6.7.6.2</a>, <a href="#6.10.8.3">6.10.8.3</a>              vwprintf_s function, <a href="#K.3.9.1.11">K.3.9.1.11</a>
+vertical-tab character, <a href="#5.2.1">5.2.1</a>, <a href="#6.4">6.4</a>                           vwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.3.10">7.28.3.10</a>
+vertical-tab escape sequence (\v), <a href="#5.2.2">5.2.2</a>, <a href="#6.4.4.4">6.4.4.4</a>,           vwscanf_s function, <a href="#K.3.9.1.12">K.3.9.1.12</a>
+     <a href="#7.4.1.10">7.4.1.10</a>
+vfprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#K.3.5.3.8">K.3.5.3.8</a>               warnings, <a href="#I">I</a>
+vfprintf_s function, <a href="#K.3.5.3.8">K.3.5.3.8</a>, <a href="#K.3.5.3.9">K.3.5.3.9</a>,                   wchar.h header, <a href="#5.2.4.2.2">5.2.4.2.2</a>, <a href="#7.21.1">7.21.1</a>, <a href="#7.28">7.28</a>, <a href="#7.30.12">7.30.12</a>,
+     <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                                      <a href="#F">F</a>, <a href="#K.3.9">K.3.9</a>
+vfscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.9">7.21.6.9</a>                 WCHAR_MAX macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.28.1">7.28.1</a>
+vfscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                   WCHAR_MIN macro, <a href="#7.20.3">7.20.3</a>, <a href="#7.28.1">7.28.1</a>
+     <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wchar_t type, <a href="#3.7.3">3.7.3</a>, <a href="#6.4.5">6.4.5</a>, <a href="#6.7.9">6.7.9</a>, <a href="#6.10.8.2">6.10.8.2</a>, <a href="#7.19">7.19</a>,
+vfwprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.5">7.28.2.5</a>, <a href="#K.3.9.1.6">K.3.9.1.6</a>                  <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.22">7.22</a>, <a href="#7.28.1">7.28.1</a>,
+vfwprintf_s function, <a href="#K.3.9.1.6">K.3.9.1.6</a>                                  <a href="#7.28.2.1">7.28.2.1</a>, <a href="#7.28.2.2">7.28.2.2</a>
+vfwscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.6">7.28.2.6</a>, <a href="#7.28.3.10">7.28.3.10</a>               wcrtomb function, <a href="#7.21.3">7.21.3</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+vfwscanf_s function, <a href="#K.3.9.1.7">K.3.9.1.7</a>                                   <a href="#7.28.6.3.3">7.28.6.3.3</a>, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.6.5.2">K.3.6.5.2</a>, <a href="#K.3.9.3.1">K.3.9.3.1</a>,
+visibility of identifier, <a href="#6.2.1">6.2.1</a>                                   <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+visible sequence of side effects, <a href="#5.1.2.4">5.1.2.4</a>                    wcrtomb_s function, <a href="#K.3.9.3.1">K.3.9.3.1</a>, <a href="#K.3.9.3.1.1">K.3.9.3.1.1</a>
+visible side effect, <a href="#5.1.2.4">5.1.2.4</a>                                 wcscat function, <a href="#7.28.4.3.1">7.28.4.3.1</a>
+VLA, see variable length array                               wcscat_s function, <a href="#K.3.9.2.2.1">K.3.9.2.2.1</a>
+void expression, <a href="#6.3.2.2">6.3.2.2</a>                                     wcschr function, <a href="#7.28.4.5.1">7.28.4.5.1</a>
+void function parameter, <a href="#6.7.6.3">6.7.6.3</a>                             wcscmp function, <a href="#7.28.4.4.1">7.28.4.4.1</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>
+void type, <a href="#6.2.5">6.2.5</a>, <a href="#6.3.2.2">6.3.2.2</a>, <a href="#6.7.2">6.7.2</a>, <a href="#K.3.5.3.2">K.3.5.3.2</a>,                 wcscoll function, <a href="#7.28.4.4.2">7.28.4.4.2</a>, <a href="#7.28.4.4.4">7.28.4.4.4</a>
+     <a href="#K.3.9.1.2">K.3.9.1.2</a>                                               wcscpy function, <a href="#7.28.4.2.1">7.28.4.2.1</a>
+void type conversion, <a href="#6.3.2.2">6.3.2.2</a>                                wcscpy_s function, <a href="#K.3.9.2.1.1">K.3.9.2.1.1</a>
+volatile storage, <a href="#5.1.2.3">5.1.2.3</a>                                    wcscspn function, <a href="#7.28.4.5.2">7.28.4.5.2</a>
+volatile type qualifier, <a href="#6.7.3">6.7.3</a>                                wcsftime function, <a href="#7.11.1.1">7.11.1.1</a>, <a href="#7.28.5.1">7.28.5.1</a>
+volatile-qualified type, <a href="#6.2.5">6.2.5</a>, <a href="#6.7.3">6.7.3</a>                         wcslen function, <a href="#7.28.4.6.1">7.28.4.6.1</a>
+vprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.10">7.21.6.10</a>,               wcsncat function, <a href="#7.28.4.3.2">7.28.4.3.2</a>
+     <a href="#K.3.5.3.10">K.3.5.3.10</a>                                              wcsncat_s function, <a href="#K.3.9.2.2.2">K.3.9.2.2.2</a>
+vprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.10">K.3.5.3.10</a>,                   wcsncmp function, <a href="#7.28.4.4.3">7.28.4.4.3</a>
+     <a href="#K.3.5.3.11">K.3.5.3.11</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                                  wcsncpy function, <a href="#7.28.4.2.2">7.28.4.2.2</a>
+vscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.11">7.21.6.11</a>                 wcsncpy_s function, <a href="#K.3.9.2.1.2">K.3.9.2.1.2</a>
+vscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                    wcsnlen_s function, <a href="#K.3.9.2.4.1">K.3.9.2.4.1</a>
+     <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wcspbrk function, <a href="#7.28.4.5.3">7.28.4.5.3</a>
+vsnprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.12">7.21.6.12</a>,                     wcsrchr function, <a href="#7.28.4.5.4">7.28.4.5.4</a>
+     <a href="#K.3.5.3.12">K.3.5.3.12</a>                                              wcsrtombs function, <a href="#7.28.6.4.2">7.28.6.4.2</a>, <a href="#K.3.9.3.2">K.3.9.3.2</a>
+vsnprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                 wcsrtombs_s function, <a href="#K.3.9.3.2">K.3.9.3.2</a>, <a href="#K.3.9.3.2.2">K.3.9.3.2.2</a>
+     <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                      wcsspn function, <a href="#7.28.4.5.5">7.28.4.5.5</a>
+vsnwprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>                  wcsstr function, <a href="#7.28.4.5.6">7.28.4.5.6</a>
+vsprintf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.13">7.21.6.13</a>,                      wcstod function, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>
+     <a href="#K.3.5.3.13">K.3.5.3.13</a>                                              wcstod function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+vsprintf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                  wcstof function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+     <a href="#K.3.5.3.12">K.3.5.3.12</a>, <a href="#K.3.5.3.13">K.3.5.3.13</a>, <a href="#K.3.5.3.14">K.3.5.3.14</a>                      wcstoimax function, <a href="#7.8.2.4">7.8.2.4</a>
+vsscanf function, <a href="#7.21.6.8">7.21.6.8</a>, <a href="#7.21.6.14">7.21.6.14</a>                        wcstok function, <a href="#7.28.4.5.7">7.28.4.5.7</a>
+vsscanf_s function, <a href="#K.3.5.3.9">K.3.5.3.9</a>, <a href="#K.3.5.3.11">K.3.5.3.11</a>,                   wcstok_s function, <a href="#K.3.9.2.3.1">K.3.9.2.3.1</a>
+     <a href="#K.3.5.3.14">K.3.5.3.14</a>                                              wcstol function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,
+vswprintf function, <a href="#7.28.2.7">7.28.2.7</a>, <a href="#K.3.9.1.8">K.3.9.1.8</a>,                         <a href="#7.28.4.1.2">7.28.4.1.2</a>
+     <a href="#K.3.9.1.9">K.3.9.1.9</a>                                               wcstold function, <a href="#7.28.4.1.1">7.28.4.1.1</a>
+vswprintf_s function, <a href="#K.3.9.1.8">K.3.9.1.8</a>, <a href="#K.3.9.1.9">K.3.9.1.9</a>                   wcstoll function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>
+
+[<a name="p677" href="#p677">page 677</a>] (<a href="#Contents">Contents</a>)
+
+wcstombs function, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.28.6.4">7.28.6.4</a>                           <a href="#7.29.1">7.29.1</a>
+wcstombs_s function, <a href="#K.3.6.5.2">K.3.6.5.2</a>                               wmemchr function, <a href="#7.28.4.5.8">7.28.4.5.8</a>
+wcstoul function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.21.6.2">7.21.6.2</a>, <a href="#7.28.2.2">7.28.2.2</a>,               wmemcmp function, <a href="#7.28.4.4.5">7.28.4.4.5</a>
+     <a href="#7.28.4.1.2">7.28.4.1.2</a>                                              wmemcpy function, <a href="#7.28.4.2.3">7.28.4.2.3</a>
+wcstoull function, <a href="#7.8.2.4">7.8.2.4</a>, <a href="#7.28.4.1.2">7.28.4.1.2</a>                       wmemcpy_s function, <a href="#K.3.9.2.1.3">K.3.9.2.1.3</a>
+wcstoumax function, <a href="#7.8.2.4">7.8.2.4</a>                                  wmemmove function, <a href="#7.28.4.2.4">7.28.4.2.4</a>
+wcsxfrm function, <a href="#7.28.4.4.4">7.28.4.4.4</a>                                 wmemmove_s function, <a href="#K.3.9.2.1.4">K.3.9.2.1.4</a>
+wctob function, <a href="#7.28.6.1.2">7.28.6.1.2</a>, <a href="#7.29.2.1">7.29.2.1</a>                         wmemset function, <a href="#7.28.4.6.2">7.28.4.6.2</a>
+wctomb function, <a href="#7.22.7.3">7.22.7.3</a>, <a href="#7.22.8.2">7.22.8.2</a>, <a href="#7.28.6.3">7.28.6.3</a>                wprintf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.9">7.28.2.9</a>, <a href="#7.28.2.11">7.28.2.11</a>,
+wctomb_s function, <a href="#K.3.6.4.1">K.3.6.4.1</a>                                    <a href="#K.3.9.1.13">K.3.9.1.13</a>
+wctrans function, <a href="#7.29.3.2.1">7.29.3.2.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>                     wprintf_s function, <a href="#K.3.9.1.13">K.3.9.1.13</a>
+wctrans_t type, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.3.2.2">7.29.3.2.2</a>                           wscanf function, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.2.10">7.28.2.10</a>, <a href="#7.28.2.12">7.28.2.12</a>,
+wctype function, <a href="#7.29.2.2.1">7.29.2.2.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>                         <a href="#7.28.3.10">7.28.3.10</a>
+wctype.h header, <a href="#7.29">7.29</a>, <a href="#7.30.13">7.30.13</a>                               wscanf_s function, <a href="#K.3.9.1.12">K.3.9.1.12</a>, <a href="#K.3.9.1.14">K.3.9.1.14</a>
+wctype_t type, <a href="#7.29.1">7.29.1</a>, <a href="#7.29.2.2.2">7.29.2.2.2</a>
+weaker, <a href="#6.2.8">6.2.8</a>                                                xor macro, <a href="#7.9">7.9</a>
+WEOF macro, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.3.1">7.28.3.1</a>, <a href="#7.28.3.3">7.28.3.3</a>, <a href="#7.28.3.6">7.28.3.6</a>,            xor_eq macro, <a href="#7.9">7.9</a>
+     <a href="#7.28.3.7">7.28.3.7</a>, <a href="#7.28.3.8">7.28.3.8</a>, <a href="#7.28.3.9">7.28.3.9</a>, <a href="#7.28.3.10">7.28.3.10</a>,                xtime type, <a href="#7.25.1">7.25.1</a>, <a href="#7.25.3.5">7.25.3.5</a>, <a href="#7.25.4.4">7.25.4.4</a>, <a href="#7.25.5.7">7.25.5.7</a>,
+     <a href="#7.28.6.1.1">7.28.6.1.1</a>, <a href="#7.29.1">7.29.1</a>                                          <a href="#7.25.7.1">7.25.7.1</a>
+while statement, <a href="#6.8.5.1">6.8.5.1</a>                                     xtime_get function, <a href="#7.25.7.1">7.25.7.1</a>
+white space, <a href="#5.1.1.2">5.1.1.2</a>, <a href="#6.4">6.4</a>, <a href="#6.10">6.10</a>, <a href="#7.4.1.10">7.4.1.10</a>,
+     <a href="#7.29.2.1.10">7.29.2.1.10</a>
+white-space characters, <a href="#6.4">6.4</a>
+wide character, <a href="#3.7.3">3.7.3</a>
+  case mapping functions, <a href="#7.29.3.1">7.29.3.1</a>
+     extensible, <a href="#7.29.3.2">7.29.3.2</a>
+  classification functions, <a href="#7.29.2.1">7.29.2.1</a>
+     extensible, <a href="#7.29.2.2">7.29.2.2</a>
+  constant, <a href="#6.4.4.4">6.4.4.4</a>
+  formatted input/output functions, <a href="#7.28.2">7.28.2</a>,
+        <a href="#K.3.9.1">K.3.9.1</a>
+  input functions, <a href="#7.21.1">7.21.1</a>
+  input/output functions, <a href="#7.21.1">7.21.1</a>, <a href="#7.28.3">7.28.3</a>
+  output functions, <a href="#7.21.1">7.21.1</a>
+  single-byte conversion functions, <a href="#7.28.6.1">7.28.6.1</a>
+wide string, <a href="#7.1.1">7.1.1</a>
+wide string comparison functions, <a href="#7.28.4.4">7.28.4.4</a>
+wide string concatenation functions, <a href="#7.28.4.3">7.28.4.3</a>,
+     <a href="#K.3.9.2.2">K.3.9.2.2</a>
+wide string copying functions, <a href="#7.28.4.2">7.28.4.2</a>, <a href="#K.3.9.2.1">K.3.9.2.1</a>
+wide string literal, see string literal
+wide string miscellaneous functions, <a href="#7.28.4.6">7.28.4.6</a>,
+     <a href="#K.3.9.2.4">K.3.9.2.4</a>
+wide string numeric conversion functions, <a href="#7.8.2.4">7.8.2.4</a>,
+     <a href="#7.28.4.1">7.28.4.1</a>
+wide string search functions, <a href="#7.28.4.5">7.28.4.5</a>, <a href="#K.3.9.2.3">K.3.9.2.3</a>
+wide-oriented stream, <a href="#7.21.2">7.21.2</a>
+width, <a href="#6.2.6.2">6.2.6.2</a>
+WINT_MAX macro, <a href="#7.20.3">7.20.3</a>
+WINT_MIN macro, <a href="#7.20.3">7.20.3</a>
+wint_t type, <a href="#7.20.3">7.20.3</a>, <a href="#7.21.6.1">7.21.6.1</a>, <a href="#7.28.1">7.28.1</a>, <a href="#7.28.2.1">7.28.2.1</a>,
+
+[<a name="p678" href="#p678">page 678</a>] (<a href="#Contents">Contents</a>)
+</pre></body></html>
diff --git a/tohtml.pre.sh b/tohtml.pre.sh
new file mode 100755
index 0000000..75e4e7d
--- /dev/null
+++ b/tohtml.pre.sh
@@ -0,0 +1,125 @@
+#!/bin/sh
+
+export LC_ALL=C
+sed 's/&/\&amp;/g;s/</\&lt;/g;s/>/\&gt;/g' | awk '
+BEGIN {
+	getline
+	print "<html><head><title>" $0 "</title></head><body><pre>"
+	print
+
+	while (getline == 1) {
+		if ($0 ~ /^Contents/)
+			break
+		print
+	}
+	print "<a name=\"Contents\" href=\"#Contents\">Contents</a>"
+
+	while (getline == 1) {
+		id = $1
+		if (id ~ /Annex/)
+			id = $2
+		if (id ~ /^([1-9A-Z]|Index|Foreword|Introduction|Bibliography)/) {
+			if (match($0, /&lt;[a-zA-Z0-9_]*\.h&gt;/)) {
+				h=substr($0,RSTART,RLENGTH)
+				if (!(h in header))
+					header[h] = id
+			}
+			if (id ~ /\.$/)
+				id = substr(id,1,length(id)-1)
+			s = "<a href=\"#" id "\">" $0
+			if ($(NF-1) == ".")
+				print s "</a>"
+			else{
+				print s
+				getline
+				print $0 "</a>"
+			}
+			if (id == "Index")
+				break
+		} else
+			print
+	}
+	note = 1
+}
+
+!seenindex && /^ *([1-9A-Z]\.|Annex|Index|Foreword|Introduction|Bibliography)/ {
+	id = $1
+	if (id ~ /Annex/)
+		id = $2
+	if (($0 ~ /^    [1-9]\./ || id ~ /^([A-Z]|[1-9A-Z]\.[1-9][0-9.]*|Index|Foreword|Introduction|Bibliography)$/) &&
+	    (NF==1 || $2 ~ /^[A-Zv]/) &&
+	    ($0 !~ /^ *[0-9.]+[^0-9]$/)) {
+		if (id ~ /\.$/)
+			id = substr(id,1,length(id)-1)
+		print "<a name=\"" id "\" href=\"#" id "\"><b>" $0 "</b></a>"
+		if (id == "Index")
+			seenindex=1
+		next
+	}
+}
+
+/^\[page / {
+	p = substr($2,1,length($2)-1)
+	print "[<a name=\"p" p "\" href=\"#p" p "\">page " p "</a>] (<a href=\"#Contents\">Contents</a>)"
+	next
+}
+
+/^ *(Syntax|Semantics|Description|Constraints|Synopsis|Returns)$/ {
+	print "<b>" $0 "</b>"
+	next
+}
+
+{
+	s = $0
+	p = ""
+	if (seenindex)
+		r = "[ (][A-Z1-9][0-9.]*"
+	else
+		r = "[ (][A-Z1-9]\\.[0-9.]*[0-9]"
+	while (match(s, r)) {
+		p = p substr(s,1,RSTART)
+		m = substr(s,RSTART+1,RLENGTH-1)
+		if (m ~ /\.0$/ || m ~ /[4-9][0-9]/ || m ~ /[0-3][0-9][0-9]/ || substr(s,RSTART+RLENGTH,1) ~ /[a-zA-Z\-]/)
+			p = p m
+		else
+			p = p "<a href=\"#" m "\">" m "</a>"
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+	p = ""
+	while (match(s, /[Aa]nnex [A-Z]/)) {
+		p = p substr(s,1,RSTART-1)
+		m = substr(s,RSTART,RLENGTH)
+		p = p "<a href=\"#" substr(m,RLENGTH,1) "\">" m "</a>"
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+	p = ""
+	while (match(s, /&lt;[a-zA-Z0-9_]*\.h&gt;/)) {
+		p = p substr(s,1,RSTART-1)
+		m = substr(s,RSTART,RLENGTH)
+		if (m in header)
+			p = p "<a href=\"#" header[m] "\">" m "</a>"
+		else
+			p = p m
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+	p = ""
+	while (match(s, note "\\)")) {
+		if (note==1 && s !~ /\.1\)/)
+			break
+		p = p substr(s,1,RSTART-1)
+		p = p "<sup><a href=\"#note" note "\"><b>" note ")</b></a></sup>"
+		note++
+		s = substr(s,RSTART+RLENGTH)
+	}
+	s = p s
+	if (s ~ /^ *[1-9][0-9]*\) /) {
+		sub(/\)/,"",s)
+		sub(/[0-9]+/,"<sup><a name=\"note&\" href=\"#note&\"><b>&)</b></a></sup>",s)
+	}
+	print s
+}
+
+END { print "</pre></body></html>" }'
diff --git a/tohtml.sh b/tohtml.sh
index 8555d24..6531b60 100755
--- a/tohtml.sh
+++ b/tohtml.sh
@@ -1,125 +1,3 @@
 #!/bin/sh
 
-export LC_ALL=C
-sed 's/&/\&amp;/g;s/</\&lt;/g;s/>/\&gt;/g' | awk '
-BEGIN {
-	getline
-	print "<html><head><title>" $0 "</title></head><body><pre>"
-	print
-
-	while (getline == 1) {
-		if ($0 ~ /^Contents/)
-			break
-		print
-	}
-	print "<a name=\"Contents\" href=\"#Contents\">Contents</a>"
-
-	while (getline == 1) {
-		id = $1
-		if (id ~ /Annex/)
-			id = $2
-		if (id ~ /^([1-9A-Z]|Index|Foreword|Introduction|Bibliography)/) {
-			if (match($0, /&lt;[a-zA-Z0-9_]*\.h&gt;/)) {
-				h=substr($0,RSTART,RLENGTH)
-				if (!(h in header))
-					header[h] = id
-			}
-			if (id ~ /\.$/)
-				id = substr(id,1,length(id)-1)
-			s = "<a href=\"#" id "\">" $0
-			if ($(NF-1) == ".")
-				print s "</a>"
-			else{
-				print s
-				getline
-				print $0 "</a>"
-			}
-			if (id == "Index")
-				break
-		} else
-			print
-	}
-	note = 1
-}
-
-!seenindex && /^ *([1-9A-Z]\.|Annex|Index|Foreword|Introduction|Bibliography)/ {
-	id = $1
-	if (id ~ /Annex/)
-		id = $2
-	if (($0 ~ /^    [1-9]\./ || id ~ /^([A-Z]|[1-9A-Z]\.[1-9][0-9.]*|Index|Foreword|Introduction|Bibliography)$/) &&
-	    (NF==1 || $2 ~ /^[A-Z]/) &&
-	    ($0 !~ /^ *[0-9.]+[^0-9]$/)) {
-		if (id ~ /\.$/)
-			id = substr(id,1,length(id)-1)
-		print "<a name=\"" id "\" href=\"#" id "\"><b>" $0 "</b></a>"
-		if (id == "Index")
-			seenindex=1
-		next
-	}
-}
-
-/^\[page / {
-	p = substr($2,1,length($2)-1)
-	print "[<a name=\"p" p "\" href=\"#p" p "\">page " p "</a>] (<a href=\"#Contents\">Contents</a>)"
-	next
-}
-
-/^ *(Syntax|Semantics|Description|Constraints|Synopsis|Returns)$/ {
-	print "<b>" $0 "</b>"
-	next
-}
-
-{
-	s = $0
-	p = ""
-	if (seenindex)
-		r = "[ (][A-Z1-9][0-9.]*"
-	else
-		r = "[ (][A-Z1-9]\\.[0-9.]*[0-9]"
-	while (match(s, r)) {
-		p = p substr(s,1,RSTART)
-		m = substr(s,RSTART+1,RLENGTH-1)
-		if (m ~ /\.0$/ || m ~ /[4-9][0-9]/ || m ~ /[0-3][0-9][0-9]/ || substr(s,RSTART+RLENGTH,1) ~ /[a-zA-Z\-]/)
-			p = p m
-		else
-			p = p "<a href=\"#" m "\">" m "</a>"
-		s = substr(s,RSTART+RLENGTH)
-	}
-	s = p s
-	p = ""
-	while (match(s, /[Aa]nnex [A-Z]/)) {
-		p = p substr(s,1,RSTART-1)
-		m = substr(s,RSTART,RLENGTH)
-		p = p "<a href=\"#" substr(m,RLENGTH,1) "\">" m "</a>"
-		s = substr(s,RSTART+RLENGTH)
-	}
-	s = p s
-	p = ""
-	while (match(s, /&lt;[a-zA-Z0-9_]*\.h&gt;/)) {
-		p = p substr(s,1,RSTART-1)
-		m = substr(s,RSTART,RLENGTH)
-		if (m in header)
-			p = p "<a href=\"#" header[m] "\">" m "</a>"
-		else
-			p = p m
-		s = substr(s,RSTART+RLENGTH)
-	}
-	s = p s
-	p = ""
-	while (match(s, note "\\)")) {
-		if (note==1 && s !~ /\.1\)/)
-			break
-		p = p substr(s,1,RSTART-1)
-		p = p "<sup><a href=\"#note" note "\"><b>" note ")</b></a></sup>"
-		note++
-		s = substr(s,RSTART+RLENGTH)
-	}
-	s = p s
-	if (s ~ /^ *[1-9][0-9]*\) /) {
-		sub(/\)/,"",s)
-		sub(/[0-9]+/,"<sup><a name=\"note&\" href=\"#note&\"><b>&)</b></a></sup>",s)
-	}
-	print s
-}
-
-END { print "</pre></body></html>" }'
+./annot.sh | ./ann2html.sh
-- 
2.20.1