add pre.html version of n1570
authornsz <nsz@port70.net>
Sun, 24 Jul 2011 12:15:41 +0000 (14:15 +0200)
committernsz <nsz@port70.net>
Sun, 24 Jul 2011 12:15:41 +0000 (14:15 +0200)
n1570.pre.html [moved from n1548.pre.html with 79% similarity]
pdf2html.sh

similarity index 79%
rename from n1548.pre.html
rename to n1570.pre.html
index 8ef750a..6be6baf 100644 (file)
@@ -1,5 +1,5 @@
-<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
+<html><head><title>N1570                      Committee Draft -- April 12, 2011          ISO/IEC 9899:201x</title></head><body><pre>
+N1570                      Committee Draft -- April 12, 2011          ISO/IEC 9899:201x
 
 
 
@@ -34,7 +34,7 @@ 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
+Changes from the previous draft (N1539) are indicated by ''diff marks'' in the right
 margin: deleted text is marked with ''*'', new or changed text with '' ''.
 
 [page i]
@@ -46,8 +46,8 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
 <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="#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>
@@ -102,126 +102,126 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
 <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>
+<a href="#6.5.17">          6.5.17 Comma operator . . . . .          .   .   .   .   .   .   .   .   .   .   .   .   .   .   105</a>
+<a href="#6.6">     6.6 Constant expressions . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   106</a>
+<a href="#6.7">     6.7 Declarations      . . . . . . . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   108</a>
+<a href="#6.7.1">          6.7.1   Storage-class specifiers    . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   109</a>
+<a href="#6.7.2">          6.7.2   Type specifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   111</a>
+<a href="#6.7.3">          6.7.3   Type qualifiers . . . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   121</a>
+<a href="#6.7.4">          6.7.4   Function specifiers     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   125</a>
+<a href="#6.7.5">          6.7.5   Alignment specifier . . . .       .   .   .   .   .   .   .   .   .   .   .   .   .   .   127</a>
+<a href="#6.7.6">          6.7.6   Declarators     . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   128</a>
+<a href="#6.7.7">          6.7.7   Type names . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   136</a>
+<a href="#6.7.8">          6.7.8   Type definitions      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   137</a>
+<a href="#6.7.9">          6.7.9   Initialization    . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   139</a>
+<a href="#6.7.10">          6.7.10 Static assertions     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   145</a>
+<a href="#6.8">     6.8 Statements and blocks      . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   146</a>
+<a href="#6.8.1">          6.8.1   Labeled statements     . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   146</a>
+<a href="#6.8.2">          6.8.2   Compound statement       . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   147</a>
+<a href="#6.8.3">          6.8.3   Expression and null statements       .   .   .   .   .   .   .   .   .   .   .   .   .   147</a>
+<a href="#6.8.4">          6.8.4   Selection statements     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   148</a>
+<a href="#6.8.5">          6.8.5   Iteration statements . . . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   150</a>
+<a href="#6.8.6">          6.8.6   Jump statements      . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   151</a>
+<a href="#6.9">     6.9 External definitions      . . . . . . .    .   .   .   .   .   .   .   .   .   .   .   .   .   .   155</a>
+<a href="#6.9.1">          6.9.1   Function definitions . . . .      .   .   .   .   .   .   .   .   .   .   .   .   .   .   156</a>
+<a href="#6.9.2">          6.9.2   External object definitions   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   158</a>
+<a href="#6.10">     6.10 Preprocessing directives     . . . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   160</a>
+<a href="#6.10.1">          6.10.1 Conditional inclusion     . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   162</a>
+<a href="#6.10.2">          6.10.2 Source file inclusion      . . .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   164</a>
+<a href="#6.10.3">          6.10.3 Macro replacement . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   166</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>
+<a href="#6.10.4">       6.10.4 Line control . . . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   173</a>
+<a href="#6.10.5">       6.10.5 Error directive . . . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174</a>
+<a href="#6.10.6">       6.10.6 Pragma directive . . . .        .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   174</a>
+<a href="#6.10.7">       6.10.7 Null directive      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   175</a>
+<a href="#6.10.8">       6.10.8 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   175</a>
+<a href="#6.10.9">       6.10.9 Pragma operator       . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   178</a>
+<a href="#6.11">  6.11 Future language directions     . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.1">       6.11.1 Floating types      . . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.2">       6.11.2 Linkages of identifiers . .      .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.3">       6.11.3 External names        . . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.4">       6.11.4 Character escape sequences          .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.5">       6.11.5 Storage-class specifiers     .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.6">       6.11.6 Function declarators      . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.7">       6.11.7 Function definitions . . .       .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.8">       6.11.8 Pragma directives       . . .   .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#6.11.9">       6.11.9 Predefined macro names .         .   .   .   .   .   .   .   .   .    .   .   .   .   .   .   179</a>
+<a href="#7">7. Library . . . . . . . . . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   180</a>
+<a href="#7.1">   7.1 Introduction     . . . . . . . . . . . . .             .   .   .   .   .    .   .   .   .   .   .   180</a>
+<a href="#7.1.1">         7.1.1 Definitions of terms . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   180</a>
+<a href="#7.1.2">         7.1.2 Standard headers . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   181</a>
+<a href="#7.1.3">         7.1.3 Reserved identifiers . . . . . . .              .   .   .   .   .    .   .   .   .   .   .   182</a>
+<a href="#7.1.4">         7.1.4 Use of library functions    . . . . .          .   .   .   .   .    .   .   .   .   .   .   183</a>
+<a href="#7.2">   7.2 Diagnostics &lt;assert.h&gt;          . . . . . . .          .   .   .   .   .    .   .   .   .   .   .   186</a>
+<a href="#7.2.1">         7.2.1 Program diagnostics       . . . . . .          .   .   .   .   .    .   .   .   .   .   .   186</a>
+<a href="#7.3">   7.3 Complex arithmetic &lt;complex.h&gt;           . . .         .   .   .   .   .    .   .   .   .   .   .   188</a>
+<a href="#7.3.1">         7.3.1 Introduction . . . . . . . . . .               .   .   .   .   .    .   .   .   .   .   .   188</a>
+<a href="#7.3.2">         7.3.2 Conventions . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   189</a>
+<a href="#7.3.3">         7.3.3 Branch cuts . . . . . . . . . .                .   .   .   .   .    .   .   .   .   .   .   189</a>
+<a href="#7.3.4">         7.3.4 The CX_LIMITED_RANGE pragma                    .   .   .   .   .    .   .   .   .   .   .   189</a>
+<a href="#7.3.5">         7.3.5 Trigonometric functions . . . . .              .   .   .   .   .    .   .   .   .   .   .   190</a>
+<a href="#7.3.6">         7.3.6 Hyperbolic functions      . . . . . .          .   .   .   .   .    .   .   .   .   .   .   192</a>
+<a href="#7.3.7">         7.3.7 Exponential and logarithmic functions              .   .   .   .    .   .   .   .   .   .   194</a>
+<a href="#7.3.8">         7.3.8 Power and absolute-value functions             .   .   .   .   .    .   .   .   .   .   .   195</a>
+<a href="#7.3.9">         7.3.9 Manipulation functions      . . . . .          .   .   .   .   .    .   .   .   .   .   .   196</a>
+<a href="#7.4">   7.4 Character handling &lt;ctype.h&gt; . . . . .                 .   .   .   .   .    .   .   .   .   .   .   200</a>
+<a href="#7.4.1">         7.4.1 Character classification functions    .         .   .   .   .   .    .   .   .   .   .   .   200</a>
+<a href="#7.4.2">         7.4.2 Character case mapping functions     .         .   .   .   .   .    .   .   .   .   .   .   203</a>
+<a href="#7.5">   7.5 Errors &lt;errno.h&gt;         . . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   205</a>
+<a href="#7.6">   7.6 Floating-point environment &lt;fenv.h&gt;        . .         .   .   .   .   .    .   .   .   .   .   .   206</a>
+<a href="#7.6.1">         7.6.1 The FENV_ACCESS pragma           . . .         .   .   .   .   .    .   .   .   .   .   .   208</a>
+<a href="#7.6.2">         7.6.2 Floating-point exceptions      . . . .         .   .   .   .   .    .   .   .   .   .   .   209</a>
+<a href="#7.6.3">         7.6.3 Rounding . . . . . . . . . . .                 .   .   .   .   .    .   .   .   .   .   .   212</a>
+<a href="#7.6.4">         7.6.4 Environment        . . . . . . . . .           .   .   .   .   .    .   .   .   .   .   .   213</a>
+<a href="#7.7">   7.7 Characteristics of floating types &lt;float.h&gt;             .   .   .   .   .    .   .   .   .   .   .   216</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.8">     7.8    Format conversion of integer types &lt;inttypes.h&gt; . . . .           .   .   .   .   217</a>
+<a href="#7.8.1">            7.8.1    Macros for format specifiers      . . . . . . . . . .     .   .   .   .   217</a>
+<a href="#7.8.2">            7.8.2    Functions for greatest-width integer types   . . . . .   .   .   .   .   218</a>
+<a href="#7.9">     7.9    Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . .            .   .   .   .   221</a>
+<a href="#7.10">     7.10   Sizes of integer types &lt;limits.h&gt;         . . . . . . . . . .     .   .   .   .   222</a>
+<a href="#7.11">     7.11   Localization &lt;locale.h&gt; . . . . . . . . . . . . . .               .   .   .   .   223</a>
+<a href="#7.11.1">            7.11.1 Locale control . . . . . . . . . . . . . . . .             .   .   .   .   224</a>
+<a href="#7.11.2">            7.11.2 Numeric formatting convention inquiry . . . . . .          .   .   .   .   225</a>
+<a href="#7.12">     7.12   Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                .   .   .   .   231</a>
+<a href="#7.12.1">            7.12.1 Treatment of error conditions . . . . . . . . . .          .   .   .   .   233</a>
+<a href="#7.12.2">            7.12.2 The FP_CONTRACT pragma             . . . . . . . . . .     .   .   .   .   235</a>
+<a href="#7.12.3">            7.12.3 Classification macros       . . . . . . . . . . . . .       .   .   .   .   235</a>
+<a href="#7.12.4">            7.12.4 Trigonometric functions . . . . . . . . . . . .            .   .   .   .   238</a>
+<a href="#7.12.5">            7.12.5 Hyperbolic functions       . . . . . . . . . . . . .       .   .   .   .   240</a>
+<a href="#7.12.6">            7.12.6 Exponential and logarithmic functions        . . . . . .   .   .   .   .   242</a>
+<a href="#7.12.7">            7.12.7 Power and absolute-value functions         . . . . . . .   .   .   .   .   247</a>
+<a href="#7.12.8">            7.12.8 Error and gamma functions . . . . . . . . . . .            .   .   .   .   249</a>
+<a href="#7.12.9">            7.12.9 Nearest integer functions . . . . . . . . . . . .          .   .   .   .   251</a>
+<a href="#7.12.10">            7.12.10 Remainder functions       . . . . . . . . . . . . .       .   .   .   .   254</a>
+<a href="#7.12.11">            7.12.11 Manipulation functions       . . . . . . . . . . . .      .   .   .   .   255</a>
+<a href="#7.12.12">            7.12.12 Maximum, minimum, and positive difference functions           .   .   .   257</a>
+<a href="#7.12.13">            7.12.13 Floating multiply-add . . . . . . . . . . . . .           .   .   .   .   258</a>
+<a href="#7.12.14">            7.12.14 Comparison macros . . . . . . . . . . . . . .             .   .   .   .   259</a>
+<a href="#7.13">     7.13   Nonlocal jumps &lt;setjmp.h&gt;            . . . . . . . . . . . .      .   .   .   .   262</a>
+<a href="#7.13.1">            7.13.1 Save calling environment         . . . . . . . . . . .     .   .   .   .   262</a>
+<a href="#7.13.2">            7.13.2 Restore calling environment        . . . . . . . . . .     .   .   .   .   263</a>
+<a href="#7.14">     7.14   Signal handling &lt;signal.h&gt; . . . . . . . . . . . . .              .   .   .   .   265</a>
+<a href="#7.14.1">            7.14.1 Specify signal handling       . . . . . . . . . . . .      .   .   .   .   266</a>
+<a href="#7.14.2">            7.14.2 Send signal      . . . . . . . . . . . . . . . . .         .   .   .   .   267</a>
+<a href="#7.15">     7.15   Alignment &lt;stdalign.h&gt;            . . . . . . . . . . . . .       .   .   .   .   268</a>
+<a href="#7.16">     7.16   Variable arguments &lt;stdarg.h&gt;           . . . . . . . . . . .     .   .   .   .   269</a>
+<a href="#7.16.1">            7.16.1 Variable argument list access macros . . . . . . .         .   .   .   .   269</a>
+<a href="#7.17">     7.17   Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . .                 .   .   .   .   273</a>
+<a href="#7.17.1">            7.17.1 Introduction . . . . . . . . . . . . . . . . .             .   .   .   .   273</a>
+<a href="#7.17.2">            7.17.2 Initialization      . . . . . . . . . . . . . . . .        .   .   .   .   274</a>
+<a href="#7.17.3">            7.17.3 Order and consistency . . . . . . . . . . . . .            .   .   .   .   275</a>
+<a href="#7.17.4">            7.17.4 Fences . . . . . . . . . . . . . . . . . . .               .   .   .   .   278</a>
+<a href="#7.17.5">            7.17.5 Lock-free property       . . . . . . . . . . . . . .       .   .   .   .   279</a>
+<a href="#7.17.6">            7.17.6 Atomic integer types       . . . . . . . . . . . . .       .   .   .   .   280</a>
+<a href="#7.17.7">            7.17.7 Operations on atomic types . . . . . . . . . . .           .   .   .   .   282</a>
+<a href="#7.17.8">            7.17.8 Atomic flag type and operations . . . . . . . . .           .   .   .   .   285</a>
+<a href="#7.18">     7.18   Boolean type and values &lt;stdbool.h&gt;             . . . . . . . .   .   .   .   .   287</a>
+<a href="#7.19">     7.19   Common definitions &lt;stddef.h&gt; . . . . . . . . . . .                .   .   .   .   288</a>
 <a href="#7.20">     7.20   Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . .              .   .   .   .   289</a>
 
 [page vi]
@@ -238,231 +238,236 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
 <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.8">         7.21.8 Direct input/output functions    . . . . . .    .   .    .   .   .   .   .   .   335</a>
+<a href="#7.21.9">         7.21.9 File positioning functions     . . . . . . .    .   .    .   .   .   .   .   .   336</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>
+<a href="#7.22.4">         7.22.4 Communication with the environment        . .   .   .    .   .   .   .   .   .   350</a>
+<a href="#7.22.5">         7.22.5 Searching and sorting utilities . . . . . .     .   .    .   .   .   .   .   .   354</a>
+<a href="#7.22.6">         7.22.6 Integer arithmetic functions     . . . . . .    .   .    .   .   .   .   .   .   356</a>
+<a href="#7.22.7">         7.22.7 Multibyte/wide character conversion functions       .    .   .   .   .   .   .   357</a>
+<a href="#7.22.8">         7.22.8 Multibyte/wide string conversion functions      .   .    .   .   .   .   .   .   359</a>
+<a href="#7.23">  7.23   _Noreturn &lt;stdnoreturn.h&gt;               . . . . . .    .   .    .   .   .   .   .   .   361</a>
+<a href="#7.24">  7.24   String handling &lt;string.h&gt; . . . . . . . . .           .   .    .   .   .   .   .   .   362</a>
+<a href="#7.24.1">         7.24.1 String function conventions . . . . . . .       .   .    .   .   .   .   .   .   362</a>
+<a href="#7.24.2">         7.24.2 Copying functions       . . . . . . . . . .     .   .    .   .   .   .   .   .   362</a>
+<a href="#7.24.3">         7.24.3 Concatenation functions . . . . . . . .         .   .    .   .   .   .   .   .   364</a>
+<a href="#7.24.4">         7.24.4 Comparison functions . . . . . . . . .          .   .    .   .   .   .   .   .   365</a>
+<a href="#7.24.5">         7.24.5 Search functions      . . . . . . . . . . .     .   .    .   .   .   .   .   .   367</a>
+<a href="#7.24.6">         7.24.6 Miscellaneous functions . . . . . . . .         .   .    .   .   .   .   .   .   371</a>
+<a href="#7.25">  7.25   Type-generic math &lt;tgmath.h&gt;          . . . . . . .    .   .    .   .   .   .   .   .   373</a>
+<a href="#7.26">  7.26   Threads &lt;threads.h&gt;          . . . . . . . . . . .     .   .    .   .   .   .   .   .   376</a>
+<a href="#7.26.1">         7.26.1 Introduction . . . . . . . . . . . . .          .   .    .   .   .   .   .   .   376</a>
+<a href="#7.26.2">         7.26.2 Initialization functions . . . . . . . . .      .   .    .   .   .   .   .   .   378</a>
+<a href="#7.26.3">         7.26.3 Condition variable functions     . . . . . .    .   .    .   .   .   .   .   .   378</a>
+<a href="#7.26.4">         7.26.4 Mutex functions       . . . . . . . . . . .     .   .    .   .   .   .   .   .   380</a>
+<a href="#7.26.5">         7.26.5 Thread functions . . . . . . . . . . .          .   .    .   .   .   .   .   .   383</a>
+<a href="#7.26.6">         7.26.6 Thread-specific storage functions     . . . .    .   .    .   .   .   .   .   .   386</a>
+<a href="#7.27">  7.27   Date and time &lt;time.h&gt;         . . . . . . . . . .     .   .    .   .   .   .   .   .   388</a>
+<a href="#7.27.1">         7.27.1 Components of time        . . . . . . . . .     .   .    .   .   .   .   .   .   388</a>
+<a href="#7.27.2">         7.27.2 Time manipulation functions      . . . . . .    .   .    .   .   .   .   .   .   389</a>
+<a href="#7.27.3">         7.27.3 Time conversion functions      . . . . . . .    .   .    .   .   .   .   .   .   392</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>
+<a href="#7.28">   7.28 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .               . .     .   398</a>
+<a href="#7.28.1">        7.28.1 Restartable multibyte/wide character conversion functions        .     .   398</a>
+<a href="#7.29">   7.29 Extended multibyte and wide character utilities &lt;wchar.h&gt; . .         . .     .   402</a>
+<a href="#7.29.1">        7.29.1 Introduction . . . . . . . . . . . . . . . . . .               . .     .   402</a>
+<a href="#7.29.2">        7.29.2 Formatted wide character input/output functions       . . .    . .     .   403</a>
+<a href="#7.29.3">        7.29.3 Wide character input/output functions        . . . . . . .     . .     .   421</a>
+<a href="#7.29.4">        7.29.4 General wide string utilities     . . . . . . . . . . .        . .     .   426</a>
+<a href="#7.29.4.1">                 7.29.4.1 Wide string numeric conversion functions     . .    . .     .   426</a>
+<a href="#7.29.4.2">                 7.29.4.2 Wide string copying functions . . . . . . .         . .     .   430</a>
+<a href="#7.29.4.3">                 7.29.4.3 Wide string concatenation functions      . . . .    . .     .   432</a>
+<a href="#7.29.4.4">                 7.29.4.4 Wide string comparison functions      . . . . .     . .     .   433</a>
+<a href="#7.29.4.5">                 7.29.4.5 Wide string search functions      . . . . . . .     . .     .   435</a>
+<a href="#7.29.4.6">                 7.29.4.6 Miscellaneous functions      . . . . . . . . .      . .     .   439</a>
+<a href="#7.29.5">        7.29.5 Wide character time conversion functions       . . . . . .     . .     .   439</a>
+<a href="#7.29.6">        7.29.6 Extended multibyte/wide character conversion utilities .       . .     .   440</a>
+<a href="#7.29.6.1">                 7.29.6.1 Single-byte/wide character conversion functions     . .     .   441</a>
+<a href="#7.29.6.2">                 7.29.6.2 Conversion state functions     . . . . . . . .      . .     .   441</a>
+<a href="#7.29.6.3">                 7.29.6.3 Restartable multibyte/wide character conversion
+                           functions   . . . . . . . . . . . . . . .          . . . 442</a>
+<a href="#7.29.6.4">                 7.29.6.4 Restartable multibyte/wide string conversion
+                           functions   . . . . . . . . . . . . . . .          .   .   .   444</a>
+<a href="#7.30">   7.30 Wide character classification and mapping utilities &lt;wctype.h&gt;         .   .   .   447</a>
+<a href="#7.30.1">        7.30.1 Introduction . . . . . . . . . . . . . . . . . .               .   .   .   447</a>
+<a href="#7.30.2">        7.30.2 Wide character classification utilities . . . . . . . .         .   .   .   448</a>
+<a href="#7.30.2.1">                 7.30.2.1 Wide character classification functions     . . .    .   .   .   448</a>
+<a href="#7.30.2.2">                 7.30.2.2 Extensible wide character classification
+                           functions   . . . . . . . . . . . . . . .          . . . 451</a>
+<a href="#7.30.3">        7.30.3 Wide character case mapping utilities . . . . . . . .          . . . 453</a>
+<a href="#7.30.3.1">                 7.30.3.1 Wide character case mapping functions      . . .    . . . 453</a>
+<a href="#7.30.3.2">                 7.30.3.2 Extensible wide character case mapping
+                           functions   . . . . . . . . . . . . . . .          .   .   .   453</a>
+<a href="#7.31">   7.31 Future library directions    . . . . . . . . . . . . . . . .          .   .   .   455</a>
+<a href="#7.31.1">        7.31.1 Complex arithmetic &lt;complex.h&gt; . . . . . . . .                 .   .   .   455</a>
+<a href="#7.31.2">        7.31.2 Character handling &lt;ctype.h&gt;            . . . . . . . . .      .   .   .   455</a>
+<a href="#7.31.3">        7.31.3 Errors &lt;errno.h&gt;           . . . . . . . . . . . . . .         .   .   .   455</a>
+<a href="#7.31.4">        7.31.4 Floating-point environment &lt;fenv.h&gt; . . . . . . .              .   .   .   455</a>
+<a href="#7.31.5">        7.31.5 Format conversion of integer types &lt;inttypes.h&gt;            .   .   .   .   455</a>
+<a href="#7.31.6">        7.31.6 Localization &lt;locale.h&gt;           . . . . . . . . . . .        .   .   .   455</a>
+<a href="#7.31.7">        7.31.7 Signal handling &lt;signal.h&gt;           . . . . . . . . . .       .   .   .   455</a>
+<a href="#7.31.8">        7.31.8 Atomics &lt;stdatomic.h&gt;             . . . . . . . . . . .        .   .   .   455</a>
+<a href="#7.31.9">        7.31.9 Boolean type and values &lt;stdbool.h&gt;            . . . . . .     .   .   .   456</a>
+<a href="#7.31.10">        7.31.10 Integer types &lt;stdint.h&gt;         . . . . . . . . . . .        .   .   .   456</a>
+<a href="#7.31.11">        7.31.11 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . .        .   .   .   456</a>
+<a href="#7.31.12">        7.31.12 General utilities &lt;stdlib.h&gt;        . . . . . . . . . .       .   .   .   456</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>
+<a href="#7.31.13">        7.31.13 String handling &lt;string.h&gt;        . . . . . . .            . . . . . . 456</a>
+<a href="#7.31.14">        7.31.14 Date and time &lt;time.h&gt;        . . . . . . . . .            . . . . . . 456</a>
+<a href="#7.31.15">        7.31.15 Threads &lt;threads.h&gt; . . . . . . . . . .                    . . . . . . 456</a>
+<a href="#7.31.16">        7.31.16 Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;        . . . . . . . . . . . . . .               . . . . . . 456</a>
+<a href="#7.31.17">        7.31.17 Wide character classification and mapping utilities
+                &lt;wctype.h&gt; . . . . . . . . . . . . . .                     . . . . . . 457</a>
+<a href="#A">Annex A (informative) Language syntax summary   . .       .   .   .   .    .   .   .   .   .   .   458</a>
+<a href="#A.1">  A.1 Lexical grammar       . . . . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   458</a>
+<a href="#A.2">  A.2 Phrase structure grammar . . . . . . . . .          .   .   .   .    .   .   .   .   .   .   465</a>
+<a href="#A.3">  A.3 Preprocessing directives    . . . . . . . . .       .   .   .   .    .   .   .   .   .   .   473</a>
+<a href="#B">Annex B (informative) Library summary     . . . . . . . . . . . . .                    .   .   .   475</a>
+<a href="#B.1">  B.1 Diagnostics &lt;assert.h&gt;          . . . . . . . . . . . . . . .                    .   .   .   475</a>
+<a href="#B.2">  B.2 Complex &lt;complex.h&gt; . . . . . . . . . . . . . . . .                              .   .   .   475</a>
+<a href="#B.3">  B.3 Character handling &lt;ctype.h&gt; . . . . . . . . . . . . .                           .   .   .   477</a>
+<a href="#B.4">  B.4 Errors &lt;errno.h&gt;         . . . . . . . . . . . . . . . . . .                     .   .   .   477</a>
+<a href="#B.5">  B.5 Floating-point environment &lt;fenv.h&gt;          . . . . . . . . . .                 .   .   .   477</a>
+<a href="#B.6">  B.6 Characteristics of floating types &lt;float.h&gt; . . . . . . . .                       .   .   .   478</a>
+<a href="#B.7">  B.7 Format conversion of integer types &lt;inttypes.h&gt; . . . . .                        .   .   .   478</a>
+<a href="#B.8">  B.8 Alternative spellings &lt;iso646.h&gt; . . . . . . . . . . . .                         .   .   .   479</a>
+<a href="#B.9">  B.9 Sizes of integer types &lt;limits.h&gt;          . . . . . . . . . . .                 .   .   .   479</a>
+<a href="#B.10">  B.10 Localization &lt;locale.h&gt; . . . . . . . . . . . . . . .                           .   .   .   479</a>
+<a href="#B.11">  B.11 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . . .                            .   .   .   479</a>
+<a href="#B.12">  B.12 Nonlocal jumps &lt;setjmp.h&gt;          . . . . . . . . . . . . .                    .   .   .   484</a>
+<a href="#B.13">  B.13 Signal handling &lt;signal.h&gt; . . . . . . . . . . . . . .                          .   .   .   484</a>
+<a href="#B.14">  B.14 Alignment &lt;stdalign.h&gt;           . . . . . . . . . . . . . .                    .   .   .   485</a>
+<a href="#B.15">  B.15 Variable arguments &lt;stdarg.h&gt;         . . . . . . . . . . . .                   .   .   .   485</a>
+<a href="#B.16">  B.16 Atomics &lt;stdatomic.h&gt; . . . . . . . . . . . . . . .                             .   .   .   485</a>
+<a href="#B.17">  B.17 Boolean type and values &lt;stdbool.h&gt;           . . . . . . . . .                 .   .   .   487</a>
+<a href="#B.18">  B.18 Common definitions &lt;stddef.h&gt; . . . . . . . . . . . .                            .   .   .   487</a>
+<a href="#B.19">  B.19 Integer types &lt;stdint.h&gt; . . . . . . . . . . . . . . .                          .   .   .   487</a>
+<a href="#B.20">  B.20 Input/output &lt;stdio.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   488</a>
+<a href="#B.21">  B.21 General utilities &lt;stdlib.h&gt;       . . . . . . . . . . . . .                    .   .   .   491</a>
+<a href="#B.22">  B.22 _Noreturn &lt;stdnoreturn.h&gt;                 . . . . . . . . . . .                 .   .   .   493</a>
+<a href="#B.23">  B.23 String handling &lt;string.h&gt; . . . . . . . . . . . . . .                          .   .   .   493</a>
+<a href="#B.24">  B.24 Type-generic math &lt;tgmath.h&gt;          . . . . . . . . . . . .                   .   .   .   495</a>
+<a href="#B.25">  B.25 Threads &lt;threads.h&gt;          . . . . . . . . . . . . . . . .                    .   .   .   495</a>
+<a href="#B.26">  B.26 Date and time &lt;time.h&gt;         . . . . . . . . . . . . . . .                    .   .   .   496</a>
+<a href="#B.27">  B.27 Unicode utilities &lt;uchar.h&gt; . . . . . . . . . . . . . .                         .   .   .   497</a>
+<a href="#B.28">  B.28 Extended multibyte/wide character utilities &lt;wchar.h&gt;     . . .                 .   .   .   497</a>
+<a href="#B.29">  B.29 Wide character classification and mapping utilities &lt;wctype.h&gt;                   .   .   .   502</a>
+<a href="#C">Annex C (informative) Sequence points     . . . . . . . . . . . . . . . . . 503</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>
+<a href="#D">Annex D (normative) Universal character names for identifiers . . . . . . . 504</a>
+<a href="#D.1">  D.1 Ranges of characters allowed       . . . . . . . . . . . . . . . . . 504</a>
+<a href="#D.2">  D.2 Ranges of characters disallowed initially . . . . . . . . . . . . . 504</a>
+<a href="#E">Annex E (informative) Implementation limits     . . . . . . . . . . . . . . 505</a>
+<a href="#F">Annex F (normative) IEC 60559 floating-point arithmetic . . . . . .         . .     .   .   507</a>
+<a href="#F.1">  F.1 Introduction      . . . . . . . . . . . . . . . . . . . .            . .     .   .   507</a>
+<a href="#F.2">  F.2 Types . . . . . . . . . . . . . . . . . . . . . . .                  . .     .   .   507</a>
+<a href="#F.3">  F.3 Operators and functions       . . . . . . . . . . . . . . .          . .     .   .   508</a>
+<a href="#F.4">  F.4 Floating to integer conversion    . . . . . . . . . . . . .          . .     .   .   510</a>
+<a href="#F.5">  F.5 Binary-decimal conversion       . . . . . . . . . . . . . .          . .     .   .   510</a>
+<a href="#F.6">  F.6 The return statement . . . . . . . . . . . . . . . .                 . .     .   .   511</a>
+<a href="#F.7">  F.7 Contracted expressions . . . . . . . . . . . . . . . .               . .     .   .   511</a>
+<a href="#F.8">  F.8 Floating-point environment      . . . . . . . . . . . . . .          . .     .   .   511</a>
+<a href="#F.9">  F.9 Optimization . . . . . . . . . . . . . . . . . . . .                 . .     .   .   514</a>
+<a href="#F.10">  F.10 Mathematics &lt;math.h&gt; . . . . . . . . . . . . . . .                  . .     .   .   517</a>
+<a href="#F.10.1">        F.10.1 Trigonometric functions . . . . . . . . . . . .             . .     .   .   518</a>
+<a href="#F.10.2">        F.10.2 Hyperbolic functions     . . . . . . . . . . . . .          . .     .   .   520</a>
+<a href="#F.10.3">        F.10.3 Exponential and logarithmic functions    . . . . . .        . .     .   .   520</a>
+<a href="#F.10.4">        F.10.4 Power and absolute value functions     . . . . . . .        . .     .   .   524</a>
+<a href="#F.10.5">        F.10.5 Error and gamma functions . . . . . . . . . . .             . .     .   .   525</a>
+<a href="#F.10.6">        F.10.6 Nearest integer functions . . . . . . . . . . . .           . .     .   .   526</a>
+<a href="#F.10.7">        F.10.7 Remainder functions      . . . . . . . . . . . . .          . .     .   .   528</a>
+<a href="#F.10.8">        F.10.8 Manipulation functions     . . . . . . . . . . . .          . .     .   .   529</a>
+<a href="#F.10.9">        F.10.9 Maximum, minimum, and positive difference functions           .     .   .   530</a>
+<a href="#F.10.10">        F.10.10 Floating multiply-add . . . . . . . . . . . . .            . .     .   .   530</a>
+<a href="#F.10.11">        F.10.11 Comparison macros . . . . . . . . . . . . . .              . .     .   .   531</a>
+<a href="#G">Annex G (normative) IEC 60559-compatible complex arithmetic    .   .   .   .   .   .   .   532</a>
+<a href="#G.1">  G.1 Introduction     . . . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   532</a>
+<a href="#G.2">  G.2 Types . . . . . . . . . . . . . . . . . . . .            .   .   .   .   .   .   .   532</a>
+<a href="#G.3">  G.3 Conventions      . . . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   532</a>
+<a href="#G.4">  G.4 Conversions      . . . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   533</a>
+<a href="#G.4.1">       G.4.1 Imaginary types     . . . . . . . . . . . .       .   .   .   .   .   .   .   533</a>
+<a href="#G.4.2">       G.4.2 Real and imaginary . . . . . . . . . . .          .   .   .   .   .   .   .   533</a>
+<a href="#G.4.3">       G.4.3 Imaginary and complex       . . . . . . . . .     .   .   .   .   .   .   .   533</a>
+<a href="#G.5">  G.5 Binary operators     . . . . . . . . . . . . . . .       .   .   .   .   .   .   .   533</a>
+<a href="#G.5.1">       G.5.1 Multiplicative operators    . . . . . . . . .     .   .   .   .   .   .   .   534</a>
+<a href="#G.5.2">       G.5.2 Additive operators     . . . . . . . . . . .      .   .   .   .   .   .   .   537</a>
+<a href="#G.6">  G.6 Complex arithmetic &lt;complex.h&gt;         . . . . . . .     .   .   .   .   .   .   .   537</a>
+<a href="#G.6.1">       G.6.1 Trigonometric functions . . . . . . . . .         .   .   .   .   .   .   .   539</a>
+<a href="#G.6.2">       G.6.2 Hyperbolic functions     . . . . . . . . . .      .   .   .   .   .   .   .   539</a>
+<a href="#G.6.3">       G.6.3 Exponential and logarithmic functions     . . .   .   .   .   .   .   .   .   543</a>
+<a href="#G.6.4">       G.6.4 Power and absolute-value functions      . . . .   .   .   .   .   .   .   .   544</a>
+<a href="#G.7">  G.7 Type-generic math &lt;tgmath.h&gt;         . . . . . . . .     .   .   .   .   .   .   .   545</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>
+<a href="#H">Annex H (informative) Language independent arithmetic . .                 .   .    .   .   .   .   .   .   546</a>
+<a href="#H.1">  H.1 Introduction     . . . . . . . . . . . . . . . .                    .   .    .   .   .   .   .   .   546</a>
+<a href="#H.2">  H.2 Types . . . . . . . . . . . . . . . . . . .                         .   .    .   .   .   .   .   .   546</a>
+<a href="#H.3">  H.3 Notification      . . . . . . . . . . . . . . . .                    .   .    .   .   .   .   .   .   550</a>
+<a href="#I">Annex I (informative) Common warnings         . . . . . . . . . . . . . . . . 552</a>
+<a href="#J">Annex J (informative) Portability issues    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   554</a>
+<a href="#J.1">  J.1 Unspecified behavior . . . .           . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   554</a>
+<a href="#J.2">  J.2 Undefined behavior          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   557</a>
+<a href="#J.3">  J.3 Implementation-defined behavior          . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   571</a>
+<a href="#J.4">  J.4 Locale-specific behavior         . .   . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   578</a>
+<a href="#J.5">  J.5 Common extensions          . . . .    . . . .   .   .   .   .   .   .   .    .   .   .   .   .   .   579</a>
+<a href="#K">Annex K (normative) Bounds-checking interfaces . . . . . . . . .                           .   .   .   .   582</a>
+<a href="#K.1">  K.1 Background       . . . . . . . . . . . . . . . . . . . .                             .   .   .   .   582</a>
+<a href="#K.2">  K.2 Scope . . . . . . . . . . . . . . . . . . . . . . .                                  .   .   .   .   583</a>
+<a href="#K.3">  K.3 Library     . . . . . . . . . . . . . . . . . . . . . .                              .   .   .   .   583</a>
+<a href="#K.3.1">       K.3.1 Introduction . . . . . . . . . . . . . . . . .                                .   .   .   .   583</a>
+<a href="#K.3.1.1">                K.3.1.1 Standard headers     . . . . . . . . . . .                         .   .   .   .   583</a>
+<a href="#K.3.1.2">                K.3.1.2 Reserved identifiers     . . . . . . . . . .                        .   .   .   .   584</a>
+<a href="#K.3.1.3">                K.3.1.3 Use of errno . . . . . . . . . . . . .                             .   .   .   .   584</a>
+<a href="#K.3.1.4">                K.3.1.4 Runtime-constraint violations     . . . . . .                      .   .   .   .   584</a>
+<a href="#K.3.2">       K.3.2 Errors &lt;errno.h&gt;           . . . . . . . . . . . . .                          .   .   .   .   585</a>
+<a href="#K.3.3">       K.3.3 Common definitions &lt;stddef.h&gt;               . . . . . . .                      .   .   .   .   585</a>
+<a href="#K.3.4">       K.3.4 Integer types &lt;stdint.h&gt;           . . . . . . . . . .                        .   .   .   .   585</a>
+<a href="#K.3.5">       K.3.5 Input/output &lt;stdio.h&gt;          . . . . . . . . . . .                         .   .   .   .   586</a>
+<a href="#K.3.5.1">                K.3.5.1 Operations on files      . . . . . . . . . .                        .   .   .   .   586</a>
+<a href="#K.3.5.2">                K.3.5.2 File access functions . . . . . . . . . .                          .   .   .   .   588</a>
+<a href="#K.3.5.3">                K.3.5.3 Formatted input/output functions . . . . .                         .   .   .   .   591</a>
+<a href="#K.3.5.4">                K.3.5.4 Character input/output functions . . . . .                         .   .   .   .   602</a>
+<a href="#K.3.6">       K.3.6 General utilities &lt;stdlib.h&gt;          . . . . . . . . .                       .   .   .   .   604</a>
+<a href="#K.3.6.1">                K.3.6.1 Runtime-constraint handling       . . . . . .                      .   .   .   .   604</a>
+<a href="#K.3.6.2">                K.3.6.2 Communication with the environment . . .                           .   .   .   .   606</a>
+<a href="#K.3.6.3">                K.3.6.3 Searching and sorting utilities . . . . . .                        .   .   .   .   607</a>
+<a href="#K.3.6.4">                K.3.6.4 Multibyte/wide character conversion functions                          .   .   .   610</a>
+<a href="#K.3.6.5">                K.3.6.5 Multibyte/wide string conversion functions .                       .   .   .   .   611</a>
+<a href="#K.3.7">       K.3.7 String handling &lt;string.h&gt;            . . . . . . . . .                       .   .   .   .   614</a>
+<a href="#K.3.7.1">                K.3.7.1 Copying functions       . . . . . . . . . .                        .   .   .   .   614</a>
+<a href="#K.3.7.2">                K.3.7.2 Concatenation functions       . . . . . . . .                      .   .   .   .   617</a>
+<a href="#K.3.7.3">                K.3.7.3 Search functions     . . . . . . . . . . .                         .   .   .   .   620</a>
+<a href="#K.3.7.4">                K.3.7.4 Miscellaneous functions       . . . . . . . .                      .   .   .   .   621</a>
+<a href="#K.3.8">       K.3.8 Date and time &lt;time.h&gt;          . . . . . . . . . . .                         .   .   .   .   624</a>
+<a href="#K.3.8.1">                K.3.8.1 Components of time . . . . . . . . . .                             .   .   .   .   624</a>
+<a href="#K.3.8.2">                K.3.8.2 Time conversion functions       . . . . . . .                      .   .   .   .   624</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 href="#K.3.9">        K.3.9   Extended multibyte and wide character utilities
+                &lt;wchar.h&gt;        . . . . . . . . . . . . . . . . .                            . . . 627</a>
+<a href="#K.3.9.1">                K.3.9.1 Formatted wide character input/output functions                       . . . 628</a>
+<a href="#K.3.9.2">                K.3.9.2 General wide string utilities . . . . . . . .                         . . . 639</a>
+<a href="#K.3.9.3">                K.3.9.3 Extended multibyte/wide character conversion
+                        utilities . . . . . . . . . . . . . . . .                             . . . 647</a>
+<a href="#L">Annex L (normative) Analyzability . .     .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   652</a>
+<a href="#L.1">  L.1 Scope . . . . . . . . . . .         .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   652</a>
+<a href="#L.2">  L.2 Definitions . . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   652</a>
+<a href="#L.3">  L.3 Requirements . . . . . . . .        .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   653</a>
+<a href="#Bibliography">Bibliography    . . . . . . . . . . . . . . . . . . . . . . . . . . . 654</a>
+<a href="#Index">Index    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657</a>
 
 [<a name="pxii" href="#pxii">page xii</a>] (<a href="#Contents">Contents</a>)
 
@@ -498,10 +503,10 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
     -- 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>)
+      <a href="#7.26">&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
+    -- Unicode characters and           strings   (<a href="#7.28">&lt;uchar.h&gt;</a>)       (originally   specified    in
       ISO/IEC TR 19769:2004)
     -- type-generic expressions
 
@@ -521,7 +526,7 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
 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
+    -- wide character library support in <a href="#7.29">&lt;wchar.h&gt;</a> and <a href="#7.30">&lt;wctype.h&gt;</a> (originally
       specified in AMD1)
     -- more precise aliasing rules via effective type
     -- restricted pointers
@@ -529,7 +534,7 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
     -- 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>
+    -- type-generic math macros in <a href="#7.25">&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>
@@ -553,7 +558,7 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
 -- 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>
+-- the vscanf family of functions in <a href="#7.21">&lt;stdio.h&gt;</a> and <a href="#7.29">&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>
@@ -583,7 +588,7 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
     -- 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, *
+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.
@@ -598,7 +603,7 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
 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.
+    features) or new programs (for language [6.11] or library features [7.31]) 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);
@@ -775,8 +780,8 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
 
 <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
+    value representable by 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
@@ -920,13 +925,13 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
     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>
+    freestanding implementation shall accept any strictly conforming program 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>,           <a href="#7.20">&lt;stdint.h&gt;</a>,         and
+    <a href="#7.23">&lt;stdnoreturn.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>
 
 
 
@@ -950,7 +955,8 @@ margin: deleted text is marked with ''*'', new or changed text with '' ''.
     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>).
+    (<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>),
+    <a href="#7.23">&lt;stdnoreturn.h&gt;</a> (<a href="#7.23">7.23</a>).
 
 
 
@@ -1170,9 +1176,11 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
      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.
+     sig_atomic_t are unspecified, as is the state of the floating-point environment. The
+     value of any object modified by the handler that is neither a lock-free atomic object nor of
+     type volatile sig_atomic_t becomes indeterminate when the handler exits, as
+     does the state of the floating-point environment if it is modified by the handler and not
+     restored to its original state.
 6    The least requirements on a conforming implementation are:
      -- Accesses to volatile objects are evaluated strictly according to the rules of the abstract
        machine.
@@ -1206,11 +1214,12 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
               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>)
 
+     overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only
+     produce the same result, possibly omitting the promotions.
+
 12   EXAMPLE 3       Similarly, in the fragment
               float f1, f2;
               double d;
@@ -1256,10 +1265,10 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
      [-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>)
 
+     while the original expression would not; nor can the expression be rewritten either as
               a = ((a + 32765) + b);
      or
               a = (a + (b + 32765));
@@ -1281,8 +1290,8 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
      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>).
+     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>), floating-
+     point environment <a href="#7.6">&lt;fenv.h&gt;</a> (<a href="#7.6">7.6</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
@@ -1300,8 +1309,6 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
      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.
@@ -1309,7 +1316,7 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
 [<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 href="#7.26.4">7.26.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
@@ -1334,10 +1341,10 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
      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.
+10   A release sequence headed by a release operation A 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 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
@@ -1370,9 +1377,9 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
        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
+     -- A performs a release operation on an atomic object M, and, in another thread, 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
@@ -1483,16 +1490,16 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
     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
+            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
+            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
+            0    1   2      3   4     5   6   7    8    9
     the following 29 graphic characters
-            !    "   #      %   &amp;   '    (    )    *    +    ,    -   .    /    :
-            ;    &lt;   =      &gt;   ?   [    \    ]    ^    _    {    |   }    ~
+            !    "   #      %   &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
@@ -1753,7 +1760,7 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
     <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
+    <a href="#7.21">&lt;stdio.h&gt;</a>, <a href="#7.22">&lt;stdlib.h&gt;</a>, and <a href="#7.29">&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
@@ -1786,14 +1793,14 @@ preprocessing directives (<a href="#6.10">6.10</a>), trigraph sequences (<a href
      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.
+              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-
@@ -1983,8 +1990,8 @@ example, if the widest type were to use the minimal-width IEC 60559 double-exten
 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.3">&lt;complex.h&gt;</a> (<a href="#7.3">7.3</a>), extended multibyte and wide character utilities <a href="#7.29">&lt;wchar.h&gt;</a>
+(<a href="#7.29">7.29</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>)
@@ -2551,13 +2558,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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).
+    _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
+    _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
+    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.
 
@@ -2571,7 +2578,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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
+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:
@@ -2664,8 +2671,8 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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. 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.
+    conversions may be represented in greater range and precision than that required by the
+    new type (see <a href="#6.3.1.8">6.3.1.8</a> and <a href="#6.8.6.4">6.8.6.4</a>).
 <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
@@ -2673,8 +2680,8 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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. 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.
+    conversions may be represented in greater range and precision than that required by the
+    new type (see <a href="#6.3.1.8">6.3.1.8</a> and <a href="#6.8.6.4">6.8.6.4</a>).
 <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.
@@ -2722,7 +2729,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                   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
+    represented in greater range and precision than that required by the type; the types are not
     changed thereby.<sup><a href="#note63"><b>63)</b></a></sup>
 
 
@@ -2744,26 +2751,26 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.
+2   Except when it is the operand of the sizeof operator, the _Alignof 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, the _Alignof 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
+    operand of the sizeof operator, the _Alignof 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
 
 
     <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
@@ -2772,17 +2779,18 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
         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>.
+    <sup><a name="note65" href="#note65"><b>65)</b></a></sup> Because this conversion does not occur, the operand of the sizeof or _Alignof operator remains
+        a function designator and violates the constraints 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''.
+    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.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
+    (<a href="#6.5.3.1">6.5.3.1</a>), the sizeof and _Alignof operators (<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 name="6.3.2.2" href="#6.3.2.2"><b>    6.3.2.2 void</b></a>
 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
@@ -2810,8 +2818,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.
@@ -2906,21 +2912,21 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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
+                   auto                        * if                             unsigned
+                   break                         inline                         void
+                   case                          int                            volatile
+                   char                          long                           while
+                   const                         register                       _Alignas
+                   continue                      restrict                       _Alignof
+                   default                       return                         _Atomic
+                   do                            short                          _Bool
+                   double                        signed                         _Complex
+                   else                          sizeof                         _Generic
+                   enum                          static                         _Imaginary
+                   extern                        struct                         _Noreturn
+                   float                         switch                         _Static_assert
+                   for                           typedef                        _Thread_local
+                   goto                          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
@@ -3321,7 +3327,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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
+     <a href="#7.28">&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
@@ -3357,7 +3363,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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 href="#7.22.7.2">7.22.7.2</a>), Unicode utilities <a href="#7.28">&lt;uchar.h&gt;</a> (<a href="#7.28">7.28</a>).
 <a name="6.4.5" href="#6.4.5"><b>     6.4.5 String literals</b></a>
 <b>     Syntax</b>
 1             string-literal:
@@ -3447,15 +3453,15 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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>).
+    function (<a href="#7.22.8.1">7.22.8.1</a>), Unicode utilities <a href="#7.28">&lt;uchar.h&gt;</a> (<a href="#7.28">7.28</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; &lt; &gt; &lt;= &gt;=                             ==       !=    ^    |   &amp;&amp;   ||
                     ? : ; ...
-                    = *= /= %= += -= &lt;&lt;=                        &gt;&gt;=    &amp;=       ^=   |=
+                    = *= /= %= += -= &lt;&lt;=                            &gt;&gt;=       &amp;=       ^=   |=
                     , # ##
                     &lt;: :&gt; &lt;% %&gt; %: %:%:
 <b>    Semantics</b>
@@ -3589,7 +3595,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>         *
+    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
@@ -3648,13 +3654,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>).
+    Forward references: the FP_CONTRACT pragma (<a href="#7.12.2">7.12.2</a>), copying functions (<a href="#7.24.2">7.24.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
+    <sup><a name="note89" href="#note89"><b>89)</b></a></sup> The intermediate operations in the contracted expression are evaluated as if to infinite range and
+        precision, 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
@@ -3682,6 +3688,8 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.
+6   A generic selection is a primary expression. Its type and value depend on the selected
+    generic association, as detailed in the following subclause.
     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>
@@ -3693,14 +3701,16 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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>)
 
+<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
     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
@@ -3735,12 +3745,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                     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>)
 
+             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 complete object type'', the other
@@ -3771,18 +3781,15 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
     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="p80" href="#p80">page 80</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="#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>
@@ -3794,7 +3801,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.         *
+    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
@@ -3807,17 +3814,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="note92" href="#note92"><b>92)</b></a></sup> Most often, this is the result of converting an identifier that is a function designator.
     <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
@@ -3825,6 +3825,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 [<a name="p81" href="#p81">page 81</a>] (<a href="#Contents">Contents</a>)
 
+     -- 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.
@@ -3852,20 +3860,17 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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>)
 
+<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.
 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
@@ -3889,16 +3894,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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="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.
     <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
@@ -3907,6 +3910,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 [<a name="p83" href="#p83">page 83</a>] (<a href="#Contents">Contents</a>)
 
+             s.i        int
+             s.ci       const int
+             cs.i       const int
+             cs.ci      const int
+             vs.i       volatile int
+             vs.ci      volatile const int
+
 9   EXAMPLE 3       The following is a valid fragment:
              union {
                      struct {
@@ -3977,20 +3987,21 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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.
+    <sup><a name="note98" href="#note98"><b>98)</b></a></sup> Where a pointer to an atomic object can be formed and E has integer type, E++ is equivalent to the
+        following code sequence where T is the type of E:
+                  T *addr = &amp;E;
+                  T old = *addr;
+                  T new;
+                  do {
+                         new = old + 1;
+                  } while (!atomic_compare_exchange_strong(addr, &amp;old, new));
+         with old being the result of the operation.
+         Special care must be taken if E has floating type; see <a href="#6.5.16.2">6.5.16.2</a>.
 
 [<a name="p85" href="#p85">page 85</a>] (<a href="#Contents">Contents</a>)
 
+     value is given by the initializer list.<sup><a href="#note99"><b>99)</b></a></sup>
 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
@@ -4025,7 +4036,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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:
 
 
 
@@ -4037,6 +4047,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 [<a name="p86" href="#p86">page 86</a>] (<a href="#Contents">Contents</a>)
 
+     Or, if drawline instead expected pointers to struct point:
               drawline(&amp;(struct point){.x=1, .y=1},
                     &amp;(struct point){.x=3, .y=4});
 
@@ -4092,7 +4103,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                     unary-operator cast-expression
                     sizeof unary-expression
                     sizeof ( type-name )
-                    alignof ( 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>
@@ -4162,21 +4173,21 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 [<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>
+<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.
+    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.
+3   The _Alignof operator yields the alignment requirement of its operand type. The
+    operand is not evaluated and 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
@@ -4236,7 +4247,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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
+6   If the value of the expression is represented with greater range or precision 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.
@@ -4391,7 +4402,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                      relational-expression   &gt;=   shift-expression
 <b>    Constraints</b>
 2   One of the following shall hold:
-    -- both operands have real type; or                                                            *
+    -- both operands have real type; or
     -- both operands are pointers to qualified or unqualified versions of compatible object
       types.
 <b>    Semantics</b>
@@ -4515,9 +4526,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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
+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>
@@ -4529,9 +4540,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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
+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>
@@ -4564,7 +4575,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>                        *
+    (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
@@ -4713,9 +4724,48 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 [<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>
+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>
+
+
+
+
+<sup><a name="note113" href="#note113"><b>113)</b></a></sup> Where a pointer to an atomic object can be formed and E1 and E2 have integer type, this is equivalent
+     to the following code sequence where T1 is the type of E1 and T2 is the type of E2:
+               T1 *addr = &amp;E1;
+               T2 val = (E2);
+               T1 old = *addr;
+               T1 new;
+               do {
+                     new = old op val;
+               } while (!atomic_compare_exchange_strong(addr, &amp;old, new));
+      with new being the result of the operation.
+      If E1 or E2 has floating type, then exceptional conditions or floating-point exceptions encountered
+      during discarded evaluations of new should also be discarded in order to satisfy the equivalence of E1
+      op = E2 and E1 = E1 op (E2). For example, if <a href="#F">annex F</a> is in effect, the floating types involved have
+      IEC 60559 formats, and FLT_EVAL_METHOD is 0, the equivalent code would be:
+               #include <a href="#7.6">&lt;fenv.h&gt;</a>
+               #pragma STDC FENV_ACCESS ON
+               /* ... */
+                       fenv_t fenv;
+                       T1 *addr = &amp;E1;
+                       T2 val = E2;
+                       T1 old = *addr;
+                       T1 new;
+                       feholdexcept(&amp;fenv);
+                       for (;;) {
+                             new = old op val;
+                             if (atomic_compare_exchange_strong(addr, &amp;old, new))
+                                         break;
+                             feclearexcept(FE_ALL_EXCEPT);
+                       }
+                       feupdateenv(&amp;fenv);
+      If FLT_EVAL_METHOD is not 0, then T2 must be a type with the range and precision to which E2 is
+      evaluated in order to satisfy the equivalence.
+
+[<a name="p104" href="#p104">page 104</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:
@@ -4724,12 +4774,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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>                        *
+    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)
+              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>).
@@ -4737,17 +4787,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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="p105" href="#p105">page 105</a>] (<a href="#Contents">Contents</a>)
 
 <a name="6.6" href="#6.6"><b>    6.6 Constant expressions</b></a>
 <b>    Syntax</b>
@@ -4764,22 +4806,22 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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
+    expression is evaluated in the translation environment, the arithmetic range and precision
     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.
+    expressions whose results are integer constants, _Alignof expressions, 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 or _Alignof 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="note115" href="#note115"><b>115)</b></a></sup> The operand of a sizeof or _Alignof 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
@@ -4787,7 +4829,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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 name="p106" href="#p106">page 106</a>] (<a href="#Contents">Contents</a>)
 
      -- a null pointer constant,
      -- an address constant, or
@@ -4795,9 +4837,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
        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.
+     constants, sizeof expressions whose results are integer constants, and _Alignof
+     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 or
+     _Alignof operator.
 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
@@ -4814,10 +4857,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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.
+                     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="p107" href="#p107">page 107</a>] (<a href="#Contents">Contents</a>)
 
 <a name="6.7" href="#6.7"><b>    6.7 Declarations</b></a>
 <b>    Syntax</b>
@@ -4842,8 +4885,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>.
+    that:
+    -- a typedef name may be redefined to denote the same type as it currently does,
+      provided that type is not a variably modified type;
+    -- 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>
@@ -4852,14 +4897,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     -- 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>
 
+[<a name="p108" href="#p108">page 108</a>] (<a href="#Contents">Contents</a>)
 
-
-    <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.
+    -- for an enumeration constant, is the (only) declaration of the identifier;
+    -- for a typedef name, is the first (or 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
@@ -4887,27 +4928,43 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     _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>.
+4   _Thread_local shall not appear in the declaration specifiers of a function declaration.
+
 
 
 
+    <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>.
     <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>)
+[<a name="p109" href="#p109">page 109</a>] (<a href="#Contents">Contents</a>)
 
-5   A declaration of an identifier for an object with storage-class specifier register
+<b>    Semantics</b>
+5   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>.
+6   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
+7   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
+8   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>).
+
+
+
+
+    <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 operators that can be applied to an array declared with storage-class specifier
+         register are sizeof and _Alignof.
+
+[<a name="p110" href="#p110">page 110</a>] (<a href="#Contents">Contents</a>)
+
 <a name="6.7.2" href="#6.7.2"><b>    6.7.2 Type specifiers</b></a>
 <b>    Syntax</b>
 1            type-specifier:
@@ -4929,17 +4986,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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.
@@ -4953,6 +4999,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     -- unsigned, or unsigned int
     -- long, signed long, long int, or signed long int
     -- unsigned long, or unsigned long int
+
+[<a name="p111" href="#p111">page 111</a>] (<a href="#Contents">Contents</a>)
+
     -- long long, signed long long, long long int, or
       signed long long int
     -- unsigned long long, or unsigned long long int
@@ -4969,9 +5018,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     -- 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
@@ -4986,43 +5032,49 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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
+
+[<a name="p112" href="#p112">page 112</a>] (<a href="#Contents">Contents</a>)
+
+            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.
+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.
+
+    <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.
 
-[<a name="p111" href="#p111">page 111</a>] (<a href="#Contents">Contents</a>)
+[<a name="p113" href="#p113">page 113</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
@@ -5031,26 +5083,16 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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.
+     members of the structure or union. If the struct-declaration-list does not contain any
+     named members, either directly or via an anonymous structure or anonymous union, 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-
@@ -5062,13 +5104,26 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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
+
+
+     <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.
+     <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="p114" href="#p114">page 114</a>] (<a href="#Contents">Contents</a>)
+
      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.
+13   An unnamed member whose type specifier is a structure specifier with no tag is called an
+     anonymous structure; an unnamed member whose type specifier is a union specifier 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
@@ -5083,15 +5138,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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
@@ -5102,19 +5148,22 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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;
+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;
+
+[<a name="p115" href="#p115">page 115</a>] (<a href="#Contents">Contents</a>)
+
               v1.i = 2;   // valid
               v1.k = 3;   // invalid: inner structure is not anonymous
               v1.w.k = 5; // valid
 
-20   EXAMPLE 2       After the declaration:
+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 */;
@@ -5134,9 +5183,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
               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:
@@ -5153,6 +5199,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
               struct { int n; double d[8]; } *s1;
               struct { int n; double d[5]; } *s2;
 24   Following the further successful assignments:
+
+[<a name="p116" href="#p116">page 116</a>] (<a href="#Contents">Contents</a>)
+
               s1 = malloc(sizeof (struct s) + 10);
               s2 = malloc(sizeof (struct s) + 6);
      they then behave as if the declarations were:
@@ -5168,25 +5217,33 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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.
 
+26   EXAMPLE 3 Because members of anonymous structures and unions are considered to be members of the
+     containing structure or union, struct s in the following example has more than one named member and
+     thus the use of a flexible array member is valid:
+              struct s {
+                    struct { int i; };
+                    int a[];
+              };
+
      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="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.
 
-[<a name="p115" href="#p115">page 115</a>] (<a href="#Contents">Contents</a>)
+[<a name="p117" href="#p117">page 117</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
@@ -5201,24 +5258,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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)
-                   /* ... */
+            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 }.
 
@@ -5231,6 +5277,15 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 3   A type specifier of the form
             enum identifier
     without an enumerator list shall only appear after the type it specifies is complete.
+
+
+    <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="p118" href="#p118">page 118</a>] (<a href="#Contents">Contents</a>)
+
 <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
@@ -5241,7 +5296,22 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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 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)
 
 
 
@@ -5249,25 +5319,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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.
+    <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="p117" href="#p117">page 117</a>] (<a href="#Contents">Contents</a>)
+[<a name="p119" href="#p119">page 119</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
@@ -5282,18 +5341,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
               };
      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
@@ -5314,27 +5361,27 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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;
+             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="p120" href="#p120">page 120</a>] (<a href="#Contents">Contents</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="6.7.3" href="#6.7.3"><b>    6.7.3 Type qualifiers</b></a>
 <b>    Syntax</b>
 1            type-qualifier:
@@ -5353,29 +5400,23 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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>)
+[<a name="p121" href="#p121">page 121</a>] (<a href="#Contents">Contents</a>)
 
+     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
      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
@@ -5391,27 +5432,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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 *''
+11   EXAMPLE 1       An object declared
+             extern const volatile int real_time_clock;
 
 
 
+     <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).
      <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
@@ -5420,7 +5448,24 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
           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>)
+[<a name="p122" href="#p122">page 122</a>] (<a href="#Contents">Contents</a>)
+
+     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 *''
 
 13   EXAMPLE 3       The declaration
               _Atomic volatile int *p;
@@ -5443,6 +5488,15 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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
+
+
+     <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="p123" href="#p123">page 123</a>] (<a href="#Contents">Contents</a>)
+
      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.
@@ -5451,20 +5505,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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[];
+             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)
              {
@@ -5496,23 +5542,22 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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.
 
+[<a name="p124" href="#p124">page 124</a>] (<a href="#Contents">Contents</a>)
+
 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>)
-
+              {
+                       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.
@@ -5539,25 +5584,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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 *
+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>
 
+[<a name="p125" href="#p125">page 125</a>] (<a href="#Contents">Contents</a>)
 
-
-
-     <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>)
-
+     The extent to which such suggestions are effective is implementation-defined.<sup><a href="#note139"><b>139)</b></a></sup>
 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
@@ -5584,6 +5616,25 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                     return (5.0 * (t - 32.0)) / 9.0;
               }
               extern double fahr(double);                  // creates an external definition
+
+
+
+
+     <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.
+     <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="p126" href="#p126">page 126</a>] (<a href="#Contents">Contents</a>)
+
               double convert(int is_fahr, double temp)
               {
                     /* A translator may perform inline substitutions */
@@ -5595,58 +5646,43 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      definition are distinct and either may be used for the call.
 
 12   EXAMPLE 2
+              _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.
 
+[<a name="p127" href="#p127">page 127</a>] (<a href="#Contents">Contents</a>)
 
-
-     <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:
@@ -5675,6 +5711,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              parameter-declaration:
                    declaration-specifiers declarator
                    declaration-specifiers abstract-declaratoropt
+
+
+
+    <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="p128" href="#p128">page 128</a>] (<a href="#Contents">Contents</a>)
+
              identifier-list:
                     identifier
                     identifier-list , identifier
@@ -5684,22 +5728,19 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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
+             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
+             identifier
     then the type specified for ident is T .
 6   If, in the declaration ''T D1'', D1 has the form
-            ( D )
+             ( 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.
@@ -5708,6 +5749,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p129" href="#p129">page 129</a>] (<a href="#Contents">Contents</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
@@ -5719,19 +5763,16 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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;
+            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;
+            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>
@@ -5747,6 +5788,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.
+
+[<a name="p130" href="#p130">page 130</a>] (<a href="#Contents">Contents</a>)
+
 <b>    Semantics</b>
 3   If, in the declaration ''T D1'', D1 has one of the forms:
              D[ type-qualifier-listopt assignment-expressionopt ]
@@ -5759,11 +5803,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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
@@ -5785,12 +5824,21 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     declares an array of float numbers and an array of pointers to float numbers.
 
 8   EXAMPLE 2       Note the distinction between the declarations
+
+
+
+
+    <sup><a name="note142" href="#note142"><b>142)</b></a></sup> When several ''array of'' specifications are adjacent, a multidimensional array is declared.
+    <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="p131" href="#p131">page 131</a>] (<a href="#Contents">Contents</a>)
+
              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.
+     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.
+9    EXAMPLE 3      The following declarations demonstrate the compatibility rules for variably modified types.
              extern int n;
              extern int m;
              void fcompat(void)
@@ -5804,13 +5852,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                                 // 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
@@ -5818,27 +5859,30 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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
+             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
+                   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 (*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
+                      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>),
+     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="p132" href="#p132">page 132</a>] (<a href="#Contents">Contents</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
@@ -5850,12 +5894,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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 )
+             D( parameter-type-list )
      or
-            D( identifier-listopt )
+             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 ''.
@@ -5873,6 +5914,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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.
+
+
+
+     <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="p133" href="#p133">page 133</a>] (<a href="#Contents">Contents</a>)
+
 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
@@ -5886,14 +5935,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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
@@ -5917,30 +5958,30 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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
+
+
+     <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="p134" href="#p134">page 134</a>] (<a href="#Contents">Contents</a>)
+
      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);
+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, ...);
+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.
@@ -5962,22 +6003,22 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                }
 
 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]);
+               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.)
+               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]);
 
-     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="p135" href="#p135">page 135</a>] (<a href="#Contents">Contents</a>)
 
-[<a name="p134" href="#p134">page 134</a>] (<a href="#Contents">Contents</a>)
+    (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="6.7.7" href="#6.7.7"><b>    6.7.7 Type names</b></a>
 <b>    Syntax</b>
 1            type-name:
@@ -6011,17 +6052,16 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p136" href="#p136">page 136</a>] (<a href="#Contents">Contents</a>)
+
+    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.
 
 <a name="6.7.8" href="#6.7.8"><b>    6.7.8 Type definitions</b></a>
 <b>    Syntax</b>
@@ -6059,9 +6099,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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>)
+[<a name="p137" href="#p137">page 137</a>] (<a href="#Contents">Contents</a>)
+
+    s1, but not compatible with the types struct s2, t2, the type pointed to by tp2, or int.
 
 6   EXAMPLE 3       The following obscure constructions
              typedef signed int t;
@@ -6105,7 +6146,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                          a[i-1] = b[i];
              }
 
-[<a name="p137" href="#p137">page 137</a>] (<a href="#Contents">Contents</a>)
+[<a name="p138" href="#p138">page 138</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>
@@ -6143,7 +6184,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>)
+[<a name="p139" href="#p139">page 139</a>] (<a href="#Contents">Contents</a>)
 
 <b>     Semantics</b>
 8    An initializer specifies the initial value stored in an object.
@@ -6174,14 +6215,15 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      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.
+     wchar_t, char16_t, or char32_t may be initialized by a wide string literal with
+     the corresponding encoding prefix (L, u, or U, respectively), 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>)
+[<a name="p140" href="#p140">page 140</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
@@ -6224,7 +6266,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      <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>)
+[<a name="p141" href="#p141">page 141</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
@@ -6272,7 +6314,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
      <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>)
+[<a name="p142" href="#p142">page 142</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.
 
@@ -6314,14 +6356,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 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
+               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>)
+[<a name="p143" href="#p143">page 143</a>] (<a href="#Contents">Contents</a>)
 
 32   EXAMPLE 8       The declaration
               char s[] = "abc", t[3] = "abc";
@@ -6363,7 +6405,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
      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="p144" href="#p144">page 144</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>
@@ -6379,7 +6421,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p145" href="#p145">page 145</a>] (<a href="#Contents">Contents</a>)
 
 <a name="6.8" href="#6.8"><b>    6.8 Statements and blocks</b></a>
 <b>    Syntax</b>
@@ -6418,7 +6460,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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>)
+[<a name="p146" href="#p146">page 146</a>] (<a href="#Contents">Contents</a>)
 
 3   Label names shall be unique within a function.
 <b>    Semantics</b>
@@ -6457,7 +6499,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
     <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>)
+[<a name="p147" href="#p147">page 147</a>] (<a href="#Contents">Contents</a>)
 
 5   EXAMPLE 2       In the program fragment
              char *s;
@@ -6500,7 +6542,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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>)
+[<a name="p148" href="#p148">page 148</a>] (<a href="#Contents">Contents</a>)
 
     to 0. If the first substatement is reached via a label, the second substatement is not
     executed.
@@ -6540,7 +6582,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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>)
+[<a name="p149" href="#p149">page 149</a>] (<a href="#Contents">Contents</a>)
 
 7   EXAMPLE        In the artificial program fragment
              switch (expr)
@@ -6583,7 +6625,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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 name="p150" href="#p150">page 150</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>
@@ -6623,7 +6665,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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>)
+[<a name="p151" href="#p151">page 151</a>] (<a href="#Contents">Contents</a>)
 
 <b>    Semantics</b>
 2   A jump statement causes an unconditional jump to another place.
@@ -6658,7 +6700,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                     /* ... */
             }
 
-[<a name="p151" href="#p151">page 151</a>] (<a href="#Contents">Contents</a>)
+[<a name="p152" href="#p152">page 152</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.
@@ -6701,7 +6743,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
     <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="p153" href="#p153">page 153</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>
@@ -6743,7 +6785,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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="p154" href="#p154">page 154</a>] (<a href="#Contents">Contents</a>)
 
 <a name="6.9" href="#6.9"><b>    6.9 External definitions</b></a>
 <b>    Syntax</b>
@@ -6758,9 +6800,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.
+    linkage is used in an expression (other than as a part of the operand of a sizeof or
+    _Alignof 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''
@@ -6769,10 +6811,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>
+    linkage is used in an expression (other than as part of the operand of a sizeof or
+    _Alignof 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>
 
 
 
@@ -6780,7 +6822,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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="p155" href="#p155">page 155</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>
@@ -6822,7 +6864,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                   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>)
+[<a name="p156" href="#p156">page 156</a>] (<a href="#Contents">Contents</a>)
 
 <b>     Semantics</b>
 7    The declarator in a function definition specifies the name of the function being defined
@@ -6862,7 +6904,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
      <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>)
+[<a name="p157" href="#p157">page 157</a>] (<a href="#Contents">Contents</a>)
 
               extern int max(a, b)
               int a, b;
@@ -6904,7 +6946,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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>)
+[<a name="p158" href="#p158">page 158</a>] (<a href="#Contents">Contents</a>)
 
 4   EXAMPLE 1
              int i1 = 1;                    // definition, external linkage
@@ -6928,7 +6970,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p159" href="#p159">page 159</a>] (<a href="#Contents">Contents</a>)
 
 <a name="6.10" href="#6.10"><b>    6.10 Preprocessing directives</b></a>
 <b>    Syntax</b>
@@ -6952,13 +6994,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
                      elif-group
                      elif-groups elif-group
              elif-group:
-                     # elif       constant-expression new-line groupopt
+                     # elif        constant-expression new-line groupopt
              else-group:
-                     # else       new-line groupopt
+                     # else        new-line groupopt
              endif-line:
-                     # endif      new-line
+                     # endif       new-line
 
-[<a name="p159" href="#p159">page 159</a>] (<a href="#Contents">Contents</a>)
+[<a name="p160" href="#p160">page 160</a>] (<a href="#Contents">Contents</a>)
 
              control-line:
                     # include pp-tokens new-line
@@ -6999,7 +7041,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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>)
+[<a name="p161" href="#p161">page 161</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
@@ -7020,8 +7062,8 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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;
+             #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.
@@ -7029,7 +7071,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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 *
+    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
@@ -7040,7 +7082,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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>)
+[<a name="p162" href="#p162">page 162</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.
@@ -7079,10 +7121,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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)
+            #if 'z' - 'a' == 25
+            if ('z' - 'a' == 25)
 
-[<a name="p162" href="#p162">page 162</a>] (<a href="#Contents">Contents</a>)
+[<a name="p163" href="#p163">page 163</a>] (<a href="#Contents">Contents</a>)
 
 5   Preprocessing directives of the forms
        # ifdef identifier new-line groupopt
@@ -7121,7 +7163,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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>)
+[<a name="p164" href="#p164">page 164</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
@@ -7146,8 +7188,8 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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"
+              #include <a href="#7.21">&lt;stdio.h&gt;</a>
+              #include "myprog.h"
 
 
 
@@ -7155,17 +7197,17 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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>)
+[<a name="p165" href="#p165">page 165</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
+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>
@@ -7197,7 +7239,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>)
+[<a name="p166" href="#p166">page 166</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
@@ -7238,7 +7280,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
           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>)
+[<a name="p167" href="#p167">page 167</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
@@ -7275,7 +7317,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p168" href="#p168">page 168</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>
@@ -7317,7 +7359,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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="p169" href="#p169">page 169</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 ##
@@ -7333,43 +7375,56 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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.
+4   EXAMPLE There are cases where it is not clear whether a replacement is nested or not. For example,
+    given the following macro definitions:
+            #define f(a) a*g
+            #define g(a) f(a)
+    the invocation
+            f(2)(9)
+    may expand to either
+            2*f(9)
+    or
+            2*9*g
+    Strictly conforming programs are not permitted to depend on such unspecified behavior.
+
 <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
+         # 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
+3   EXAMPLE 1        The simplest use of this facility is to define a ''manifest constant'', as in
             #define TABSIZE 100
-            int table[TABSIZE];
+
+[<a name="p170" href="#p170">page 170</a>] (<a href="#Contents">Contents</a>)
+
+             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))
+             #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
+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);
@@ -7381,7 +7436,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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
+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)
@@ -7392,6 +7447,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              #define xglue(a, b) glue(a, b)
              #define HIGHLOW     "hello"
              #define LOW         LOW ", world"
+
+[<a name="p171" href="#p171">page 171</a>] (<a href="#Contents">Contents</a>)
+
              debug(1, 2);
              fputs(str(strncmp("abc\0d", "abc", '\4') // this goes away
                    == 0) str(: @\n), s);
@@ -7399,9 +7457,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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",
@@ -7441,6 +7496,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              #define      FUNC_LIKE(b) ( b ) // different parameter spelling
 
 9   EXAMPLE 7        Finally, to show the variable argument list macro facilities:
+
+[<a name="p172" href="#p172">page 172</a>] (<a href="#Contents">Contents</a>)
+
              #define debug(...)       fprintf(stderr, __VA_ARGS__)
              #define showlist(...)    puts(#__VA_ARGS__)
              #define report(test, ...) ((test)?puts(#test):\
@@ -7449,9 +7507,6 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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 );
@@ -7484,7 +7539,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p173" href="#p173">page 173</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>
@@ -7523,7 +7578,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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="p174" href="#p174">page 174</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>
@@ -7561,14 +7616,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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>)
+[<a name="p175" href="#p175">page 175</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>).
+    Forward references: the asctime function (<a href="#7.27.3.1">7.27.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,
@@ -7591,7 +7646,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
               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>).
+    Forward references: common definitions (<a href="#7.19">7.19</a>), unicode utilities (<a href="#7.28">7.28</a>).
 
 
 
@@ -7601,7 +7656,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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="p176" href="#p176">page 176</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:
@@ -7614,47 +7669,50 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
               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_ATOMICS__ 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.
     __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.
+              implementation does not support the <a href="#7.26">&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>)
+[<a name="p177" href="#p177">page 177</a>] (<a href="#Contents">Contents</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 any encoding prefix,
+    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"
+             #pragma listing on "..\listing.dir"
     can also be expressed as:
-              _Pragma ( "listing on \"..\\listing.dir\"" )
+             _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 )
+             #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="p178" href="#p178">page 178</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>
@@ -7684,7 +7742,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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="p179" href="#p179">page 179</a>] (<a href="#Contents">Contents</a>)
 
 
 <a name="7" href="#7"><b>    7. Library</b></a>
@@ -7716,13 +7774,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.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>).
+         (<a href="#7.22.1">7.22.1</a>, <a href="#7.29.4.1">7.29.4.1</a>) and the formatted input/output functions (<a href="#7.21.6">7.21.6</a>, <a href="#7.29.2">7.29.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="p180" href="#p180">page 180</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>
@@ -7731,13 +7789,16 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>
+           <a href="#7.2">&lt;assert.h&gt;</a>                     <a href="#7.12">&lt;math.h&gt;</a>                        <a href="#7.22">&lt;stdlib.h&gt;</a>
+           <a href="#7.3">&lt;complex.h&gt;</a>                    <a href="#7.13">&lt;setjmp.h&gt;</a>                      <a href="#7.23">&lt;stdnoreturn.h&gt;</a>
+           <a href="#7.4">&lt;ctype.h&gt;</a>                      <a href="#7.14">&lt;signal.h&gt;</a>                      <a href="#7.24">&lt;string.h&gt;</a>
+           <a href="#7.5">&lt;errno.h&gt;</a>                      <a href="#7.15">&lt;stdalign.h&gt;</a>                    <a href="#7.25">&lt;tgmath.h&gt;</a>
+           <a href="#7.6">&lt;fenv.h&gt;</a>                       <a href="#7.16">&lt;stdarg.h&gt;</a>                      <a href="#7.26">&lt;threads.h&gt;</a>
+           <a href="#7.7">&lt;float.h&gt;</a>                      <a href="#7.17">&lt;stdatomic.h&gt;</a>                   <a href="#7.27">&lt;time.h&gt;</a>
+           <a href="#7.8">&lt;inttypes.h&gt;</a>                   <a href="#7.18">&lt;stdbool.h&gt;</a>                     <a href="#7.28">&lt;uchar.h&gt;</a>
+           <a href="#7.9">&lt;iso646.h&gt;</a>                     <a href="#7.19">&lt;stddef.h&gt;</a>                      <a href="#7.29">&lt;wchar.h&gt;</a>
+           <a href="#7.10">&lt;limits.h&gt;</a>                     <a href="#7.20">&lt;stdint.h&gt;</a>                      <a href="#7.30">&lt;wctype.h&gt;</a>
+           <a href="#7.11">&lt;locale.h&gt;</a>                     <a href="#7.21">&lt;stdio.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.
@@ -7749,23 +7810,21 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.
+    macros with names lexically identical to keywords currently defined prior to the inclusion
+    of the header or when any macro defined in the header is expanded.
 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
+    <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.26">&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>)
+[<a name="p181" href="#p181">page 181</a>] (<a href="#Contents">Contents</a>)
 
+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>).
 <a name="7.1.3" href="#7.1.3"><b>    7.1.3 Reserved identifiers</b></a>
@@ -7798,7 +7857,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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="p182" href="#p182">page 182</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
@@ -7833,16 +7892,16 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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.
+                  #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>)
+[<a name="p183" href="#p183">page 183</a>] (<a href="#Contents">Contents</a>)
 
     integer constant expressions shall additionally be suitable for use in #if preprocessing
     directives.
@@ -7876,10 +7935,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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.
+         explicitly share objects between threads. Similarly, an implementation of memcpy is not permitted to
+         copy bytes beyond the specified length of the destination object and then restore the original values
+         because it could cause a data race if the program shared those bytes 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>)
+[<a name="p184" href="#p184">page 184</a>] (<a href="#Contents">Contents</a>)
 
             #include <a href="#7.22">&lt;stdlib.h&gt;</a>
             #undef atoi
@@ -7897,7 +7958,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
             /* ... */
             i = atoi(str);
 
-[<a name="p184" href="#p184">page 184</a>] (<a href="#Contents">Contents</a>)
+[<a name="p185" href="#p185">page 185</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
@@ -7933,15 +7994,15 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 
     <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.
+          Assertion failed: expression, function abc, file xyz, line nnn.
 
-[<a name="p185" href="#p185">page 185</a>] (<a href="#Contents">Contents</a>)
+[<a name="p186" href="#p186">page 186</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="p187" href="#p187">page 187</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>
@@ -7973,11 +8034,11 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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="note192" href="#note192"><b>192)</b></a></sup> See ''future library directions'' (<a href="#7.31.1">7.31.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>)
+[<a name="p188" href="#p188">page 188</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>
@@ -8001,8 +8062,8 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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
+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
@@ -8017,17 +8078,17 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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>)
+[<a name="p189" href="#p189">page 189</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);
+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.
@@ -8037,10 +8098,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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.
@@ -8049,21 +8110,21 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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.
+             (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>)
+[<a name="p190" href="#p190">page 190</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);
+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.
@@ -8073,33 +8134,33 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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);
+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>)
+[<a name="p191" href="#p191">page 191</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);
+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>
@@ -8107,10 +8168,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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);
+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.
@@ -8120,12 +8181,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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>)
+[<a name="p192" href="#p192">page 192</a>] (<a href="#Contents">Contents</a>)
 
 <b>    Description</b>
 2   The casinh functions compute the complex arc hyperbolic sine of z, with branch cuts
@@ -8136,10 +8197,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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.
@@ -8149,33 +8210,33 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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="p193" href="#p193">page 193</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);
+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);
+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>
@@ -8183,23 +8244,23 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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);
+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="p194" href="#p194">page 194</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);
+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.
@@ -8210,10 +8271,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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);
+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.
@@ -8221,13 +8282,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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);
+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>)
+[<a name="p195" href="#p195">page 195</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
@@ -8236,10 +8297,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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);
+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.
@@ -8249,64 +8310,62 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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);
+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="p196" href="#p196">page 196</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);
+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);
+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.
+    value of y. The resulting expression shall 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)))
+3   The CMPLX macros return the complex value x + i y.
+4   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="p197" href="#p197">page 197</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);
+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.
@@ -8314,28 +8373,28 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 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);
+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))
+           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);
+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>)
+[<a name="p198" href="#p198">page 198</a>] (<a href="#Contents">Contents</a>)
 
 <b>    Returns</b>
 3   The creal functions return the real part value.
@@ -8345,7 +8404,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
     <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="p199" href="#p199">page 199</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
@@ -8378,12 +8437,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 
 
-    <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="note198" href="#note198"><b>198)</b></a></sup> See ''future library directions'' (<a href="#7.31.2">7.31.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>)
+[<a name="p200" href="#p200">page 200</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.
@@ -8420,14 +8479,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     <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>)
+[<a name="p201" href="#p201">page 201</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);
+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
@@ -8435,14 +8494,14 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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);
+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"
@@ -8450,21 +8509,21 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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>)
+[<a name="p202" href="#p202">page 202</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);
+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
@@ -8472,15 +8531,15 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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);
+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);
+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>
@@ -8489,12 +8548,12 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p203" href="#p203">page 203</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);
+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>
@@ -8503,7 +8562,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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="p204" href="#p204">page 204</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
@@ -8536,9 +8595,9 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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>).
+    <sup><a name="note203" href="#note203"><b>203)</b></a></sup> See ''future library directions'' (<a href="#7.31.3">7.31.3</a>).
 
-[<a name="p204" href="#p204">page 204</a>] (<a href="#Contents">Contents</a>)
+[<a name="p205" href="#p205">page 205</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
@@ -8578,7 +8637,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
          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>)
+[<a name="p206" href="#p206">page 206</a>] (<a href="#Contents">Contents</a>)
 
 6   Each of the macros
              FE_DIVBYZERO
@@ -8588,11 +8647,11 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
              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
+    exceptions, with macro definitions beginning with FE_ and an uppercase letter,<sup><a href="#note208"><b>208)</b></a></sup> 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>
+    zero.<sup><a href="#note209"><b>209)</b></a></sup>
 7   The macro
              FE_ALL_EXCEPT
     is simply the bitwise OR of all floating-point exception macros defined by the
@@ -8605,29 +8664,30 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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
+    with FE_ and an uppercase letter,<sup><a href="#note210"><b>210)</b></a></sup> 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
-
+    nonnegative values.<sup><a href="#note211"><b>211)</b></a></sup>
 
 
     <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
+    <sup><a name="note208" href="#note208"><b>208)</b></a></sup> See ''future library directions'' (<a href="#7.31.4">7.31.4</a>).
+    <sup><a name="note209" href="#note209"><b>209)</b></a></sup> The macros should be distinct powers of two.
+    <sup><a name="note210" href="#note210"><b>210)</b></a></sup> See ''future library directions'' (<a href="#7.31.4">7.31.4</a>).
+    <sup><a name="note211" href="#note211"><b>211)</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>)
+[<a name="p207" href="#p207">page 207</a>] (<a href="#Contents">Contents</a>)
 
+9    The macro
               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.
+     FE_ and an uppercase letter,<sup><a href="#note212"><b>212)</b></a></sup> 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>
@@ -8635,7 +8695,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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
+     run under non-default floating-point control modes.<sup><a href="#note213"><b>213)</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
@@ -8654,13 +8714,13 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 
 
-
-     <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
+     <sup><a name="note212" href="#note212"><b>212)</b></a></sup> See ''future library directions'' (<a href="#7.31.4">7.31.4</a>).
+     <sup><a name="note213" href="#note213"><b>213)</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>)
+[<a name="p208" href="#p208">page 208</a>] (<a href="#Contents">Contents</a>)
 
 3   EXAMPLE
             #include <a href="#7.6">&lt;fenv.h&gt;</a>
@@ -8676,10 +8736,10 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
             }
 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>
+    contain an appropriately placed invocation of #pragma STDC FENV_ACCESS ON.<sup><a href="#note214"><b>214)</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
+1   The following functions provide access to the floating-point status flags.<sup><a href="#note215"><b>215)</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
@@ -8696,16 +8756,16 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
     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
+    <sup><a name="note214" href="#note214"><b>214)</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
+    <sup><a name="note215" href="#note215"><b>215)</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="p209" href="#p209">page 209</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>
@@ -8725,7 +8785,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</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
+    represented by its argument.<sup><a href="#note216"><b>216)</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.
@@ -8736,11 +8796,11 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 
 
 
-    <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.
+    <sup><a name="note216" href="#note216"><b>216)</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="p210" href="#p210">page 210</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>
@@ -8765,7 +8825,7 @@ Forward references:        conditional inclusion (<a href="#6.10.1">6.10.1</a>),
 <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>
+    point status flags to be queried.<sup><a href="#note217"><b>217)</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